};
return __assign.apply(this, arguments);
};
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+ if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+ return cooked;
+};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
-var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
- if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
- return cooked;
-};
var ts;
(function (ts) {
- ts.versionMajorMinor = "3.9";
- ts.version = "3.9.5";
- function tryGetNativeMap() {
- return typeof Map !== "undefined" && "entries" in Map.prototype ? Map : undefined;
- }
- ts.tryGetNativeMap = tryGetNativeMap;
- ts.Map = tryGetNativeMap() || (function () {
- if (typeof ts.createMapShim === "function") {
- return ts.createMapShim();
- }
- throw new Error("TypeScript requires an environment that provides a compatible native Map implementation.");
- })();
+ ts.versionMajorMinor = "4.1";
+ ts.version = "4.1.2";
+ var NativeCollections;
+ (function (NativeCollections) {
+ function tryGetNativeMap() {
+ return typeof Map !== "undefined" && "entries" in Map.prototype && new Map([[0, 0]]).size === 1 ? Map : undefined;
+ }
+ NativeCollections.tryGetNativeMap = tryGetNativeMap;
+ function tryGetNativeSet() {
+ return typeof Set !== "undefined" && "entries" in Set.prototype && new Set([0]).size === 1 ? Set : undefined;
+ }
+ NativeCollections.tryGetNativeSet = tryGetNativeSet;
+ })(NativeCollections = ts.NativeCollections || (ts.NativeCollections = {}));
})(ts || (ts = {}));
var ts;
(function (ts) {
+ function getCollectionImplementation(name, nativeFactory, shimFactory) {
+ var _a;
+ var constructor = (_a = ts.NativeCollections[nativeFactory]()) !== null && _a !== void 0 ? _a : ts.ShimCollections === null || ts.ShimCollections === void 0 ? void 0 : ts.ShimCollections[shimFactory](getIterator);
+ if (constructor)
+ return constructor;
+ throw new Error("TypeScript requires an environment that provides a compatible native " + name + " implementation.");
+ }
+ ts.Map = getCollectionImplementation("Map", "tryGetNativeMap", "createMapShim");
+ ts.Set = getCollectionImplementation("Set", "tryGetNativeSet", "createSetShim");
+ function getIterator(iterable) {
+ if (iterable) {
+ if (isArray(iterable))
+ return arrayIterator(iterable);
+ if (iterable instanceof ts.Map)
+ return iterable.entries();
+ if (iterable instanceof ts.Set)
+ return iterable.values();
+ throw new Error("Iteration not supported.");
+ }
+ }
+ ts.getIterator = getIterator;
ts.emptyArray = [];
+ ts.emptyMap = new ts.Map();
+ ts.emptySet = new ts.Set();
function createMap() {
return new ts.Map();
}
ts.createMap = createMap;
- function createMapFromEntries(entries) {
- var map = createMap();
- for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
- var _a = entries_1[_i], key = _a[0], value = _a[1];
- map.set(key, value);
- }
- return map;
- }
- ts.createMapFromEntries = createMapFromEntries;
function createMapFromTemplate(template) {
var map = new ts.Map();
for (var key in template) {
}
}
ts.firstDefinedIterator = firstDefinedIterator;
+ function reduceLeftIterator(iterator, f, initial) {
+ var result = initial;
+ if (iterator) {
+ for (var step = iterator.next(), pos = 0; !step.done; step = iterator.next(), pos++) {
+ result = f(result, step.value, pos);
+ }
+ }
+ return result;
+ }
+ ts.reduceLeftIterator = reduceLeftIterator;
function zipWith(arrayA, arrayB, callback) {
var result = [];
ts.Debug.assertEqual(arrayA.length, arrayB.length);
ts.zipToIterator = zipToIterator;
function zipToMap(keys, values) {
ts.Debug.assert(keys.length === values.length);
- var map = createMap();
+ var map = new ts.Map();
for (var i = 0; i < keys.length; ++i) {
map.set(keys[i], values[i]);
}
return map;
}
ts.zipToMap = zipToMap;
+ function intersperse(input, element) {
+ if (input.length <= 1) {
+ return input;
+ }
+ var result = [];
+ for (var i = 0, n = input.length; i < n; i++) {
+ if (i)
+ result.push(element);
+ result.push(input[i]);
+ }
+ return result;
+ }
+ ts.intersperse = intersperse;
function every(array, callback) {
if (array) {
for (var i = 0; i < array.length; i++) {
};
}
ts.mapDefinedIterator = mapDefinedIterator;
- function mapDefinedMap(map, mapValue, mapKey) {
- if (mapKey === void 0) { mapKey = identity; }
- var result = createMap();
+ function mapDefinedEntries(map, f) {
+ if (!map) {
+ return undefined;
+ }
+ var result = new ts.Map();
map.forEach(function (value, key) {
- var mapped = mapValue(value, key);
- if (mapped !== undefined) {
- result.set(mapKey(key), mapped);
+ var entry = f(key, value);
+ if (entry !== undefined) {
+ var newKey = entry[0], newValue = entry[1];
+ if (newKey !== undefined && newValue !== undefined) {
+ result.set(newKey, newValue);
+ }
}
});
return result;
}
- ts.mapDefinedMap = mapDefinedMap;
+ ts.mapDefinedEntries = mapDefinedEntries;
+ function mapDefinedValues(set, f) {
+ if (set) {
+ var result_1 = new ts.Set();
+ set.forEach(function (value) {
+ var newValue = f(value);
+ if (newValue !== undefined) {
+ result_1.add(newValue);
+ }
+ });
+ return result_1;
+ }
+ }
+ ts.mapDefinedValues = mapDefinedValues;
+ function getOrUpdate(map, key, callback) {
+ if (map.has(key)) {
+ return map.get(key);
+ }
+ var value = callback();
+ map.set(key, value);
+ return value;
+ }
+ ts.getOrUpdate = getOrUpdate;
+ function tryAddToSet(set, value) {
+ if (!set.has(value)) {
+ set.add(value);
+ return true;
+ }
+ return false;
+ }
+ ts.tryAddToSet = tryAddToSet;
ts.emptyIterator = { next: function () { return ({ value: undefined, done: true }); } };
function singleIterator(value) {
var done = false;
if (!map) {
return undefined;
}
- var result = createMap();
+ var result = new ts.Map();
map.forEach(function (value, key) {
var _a = f(key, value), newKey = _a[0], newValue = _a[1];
result.set(newKey, newValue);
return deduplicateSorted(sort(array, comparer), equalityComparer || comparer || compareStringsCaseSensitive);
}
ts.sortAndDeduplicate = sortAndDeduplicate;
+ function arrayIsSorted(array, comparer) {
+ if (array.length < 2)
+ return true;
+ var prevElement = array[0];
+ for (var _i = 0, _a = array.slice(1); _i < _a.length; _i++) {
+ var element = _a[_i];
+ if (comparer(prevElement, element) === 1) {
+ return false;
+ }
+ prevElement = element;
+ }
+ return true;
+ }
+ ts.arrayIsSorted = arrayIsSorted;
function arrayIsEqualTo(array1, array2, equalityComparer) {
if (equalityComparer === void 0) { equalityComparer = equateValues; }
if (!array1 || !array2) {
var high = array.length - 1;
while (low <= high) {
var middle = low + ((high - low) >> 1);
- var midKey = keySelector(array[middle]);
+ var midKey = keySelector(array[middle], middle);
switch (keyComparer(midKey, key)) {
case -1:
low = middle + 1;
return values;
}
ts.getOwnValues = getOwnValues;
+ var _entries = Object.entries || (function (obj) {
+ var keys = getOwnKeys(obj);
+ var result = Array(keys.length);
+ for (var i = 0; i < keys.length; i++) {
+ result[i] = [keys[i], obj[keys[i]]];
+ }
+ return result;
+ });
+ function getEntries(obj) {
+ return obj ? _entries(obj) : [];
+ }
+ ts.getEntries = getEntries;
+ function arrayOf(count, f) {
+ var result = new Array(count);
+ for (var i = 0; i < count; i++) {
+ result[i] = f(i);
+ }
+ return result;
+ }
+ ts.arrayOf = arrayOf;
function arrayFrom(iterator, map) {
var result = [];
for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
ts.equalOwnProperties = equalOwnProperties;
function arrayToMap(array, makeKey, makeValue) {
if (makeValue === void 0) { makeValue = identity; }
- var result = createMap();
+ var result = new ts.Map();
for (var _i = 0, array_6 = array; _i < array_6.length; _i++) {
var value = array_6[_i];
var key = makeKey(value);
return fn ? fn.bind(obj) : undefined;
}
ts.maybeBind = maybeBind;
- function mapMap(map, f) {
- var result = createMap();
- map.forEach(function (t, key) { return result.set.apply(result, (f(t, key))); });
- return result;
- }
- ts.mapMap = mapMap;
function createMultiMap() {
- var map = createMap();
+ var map = new ts.Map();
map.add = multiMapAdd;
map.remove = multiMapRemove;
return map;
};
}
ts.memoize = memoize;
+ function memoizeOne(callback) {
+ var map = new ts.Map();
+ return function (arg) {
+ var key = typeof arg + ":" + arg;
+ var value = map.get(key);
+ if (value === undefined && !map.has(key)) {
+ value = callback(arg);
+ map.set(key, value);
+ }
+ return value;
+ };
+ }
+ ts.memoizeOne = memoizeOne;
function compose(a, b, c, d, e) {
if (!!e) {
var args_2 = [];
var oldIndex = 0;
var newLen = newItems.length;
var oldLen = oldItems.length;
+ var hasChanges = false;
while (newIndex < newLen && oldIndex < oldLen) {
var newItem = newItems[newIndex];
var oldItem = oldItems[oldIndex];
if (compareResult === -1) {
inserted(newItem);
newIndex++;
+ hasChanges = true;
}
else if (compareResult === 1) {
deleted(oldItem);
oldIndex++;
+ hasChanges = true;
}
else {
unchanged(oldItem, newItem);
}
while (newIndex < newLen) {
inserted(newItems[newIndex++]);
+ hasChanges = true;
}
while (oldIndex < oldLen) {
deleted(oldItems[oldIndex++]);
+ hasChanges = true;
}
+ return hasChanges;
}
ts.enumerateInsertsAndDeletes = enumerateInsertsAndDeletes;
function fill(length, cb) {
}
}
}
- function padLeft(s, length) {
- while (s.length < length) {
- s = " " + s;
- }
- return s;
+ function padLeft(s, length, padString) {
+ if (padString === void 0) { padString = " "; }
+ return length <= s.length ? s : padString.repeat(length - s.length) + s;
}
ts.padLeft = padLeft;
- function padRight(s, length) {
- while (s.length < length) {
- s = s + " ";
- }
- return s;
+ function padRight(s, length, padString) {
+ if (padString === void 0) { padString = " "; }
+ return length <= s.length ? s : s + padString.repeat(length - s.length);
}
ts.padRight = padRight;
+ function takeWhile(array, predicate) {
+ var len = array.length;
+ var index = 0;
+ while (index < len && predicate(array[index])) {
+ index++;
+ }
+ return array.slice(0, index);
+ }
+ ts.takeWhile = takeWhile;
})(ts || (ts = {}));
var ts;
(function (ts) {
+ var LogLevel;
+ (function (LogLevel) {
+ LogLevel[LogLevel["Off"] = 0] = "Off";
+ LogLevel[LogLevel["Error"] = 1] = "Error";
+ LogLevel[LogLevel["Warning"] = 2] = "Warning";
+ LogLevel[LogLevel["Info"] = 3] = "Info";
+ LogLevel[LogLevel["Verbose"] = 4] = "Verbose";
+ })(LogLevel = ts.LogLevel || (ts.LogLevel = {}));
var Debug;
(function (Debug) {
+ var typeScriptVersion;
var currentAssertionLevel = 0;
+ Debug.currentLogLevel = LogLevel.Warning;
Debug.isDebugging = false;
+ function getTypeScriptVersion() {
+ return typeScriptVersion !== null && typeScriptVersion !== void 0 ? typeScriptVersion : (typeScriptVersion = new ts.Version(ts.version));
+ }
+ Debug.getTypeScriptVersion = getTypeScriptVersion;
+ function shouldLog(level) {
+ return Debug.currentLogLevel <= level;
+ }
+ Debug.shouldLog = shouldLog;
+ function logMessage(level, s) {
+ if (Debug.loggingHost && shouldLog(level)) {
+ Debug.loggingHost.log(level, s);
+ }
+ }
+ function log(s) {
+ logMessage(LogLevel.Info, s);
+ }
+ Debug.log = log;
+ (function (log_1) {
+ function error(s) {
+ logMessage(LogLevel.Error, s);
+ }
+ log_1.error = error;
+ function warn(s) {
+ logMessage(LogLevel.Warning, s);
+ }
+ log_1.warn = warn;
+ function log(s) {
+ logMessage(LogLevel.Info, s);
+ }
+ log_1.log = log;
+ function trace(s) {
+ logMessage(LogLevel.Verbose, s);
+ }
+ log_1.trace = trace;
+ })(log = Debug.log || (Debug.log = {}));
var assertionCache = {};
function getAssertionLevel() {
return currentAssertionLevel;
return formatEnum(flags, ts.ObjectFlags, true);
}
Debug.formatObjectFlags = formatObjectFlags;
+ function formatFlowFlags(flags) {
+ return formatEnum(flags, ts.FlowFlags, true);
+ }
+ Debug.formatFlowFlags = formatFlowFlags;
var isDebugInfoEnabled = false;
var extendedDebugModule;
function extendedDebug() {
return extendedDebug().formatControlFlowGraph(flowNode);
}
Debug.formatControlFlowGraph = formatControlFlowGraph;
+ var flowNodeProto;
+ function attachFlowNodeDebugInfoWorker(flowNode) {
+ if (!("__debugFlowFlags" in flowNode)) {
+ Object.defineProperties(flowNode, {
+ __tsDebuggerDisplay: {
+ value: function () {
+ var flowHeader = this.flags & 2 ? "FlowStart" :
+ this.flags & 4 ? "FlowBranchLabel" :
+ this.flags & 8 ? "FlowLoopLabel" :
+ this.flags & 16 ? "FlowAssignment" :
+ this.flags & 32 ? "FlowTrueCondition" :
+ this.flags & 64 ? "FlowFalseCondition" :
+ this.flags & 128 ? "FlowSwitchClause" :
+ this.flags & 256 ? "FlowArrayMutation" :
+ this.flags & 512 ? "FlowCall" :
+ this.flags & 1024 ? "FlowReduceLabel" :
+ this.flags & 1 ? "FlowUnreachable" :
+ "UnknownFlow";
+ var remainingFlags = this.flags & ~(2048 - 1);
+ return "" + flowHeader + (remainingFlags ? " (" + formatFlowFlags(remainingFlags) + ")" : "");
+ }
+ },
+ __debugFlowFlags: { get: function () { return formatEnum(this.flags, ts.FlowFlags, true); } },
+ __debugToString: { value: function () { return formatControlFlowGraph(this); } }
+ });
+ }
+ }
function attachFlowNodeDebugInfo(flowNode) {
if (isDebugInfoEnabled) {
- if (!("__debugFlowFlags" in flowNode)) {
- Object.defineProperties(flowNode, {
- __debugFlowFlags: { get: function () { return formatEnum(this.flags, ts.FlowFlags, true); } },
- __debugToString: { value: function () { return formatControlFlowGraph(this); } }
- });
+ if (typeof Object.setPrototypeOf === "function") {
+ if (!flowNodeProto) {
+ flowNodeProto = Object.create(Object.prototype);
+ attachFlowNodeDebugInfoWorker(flowNodeProto);
+ }
+ Object.setPrototypeOf(flowNode, flowNodeProto);
+ }
+ else {
+ attachFlowNodeDebugInfoWorker(flowNode);
}
}
}
Debug.attachFlowNodeDebugInfo = attachFlowNodeDebugInfo;
+ var nodeArrayProto;
+ function attachNodeArrayDebugInfoWorker(array) {
+ if (!("__tsDebuggerDisplay" in array)) {
+ Object.defineProperties(array, {
+ __tsDebuggerDisplay: {
+ value: function (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);
+ }
+ }
+ }
+ Debug.attachNodeArrayDebugInfo = attachNodeArrayDebugInfo;
function enableDebugInfo() {
if (isDebugInfoEnabled)
return;
+ var weakTypeTextMap;
+ var weakNodeTextMap;
+ function getWeakTypeTextMap() {
+ if (weakTypeTextMap === undefined) {
+ if (typeof WeakMap === "function")
+ weakTypeTextMap = new WeakMap();
+ }
+ return weakTypeTextMap;
+ }
+ function getWeakNodeTextMap() {
+ if (weakNodeTextMap === undefined) {
+ if (typeof WeakMap === "function")
+ weakNodeTextMap = new WeakMap();
+ }
+ return weakNodeTextMap;
+ }
Object.defineProperties(ts.objectAllocator.getSymbolConstructor().prototype, {
+ __tsDebuggerDisplay: {
+ value: function () {
+ var symbolHeader = this.flags & 33554432 ? "TransientSymbol" :
+ "Symbol";
+ var remainingSymbolFlags = this.flags & ~33554432;
+ return symbolHeader + " '" + ts.symbolName(this) + "'" + (remainingSymbolFlags ? " (" + formatSymbolFlags(remainingSymbolFlags) + ")" : "");
+ }
+ },
__debugFlags: { get: function () { return formatSymbolFlags(this.flags); } }
});
Object.defineProperties(ts.objectAllocator.getTypeConstructor().prototype, {
+ __tsDebuggerDisplay: {
+ value: function () {
+ var typeHeader = this.flags & 98304 ? "NullableType" :
+ this.flags & 384 ? "LiteralType " + JSON.stringify(this.value) :
+ this.flags & 2048 ? "LiteralType " + (this.value.negative ? "-" : "") + this.value.base10Value + "n" :
+ this.flags & 8192 ? "UniqueESSymbolType" :
+ this.flags & 32 ? "EnumType" :
+ this.flags & 67359327 ? "IntrinsicType " + this.intrinsicName :
+ this.flags & 1048576 ? "UnionType" :
+ this.flags & 2097152 ? "IntersectionType" :
+ this.flags & 4194304 ? "IndexType" :
+ this.flags & 8388608 ? "IndexedAccessType" :
+ this.flags & 16777216 ? "ConditionalType" :
+ this.flags & 33554432 ? "SubstitutionType" :
+ this.flags & 262144 ? "TypeParameter" :
+ this.flags & 524288 ?
+ this.objectFlags & 3 ? "InterfaceType" :
+ this.objectFlags & 4 ? "TypeReference" :
+ this.objectFlags & 8 ? "TupleType" :
+ this.objectFlags & 16 ? "AnonymousType" :
+ this.objectFlags & 32 ? "MappedType" :
+ this.objectFlags & 2048 ? "ReverseMappedType" :
+ this.objectFlags & 256 ? "EvolvingArrayType" :
+ "ObjectType" :
+ "Type";
+ var remainingObjectFlags = this.flags & 524288 ? this.objectFlags & ~2367 : 0;
+ return "" + typeHeader + (this.symbol ? " '" + ts.symbolName(this.symbol) + "'" : "") + (remainingObjectFlags ? " (" + formatObjectFlags(remainingObjectFlags) + ")" : "");
+ }
+ },
__debugFlags: { get: function () { return formatTypeFlags(this.flags); } },
__debugObjectFlags: { get: function () { return this.flags & 524288 ? formatObjectFlags(this.objectFlags) : ""; } },
- __debugTypeToString: { value: function () { return this.checker.typeToString(this); } },
+ __debugTypeToString: {
+ value: function () {
+ var map = getWeakTypeTextMap();
+ var text = map === null || map === void 0 ? void 0 : map.get(this);
+ if (text === undefined) {
+ text = this.checker.typeToString(this);
+ map === null || map === void 0 ? void 0 : map.set(this, text);
+ }
+ return text;
+ }
+ },
});
var nodeConstructors = [
ts.objectAllocator.getNodeConstructor(),
var ctor = nodeConstructors_1[_i];
if (!ctor.prototype.hasOwnProperty("__debugKind")) {
Object.defineProperties(ctor.prototype, {
+ __tsDebuggerDisplay: {
+ value: function () {
+ var nodeHeader = ts.isGeneratedIdentifier(this) ? "GeneratedIdentifier" :
+ ts.isIdentifier(this) ? "Identifier '" + ts.idText(this) + "'" :
+ ts.isPrivateIdentifier(this) ? "PrivateIdentifier '" + ts.idText(this) + "'" :
+ ts.isStringLiteral(this) ? "StringLiteral " + JSON.stringify(this.text.length < 10 ? this.text : this.text.slice(10) + "...") :
+ ts.isNumericLiteral(this) ? "NumericLiteral " + this.text :
+ ts.isBigIntLiteral(this) ? "BigIntLiteral " + this.text + "n" :
+ ts.isTypeParameterDeclaration(this) ? "TypeParameterDeclaration" :
+ ts.isParameter(this) ? "ParameterDeclaration" :
+ ts.isConstructorDeclaration(this) ? "ConstructorDeclaration" :
+ ts.isGetAccessorDeclaration(this) ? "GetAccessorDeclaration" :
+ ts.isSetAccessorDeclaration(this) ? "SetAccessorDeclaration" :
+ ts.isCallSignatureDeclaration(this) ? "CallSignatureDeclaration" :
+ ts.isConstructSignatureDeclaration(this) ? "ConstructSignatureDeclaration" :
+ ts.isIndexSignatureDeclaration(this) ? "IndexSignatureDeclaration" :
+ ts.isTypePredicateNode(this) ? "TypePredicateNode" :
+ ts.isTypeReferenceNode(this) ? "TypeReferenceNode" :
+ ts.isFunctionTypeNode(this) ? "FunctionTypeNode" :
+ ts.isConstructorTypeNode(this) ? "ConstructorTypeNode" :
+ ts.isTypeQueryNode(this) ? "TypeQueryNode" :
+ ts.isTypeLiteralNode(this) ? "TypeLiteralNode" :
+ ts.isArrayTypeNode(this) ? "ArrayTypeNode" :
+ ts.isTupleTypeNode(this) ? "TupleTypeNode" :
+ ts.isOptionalTypeNode(this) ? "OptionalTypeNode" :
+ ts.isRestTypeNode(this) ? "RestTypeNode" :
+ ts.isUnionTypeNode(this) ? "UnionTypeNode" :
+ ts.isIntersectionTypeNode(this) ? "IntersectionTypeNode" :
+ ts.isConditionalTypeNode(this) ? "ConditionalTypeNode" :
+ ts.isInferTypeNode(this) ? "InferTypeNode" :
+ ts.isParenthesizedTypeNode(this) ? "ParenthesizedTypeNode" :
+ ts.isThisTypeNode(this) ? "ThisTypeNode" :
+ ts.isTypeOperatorNode(this) ? "TypeOperatorNode" :
+ ts.isIndexedAccessTypeNode(this) ? "IndexedAccessTypeNode" :
+ ts.isMappedTypeNode(this) ? "MappedTypeNode" :
+ ts.isLiteralTypeNode(this) ? "LiteralTypeNode" :
+ ts.isNamedTupleMember(this) ? "NamedTupleMember" :
+ ts.isImportTypeNode(this) ? "ImportTypeNode" :
+ formatSyntaxKind(this.kind);
+ return "" + nodeHeader + (this.flags ? " (" + formatNodeFlags(this.flags) + ")" : "");
+ }
+ },
__debugKind: { get: function () { return formatSyntaxKind(this.kind); } },
__debugNodeFlags: { get: function () { return formatNodeFlags(this.flags); } },
- __debugModifierFlags: { get: function () { return formatModifierFlags(ts.getModifierFlagsNoCache(this)); } },
+ __debugModifierFlags: { get: function () { return formatModifierFlags(ts.getEffectiveModifierFlagsNoCache(this)); } },
__debugTransformFlags: { get: function () { return formatTransformFlags(this.transformFlags); } },
__debugIsParseTreeNode: { get: function () { return ts.isParseTreeNode(this); } },
__debugEmitFlags: { get: function () { return formatEmitFlags(ts.getEmitFlags(this)); } },
value: function (includeTrivia) {
if (ts.nodeIsSynthesized(this))
return "";
- var parseNode = ts.getParseTreeNode(this);
- var sourceFile = parseNode && ts.getSourceFileOfNode(parseNode);
- return sourceFile ? ts.getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : "";
+ var map = getWeakNodeTextMap();
+ var text = map === null || map === void 0 ? void 0 : map.get(this);
+ if (text === undefined) {
+ var parseNode = ts.getParseTreeNode(this);
+ var sourceFile = parseNode && ts.getSourceFileOfNode(parseNode);
+ text = sourceFile ? ts.getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : "";
+ map === null || map === void 0 ? void 0 : map.set(this, text);
+ }
+ return text;
}
}
});
isDebugInfoEnabled = true;
}
Debug.enableDebugInfo = enableDebugInfo;
- })(Debug = ts.Debug || (ts.Debug = {}));
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- ts.timestamp = typeof performance !== "undefined" && performance.now ? function () { return performance.now(); } : Date.now ? Date.now : function () { return +(new Date()); };
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- var performance;
- (function (performance) {
- var profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true ? onProfilerEvent : function () { };
- var enabled = false;
- var profilerStart = 0;
- var counts;
- var marks;
- var measures;
- function createTimerIf(condition, measureName, startMarkName, endMarkName) {
- return condition ? createTimer(measureName, startMarkName, endMarkName) : performance.nullTimer;
- }
- performance.createTimerIf = createTimerIf;
- function createTimer(measureName, startMarkName, endMarkName) {
- var enterCount = 0;
- return {
- enter: enter,
- exit: exit
+ function formatDeprecationMessage(name, error, errorAfter, since, message) {
+ var deprecationMessage = error ? "DeprecationError: " : "DeprecationWarning: ";
+ deprecationMessage += "'" + name + "' ";
+ deprecationMessage += since ? "has been deprecated since v" + since : "is deprecated";
+ deprecationMessage += error ? " and can no longer be used." : errorAfter ? " and will no longer be usable after v" + errorAfter + "." : ".";
+ deprecationMessage += message ? " " + ts.formatStringFromArgs(message, [name], 0) : "";
+ return deprecationMessage;
+ }
+ function createErrorDeprecation(name, errorAfter, since, message) {
+ var deprecationMessage = formatDeprecationMessage(name, true, errorAfter, since, message);
+ return function () {
+ throw new TypeError(deprecationMessage);
};
- function enter() {
- if (++enterCount === 1) {
- mark(startMarkName);
- }
- }
- function exit() {
- if (--enterCount === 0) {
- mark(endMarkName);
- measure(measureName, startMarkName, endMarkName);
- }
- else if (enterCount < 0) {
- ts.Debug.fail("enter/exit count does not match.");
- }
- }
- }
- performance.createTimer = createTimer;
- performance.nullTimer = { enter: ts.noop, exit: ts.noop };
- function mark(markName) {
- if (enabled) {
- marks.set(markName, ts.timestamp());
- counts.set(markName, (counts.get(markName) || 0) + 1);
- profilerEvent(markName);
- }
- }
- performance.mark = mark;
- function measure(measureName, startMarkName, endMarkName) {
- if (enabled) {
- var end = endMarkName && marks.get(endMarkName) || ts.timestamp();
- var start = startMarkName && marks.get(startMarkName) || profilerStart;
- measures.set(measureName, (measures.get(measureName) || 0) + (end - start));
- }
- }
- performance.measure = measure;
- function getCount(markName) {
- return counts && counts.get(markName) || 0;
- }
- performance.getCount = getCount;
- function getDuration(measureName) {
- return measures && measures.get(measureName) || 0;
}
- performance.getDuration = getDuration;
- function forEachMeasure(cb) {
- measures.forEach(function (measure, key) {
- cb(key, measure);
- });
+ function createWarningDeprecation(name, errorAfter, since, message) {
+ var hasWrittenDeprecation = false;
+ return function () {
+ if (!hasWrittenDeprecation) {
+ log.warn(formatDeprecationMessage(name, false, errorAfter, since, message));
+ hasWrittenDeprecation = true;
+ }
+ };
}
- performance.forEachMeasure = forEachMeasure;
- function enable() {
- counts = ts.createMap();
- marks = ts.createMap();
- measures = ts.createMap();
- enabled = true;
- profilerStart = ts.timestamp();
+ function createDeprecation(name, options) {
+ var _a, _b;
+ if (options === void 0) { options = {}; }
+ var version = typeof options.typeScriptVersion === "string" ? new ts.Version(options.typeScriptVersion) : (_a = options.typeScriptVersion) !== null && _a !== void 0 ? _a : getTypeScriptVersion();
+ var errorAfter = typeof options.errorAfter === "string" ? new ts.Version(options.errorAfter) : options.errorAfter;
+ var warnAfter = typeof options.warnAfter === "string" ? new ts.Version(options.warnAfter) : options.warnAfter;
+ var since = typeof options.since === "string" ? new ts.Version(options.since) : (_b = options.since) !== null && _b !== void 0 ? _b : warnAfter;
+ var error = options.error || errorAfter && version.compareTo(errorAfter) <= 0;
+ var warn = !warnAfter || version.compareTo(warnAfter) >= 0;
+ return error ? createErrorDeprecation(name, errorAfter, since, options.message) :
+ warn ? createWarningDeprecation(name, errorAfter, since, options.message) :
+ ts.noop;
+ }
+ function wrapFunction(deprecation, func) {
+ return function () {
+ deprecation();
+ return func.apply(this, arguments);
+ };
}
- performance.enable = enable;
- function disable() {
- enabled = false;
+ function deprecate(func, options) {
+ var deprecation = createDeprecation(getFunctionName(func), options);
+ return wrapFunction(deprecation, func);
}
- performance.disable = disable;
- })(performance = ts.performance || (ts.performance = {}));
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- var nullLogger = {
- logEvent: ts.noop,
- logErrEvent: ts.noop,
- logPerfEvent: ts.noop,
- logInfoEvent: ts.noop,
- logStartCommand: ts.noop,
- logStopCommand: ts.noop,
- logStartUpdateProgram: ts.noop,
- logStopUpdateProgram: ts.noop,
- logStartUpdateGraph: ts.noop,
- logStopUpdateGraph: ts.noop,
- logStartResolveModule: ts.noop,
- logStopResolveModule: ts.noop,
- logStartParseSourceFile: ts.noop,
- logStopParseSourceFile: ts.noop,
- logStartReadFile: ts.noop,
- logStopReadFile: ts.noop,
- logStartBindFile: ts.noop,
- logStopBindFile: ts.noop,
- logStartScheduledOperation: ts.noop,
- logStopScheduledOperation: ts.noop,
- };
- var etwModule;
- try {
- etwModule = require("@microsoft/typescript-etw");
- }
- catch (e) {
- etwModule = undefined;
- }
- ts.perfLogger = etwModule && etwModule.logEvent ? etwModule : nullLogger;
+ Debug.deprecate = deprecate;
+ })(Debug = ts.Debug || (ts.Debug = {}));
})(ts || (ts = {}));
var ts;
(function (ts) {
return ts.compareValues(this.major, other.major)
|| ts.compareValues(this.minor, other.minor)
|| ts.compareValues(this.patch, other.patch)
- || comparePrerelaseIdentifiers(this.prerelease, other.prerelease);
+ || comparePrereleaseIdentifiers(this.prerelease, other.prerelease);
};
Version.prototype.increment = function (field) {
switch (field) {
build: build
};
}
- function comparePrerelaseIdentifiers(left, right) {
+ function comparePrereleaseIdentifiers(left, right) {
if (left === right)
return 0;
if (left.length === 0)
}
})(ts || (ts = {}));
var ts;
+(function (ts) {
+ function hasRequiredAPI(performance, PerformanceObserver) {
+ return typeof performance === "object" &&
+ typeof performance.timeOrigin === "number" &&
+ typeof performance.mark === "function" &&
+ typeof performance.measure === "function" &&
+ typeof performance.now === "function" &&
+ typeof PerformanceObserver === "function";
+ }
+ function tryGetWebPerformanceHooks() {
+ if (typeof performance === "object" &&
+ typeof PerformanceObserver === "function" &&
+ hasRequiredAPI(performance, PerformanceObserver)) {
+ return {
+ performance: performance,
+ PerformanceObserver: PerformanceObserver
+ };
+ }
+ }
+ function tryGetNodePerformanceHooks() {
+ if (typeof module === "object" && typeof require === "function") {
+ try {
+ var _a = require("perf_hooks"), performance_1 = _a.performance, PerformanceObserver_1 = _a.PerformanceObserver;
+ if (hasRequiredAPI(performance_1, PerformanceObserver_1)) {
+ var version_1 = new ts.Version(process.versions.node);
+ var range = new ts.VersionRange("<12.16.3 || 13 <13.13");
+ if (range.test(version_1)) {
+ return {
+ performance: {
+ get timeOrigin() { return performance_1.timeOrigin; },
+ now: function () { return performance_1.now(); },
+ mark: function (name) { return performance_1.mark(name); },
+ measure: function (name, start, end) {
+ if (start === void 0) { start = "nodeStart"; }
+ if (end === undefined) {
+ end = "__performance.measure-fix__";
+ performance_1.mark(end);
+ }
+ performance_1.measure(name, start, end);
+ if (end === "__performance.measure-fix__") {
+ performance_1.clearMarks("__performance.measure-fix__");
+ }
+ }
+ },
+ PerformanceObserver: PerformanceObserver_1
+ };
+ }
+ return {
+ performance: performance_1,
+ PerformanceObserver: PerformanceObserver_1
+ };
+ }
+ }
+ catch (_b) {
+ }
+ }
+ }
+ var nativePerformanceHooks = tryGetWebPerformanceHooks() || tryGetNodePerformanceHooks();
+ var nativePerformance = nativePerformanceHooks === null || nativePerformanceHooks === void 0 ? void 0 : nativePerformanceHooks.performance;
+ function tryGetNativePerformanceHooks() {
+ return nativePerformanceHooks;
+ }
+ ts.tryGetNativePerformanceHooks = tryGetNativePerformanceHooks;
+ ts.timestamp = nativePerformance ? function () { return nativePerformance.now(); } :
+ Date.now ? Date.now :
+ function () { return +(new Date()); };
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ var performance;
+ (function (performance) {
+ var perfHooks;
+ var perfObserver;
+ var performanceImpl;
+ function createTimerIf(condition, measureName, startMarkName, endMarkName) {
+ return condition ? createTimer(measureName, startMarkName, endMarkName) : performance.nullTimer;
+ }
+ performance.createTimerIf = createTimerIf;
+ function createTimer(measureName, startMarkName, endMarkName) {
+ var enterCount = 0;
+ return {
+ enter: enter,
+ exit: exit
+ };
+ function enter() {
+ if (++enterCount === 1) {
+ mark(startMarkName);
+ }
+ }
+ function exit() {
+ if (--enterCount === 0) {
+ mark(endMarkName);
+ measure(measureName, startMarkName, endMarkName);
+ }
+ else if (enterCount < 0) {
+ ts.Debug.fail("enter/exit count does not match.");
+ }
+ }
+ }
+ performance.createTimer = createTimer;
+ performance.nullTimer = { enter: ts.noop, exit: ts.noop };
+ var counts = new ts.Map();
+ var durations = new ts.Map();
+ function mark(markName) {
+ performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.mark(markName);
+ }
+ performance.mark = mark;
+ function measure(measureName, startMarkName, endMarkName) {
+ performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.measure(measureName, startMarkName, endMarkName);
+ }
+ performance.measure = measure;
+ function getCount(markName) {
+ return counts.get(markName) || 0;
+ }
+ performance.getCount = getCount;
+ function getDuration(measureName) {
+ return durations.get(measureName) || 0;
+ }
+ performance.getDuration = getDuration;
+ function forEachMeasure(cb) {
+ durations.forEach(function (duration, measureName) { return cb(measureName, duration); });
+ }
+ performance.forEachMeasure = forEachMeasure;
+ function isEnabled() {
+ return !!performanceImpl;
+ }
+ performance.isEnabled = isEnabled;
+ function enable() {
+ if (!performanceImpl) {
+ perfHooks || (perfHooks = ts.tryGetNativePerformanceHooks());
+ if (!perfHooks)
+ return false;
+ perfObserver || (perfObserver = new perfHooks.PerformanceObserver(updateStatisticsFromList));
+ perfObserver.observe({ entryTypes: ["mark", "measure"] });
+ performanceImpl = perfHooks.performance;
+ }
+ return true;
+ }
+ performance.enable = enable;
+ function disable() {
+ perfObserver === null || perfObserver === void 0 ? void 0 : perfObserver.disconnect();
+ performanceImpl = undefined;
+ counts.clear();
+ durations.clear();
+ }
+ performance.disable = disable;
+ function updateStatisticsFromList(list) {
+ for (var _i = 0, _a = list.getEntriesByType("mark"); _i < _a.length; _i++) {
+ var mark_1 = _a[_i];
+ counts.set(mark_1.name, (counts.get(mark_1.name) || 0) + 1);
+ }
+ for (var _b = 0, _c = list.getEntriesByType("measure"); _b < _c.length; _b++) {
+ var measure_1 = _c[_b];
+ durations.set(measure_1.name, (durations.get(measure_1.name) || 0) + measure_1.duration);
+ }
+ }
+ })(performance = ts.performance || (ts.performance = {}));
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ var _a;
+ var nullLogger = {
+ logEvent: ts.noop,
+ logErrEvent: ts.noop,
+ logPerfEvent: ts.noop,
+ logInfoEvent: ts.noop,
+ logStartCommand: ts.noop,
+ logStopCommand: ts.noop,
+ logStartUpdateProgram: ts.noop,
+ logStopUpdateProgram: ts.noop,
+ logStartUpdateGraph: ts.noop,
+ logStopUpdateGraph: ts.noop,
+ logStartResolveModule: ts.noop,
+ logStopResolveModule: ts.noop,
+ logStartParseSourceFile: ts.noop,
+ logStopParseSourceFile: ts.noop,
+ logStartReadFile: ts.noop,
+ logStopReadFile: ts.noop,
+ logStartBindFile: ts.noop,
+ logStopBindFile: ts.noop,
+ logStartScheduledOperation: ts.noop,
+ logStopScheduledOperation: ts.noop,
+ };
+ var etwModule;
+ try {
+ var etwModulePath = (_a = process.env.TS_ETW_MODULE_PATH) !== null && _a !== void 0 ? _a : "./node_modules/@microsoft/typescript-etw";
+ etwModule = require(etwModulePath);
+ }
+ catch (e) {
+ etwModule = undefined;
+ }
+ ts.perfLogger = etwModule && etwModule.logEvent ? etwModule : nullLogger;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ var tracing;
+ (function (tracing) {
+ var fs;
+ var traceCount = 0;
+ var traceFd;
+ var legendPath;
+ var legend = [];
+ function startTracing(configFilePath, traceDir, isBuildMode) {
+ ts.Debug.assert(!traceFd, "Tracing already started");
+ if (fs === undefined) {
+ try {
+ fs = require("fs");
+ }
+ catch (_a) {
+ fs = false;
+ }
+ }
+ if (!fs) {
+ return;
+ }
+ if (legendPath === undefined) {
+ legendPath = ts.combinePaths(traceDir, "legend.json");
+ }
+ if (!fs.existsSync(traceDir)) {
+ fs.mkdirSync(traceDir, { recursive: true });
+ }
+ var countPart = isBuildMode ? "." + ++traceCount : "";
+ var tracePath = ts.combinePaths(traceDir, "trace" + countPart + ".json");
+ var typesPath = ts.combinePaths(traceDir, "types" + countPart + ".json");
+ legend.push({
+ configFilePath: configFilePath,
+ tracePath: tracePath,
+ typesPath: typesPath,
+ });
+ traceFd = fs.openSync(tracePath, "w");
+ var meta = { cat: "__metadata", ph: "M", ts: 1000 * ts.timestamp(), pid: 1, tid: 1 };
+ fs.writeSync(traceFd, "[\n"
+ + [__assign({ name: "process_name", args: { name: "tsc" } }, meta), __assign({ name: "thread_name", args: { name: "Main" } }, meta), __assign(__assign({ name: "TracingStartedInBrowser" }, meta), { cat: "disabled-by-default-devtools.timeline" })]
+ .map(function (v) { return JSON.stringify(v); }).join(",\n"));
+ }
+ tracing.startTracing = startTracing;
+ function stopTracing(typeCatalog) {
+ if (!traceFd) {
+ ts.Debug.assert(!fs, "Tracing is not in progress");
+ return;
+ }
+ ts.Debug.assert(fs);
+ fs.writeSync(traceFd, "\n]\n");
+ fs.closeSync(traceFd);
+ traceFd = undefined;
+ if (typeCatalog) {
+ dumpTypes(typeCatalog);
+ }
+ else {
+ legend[legend.length - 1].typesPath = undefined;
+ }
+ }
+ tracing.stopTracing = stopTracing;
+ function isTracing() {
+ return !!traceFd;
+ }
+ tracing.isTracing = isTracing;
+ function begin(phase, name, args) {
+ if (!traceFd)
+ return;
+ writeEvent("B", phase, name, args);
+ }
+ tracing.begin = begin;
+ function end(phase, name, args) {
+ if (!traceFd)
+ return;
+ writeEvent("E", phase, name, args);
+ }
+ tracing.end = end;
+ function instant(phase, name, args) {
+ if (!traceFd)
+ return;
+ writeEvent("I", phase, name, args, "\"s\":\"g\"");
+ }
+ tracing.instant = instant;
+ var completeEvents = [];
+ function push(phase, name, args) {
+ if (!traceFd)
+ return;
+ completeEvents.push({ phase: phase, name: name, args: args, time: 1000 * ts.timestamp() });
+ }
+ tracing.push = push;
+ function pop() {
+ if (!traceFd)
+ return;
+ ts.Debug.assert(completeEvents.length > 0);
+ var _a = completeEvents.pop(), phase = _a.phase, name = _a.name, args = _a.args, time = _a.time;
+ var dur = 1000 * ts.timestamp() - time;
+ writeEvent("X", phase, name, args, "\"dur\":" + dur, time);
+ }
+ tracing.pop = pop;
+ function writeEvent(eventType, phase, name, args, extras, time) {
+ if (time === void 0) { time = 1000 * ts.timestamp(); }
+ ts.Debug.assert(traceFd);
+ ts.Debug.assert(fs);
+ ts.performance.mark("beginTracing");
+ fs.writeSync(traceFd, ",\n{\"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, "}");
+ ts.performance.mark("endTracing");
+ ts.performance.measure("Tracing", "beginTracing", "endTracing");
+ }
+ function indexFromOne(lc) {
+ return {
+ line: lc.line + 1,
+ character: lc.character + 1,
+ };
+ }
+ function dumpTypes(types) {
+ var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+ ts.Debug.assert(fs);
+ ts.performance.mark("beginDumpTypes");
+ var typesPath = legend[legend.length - 1].typesPath;
+ var typesFd = fs.openSync(typesPath, "w");
+ var recursionIdentityMap = new ts.Map();
+ fs.writeSync(typesFd, "[");
+ var numTypes = types.length;
+ for (var i = 0; i < numTypes; i++) {
+ var type = types[i];
+ var objectFlags = type.objectFlags;
+ var symbol = (_a = type.aliasSymbol) !== null && _a !== void 0 ? _a : type.symbol;
+ var firstDeclaration = (_b = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _b === void 0 ? void 0 : _b[0];
+ var firstFile = firstDeclaration && ts.getSourceFileOfNode(firstDeclaration);
+ var display = void 0;
+ if ((objectFlags & 16) | (type.flags & 2944)) {
+ try {
+ display = (_c = type.checker) === null || _c === void 0 ? void 0 : _c.typeToString(type);
+ }
+ catch (_s) {
+ display = undefined;
+ }
+ }
+ var indexedAccessProperties = {};
+ if (type.flags & 8388608) {
+ var indexedAccessType = type;
+ indexedAccessProperties = {
+ indexedAccessObjectType: (_d = indexedAccessType.objectType) === null || _d === void 0 ? void 0 : _d.id,
+ indexedAccessIndexType: (_e = indexedAccessType.indexType) === null || _e === void 0 ? void 0 : _e.id,
+ };
+ }
+ var referenceProperties = {};
+ if (objectFlags & 4) {
+ var referenceType = type;
+ referenceProperties = {
+ instantiatedType: (_f = referenceType.target) === null || _f === void 0 ? void 0 : _f.id,
+ typeArguments: (_g = referenceType.resolvedTypeArguments) === null || _g === void 0 ? void 0 : _g.map(function (t) { return t.id; }),
+ };
+ }
+ var conditionalProperties = {};
+ if (type.flags & 16777216) {
+ var conditionalType = type;
+ conditionalProperties = {
+ conditionalCheckType: (_h = conditionalType.checkType) === null || _h === void 0 ? void 0 : _h.id,
+ conditionalExtendsType: (_j = conditionalType.extendsType) === null || _j === void 0 ? void 0 : _j.id,
+ conditionalTrueType: (_l = (_k = conditionalType.resolvedTrueType) === null || _k === void 0 ? void 0 : _k.id) !== null && _l !== void 0 ? _l : -1,
+ conditionalFalseType: (_o = (_m = conditionalType.resolvedFalseType) === null || _m === void 0 ? void 0 : _m.id) !== null && _o !== void 0 ? _o : -1,
+ };
+ }
+ var recursionToken = void 0;
+ var recursionIdentity = type.checker.getRecursionIdentity(type);
+ if (recursionIdentity) {
+ recursionToken = recursionIdentityMap.get(recursionIdentity);
+ if (!recursionToken) {
+ recursionToken = recursionIdentityMap.size;
+ recursionIdentityMap.set(recursionIdentity, recursionToken);
+ }
+ }
+ var descriptor = __assign(__assign(__assign(__assign({ id: type.id, intrinsicName: type.intrinsicName, symbolName: (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) && ts.unescapeLeadingUnderscores(symbol.escapedName), recursionId: recursionToken, unionTypes: (type.flags & 1048576) ? (_p = type.types) === null || _p === void 0 ? void 0 : _p.map(function (t) { return t.id; }) : undefined, intersectionTypes: (type.flags & 2097152) ? type.types.map(function (t) { return t.id; }) : undefined, aliasTypeArguments: (_q = type.aliasTypeArguments) === null || _q === void 0 ? void 0 : _q.map(function (t) { return t.id; }), keyofType: (type.flags & 4194304) ? (_r = type.type) === null || _r === void 0 ? void 0 : _r.id : undefined }, indexedAccessProperties), referenceProperties), conditionalProperties), { firstDeclaration: firstDeclaration && {
+ path: firstFile.path,
+ start: indexFromOne(ts.getLineAndCharacterOfPosition(firstFile, firstDeclaration.pos)),
+ end: indexFromOne(ts.getLineAndCharacterOfPosition(ts.getSourceFileOfNode(firstDeclaration), firstDeclaration.end)),
+ }, flags: ts.Debug.formatTypeFlags(type.flags).split("|"), display: display });
+ fs.writeSync(typesFd, JSON.stringify(descriptor));
+ if (i < numTypes - 1) {
+ fs.writeSync(typesFd, ",\n");
+ }
+ }
+ fs.writeSync(typesFd, "]\n");
+ fs.closeSync(typesFd);
+ ts.performance.mark("endDumpTypes");
+ ts.performance.measure("Dump types", "beginDumpTypes", "endDumpTypes");
+ }
+ function dumpLegend() {
+ if (!legendPath) {
+ return;
+ }
+ ts.Debug.assert(fs);
+ fs.writeFileSync(legendPath, JSON.stringify(legend));
+ }
+ tracing.dumpLegend = dumpLegend;
+ })(tracing = ts.tracing || (ts.tracing = {}));
+})(ts || (ts = {}));
+var ts;
(function (ts) {
var OperationCanceledException = (function () {
function OperationCanceledException() {
args: [{ name: "factory" }],
kind: 4
},
+ "jsxfrag": {
+ args: [{ name: "factory" }],
+ kind: 4
+ },
+ "jsximportsource": {
+ args: [{ name: "factory" }],
+ kind: 4
+ },
+ "jsxruntime": {
+ args: [{ name: "factory" }],
+ kind: 4
+ },
};
})(ts || (ts = {}));
var ts;
+(function (ts) {
+ ts.directorySeparator = "/";
+ var altDirectorySeparator = "\\";
+ var urlSchemeSeparator = "://";
+ var backslashRegExp = /\\/g;
+ function isAnyDirectorySeparator(charCode) {
+ return charCode === 47 || charCode === 92;
+ }
+ ts.isAnyDirectorySeparator = isAnyDirectorySeparator;
+ function isUrl(path) {
+ return getEncodedRootLength(path) < 0;
+ }
+ ts.isUrl = isUrl;
+ function isRootedDiskPath(path) {
+ return getEncodedRootLength(path) > 0;
+ }
+ ts.isRootedDiskPath = isRootedDiskPath;
+ function isDiskPathRoot(path) {
+ var rootLength = getEncodedRootLength(path);
+ return rootLength > 0 && rootLength === path.length;
+ }
+ ts.isDiskPathRoot = isDiskPathRoot;
+ function pathIsAbsolute(path) {
+ return getEncodedRootLength(path) !== 0;
+ }
+ ts.pathIsAbsolute = pathIsAbsolute;
+ function pathIsRelative(path) {
+ return /^\.\.?($|[\\/])/.test(path);
+ }
+ ts.pathIsRelative = pathIsRelative;
+ function pathIsBareSpecifier(path) {
+ return !pathIsAbsolute(path) && !pathIsRelative(path);
+ }
+ ts.pathIsBareSpecifier = pathIsBareSpecifier;
+ function hasExtension(fileName) {
+ return ts.stringContains(getBaseFileName(fileName), ".");
+ }
+ ts.hasExtension = hasExtension;
+ function fileExtensionIs(path, extension) {
+ return path.length > extension.length && ts.endsWith(path, extension);
+ }
+ ts.fileExtensionIs = fileExtensionIs;
+ function fileExtensionIsOneOf(path, extensions) {
+ for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) {
+ var extension = extensions_1[_i];
+ if (fileExtensionIs(path, extension)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ ts.fileExtensionIsOneOf = fileExtensionIsOneOf;
+ function hasTrailingDirectorySeparator(path) {
+ return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
+ }
+ ts.hasTrailingDirectorySeparator = hasTrailingDirectorySeparator;
+ function isVolumeCharacter(charCode) {
+ return (charCode >= 97 && charCode <= 122) ||
+ (charCode >= 65 && charCode <= 90);
+ }
+ function getFileUrlVolumeSeparatorEnd(url, start) {
+ var ch0 = url.charCodeAt(start);
+ if (ch0 === 58)
+ return start + 1;
+ if (ch0 === 37 && url.charCodeAt(start + 1) === 51) {
+ var ch2 = url.charCodeAt(start + 2);
+ if (ch2 === 97 || ch2 === 65)
+ return start + 3;
+ }
+ return -1;
+ }
+ function getEncodedRootLength(path) {
+ if (!path)
+ return 0;
+ var ch0 = path.charCodeAt(0);
+ if (ch0 === 47 || ch0 === 92) {
+ if (path.charCodeAt(1) !== ch0)
+ return 1;
+ var p1 = path.indexOf(ch0 === 47 ? ts.directorySeparator : altDirectorySeparator, 2);
+ if (p1 < 0)
+ return path.length;
+ return p1 + 1;
+ }
+ if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58) {
+ var ch2 = path.charCodeAt(2);
+ if (ch2 === 47 || ch2 === 92)
+ return 3;
+ if (path.length === 2)
+ return 2;
+ }
+ var schemeEnd = path.indexOf(urlSchemeSeparator);
+ if (schemeEnd !== -1) {
+ var authorityStart = schemeEnd + urlSchemeSeparator.length;
+ var authorityEnd = path.indexOf(ts.directorySeparator, authorityStart);
+ if (authorityEnd !== -1) {
+ var scheme = path.slice(0, schemeEnd);
+ var authority = path.slice(authorityStart, authorityEnd);
+ if (scheme === "file" && (authority === "" || authority === "localhost") &&
+ isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
+ var volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
+ if (volumeSeparatorEnd !== -1) {
+ if (path.charCodeAt(volumeSeparatorEnd) === 47) {
+ return ~(volumeSeparatorEnd + 1);
+ }
+ if (volumeSeparatorEnd === path.length) {
+ return ~volumeSeparatorEnd;
+ }
+ }
+ }
+ return ~(authorityEnd + 1);
+ }
+ return ~path.length;
+ }
+ return 0;
+ }
+ function getRootLength(path) {
+ var rootLength = getEncodedRootLength(path);
+ return rootLength < 0 ? ~rootLength : rootLength;
+ }
+ ts.getRootLength = getRootLength;
+ function getDirectoryPath(path) {
+ path = normalizeSlashes(path);
+ var rootLength = getRootLength(path);
+ if (rootLength === path.length)
+ return path;
+ path = removeTrailingDirectorySeparator(path);
+ return path.slice(0, Math.max(rootLength, path.lastIndexOf(ts.directorySeparator)));
+ }
+ ts.getDirectoryPath = getDirectoryPath;
+ function getBaseFileName(path, extensions, ignoreCase) {
+ path = normalizeSlashes(path);
+ var rootLength = getRootLength(path);
+ if (rootLength === path.length)
+ return "";
+ path = removeTrailingDirectorySeparator(path);
+ var name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(ts.directorySeparator) + 1));
+ var extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined;
+ return extension ? name.slice(0, name.length - extension.length) : name;
+ }
+ ts.getBaseFileName = getBaseFileName;
+ function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
+ if (!ts.startsWith(extension, "."))
+ extension = "." + extension;
+ if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46) {
+ var pathExtension = path.slice(path.length - extension.length);
+ if (stringEqualityComparer(pathExtension, extension)) {
+ return pathExtension;
+ }
+ }
+ }
+ function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) {
+ if (typeof extensions === "string") {
+ return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || "";
+ }
+ for (var _i = 0, extensions_2 = extensions; _i < extensions_2.length; _i++) {
+ var extension = extensions_2[_i];
+ var result = tryGetExtensionFromPath(path, extension, stringEqualityComparer);
+ if (result)
+ return result;
+ }
+ return "";
+ }
+ function getAnyExtensionFromPath(path, extensions, ignoreCase) {
+ if (extensions) {
+ return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive);
+ }
+ var baseFileName = getBaseFileName(path);
+ var extensionIndex = baseFileName.lastIndexOf(".");
+ if (extensionIndex >= 0) {
+ return baseFileName.substring(extensionIndex);
+ }
+ return "";
+ }
+ ts.getAnyExtensionFromPath = getAnyExtensionFromPath;
+ function pathComponents(path, rootLength) {
+ var root = path.substring(0, rootLength);
+ var rest = path.substring(rootLength).split(ts.directorySeparator);
+ if (rest.length && !ts.lastOrUndefined(rest))
+ rest.pop();
+ return __spreadArrays([root], rest);
+ }
+ function getPathComponents(path, currentDirectory) {
+ if (currentDirectory === void 0) { currentDirectory = ""; }
+ path = combinePaths(currentDirectory, path);
+ return pathComponents(path, getRootLength(path));
+ }
+ ts.getPathComponents = getPathComponents;
+ function getPathFromPathComponents(pathComponents) {
+ if (pathComponents.length === 0)
+ return "";
+ var root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]);
+ return root + pathComponents.slice(1).join(ts.directorySeparator);
+ }
+ ts.getPathFromPathComponents = getPathFromPathComponents;
+ function normalizeSlashes(path) {
+ return path.replace(backslashRegExp, ts.directorySeparator);
+ }
+ ts.normalizeSlashes = normalizeSlashes;
+ function reducePathComponents(components) {
+ if (!ts.some(components))
+ return [];
+ var reduced = [components[0]];
+ for (var i = 1; i < components.length; i++) {
+ var component = components[i];
+ if (!component)
+ continue;
+ if (component === ".")
+ continue;
+ if (component === "..") {
+ if (reduced.length > 1) {
+ if (reduced[reduced.length - 1] !== "..") {
+ reduced.pop();
+ continue;
+ }
+ }
+ else if (reduced[0])
+ continue;
+ }
+ reduced.push(component);
+ }
+ return reduced;
+ }
+ ts.reducePathComponents = reducePathComponents;
+ function combinePaths(path) {
+ var paths = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ paths[_i - 1] = arguments[_i];
+ }
+ if (path)
+ path = normalizeSlashes(path);
+ for (var _a = 0, paths_1 = paths; _a < paths_1.length; _a++) {
+ var relativePath = paths_1[_a];
+ if (!relativePath)
+ continue;
+ relativePath = normalizeSlashes(relativePath);
+ if (!path || getRootLength(relativePath) !== 0) {
+ path = relativePath;
+ }
+ else {
+ path = ensureTrailingDirectorySeparator(path) + relativePath;
+ }
+ }
+ return path;
+ }
+ ts.combinePaths = combinePaths;
+ function resolvePath(path) {
+ var paths = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ paths[_i - 1] = arguments[_i];
+ }
+ return normalizePath(ts.some(paths) ? combinePaths.apply(void 0, __spreadArrays([path], paths)) : normalizeSlashes(path));
+ }
+ ts.resolvePath = resolvePath;
+ function getNormalizedPathComponents(path, currentDirectory) {
+ return reducePathComponents(getPathComponents(path, currentDirectory));
+ }
+ ts.getNormalizedPathComponents = getNormalizedPathComponents;
+ function getNormalizedAbsolutePath(fileName, currentDirectory) {
+ return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory));
+ }
+ ts.getNormalizedAbsolutePath = getNormalizedAbsolutePath;
+ function normalizePath(path) {
+ path = normalizeSlashes(path);
+ var normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
+ return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+ }
+ ts.normalizePath = normalizePath;
+ function getPathWithoutRoot(pathComponents) {
+ if (pathComponents.length === 0)
+ return "";
+ return pathComponents.slice(1).join(ts.directorySeparator);
+ }
+ function getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory) {
+ return getPathWithoutRoot(getNormalizedPathComponents(fileName, currentDirectory));
+ }
+ ts.getNormalizedAbsolutePathWithoutRoot = getNormalizedAbsolutePathWithoutRoot;
+ function toPath(fileName, basePath, getCanonicalFileName) {
+ var nonCanonicalizedPath = isRootedDiskPath(fileName)
+ ? normalizePath(fileName)
+ : getNormalizedAbsolutePath(fileName, basePath);
+ return getCanonicalFileName(nonCanonicalizedPath);
+ }
+ ts.toPath = toPath;
+ function normalizePathAndParts(path) {
+ path = normalizeSlashes(path);
+ var _a = reducePathComponents(getPathComponents(path)), root = _a[0], parts = _a.slice(1);
+ if (parts.length) {
+ var joinedParts = root + parts.join(ts.directorySeparator);
+ return { path: hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(joinedParts) : joinedParts, parts: parts };
+ }
+ else {
+ return { path: root, parts: parts };
+ }
+ }
+ ts.normalizePathAndParts = normalizePathAndParts;
+ function removeTrailingDirectorySeparator(path) {
+ if (hasTrailingDirectorySeparator(path)) {
+ return path.substr(0, path.length - 1);
+ }
+ return path;
+ }
+ ts.removeTrailingDirectorySeparator = removeTrailingDirectorySeparator;
+ function ensureTrailingDirectorySeparator(path) {
+ if (!hasTrailingDirectorySeparator(path)) {
+ return path + ts.directorySeparator;
+ }
+ return path;
+ }
+ ts.ensureTrailingDirectorySeparator = ensureTrailingDirectorySeparator;
+ function ensurePathIsNonModuleName(path) {
+ return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path;
+ }
+ ts.ensurePathIsNonModuleName = ensurePathIsNonModuleName;
+ function changeAnyExtension(path, ext, extensions, ignoreCase) {
+ var pathext = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path);
+ return pathext ? path.slice(0, path.length - pathext.length) + (ts.startsWith(ext, ".") ? ext : "." + ext) : path;
+ }
+ ts.changeAnyExtension = changeAnyExtension;
+ var relativePathSegmentRegExp = /(^|\/)\.{0,2}($|\/)/;
+ function comparePathsWorker(a, b, componentComparer) {
+ if (a === b)
+ return 0;
+ if (a === undefined)
+ return -1;
+ if (b === undefined)
+ return 1;
+ var aRoot = a.substring(0, getRootLength(a));
+ var bRoot = b.substring(0, getRootLength(b));
+ var result = ts.compareStringsCaseInsensitive(aRoot, bRoot);
+ if (result !== 0) {
+ return result;
+ }
+ var aRest = a.substring(aRoot.length);
+ var bRest = b.substring(bRoot.length);
+ if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) {
+ return componentComparer(aRest, bRest);
+ }
+ var aComponents = reducePathComponents(getPathComponents(a));
+ var bComponents = reducePathComponents(getPathComponents(b));
+ var sharedLength = Math.min(aComponents.length, bComponents.length);
+ for (var i = 1; i < sharedLength; i++) {
+ var result_2 = componentComparer(aComponents[i], bComponents[i]);
+ if (result_2 !== 0) {
+ return result_2;
+ }
+ }
+ return ts.compareValues(aComponents.length, bComponents.length);
+ }
+ function comparePathsCaseSensitive(a, b) {
+ return comparePathsWorker(a, b, ts.compareStringsCaseSensitive);
+ }
+ ts.comparePathsCaseSensitive = comparePathsCaseSensitive;
+ function comparePathsCaseInsensitive(a, b) {
+ return comparePathsWorker(a, b, ts.compareStringsCaseInsensitive);
+ }
+ ts.comparePathsCaseInsensitive = comparePathsCaseInsensitive;
+ function comparePaths(a, b, currentDirectory, ignoreCase) {
+ if (typeof currentDirectory === "string") {
+ a = combinePaths(currentDirectory, a);
+ b = combinePaths(currentDirectory, b);
+ }
+ else if (typeof currentDirectory === "boolean") {
+ ignoreCase = currentDirectory;
+ }
+ return comparePathsWorker(a, b, ts.getStringComparer(ignoreCase));
+ }
+ ts.comparePaths = comparePaths;
+ function containsPath(parent, child, currentDirectory, ignoreCase) {
+ if (typeof currentDirectory === "string") {
+ parent = combinePaths(currentDirectory, parent);
+ child = combinePaths(currentDirectory, child);
+ }
+ else if (typeof currentDirectory === "boolean") {
+ ignoreCase = currentDirectory;
+ }
+ if (parent === undefined || child === undefined)
+ return false;
+ if (parent === child)
+ return true;
+ var parentComponents = reducePathComponents(getPathComponents(parent));
+ var childComponents = reducePathComponents(getPathComponents(child));
+ if (childComponents.length < parentComponents.length) {
+ return false;
+ }
+ var componentEqualityComparer = ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive;
+ for (var i = 0; i < parentComponents.length; i++) {
+ var equalityComparer = i === 0 ? ts.equateStringsCaseInsensitive : componentEqualityComparer;
+ if (!equalityComparer(parentComponents[i], childComponents[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ ts.containsPath = containsPath;
+ function startsWithDirectory(fileName, directoryName, getCanonicalFileName) {
+ var canonicalFileName = getCanonicalFileName(fileName);
+ var canonicalDirectoryName = getCanonicalFileName(directoryName);
+ return ts.startsWith(canonicalFileName, canonicalDirectoryName + "/") || ts.startsWith(canonicalFileName, canonicalDirectoryName + "\\");
+ }
+ ts.startsWithDirectory = startsWithDirectory;
+ function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) {
+ var fromComponents = reducePathComponents(getPathComponents(from));
+ var toComponents = reducePathComponents(getPathComponents(to));
+ var start;
+ for (start = 0; start < fromComponents.length && start < toComponents.length; start++) {
+ var fromComponent = getCanonicalFileName(fromComponents[start]);
+ var toComponent = getCanonicalFileName(toComponents[start]);
+ var comparer = start === 0 ? ts.equateStringsCaseInsensitive : stringEqualityComparer;
+ if (!comparer(fromComponent, toComponent))
+ break;
+ }
+ if (start === 0) {
+ return toComponents;
+ }
+ var components = toComponents.slice(start);
+ var relative = [];
+ for (; start < fromComponents.length; start++) {
+ relative.push("..");
+ }
+ return __spreadArrays([""], relative, components);
+ }
+ ts.getPathComponentsRelativeTo = getPathComponentsRelativeTo;
+ function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
+ ts.Debug.assert((getRootLength(fromDirectory) > 0) === (getRootLength(to) > 0), "Paths must either both be absolute or both be relative");
+ var getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : ts.identity;
+ var ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false;
+ var pathComponents = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive, getCanonicalFileName);
+ return getPathFromPathComponents(pathComponents);
+ }
+ ts.getRelativePathFromDirectory = getRelativePathFromDirectory;
+ function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
+ return !isRootedDiskPath(absoluteOrRelativePath)
+ ? absoluteOrRelativePath
+ : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false);
+ }
+ ts.convertToRelativePath = convertToRelativePath;
+ function getRelativePathFromFile(from, to, getCanonicalFileName) {
+ return ensurePathIsNonModuleName(getRelativePathFromDirectory(getDirectoryPath(from), to, getCanonicalFileName));
+ }
+ ts.getRelativePathFromFile = getRelativePathFromFile;
+ function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) {
+ var pathComponents = getPathComponentsRelativeTo(resolvePath(currentDirectory, directoryPathOrUrl), resolvePath(currentDirectory, relativeOrAbsolutePath), ts.equateStringsCaseSensitive, getCanonicalFileName);
+ var firstComponent = pathComponents[0];
+ if (isAbsolutePathAnUrl && isRootedDiskPath(firstComponent)) {
+ var prefix = firstComponent.charAt(0) === ts.directorySeparator ? "file://" : "file:///";
+ pathComponents[0] = prefix + firstComponent;
+ }
+ return getPathFromPathComponents(pathComponents);
+ }
+ ts.getRelativePathToDirectoryOrUrl = getRelativePathToDirectoryOrUrl;
+ function forEachAncestorDirectory(directory, callback) {
+ while (true) {
+ var result = callback(directory);
+ if (result !== undefined) {
+ return result;
+ }
+ var parentPath = getDirectoryPath(directory);
+ if (parentPath === directory) {
+ return undefined;
+ }
+ directory = parentPath;
+ }
+ }
+ ts.forEachAncestorDirectory = forEachAncestorDirectory;
+ function isNodeModulesDirectory(dirPath) {
+ return ts.endsWith(dirPath, "/node_modules");
+ }
+ ts.isNodeModulesDirectory = isNodeModulesDirectory;
+})(ts || (ts = {}));
+var ts;
(function (ts) {
function generateDjb2Hash(data) {
var acc = 5381;
ts.createDynamicPriorityPollingWatchFile = createDynamicPriorityPollingWatchFile;
function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames) {
var fileWatcherCallbacks = ts.createMultiMap();
- var dirWatchers = ts.createMap();
+ var dirWatchers = new ts.Map();
var toCanonicalName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
return nonPollingWatchFile;
function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) {
}
}
function createSingleFileWatcherPerName(watchFile, useCaseSensitiveFileNames) {
- var cache = ts.createMap();
+ var cache = new ts.Map();
var callbacksCache = ts.createMultiMap();
var toCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
return function (fileName, callback, pollingInterval, options) {
}
ts.setSysLog = setSysLog;
function createDirectoryWatcherSupportingRecursive(host) {
- var cache = ts.createMap();
+ var cache = new ts.Map();
var callbackCache = ts.createMultiMap();
- var cacheToUpdateChildWatches = ts.createMap();
+ var cacheToUpdateChildWatches = new ts.Map();
var timerToUpdateChildWatches;
var filePathComparer = ts.getStringComparer(!host.useCaseSensitiveFileNames);
var toCanonicalFilePath = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames);
}
};
}
- function invokeCallbacks(dirPath, fileNameOrInvokeMap) {
+ function invokeCallbacks(dirPath, fileNameOrInvokeMap, fileNames) {
var fileName;
var invokeMap;
if (ts.isString(fileNameOrInvokeMap)) {
invokeMap = fileNameOrInvokeMap;
}
callbackCache.forEach(function (callbacks, rootDirName) {
- if (invokeMap && invokeMap.has(rootDirName))
+ var _a;
+ if (invokeMap && invokeMap.get(rootDirName) === true)
return;
if (rootDirName === dirPath || (ts.startsWith(dirPath, rootDirName) && dirPath[rootDirName.length] === ts.directorySeparator)) {
if (invokeMap) {
- invokeMap.set(rootDirName, true);
+ if (fileNames) {
+ var existing = invokeMap.get(rootDirName);
+ if (existing) {
+ (_a = existing).push.apply(_a, fileNames);
+ }
+ else {
+ invokeMap.set(rootDirName, fileNames.slice());
+ }
+ }
+ else {
+ invokeMap.set(rootDirName, true);
+ }
}
else {
callbacks.forEach(function (_a) {
function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
var parentWatcher = cache.get(dirPath);
if (parentWatcher && host.directoryExists(dirName)) {
- scheduleUpdateChildWatches(dirName, dirPath, options);
+ scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
return;
}
invokeCallbacks(dirPath, fileName);
removeChildWatches(parentWatcher);
}
- function scheduleUpdateChildWatches(dirName, dirPath, options) {
- if (!cacheToUpdateChildWatches.has(dirPath)) {
- cacheToUpdateChildWatches.set(dirPath, { dirName: dirName, options: options });
+ function scheduleUpdateChildWatches(dirName, dirPath, fileName, options) {
+ var existing = cacheToUpdateChildWatches.get(dirPath);
+ if (existing) {
+ existing.fileNames.push(fileName);
+ }
+ else {
+ cacheToUpdateChildWatches.set(dirPath, { dirName: dirName, options: options, fileNames: [fileName] });
}
if (timerToUpdateChildWatches) {
host.clearTimeout(timerToUpdateChildWatches);
timerToUpdateChildWatches = undefined;
ts.sysLog("sysLog:: onTimerToUpdateChildWatches:: " + cacheToUpdateChildWatches.size);
var start = ts.timestamp();
- var invokeMap = ts.createMap();
+ var invokeMap = new ts.Map();
while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) {
- var _a = cacheToUpdateChildWatches.entries().next(), _b = _a.value, dirPath = _b[0], _c = _b[1], dirName = _c.dirName, options = _c.options, done = _a.done;
+ var _a = cacheToUpdateChildWatches.entries().next(), _b = _a.value, dirPath = _b[0], _c = _b[1], dirName = _c.dirName, options = _c.options, fileNames = _c.fileNames, done = _a.done;
ts.Debug.assert(!done);
cacheToUpdateChildWatches.delete(dirPath);
- invokeCallbacks(dirPath, invokeMap);
- updateChildWatches(dirName, dirPath, options);
+ var hasChanges = updateChildWatches(dirName, dirPath, options);
+ invokeCallbacks(dirPath, invokeMap, hasChanges ? undefined : fileNames);
}
ts.sysLog("sysLog:: invokingWatchers:: " + (ts.timestamp() - start) + "ms:: " + cacheToUpdateChildWatches.size);
callbackCache.forEach(function (callbacks, rootDirName) {
- if (invokeMap.has(rootDirName)) {
+ var existing = invokeMap.get(rootDirName);
+ if (existing) {
callbacks.forEach(function (_a) {
var callback = _a.callback, dirName = _a.dirName;
- return callback(dirName);
+ if (ts.isArray(existing)) {
+ existing.forEach(callback);
+ }
+ else {
+ callback(dirName);
+ }
});
}
});
removeChildWatches(cache.get(toCanonicalFilePath(childWatcher.dirName)));
}
}
- function updateChildWatches(dirName, dirPath, options) {
- var parentWatcher = cache.get(dirPath);
- if (parentWatcher) {
- parentWatcher.childWatches = watchChildDirectories(dirName, parentWatcher.childWatches, options);
- }
- }
- function watchChildDirectories(parentDir, existingChildWatches, options) {
+ function updateChildWatches(parentDir, parentDirPath, options) {
+ var parentWatcher = cache.get(parentDirPath);
+ if (!parentWatcher)
+ return false;
var newChildWatches;
- ts.enumerateInsertsAndDeletes(host.directoryExists(parentDir) ? ts.mapDefined(host.getAccessibleSortedChildDirectories(parentDir), function (child) {
+ var hasChanges = ts.enumerateInsertsAndDeletes(host.directoryExists(parentDir) ? ts.mapDefined(host.getAccessibleSortedChildDirectories(parentDir), function (child) {
var childFullName = ts.getNormalizedAbsolutePath(child, parentDir);
return !isIgnoredPath(childFullName) && filePathComparer(childFullName, ts.normalizePath(host.realpath(childFullName))) === 0 ? childFullName : undefined;
- }) : ts.emptyArray, existingChildWatches, function (child, childWatcher) { return filePathComparer(child, childWatcher.dirName); }, createAndAddChildDirectoryWatcher, ts.closeFileWatcher, addChildDirectoryWatcher);
- return newChildWatches || ts.emptyArray;
+ }) : ts.emptyArray, parentWatcher.childWatches, function (child, childWatcher) { return filePathComparer(child, childWatcher.dirName); }, createAndAddChildDirectoryWatcher, ts.closeFileWatcher, addChildDirectoryWatcher);
+ parentWatcher.childWatches = newChildWatches || ts.emptyArray;
+ return hasChanges;
function createAndAddChildDirectoryWatcher(childName) {
var result = createDirectoryWatcher(childName, options);
addChildDirectoryWatcher(result);
enableCPUProfiler: enableCPUProfiler,
disableCPUProfiler: disableCPUProfiler,
realpath: realpath,
- debugMode: !!process.env.NODE_INSPECTOR_IPC || ts.some(process.execArgv, function (arg) { return /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg); }),
+ debugMode: !!process.env.NODE_INSPECTOR_IPC || !!process.env.VSCODE_INSPECTOR_OPTIONS || ts.some(process.execArgv, function (arg) { return /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg); }),
tryEnableSourceMapsForHost: function () {
try {
require("source-map-support").install();
}
function cleanupPaths(profile) {
var externalFileCounter = 0;
- var remappedPaths = ts.createMap();
+ var remappedPaths = new ts.Map();
var normalizedDir = ts.normalizeSlashes(__dirname);
var fileUrlRoot = "file://" + (ts.getRootLength(normalizedDir) === 1 ? "" : "/") + normalizedDir;
for (var _i = 0, _a = profile.nodes; _i < _a.length; _i++) {
var entries = _fs.readdirSync(path || ".", { withFileTypes: true });
var files = [];
var directories = [];
- for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
- var dirent = entries_2[_i];
+ for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+ var dirent = entries_1[_i];
var entry = typeof dirent === "string" ? dirent : dirent.name;
if (entry === "." || entry === "..") {
continue;
return ts.matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
}
function fileSystemEntryExists(path, entryKind) {
+ var originalStackTraceLimit = Error.stackTraceLimit;
+ Error.stackTraceLimit = 0;
try {
var stat = _fs.statSync(path);
switch (entryKind) {
catch (e) {
return false;
}
+ finally {
+ Error.stackTraceLimit = originalStackTraceLimit;
+ }
}
function fileExists(path) {
return fileSystemEntryExists(path, 0);
})(ts || (ts = {}));
var ts;
(function (ts) {
- ts.directorySeparator = "/";
- var altDirectorySeparator = "\\";
- var urlSchemeSeparator = "://";
- var backslashRegExp = /\\/g;
- function isAnyDirectorySeparator(charCode) {
- return charCode === 47 || charCode === 92;
- }
- ts.isAnyDirectorySeparator = isAnyDirectorySeparator;
- function isUrl(path) {
- return getEncodedRootLength(path) < 0;
- }
- ts.isUrl = isUrl;
- function isRootedDiskPath(path) {
- return getEncodedRootLength(path) > 0;
- }
- ts.isRootedDiskPath = isRootedDiskPath;
- function isDiskPathRoot(path) {
- var rootLength = getEncodedRootLength(path);
- return rootLength > 0 && rootLength === path.length;
- }
- ts.isDiskPathRoot = isDiskPathRoot;
- function pathIsAbsolute(path) {
- return getEncodedRootLength(path) !== 0;
- }
- ts.pathIsAbsolute = pathIsAbsolute;
- function pathIsRelative(path) {
- return /^\.\.?($|[\\/])/.test(path);
- }
- ts.pathIsRelative = pathIsRelative;
- function hasExtension(fileName) {
- return ts.stringContains(getBaseFileName(fileName), ".");
- }
- ts.hasExtension = hasExtension;
- function fileExtensionIs(path, extension) {
- return path.length > extension.length && ts.endsWith(path, extension);
- }
- ts.fileExtensionIs = fileExtensionIs;
- function fileExtensionIsOneOf(path, extensions) {
- for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) {
- var extension = extensions_1[_i];
- if (fileExtensionIs(path, extension)) {
- return true;
- }
- }
- return false;
- }
- ts.fileExtensionIsOneOf = fileExtensionIsOneOf;
- function hasTrailingDirectorySeparator(path) {
- return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
- }
- ts.hasTrailingDirectorySeparator = hasTrailingDirectorySeparator;
- function isVolumeCharacter(charCode) {
- return (charCode >= 97 && charCode <= 122) ||
- (charCode >= 65 && charCode <= 90);
- }
- function getFileUrlVolumeSeparatorEnd(url, start) {
- var ch0 = url.charCodeAt(start);
- if (ch0 === 58)
- return start + 1;
- if (ch0 === 37 && url.charCodeAt(start + 1) === 51) {
- var ch2 = url.charCodeAt(start + 2);
- if (ch2 === 97 || ch2 === 65)
- return start + 3;
- }
- return -1;
- }
- function getEncodedRootLength(path) {
- if (!path)
- return 0;
- var ch0 = path.charCodeAt(0);
- if (ch0 === 47 || ch0 === 92) {
- if (path.charCodeAt(1) !== ch0)
- return 1;
- var p1 = path.indexOf(ch0 === 47 ? ts.directorySeparator : altDirectorySeparator, 2);
- if (p1 < 0)
- return path.length;
- return p1 + 1;
- }
- if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58) {
- var ch2 = path.charCodeAt(2);
- if (ch2 === 47 || ch2 === 92)
- return 3;
- if (path.length === 2)
- return 2;
- }
- var schemeEnd = path.indexOf(urlSchemeSeparator);
- if (schemeEnd !== -1) {
- var authorityStart = schemeEnd + urlSchemeSeparator.length;
- var authorityEnd = path.indexOf(ts.directorySeparator, authorityStart);
- if (authorityEnd !== -1) {
- var scheme = path.slice(0, schemeEnd);
- var authority = path.slice(authorityStart, authorityEnd);
- if (scheme === "file" && (authority === "" || authority === "localhost") &&
- isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
- var volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
- if (volumeSeparatorEnd !== -1) {
- if (path.charCodeAt(volumeSeparatorEnd) === 47) {
- return ~(volumeSeparatorEnd + 1);
- }
- if (volumeSeparatorEnd === path.length) {
- return ~volumeSeparatorEnd;
- }
- }
- }
- return ~(authorityEnd + 1);
- }
- return ~path.length;
- }
- return 0;
- }
- function getRootLength(path) {
- var rootLength = getEncodedRootLength(path);
- return rootLength < 0 ? ~rootLength : rootLength;
- }
- ts.getRootLength = getRootLength;
- function getDirectoryPath(path) {
- path = normalizeSlashes(path);
- var rootLength = getRootLength(path);
- if (rootLength === path.length)
- return path;
- path = removeTrailingDirectorySeparator(path);
- return path.slice(0, Math.max(rootLength, path.lastIndexOf(ts.directorySeparator)));
- }
- ts.getDirectoryPath = getDirectoryPath;
- function getBaseFileName(path, extensions, ignoreCase) {
- path = normalizeSlashes(path);
- var rootLength = getRootLength(path);
- if (rootLength === path.length)
- return "";
- path = removeTrailingDirectorySeparator(path);
- var name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(ts.directorySeparator) + 1));
- var extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined;
- return extension ? name.slice(0, name.length - extension.length) : name;
- }
- ts.getBaseFileName = getBaseFileName;
- function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
- if (!ts.startsWith(extension, "."))
- extension = "." + extension;
- if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46) {
- var pathExtension = path.slice(path.length - extension.length);
- if (stringEqualityComparer(pathExtension, extension)) {
- return pathExtension;
- }
- }
- }
- function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) {
- if (typeof extensions === "string") {
- return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || "";
- }
- for (var _i = 0, extensions_2 = extensions; _i < extensions_2.length; _i++) {
- var extension = extensions_2[_i];
- var result = tryGetExtensionFromPath(path, extension, stringEqualityComparer);
- if (result)
- return result;
- }
- return "";
- }
- function getAnyExtensionFromPath(path, extensions, ignoreCase) {
- if (extensions) {
- return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive);
- }
- var baseFileName = getBaseFileName(path);
- var extensionIndex = baseFileName.lastIndexOf(".");
- if (extensionIndex >= 0) {
- return baseFileName.substring(extensionIndex);
- }
- return "";
- }
- ts.getAnyExtensionFromPath = getAnyExtensionFromPath;
- function pathComponents(path, rootLength) {
- var root = path.substring(0, rootLength);
- var rest = path.substring(rootLength).split(ts.directorySeparator);
- if (rest.length && !ts.lastOrUndefined(rest))
- rest.pop();
- return __spreadArrays([root], rest);
- }
- function getPathComponents(path, currentDirectory) {
- if (currentDirectory === void 0) { currentDirectory = ""; }
- path = combinePaths(currentDirectory, path);
- return pathComponents(path, getRootLength(path));
- }
- ts.getPathComponents = getPathComponents;
- function getPathFromPathComponents(pathComponents) {
- if (pathComponents.length === 0)
- return "";
- var root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]);
- return root + pathComponents.slice(1).join(ts.directorySeparator);
- }
- ts.getPathFromPathComponents = getPathFromPathComponents;
- function normalizeSlashes(path) {
- return path.replace(backslashRegExp, ts.directorySeparator);
- }
- ts.normalizeSlashes = normalizeSlashes;
- function reducePathComponents(components) {
- if (!ts.some(components))
- return [];
- var reduced = [components[0]];
- for (var i = 1; i < components.length; i++) {
- var component = components[i];
- if (!component)
- continue;
- if (component === ".")
- continue;
- if (component === "..") {
- if (reduced.length > 1) {
- if (reduced[reduced.length - 1] !== "..") {
- reduced.pop();
- continue;
- }
- }
- else if (reduced[0])
- continue;
- }
- reduced.push(component);
- }
- return reduced;
- }
- ts.reducePathComponents = reducePathComponents;
- function combinePaths(path) {
- var paths = [];
- for (var _i = 1; _i < arguments.length; _i++) {
- paths[_i - 1] = arguments[_i];
- }
- if (path)
- path = normalizeSlashes(path);
- for (var _a = 0, paths_1 = paths; _a < paths_1.length; _a++) {
- var relativePath = paths_1[_a];
- if (!relativePath)
- continue;
- relativePath = normalizeSlashes(relativePath);
- if (!path || getRootLength(relativePath) !== 0) {
- path = relativePath;
- }
- else {
- path = ensureTrailingDirectorySeparator(path) + relativePath;
- }
- }
- return path;
- }
- ts.combinePaths = combinePaths;
- function resolvePath(path) {
- var paths = [];
- for (var _i = 1; _i < arguments.length; _i++) {
- paths[_i - 1] = arguments[_i];
- }
- return normalizePath(ts.some(paths) ? combinePaths.apply(void 0, __spreadArrays([path], paths)) : normalizeSlashes(path));
- }
- ts.resolvePath = resolvePath;
- function getNormalizedPathComponents(path, currentDirectory) {
- return reducePathComponents(getPathComponents(path, currentDirectory));
- }
- ts.getNormalizedPathComponents = getNormalizedPathComponents;
- function getNormalizedAbsolutePath(fileName, currentDirectory) {
- return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory));
- }
- ts.getNormalizedAbsolutePath = getNormalizedAbsolutePath;
- function normalizePath(path) {
- path = normalizeSlashes(path);
- var normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
- return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized;
- }
- ts.normalizePath = normalizePath;
- function getPathWithoutRoot(pathComponents) {
- if (pathComponents.length === 0)
- return "";
- return pathComponents.slice(1).join(ts.directorySeparator);
- }
- function getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory) {
- return getPathWithoutRoot(getNormalizedPathComponents(fileName, currentDirectory));
- }
- ts.getNormalizedAbsolutePathWithoutRoot = getNormalizedAbsolutePathWithoutRoot;
- function toPath(fileName, basePath, getCanonicalFileName) {
- var nonCanonicalizedPath = isRootedDiskPath(fileName)
- ? normalizePath(fileName)
- : getNormalizedAbsolutePath(fileName, basePath);
- return getCanonicalFileName(nonCanonicalizedPath);
- }
- ts.toPath = toPath;
- function normalizePathAndParts(path) {
- path = normalizeSlashes(path);
- var _a = reducePathComponents(getPathComponents(path)), root = _a[0], parts = _a.slice(1);
- if (parts.length) {
- var joinedParts = root + parts.join(ts.directorySeparator);
- return { path: hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(joinedParts) : joinedParts, parts: parts };
- }
- else {
- return { path: root, parts: parts };
- }
- }
- ts.normalizePathAndParts = normalizePathAndParts;
- function removeTrailingDirectorySeparator(path) {
- if (hasTrailingDirectorySeparator(path)) {
- return path.substr(0, path.length - 1);
- }
- return path;
- }
- ts.removeTrailingDirectorySeparator = removeTrailingDirectorySeparator;
- function ensureTrailingDirectorySeparator(path) {
- if (!hasTrailingDirectorySeparator(path)) {
- return path + ts.directorySeparator;
- }
- return path;
- }
- ts.ensureTrailingDirectorySeparator = ensureTrailingDirectorySeparator;
- function ensurePathIsNonModuleName(path) {
- return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path;
- }
- ts.ensurePathIsNonModuleName = ensurePathIsNonModuleName;
- function changeAnyExtension(path, ext, extensions, ignoreCase) {
- var pathext = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path);
- return pathext ? path.slice(0, path.length - pathext.length) + (ts.startsWith(ext, ".") ? ext : "." + ext) : path;
- }
- ts.changeAnyExtension = changeAnyExtension;
- var relativePathSegmentRegExp = /(^|\/)\.{0,2}($|\/)/;
- function comparePathsWorker(a, b, componentComparer) {
- if (a === b)
- return 0;
- if (a === undefined)
- return -1;
- if (b === undefined)
- return 1;
- var aRoot = a.substring(0, getRootLength(a));
- var bRoot = b.substring(0, getRootLength(b));
- var result = ts.compareStringsCaseInsensitive(aRoot, bRoot);
- if (result !== 0) {
- return result;
- }
- var aRest = a.substring(aRoot.length);
- var bRest = b.substring(bRoot.length);
- if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) {
- return componentComparer(aRest, bRest);
- }
- var aComponents = reducePathComponents(getPathComponents(a));
- var bComponents = reducePathComponents(getPathComponents(b));
- var sharedLength = Math.min(aComponents.length, bComponents.length);
- for (var i = 1; i < sharedLength; i++) {
- var result_1 = componentComparer(aComponents[i], bComponents[i]);
- if (result_1 !== 0) {
- return result_1;
- }
- }
- return ts.compareValues(aComponents.length, bComponents.length);
- }
- function comparePathsCaseSensitive(a, b) {
- return comparePathsWorker(a, b, ts.compareStringsCaseSensitive);
- }
- ts.comparePathsCaseSensitive = comparePathsCaseSensitive;
- function comparePathsCaseInsensitive(a, b) {
- return comparePathsWorker(a, b, ts.compareStringsCaseInsensitive);
- }
- ts.comparePathsCaseInsensitive = comparePathsCaseInsensitive;
- function comparePaths(a, b, currentDirectory, ignoreCase) {
- if (typeof currentDirectory === "string") {
- a = combinePaths(currentDirectory, a);
- b = combinePaths(currentDirectory, b);
- }
- else if (typeof currentDirectory === "boolean") {
- ignoreCase = currentDirectory;
- }
- return comparePathsWorker(a, b, ts.getStringComparer(ignoreCase));
- }
- ts.comparePaths = comparePaths;
- function containsPath(parent, child, currentDirectory, ignoreCase) {
- if (typeof currentDirectory === "string") {
- parent = combinePaths(currentDirectory, parent);
- child = combinePaths(currentDirectory, child);
- }
- else if (typeof currentDirectory === "boolean") {
- ignoreCase = currentDirectory;
- }
- if (parent === undefined || child === undefined)
- return false;
- if (parent === child)
- return true;
- var parentComponents = reducePathComponents(getPathComponents(parent));
- var childComponents = reducePathComponents(getPathComponents(child));
- if (childComponents.length < parentComponents.length) {
- return false;
- }
- var componentEqualityComparer = ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive;
- for (var i = 0; i < parentComponents.length; i++) {
- var equalityComparer = i === 0 ? ts.equateStringsCaseInsensitive : componentEqualityComparer;
- if (!equalityComparer(parentComponents[i], childComponents[i])) {
- return false;
- }
- }
- return true;
- }
- ts.containsPath = containsPath;
- function startsWithDirectory(fileName, directoryName, getCanonicalFileName) {
- var canonicalFileName = getCanonicalFileName(fileName);
- var canonicalDirectoryName = getCanonicalFileName(directoryName);
- return ts.startsWith(canonicalFileName, canonicalDirectoryName + "/") || ts.startsWith(canonicalFileName, canonicalDirectoryName + "\\");
- }
- ts.startsWithDirectory = startsWithDirectory;
- function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) {
- var fromComponents = reducePathComponents(getPathComponents(from));
- var toComponents = reducePathComponents(getPathComponents(to));
- var start;
- for (start = 0; start < fromComponents.length && start < toComponents.length; start++) {
- var fromComponent = getCanonicalFileName(fromComponents[start]);
- var toComponent = getCanonicalFileName(toComponents[start]);
- var comparer = start === 0 ? ts.equateStringsCaseInsensitive : stringEqualityComparer;
- if (!comparer(fromComponent, toComponent))
- break;
- }
- if (start === 0) {
- return toComponents;
- }
- var components = toComponents.slice(start);
- var relative = [];
- for (; start < fromComponents.length; start++) {
- relative.push("..");
- }
- return __spreadArrays([""], relative, components);
- }
- ts.getPathComponentsRelativeTo = getPathComponentsRelativeTo;
- function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
- ts.Debug.assert((getRootLength(fromDirectory) > 0) === (getRootLength(to) > 0), "Paths must either both be absolute or both be relative");
- var getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : ts.identity;
- var ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false;
- var pathComponents = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive, getCanonicalFileName);
- return getPathFromPathComponents(pathComponents);
- }
- ts.getRelativePathFromDirectory = getRelativePathFromDirectory;
- function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
- return !isRootedDiskPath(absoluteOrRelativePath)
- ? absoluteOrRelativePath
- : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false);
- }
- ts.convertToRelativePath = convertToRelativePath;
- function getRelativePathFromFile(from, to, getCanonicalFileName) {
- return ensurePathIsNonModuleName(getRelativePathFromDirectory(getDirectoryPath(from), to, getCanonicalFileName));
- }
- ts.getRelativePathFromFile = getRelativePathFromFile;
- function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) {
- var pathComponents = getPathComponentsRelativeTo(resolvePath(currentDirectory, directoryPathOrUrl), resolvePath(currentDirectory, relativeOrAbsolutePath), ts.equateStringsCaseSensitive, getCanonicalFileName);
- var firstComponent = pathComponents[0];
- if (isAbsolutePathAnUrl && isRootedDiskPath(firstComponent)) {
- var prefix = firstComponent.charAt(0) === ts.directorySeparator ? "file://" : "file:///";
- pathComponents[0] = prefix + firstComponent;
- }
- return getPathFromPathComponents(pathComponents);
- }
- ts.getRelativePathToDirectoryOrUrl = getRelativePathToDirectoryOrUrl;
- function forEachAncestorDirectory(directory, callback) {
- while (true) {
- var result = callback(directory);
- if (result !== undefined) {
- return result;
- }
- var parentPath = getDirectoryPath(directory);
- if (parentPath === directory) {
- return undefined;
- }
- directory = parentPath;
- }
- }
- ts.forEachAncestorDirectory = forEachAncestorDirectory;
- function isNodeModulesDirectory(dirPath) {
- return ts.endsWith(dirPath, "/node_modules");
- }
- ts.isNodeModulesDirectory = isNodeModulesDirectory;
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- function diag(code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid) {
- return { code: code, category: category, key: key, message: message, reportsUnnecessary: reportsUnnecessary, elidedInCompatabilityPyramid: elidedInCompatabilityPyramid };
+ function diag(code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid, reportsDeprecated) {
+ return { code: code, category: category, key: key, message: message, reportsUnnecessary: reportsUnnecessary, elidedInCompatabilityPyramid: elidedInCompatabilityPyramid, reportsDeprecated: reportsDeprecated };
}
ts.Diagnostics = {
Unterminated_string_literal: diag(1002, ts.DiagnosticCategory.Error, "Unterminated_string_literal_1002", "Unterminated string literal."),
Accessibility_modifier_already_seen: diag(1028, ts.DiagnosticCategory.Error, "Accessibility_modifier_already_seen_1028", "Accessibility modifier already seen."),
_0_modifier_must_precede_1_modifier: diag(1029, ts.DiagnosticCategory.Error, "_0_modifier_must_precede_1_modifier_1029", "'{0}' modifier must precede '{1}' modifier."),
_0_modifier_already_seen: diag(1030, ts.DiagnosticCategory.Error, "_0_modifier_already_seen_1030", "'{0}' modifier already seen."),
- _0_modifier_cannot_appear_on_a_class_element: diag(1031, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_class_element_1031", "'{0}' modifier cannot appear on a class element."),
+ _0_modifier_cannot_appear_on_class_elements_of_this_kind: diag(1031, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_class_elements_of_this_kind_1031", "'{0}' modifier cannot appear on class elements of this kind."),
super_must_be_followed_by_an_argument_list_or_member_access: diag(1034, ts.DiagnosticCategory.Error, "super_must_be_followed_by_an_argument_list_or_member_access_1034", "'super' must be followed by an argument list or member access."),
Only_ambient_modules_can_use_quoted_names: diag(1035, ts.DiagnosticCategory.Error, "Only_ambient_modules_can_use_quoted_names_1035", "Only ambient modules can use quoted names."),
Statements_are_not_allowed_in_ambient_contexts: diag(1036, ts.DiagnosticCategory.Error, "Statements_are_not_allowed_in_ambient_contexts_1036", "Statements are not allowed in ambient contexts."),
Enum_member_must_have_initializer: diag(1061, ts.DiagnosticCategory.Error, "Enum_member_must_have_initializer_1061", "Enum member must have initializer."),
Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, ts.DiagnosticCategory.Error, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."),
An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."),
- The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: diag(1064, ts.DiagnosticCategory.Error, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1064", "The return type of an async function or method must be the global Promise<T> type."),
+ The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0: diag(1064, ts.DiagnosticCategory.Error, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_wri_1064", "The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{0}>'?"),
In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, ts.DiagnosticCategory.Error, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."),
Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, ts.DiagnosticCategory.Error, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."),
Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, ts.DiagnosticCategory.Error, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."),
An_export_declaration_cannot_have_modifiers: diag(1193, ts.DiagnosticCategory.Error, "An_export_declaration_cannot_have_modifiers_1193", "An export declaration cannot have modifiers."),
Export_declarations_are_not_permitted_in_a_namespace: diag(1194, ts.DiagnosticCategory.Error, "Export_declarations_are_not_permitted_in_a_namespace_1194", "Export declarations are not permitted in a namespace."),
export_Asterisk_does_not_re_export_a_default: diag(1195, ts.DiagnosticCategory.Error, "export_Asterisk_does_not_re_export_a_default_1195", "'export *' does not re-export a default."),
- Catch_clause_variable_cannot_have_a_type_annotation: diag(1196, ts.DiagnosticCategory.Error, "Catch_clause_variable_cannot_have_a_type_annotation_1196", "Catch clause variable cannot have a type annotation."),
+ Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified: diag(1196, ts.DiagnosticCategory.Error, "Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified_1196", "Catch clause variable type annotation must be 'any' or 'unknown' if specified."),
Catch_clause_variable_cannot_have_an_initializer: diag(1197, ts.DiagnosticCategory.Error, "Catch_clause_variable_cannot_have_an_initializer_1197", "Catch clause variable cannot have an initializer."),
An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: diag(1198, ts.DiagnosticCategory.Error, "An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive_1198", "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive."),
Unterminated_Unicode_escape_sequence: diag(1199, ts.DiagnosticCategory.Error, "Unterminated_Unicode_escape_sequence_1199", "Unterminated Unicode escape sequence."),
Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type: diag(1205, ts.DiagnosticCategory.Error, "Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type_1205", "Re-exporting a type when the '--isolatedModules' flag is provided requires using 'export type'."),
Decorators_are_not_valid_here: diag(1206, ts.DiagnosticCategory.Error, "Decorators_are_not_valid_here_1206", "Decorators are not valid here."),
Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: diag(1207, ts.DiagnosticCategory.Error, "Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name_1207", "Decorators cannot be applied to multiple get/set accessors of the same name."),
- All_files_must_be_modules_when_the_isolatedModules_flag_is_provided: diag(1208, ts.DiagnosticCategory.Error, "All_files_must_be_modules_when_the_isolatedModules_flag_is_provided_1208", "All files must be modules when the '--isolatedModules' flag is provided."),
+ _0_cannot_be_compiled_under_isolatedModules_because_it_is_considered_a_global_script_file_Add_an_import_export_or_an_empty_export_statement_to_make_it_a_module: diag(1208, ts.DiagnosticCategory.Error, "_0_cannot_be_compiled_under_isolatedModules_because_it_is_considered_a_global_script_file_Add_an_imp_1208", "'{0}' cannot be compiled under '--isolatedModules' because it is considered a global script file. Add an import, export, or an empty 'export {}' statement to make it a module."),
Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode: diag(1210, ts.DiagnosticCategory.Error, "Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode_1210", "Invalid use of '{0}'. Class definitions are automatically in strict mode."),
A_class_declaration_without_the_default_modifier_must_have_a_name: diag(1211, ts.DiagnosticCategory.Error, "A_class_declaration_without_the_default_modifier_must_have_a_name_1211", "A class declaration without the 'default' modifier must have a name."),
Identifier_expected_0_is_a_reserved_word_in_strict_mode: diag(1212, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_1212", "Identifier expected. '{0}' is a reserved word in strict mode."),
A_definite_assignment_assertion_is_not_permitted_in_this_context: diag(1255, ts.DiagnosticCategory.Error, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."),
A_rest_element_must_be_last_in_a_tuple_type: diag(1256, ts.DiagnosticCategory.Error, "A_rest_element_must_be_last_in_a_tuple_type_1256", "A rest element must be last in a tuple type."),
A_required_element_cannot_follow_an_optional_element: diag(1257, ts.DiagnosticCategory.Error, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."),
- Definite_assignment_assertions_can_only_be_used_along_with_a_type_annotation: diag(1258, ts.DiagnosticCategory.Error, "Definite_assignment_assertions_can_only_be_used_along_with_a_type_annotation_1258", "Definite assignment assertions can only be used along with a type annotation."),
Module_0_can_only_be_default_imported_using_the_1_flag: diag(1259, ts.DiagnosticCategory.Error, "Module_0_can_only_be_default_imported_using_the_1_flag_1259", "Module '{0}' can only be default-imported using the '{1}' flag"),
Keywords_cannot_contain_escape_characters: diag(1260, ts.DiagnosticCategory.Error, "Keywords_cannot_contain_escape_characters_1260", "Keywords cannot contain escape characters."),
Already_included_file_name_0_differs_from_file_name_1_only_in_casing: diag(1261, ts.DiagnosticCategory.Error, "Already_included_file_name_0_differs_from_file_name_1_only_in_casing_1261", "Already included file name '{0}' differs from file name '{1}' only in casing."),
+ Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module: diag(1262, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module_1262", "Identifier expected. '{0}' is a reserved word at the top-level of a module."),
+ Declarations_with_initializers_cannot_also_have_definite_assignment_assertions: diag(1263, ts.DiagnosticCategory.Error, "Declarations_with_initializers_cannot_also_have_definite_assignment_assertions_1263", "Declarations with initializers cannot also have definite assignment assertions."),
+ Declarations_with_definite_assignment_assertions_must_also_have_type_annotations: diag(1264, ts.DiagnosticCategory.Error, "Declarations_with_definite_assignment_assertions_must_also_have_type_annotations_1264", "Declarations with definite assignment assertions must also have type annotations."),
with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
- can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment: diag(1312, ts.DiagnosticCategory.Error, "can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment_1312", "'=' can only be used in an object literal property inside a destructuring assignment."),
+ Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern: diag(1312, ts.DiagnosticCategory.Error, "Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_1312", "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern."),
The_body_of_an_if_statement_cannot_be_the_empty_statement: diag(1313, ts.DiagnosticCategory.Error, "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", "The body of an 'if' statement cannot be the empty statement."),
Global_module_exports_may_only_appear_in_module_files: diag(1314, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_module_files_1314", "Global module exports may only appear in module files."),
Global_module_exports_may_only_appear_in_declaration_files: diag(1315, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_declaration_files_1315", "Global module exports may only appear in declaration files."),
Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system_or_umd: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'esnext', 'commonjs', 'amd', 'system', or 'umd'."),
Dynamic_import_must_have_one_specifier_as_an_argument: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_import_must_have_one_specifier_as_an_argument_1324", "Dynamic import must have one specifier as an argument."),
Specifier_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Specifier_of_dynamic_import_cannot_be_spread_element_1325", "Specifier of dynamic import cannot be spread element."),
- Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments"),
+ Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments."),
String_literal_with_double_quotes_expected: diag(1327, ts.DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."),
Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal: diag(1328, ts.DiagnosticCategory.Error, "Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_li_1328", "Property value can only be string literal, numeric literal, 'true', 'false', 'null', object literal or array literal."),
_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0: diag(1329, ts.DiagnosticCategory.Error, "_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write__1329", "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?"),
Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."),
Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: diag(1340, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"),
Type_arguments_cannot_be_used_here: diag(1342, ts.DiagnosticCategory.Error, "Type_arguments_cannot_be_used_here_1342", "Type arguments cannot be used here."),
- The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_esnext_or_system: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_esnext_or_system_1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'esnext' or 'system'."),
+ The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_or_system: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_or_system_1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'esnext', or 'system'."),
A_label_is_not_allowed_here: diag(1344, ts.DiagnosticCategory.Error, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."),
- An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, ts.DiagnosticCategory.Error, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness"),
+ An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, ts.DiagnosticCategory.Error, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness."),
This_parameter_is_not_allowed_with_use_strict_directive: diag(1346, ts.DiagnosticCategory.Error, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."),
use_strict_directive_cannot_be_used_with_non_simple_parameter_list: diag(1347, ts.DiagnosticCategory.Error, "use_strict_directive_cannot_be_used_with_non_simple_parameter_list_1347", "'use strict' directive cannot be used with non-simple parameter list."),
Non_simple_parameter_declared_here: diag(1348, ts.DiagnosticCategory.Error, "Non_simple_parameter_declared_here_1348", "Non-simple parameter declared here."),
Unexpected_token_Did_you_mean_or_gt: diag(1382, ts.DiagnosticCategory.Error, "Unexpected_token_Did_you_mean_or_gt_1382", "Unexpected token. Did you mean `{'>'}` or `>`?"),
Only_named_exports_may_use_export_type: diag(1383, ts.DiagnosticCategory.Error, "Only_named_exports_may_use_export_type_1383", "Only named exports may use 'export type'."),
A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list: diag(1384, ts.DiagnosticCategory.Error, "A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list_1384", "A 'new' expression with type arguments must always be followed by a parenthesized argument list."),
+ Function_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1385, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_a_union_type_1385", "Function type notation must be parenthesized when used in a union type."),
+ Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1386, ts.DiagnosticCategory.Error, "Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type_1386", "Constructor type notation must be parenthesized when used in a union type."),
+ Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1387, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1387", "Function type notation must be parenthesized when used in an intersection type."),
+ Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1388, ts.DiagnosticCategory.Error, "Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1388", "Constructor type notation must be parenthesized when used in an intersection type."),
+ _0_is_not_allowed_as_a_variable_declaration_name: diag(1389, ts.DiagnosticCategory.Error, "_0_is_not_allowed_as_a_variable_declaration_name_1389", "'{0}' is not allowed as a variable declaration name."),
The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", undefined, true),
Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2: diag(2416, ts.DiagnosticCategory.Error, "Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2_2416", "Property '{0}' in type '{1}' is not assignable to the same property in base type '{2}'."),
Class_static_side_0_incorrectly_extends_base_class_static_side_1: diag(2417, ts.DiagnosticCategory.Error, "Class_static_side_0_incorrectly_extends_base_class_static_side_1_2417", "Class static side '{0}' incorrectly extends base class static side '{1}'."),
Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1: diag(2418, ts.DiagnosticCategory.Error, "Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1_2418", "Type of computed property's value is '{0}', which is not assignable to type '{1}'."),
+ Types_of_construct_signatures_are_incompatible: diag(2419, ts.DiagnosticCategory.Error, "Types_of_construct_signatures_are_incompatible_2419", "Types of construct signatures are incompatible."),
Class_0_incorrectly_implements_interface_1: diag(2420, ts.DiagnosticCategory.Error, "Class_0_incorrectly_implements_interface_1_2420", "Class '{0}' incorrectly implements interface '{1}'."),
A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2422, ts.DiagnosticCategory.Error, "A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_memb_2422", "A class can only implement an object type or intersection of object types with statically known members."),
Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: diag(2423, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_access_2423", "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor."),
The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property: diag(2547, ts.DiagnosticCategory.Error, "The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_pro_2547", "The type returned by the '{0}()' method of an async iterator must be a promise for a type with a 'value' property."),
Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2548, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator_2548", "Type '{0}' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator."),
Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2549, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns__2549", "Type '{0}' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator."),
+ Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later: diag(2550, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_c_2550", "Property '{0}' does not exist on type '{1}'. Do you need to change your target library? Try changing the `lib` compiler option to '{2}' or later."),
Property_0_does_not_exist_on_type_1_Did_you_mean_2: diag(2551, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Did_you_mean_2_2551", "Property '{0}' does not exist on type '{1}'. Did you mean '{2}'?"),
Cannot_find_name_0_Did_you_mean_1: diag(2552, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_1_2552", "Cannot find name '{0}'. Did you mean '{1}'?"),
Computed_values_are_not_permitted_in_an_enum_with_string_valued_members: diag(2553, ts.DiagnosticCategory.Error, "Computed_values_are_not_permitted_in_an_enum_with_string_valued_members_2553", "Computed values are not permitted in an enum with string valued members."),
Property_0_is_incompatible_with_rest_element_type: diag(2573, ts.DiagnosticCategory.Error, "Property_0_is_incompatible_with_rest_element_type_2573", "Property '{0}' is incompatible with rest element type."),
A_rest_element_type_must_be_an_array_type: diag(2574, ts.DiagnosticCategory.Error, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."),
No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments: diag(2575, ts.DiagnosticCategory.Error, "No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments_2575", "No overload expects {0} arguments, but overloads do exist that expect either {1} or {2} arguments."),
- Property_0_is_a_static_member_of_type_1: diag(2576, ts.DiagnosticCategory.Error, "Property_0_is_a_static_member_of_type_1_2576", "Property '{0}' is a static member of type '{1}'"),
+ Property_0_is_a_static_member_of_type_1: diag(2576, ts.DiagnosticCategory.Error, "Property_0_is_a_static_member_of_type_1_2576", "Property '{0}' is a static member of type '{1}'."),
Return_type_annotation_circularly_references_itself: diag(2577, ts.DiagnosticCategory.Error, "Return_type_annotation_circularly_references_itself_2577", "Return type annotation circularly references itself."),
Unused_ts_expect_error_directive: diag(2578, ts.DiagnosticCategory.Error, "Unused_ts_expect_error_directive_2578", "Unused '@ts-expect-error' directive."),
- Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode: diag(2580, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_2580", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i @types/node`."),
- Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery: diag(2581, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_2581", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i @types/jquery`."),
- Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha: diag(2582, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashje_2582", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha`."),
- Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2583, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2583", "Cannot find name '{0}'. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later."),
+ Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode: diag(2580, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashno_2580", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node`."),
+ Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery: diag(2581, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slash_2581", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i --save-dev @types/jquery`."),
+ Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha: diag(2582, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_type_2582", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i --save-dev @types/jest` or `npm i --save-dev @types/mocha`."),
+ Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later: diag(2583, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2583", "Cannot find name '{0}'. Do you need to change your target library? Try changing the `lib` compiler option to '{1}' or later."),
Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom: diag(2584, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2584", "Cannot find name '{0}'. Do you need to change your target library? Try changing the `lib` compiler option to include 'dom'."),
_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2585, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_2585", "'{0}' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later."),
Enum_type_0_circularly_references_itself: diag(2586, ts.DiagnosticCategory.Error, "Enum_type_0_circularly_references_itself_2586", "Enum type '{0}' circularly references itself."),
Cannot_assign_to_0_because_it_is_a_constant: diag(2588, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_constant_2588", "Cannot assign to '{0}' because it is a constant."),
Type_instantiation_is_excessively_deep_and_possibly_infinite: diag(2589, ts.DiagnosticCategory.Error, "Type_instantiation_is_excessively_deep_and_possibly_infinite_2589", "Type instantiation is excessively deep and possibly infinite."),
Expression_produces_a_union_type_that_is_too_complex_to_represent: diag(2590, ts.DiagnosticCategory.Error, "Expression_produces_a_union_type_that_is_too_complex_to_represent_2590", "Expression produces a union type that is too complex to represent."),
- Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig: diag(2591, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_th_2591", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i @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_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig: diag(2592, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_an_2592", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i @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_types_Slashjest_or_npm_i_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig: diag(2593, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashje_2593", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig."),
+ Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig: diag(2591, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashno_2591", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add `node` to the types field in your tsconfig."),
+ Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig: diag(2592, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slash_2592", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i --save-dev @types/jquery` and then add `jquery` to the types field in your tsconfig."),
+ Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig: diag(2593, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_type_2593", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i --save-dev @types/jest` or `npm i --save-dev @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig."),
This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag: diag(2594, ts.DiagnosticCategory.Error, "This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the__2594", "This module is declared with using 'export =', and can only be used with a default import when using the '{0}' flag."),
_0_can_only_be_imported_by_using_a_default_import: diag(2595, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_a_default_import_2595", "'{0}' can only be imported by using a default import."),
_0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: diag(2596, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import_2596", "'{0}' can only be imported by turning on the 'esModuleInterop' flag and using a default import."),
Type_of_property_0_circularly_references_itself_in_mapped_type_1: diag(2615, ts.DiagnosticCategory.Error, "Type_of_property_0_circularly_references_itself_in_mapped_type_1_2615", "Type of property '{0}' circularly references itself in mapped type '{1}'."),
_0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import: diag(2616, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import_2616", "'{0}' can only be imported by using 'import {1} = require({2})' or a default import."),
_0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: diag(2617, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_us_2617", "'{0}' can only be imported by using 'import {1} = require({2})' or by turning on the 'esModuleInterop' flag and using a default import."),
+ Source_has_0_element_s_but_target_requires_1: diag(2618, ts.DiagnosticCategory.Error, "Source_has_0_element_s_but_target_requires_1_2618", "Source has {0} element(s) but target requires {1}."),
+ Source_has_0_element_s_but_target_allows_only_1: diag(2619, ts.DiagnosticCategory.Error, "Source_has_0_element_s_but_target_allows_only_1_2619", "Source has {0} element(s) but target allows only {1}."),
+ Target_requires_0_element_s_but_source_may_have_fewer: diag(2620, ts.DiagnosticCategory.Error, "Target_requires_0_element_s_but_source_may_have_fewer_2620", "Target requires {0} element(s) but source may have fewer."),
+ Target_allows_only_0_element_s_but_source_may_have_more: diag(2621, ts.DiagnosticCategory.Error, "Target_allows_only_0_element_s_but_source_may_have_more_2621", "Target allows only {0} element(s) but source may have more."),
+ Element_at_index_0_is_variadic_in_one_type_but_not_in_the_other: diag(2622, ts.DiagnosticCategory.Error, "Element_at_index_0_is_variadic_in_one_type_but_not_in_the_other_2622", "Element at index {0} is variadic in one type but not in the other."),
Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."),
A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."),
Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."),
All_declarations_of_0_must_have_identical_modifiers: diag(2687, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_modifiers_2687", "All declarations of '{0}' must have identical modifiers."),
Cannot_find_type_definition_file_for_0: diag(2688, ts.DiagnosticCategory.Error, "Cannot_find_type_definition_file_for_0_2688", "Cannot find type definition file for '{0}'."),
Cannot_extend_an_interface_0_Did_you_mean_implements: diag(2689, ts.DiagnosticCategory.Error, "Cannot_extend_an_interface_0_Did_you_mean_implements_2689", "Cannot extend an interface '{0}'. Did you mean 'implements'?"),
+ _0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0: diag(2690, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0_2690", "'{0}' only refers to a type, but is being used as a value here. Did you mean to use '{1} in {0}'?"),
An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead: diag(2691, ts.DiagnosticCategory.Error, "An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead_2691", "An import path cannot end with a '{0}' extension. Consider importing '{1}' instead."),
_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible: diag(2692, ts.DiagnosticCategory.Error, "_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible_2692", "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible."),
_0_only_refers_to_a_type_but_is_being_used_as_a_value_here: diag(2693, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_2693", "'{0}' only refers to a type, but is being used as a value here."),
Cannot_invoke_an_object_which_is_possibly_null: diag(2721, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_2721", "Cannot invoke an object which is possibly 'null'."),
Cannot_invoke_an_object_which_is_possibly_undefined: diag(2722, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_undefined_2722", "Cannot invoke an object which is possibly 'undefined'."),
Cannot_invoke_an_object_which_is_possibly_null_or_undefined: diag(2723, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_or_undefined_2723", "Cannot invoke an object which is possibly 'null' or 'undefined'."),
- Module_0_has_no_exported_member_1_Did_you_mean_2: diag(2724, ts.DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_Did_you_mean_2_2724", "Module '{0}' has no exported member '{1}'. Did you mean '{2}'?"),
+ _0_has_no_exported_member_named_1_Did_you_mean_2: diag(2724, ts.DiagnosticCategory.Error, "_0_has_no_exported_member_named_1_Did_you_mean_2_2724", "'{0}' has no exported member named '{1}'. Did you mean '{2}'?"),
Class_name_cannot_be_Object_when_targeting_ES5_with_module_0: diag(2725, ts.DiagnosticCategory.Error, "Class_name_cannot_be_Object_when_targeting_ES5_with_module_0_2725", "Class name cannot be 'Object' when targeting ES5 with module {0}."),
Cannot_find_lib_definition_for_0: diag(2726, ts.DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_2726", "Cannot find lib definition for '{0}'."),
Cannot_find_lib_definition_for_0_Did_you_mean_1: diag(2727, ts.DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_Did_you_mean_1_2727", "Cannot find lib definition for '{0}'. Did you mean '{1}'?"),
Property_0_is_used_before_its_initialization: diag(2729, ts.DiagnosticCategory.Error, "Property_0_is_used_before_its_initialization_2729", "Property '{0}' is used before its initialization."),
An_arrow_function_cannot_have_a_this_parameter: diag(2730, ts.DiagnosticCategory.Error, "An_arrow_function_cannot_have_a_this_parameter_2730", "An arrow function cannot have a 'this' parameter."),
Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String: diag(2731, ts.DiagnosticCategory.Error, "Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_i_2731", "Implicit conversion of a 'symbol' to a 'string' will fail at runtime. Consider wrapping this expression in 'String(...)'."),
- Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension: diag(2732, ts.DiagnosticCategory.Error, "Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension_2732", "Cannot find module '{0}'. Consider using '--resolveJsonModule' to import module with '.json' extension"),
+ Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension: diag(2732, ts.DiagnosticCategory.Error, "Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension_2732", "Cannot find module '{0}'. Consider using '--resolveJsonModule' to import module with '.json' extension."),
Property_0_was_also_declared_here: diag(2733, ts.DiagnosticCategory.Error, "Property_0_was_also_declared_here_2733", "Property '{0}' was also declared here."),
Are_you_missing_a_semicolon: diag(2734, ts.DiagnosticCategory.Error, "Are_you_missing_a_semicolon_2734", "Are you missing a semicolon?"),
Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1: diag(2735, ts.DiagnosticCategory.Error, "Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1_2735", "Did you mean for '{0}' to be constrained to type 'new (...args: any[]) => {1}'?"),
Its_return_type_0_is_not_a_valid_JSX_element: diag(2787, ts.DiagnosticCategory.Error, "Its_return_type_0_is_not_a_valid_JSX_element_2787", "Its return type '{0}' is not a valid JSX element."),
Its_instance_type_0_is_not_a_valid_JSX_element: diag(2788, ts.DiagnosticCategory.Error, "Its_instance_type_0_is_not_a_valid_JSX_element_2788", "Its instance type '{0}' is not a valid JSX element."),
Its_element_type_0_is_not_a_valid_JSX_element: diag(2789, ts.DiagnosticCategory.Error, "Its_element_type_0_is_not_a_valid_JSX_element_2789", "Its element type '{0}' is not a valid JSX element."),
+ The_operand_of_a_delete_operator_must_be_optional: diag(2790, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_must_be_optional_2790", "The operand of a 'delete' operator must be optional."),
+ Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later: diag(2791, ts.DiagnosticCategory.Error, "Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_lat_2791", "Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later."),
+ Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option: diag(2792, ts.DiagnosticCategory.Error, "Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_th_2792", "Cannot find module '{0}'. Did you mean to set the 'moduleResolution' option to 'node', or to add aliases to the 'paths' option?"),
+ The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible: diag(2793, ts.DiagnosticCategory.Error, "The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_2793", "The call would have succeeded against this implementation, but implementation signatures of overloads are not externally visible."),
+ Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise: diag(2794, ts.DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise_2794", "Expected {0} arguments, but got {1}. Did you forget to include 'void' in your type argument to 'Promise'?"),
+ The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types: diag(2795, ts.DiagnosticCategory.Error, "The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types_2795", "The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types."),
+ It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tagged_template_expression_which_cannot_be_invoked: diag(2796, ts.DiagnosticCategory.Error, "It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tag_2796", "It is likely that you are missing a comma to separate these two template expressions. They form a tagged template expression which cannot be invoked."),
Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4016, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_function_has_or_is_using_private_name_1_4016", "Type parameter '{0}' of exported function has or is using private name '{1}'."),
Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4019, ts.DiagnosticCategory.Error, "Implements_clause_of_exported_class_0_has_or_is_using_private_name_1_4019", "Implements clause of exported class '{0}' has or is using private name '{1}'."),
extends_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4020, ts.DiagnosticCategory.Error, "extends_clause_of_exported_class_0_has_or_is_using_private_name_1_4020", "'extends' clause of exported class '{0}' has or is using private name '{1}'."),
+ extends_clause_of_exported_class_has_or_is_using_private_name_0: diag(4021, ts.DiagnosticCategory.Error, "extends_clause_of_exported_class_has_or_is_using_private_name_0_4021", "'extends' clause of exported class has or is using private name '{0}'."),
extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: diag(4022, ts.DiagnosticCategory.Error, "extends_clause_of_exported_interface_0_has_or_is_using_private_name_1_4022", "'extends' clause of exported interface '{0}' has or is using private name '{1}'."),
Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4023, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4023", "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named."),
Exported_variable_0_has_or_is_using_name_1_from_private_module_2: diag(4024, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_private_module_2_4024", "Exported variable '{0}' has or is using name '{1}' from private module '{2}'."),
Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0: diag(5057, ts.DiagnosticCategory.Error, "Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0_5057", "Cannot find a tsconfig.json file at the specified directory: '{0}'."),
The_specified_path_does_not_exist_Colon_0: diag(5058, ts.DiagnosticCategory.Error, "The_specified_path_does_not_exist_Colon_0_5058", "The specified path does not exist: '{0}'."),
Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier: diag(5059, ts.DiagnosticCategory.Error, "Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier_5059", "Invalid value for '--reactNamespace'. '{0}' is not a valid identifier."),
- Option_paths_cannot_be_used_without_specifying_baseUrl_option: diag(5060, ts.DiagnosticCategory.Error, "Option_paths_cannot_be_used_without_specifying_baseUrl_option_5060", "Option 'paths' cannot be used without specifying '--baseUrl' option."),
Pattern_0_can_have_at_most_one_Asterisk_character: diag(5061, ts.DiagnosticCategory.Error, "Pattern_0_can_have_at_most_one_Asterisk_character_5061", "Pattern '{0}' can have at most one '*' character."),
Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character: diag(5062, ts.DiagnosticCategory.Error, "Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character_5062", "Substitution '{0}' in pattern '{1}' can have at most one '*' character."),
Substitutions_for_pattern_0_should_be_an_array: diag(5063, ts.DiagnosticCategory.Error, "Substitutions_for_pattern_0_should_be_an_array_5063", "Substitutions for pattern '{0}' should be an array."),
Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0: diag(5081, ts.DiagnosticCategory.Error, "Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0_5081", "Cannot find a tsconfig.json file at the current directory: {0}."),
_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1: diag(5082, ts.DiagnosticCategory.Error, "_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1_5082", "'{0}' could be instantiated with an arbitrary type which could be unrelated to '{1}'."),
Cannot_read_file_0: diag(5083, ts.DiagnosticCategory.Error, "Cannot_read_file_0_5083", "Cannot read file '{0}'."),
+ Tuple_members_must_all_have_names_or_all_not_have_names: diag(5084, ts.DiagnosticCategory.Error, "Tuple_members_must_all_have_names_or_all_not_have_names_5084", "Tuple members must all have names or all not have names."),
+ A_tuple_member_cannot_be_both_optional_and_rest: diag(5085, ts.DiagnosticCategory.Error, "A_tuple_member_cannot_be_both_optional_and_rest_5085", "A tuple member cannot be both optional and rest."),
+ A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type: diag(5086, ts.DiagnosticCategory.Error, "A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_c_5086", "A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type."),
+ A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type: diag(5087, ts.DiagnosticCategory.Error, "A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type_5087", "A labeled tuple element is declared as rest with a `...` before the name, rather than before the type."),
+ The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary: diag(5088, ts.DiagnosticCategory.Error, "The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialize_5088", "The inferred type of '{0}' references a type with a cyclic structure which cannot be trivially serialized. A type annotation is necessary."),
+ Option_0_cannot_be_specified_when_option_jsx_is_1: diag(5089, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_when_option_jsx_is_1_5089", "Option '{0}' cannot be specified when option 'jsx' is '{1}'."),
+ Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash: diag(5090, ts.DiagnosticCategory.Error, "Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash_5090", "Non-relative paths are not allowed when 'baseUrl' is not set. Did you forget a leading './'?"),
Generates_a_sourcemap_for_each_corresponding_d_ts_file: diag(6000, ts.DiagnosticCategory.Message, "Generates_a_sourcemap_for_each_corresponding_d_ts_file_6000", "Generates a sourcemap for each corresponding '.d.ts' file."),
Concatenate_and_emit_output_to_single_file: diag(6001, ts.DiagnosticCategory.Message, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."),
Generates_corresponding_d_ts_file: diag(6002, ts.DiagnosticCategory.Message, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."),
Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0: diag(6202, ts.DiagnosticCategory.Error, "Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0_6202", "Project references may not form a circular graph. Cycle detected: {0}"),
_0_was_also_declared_here: diag(6203, ts.DiagnosticCategory.Message, "_0_was_also_declared_here_6203", "'{0}' was also declared here."),
and_here: diag(6204, ts.DiagnosticCategory.Message, "and_here_6204", "and here."),
- All_type_parameters_are_unused: diag(6205, ts.DiagnosticCategory.Error, "All_type_parameters_are_unused_6205", "All type parameters are unused"),
+ All_type_parameters_are_unused: diag(6205, ts.DiagnosticCategory.Error, "All_type_parameters_are_unused_6205", "All type parameters are unused."),
package_json_has_a_typesVersions_field_with_version_specific_path_mappings: diag(6206, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_field_with_version_specific_path_mappings_6206", "'package.json' has a 'typesVersions' field with version-specific path mappings."),
package_json_does_not_have_a_typesVersions_entry_that_matches_version_0: diag(6207, ts.DiagnosticCategory.Message, "package_json_does_not_have_a_typesVersions_entry_that_matches_version_0_6207", "'package.json' does not have a 'typesVersions' entry that matches version '{0}'."),
package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2: diag(6208, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_ma_6208", "'package.json' has a 'typesVersions' entry '{0}' that matches compiler version '{1}', looking for a pattern to match module name '{2}'."),
Could_not_resolve_the_path_0_with_the_extensions_Colon_1: diag(6231, ts.DiagnosticCategory.Error, "Could_not_resolve_the_path_0_with_the_extensions_Colon_1_6231", "Could not resolve the path '{0}' with the extensions: {1}."),
Declaration_augments_declaration_in_another_file_This_cannot_be_serialized: diag(6232, ts.DiagnosticCategory.Error, "Declaration_augments_declaration_in_another_file_This_cannot_be_serialized_6232", "Declaration augments declaration in another file. This cannot be serialized."),
This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file: diag(6233, ts.DiagnosticCategory.Error, "This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_fil_6233", "This is the declaration being augmented. Consider moving the augmenting declaration into the same file."),
+ This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without: diag(6234, ts.DiagnosticCategory.Error, "This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without_6234", "This expression is not callable because it is a 'get' accessor. Did you mean to use it without '()'?"),
+ Disable_loading_referenced_projects: diag(6235, ts.DiagnosticCategory.Message, "Disable_loading_referenced_projects_6235", "Disable loading referenced projects."),
+ Arguments_for_the_rest_parameter_0_were_not_provided: diag(6236, ts.DiagnosticCategory.Error, "Arguments_for_the_rest_parameter_0_were_not_provided_6236", "Arguments for the rest parameter '{0}' were not provided."),
+ Generates_an_event_trace_and_a_list_of_types: diag(6237, ts.DiagnosticCategory.Message, "Generates_an_event_trace_and_a_list_of_types_6237", "Generates an event trace and a list of types."),
+ Specify_the_module_specifier_to_be_used_to_import_the_jsx_and_jsxs_factory_functions_from_eg_react: diag(6238, ts.DiagnosticCategory.Error, "Specify_the_module_specifier_to_be_used_to_import_the_jsx_and_jsxs_factory_functions_from_eg_react_6238", "Specify the module specifier to be used to import the `jsx` and `jsxs` factory functions from. eg, react"),
Projects_to_reference: diag(6300, ts.DiagnosticCategory.Message, "Projects_to_reference_6300", "Projects to reference"),
Enable_project_compilation: diag(6302, ts.DiagnosticCategory.Message, "Enable_project_compilation_6302", "Enable project compilation"),
Composite_projects_may_not_disable_declaration_emit: diag(6304, ts.DiagnosticCategory.Error, "Composite_projects_may_not_disable_declaration_emit_6304", "Composite projects may not disable declaration emit."),
File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern: diag(6307, ts.DiagnosticCategory.Error, "File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_includ_6307", "File '{0}' is not listed within the file list of project '{1}'. Projects must list all files or use an 'include' pattern."),
Cannot_prepend_project_0_because_it_does_not_have_outFile_set: diag(6308, ts.DiagnosticCategory.Error, "Cannot_prepend_project_0_because_it_does_not_have_outFile_set_6308", "Cannot prepend project '{0}' because it does not have 'outFile' set"),
Output_file_0_from_project_1_does_not_exist: diag(6309, ts.DiagnosticCategory.Error, "Output_file_0_from_project_1_does_not_exist_6309", "Output file '{0}' from project '{1}' does not exist"),
+ Referenced_project_0_may_not_disable_emit: diag(6310, ts.DiagnosticCategory.Error, "Referenced_project_0_may_not_disable_emit_6310", "Referenced project '{0}' may not disable emit."),
Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2: diag(6350, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2_6350", "Project '{0}' is out of date because oldest output '{1}' is older than newest input '{2}'"),
Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2: diag(6351, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than oldest output '{2}'"),
Project_0_is_out_of_date_because_output_file_1_does_not_exist: diag(6352, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_file_1_does_not_exist_6352", "Project '{0}' is out of date because output file '{1}' does not exist"),
Skipping_build_of_project_0_because_its_dependency_1_was_not_built: diag(6382, ts.DiagnosticCategory.Message, "Skipping_build_of_project_0_because_its_dependency_1_was_not_built_6382", "Skipping build of project '{0}' because its dependency '{1}' was not built"),
Project_0_can_t_be_built_because_its_dependency_1_was_not_built: diag(6383, ts.DiagnosticCategory.Message, "Project_0_can_t_be_built_because_its_dependency_1_was_not_built_6383", "Project '{0}' can't be built because its dependency '{1}' was not built"),
Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it: diag(6384, ts.DiagnosticCategory.Message, "Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_di_6384", "Have recompiles in '--incremental' and '--watch' assume that changes within a file will only affect files directly depending on it."),
+ _0_is_deprecated: diag(6385, ts.DiagnosticCategory.Suggestion, "_0_is_deprecated_6385", "'{0}' is deprecated", undefined, undefined, true),
+ Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found: diag(6386, ts.DiagnosticCategory.Message, "Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_nativ_6386", "Performance timings for '--diagnostics' or '--extendedDiagnostics' are not available in this session. A native implementation of the Web Performance API could not be found."),
The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"),
The_expected_type_comes_from_this_index_signature: diag(6501, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."),
The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."),
Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing: diag(6503, ts.DiagnosticCategory.Message, "Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing_6503", "Print names of files that are part of the compilation and then stop processing."),
File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option: diag(6504, ts.DiagnosticCategory.Error, "File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option_6504", "File '{0}' is a JavaScript file. Did you mean to enable the 'allowJs' option?"),
+ Include_undefined_in_index_signature_results: diag(6800, ts.DiagnosticCategory.Message, "Include_undefined_in_index_signature_results_6800", "Include 'undefined' in index signature results"),
Variable_0_implicitly_has_an_1_type: diag(7005, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_an_1_type_7005", "Variable '{0}' implicitly has an '{1}' type."),
Parameter_0_implicitly_has_an_1_type: diag(7006, ts.DiagnosticCategory.Error, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."),
Member_0_implicitly_has_an_1_type: diag(7008, ts.DiagnosticCategory.Error, "Member_0_implicitly_has_an_1_type_7008", "Member '{0}' implicitly has an '{1}' type."),
Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation: diag(7032, ts.DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation_7032", "Property '{0}' implicitly has type 'any', because its set accessor lacks a parameter type annotation."),
Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation: diag(7033, ts.DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation_7033", "Property '{0}' implicitly has type 'any', because its get accessor lacks a return type annotation."),
Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined: diag(7034, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined_7034", "Variable '{0}' implicitly has type '{1}' in some locations where its type cannot be determined."),
- Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0: diag(7035, ts.DiagnosticCategory.Error, "Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_mod_7035", "Try `npm install @types/{1}` if it exists or add a new declaration (.d.ts) file containing `declare module '{0}';`"),
+ Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0: diag(7035, ts.DiagnosticCategory.Error, "Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare__7035", "Try `npm i --save-dev @types/{1}` if it exists or add a new declaration (.d.ts) file containing `declare module '{0}';`"),
Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0: diag(7036, ts.DiagnosticCategory.Error, "Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0_7036", "Dynamic import's specifier must be of type 'string', but here has type '{0}'."),
Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports: diag(7037, ts.DiagnosticCategory.Message, "Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for__7037", "Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'."),
Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead: diag(7038, ts.DiagnosticCategory.Message, "Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cau_7038", "Type originates at this import. A namespace-style import cannot be called or constructed, and will cause a failure at runtime. Consider using a default import or import require here instead."),
Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1: diag(7053, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1_7053", "Element implicitly has an 'any' type because expression of type '{0}' can't be used to index type '{1}'."),
No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1: diag(7054, ts.DiagnosticCategory.Error, "No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1_7054", "No index signature with a parameter of type '{0}' was found on type '{1}'."),
_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type: diag(7055, ts.DiagnosticCategory.Error, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type_7055", "'{0}', which lacks return-type annotation, implicitly has an '{1}' yield type."),
+ The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed: diag(7056, ts.DiagnosticCategory.Error, "The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_ty_7056", "The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed."),
You_cannot_rename_this_element: diag(8000, ts.DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."),
You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."),
import_can_only_be_used_in_TypeScript_files: diag(8002, ts.DiagnosticCategory.Error, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."),
The_type_of_a_function_declaration_must_match_the_function_s_signature: diag(8030, ts.DiagnosticCategory.Error, "The_type_of_a_function_declaration_must_match_the_function_s_signature_8030", "The type of a function declaration must match the function's signature."),
You_cannot_rename_a_module_via_a_global_import: diag(8031, ts.DiagnosticCategory.Error, "You_cannot_rename_a_module_via_a_global_import_8031", "You cannot rename a module via a global import."),
Qualified_name_0_is_not_allowed_without_a_leading_param_object_1: diag(8032, ts.DiagnosticCategory.Error, "Qualified_name_0_is_not_allowed_without_a_leading_param_object_1_8032", "Qualified name '{0}' is not allowed without a leading '@param {object} {1}'."),
+ A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags: diag(8033, ts.DiagnosticCategory.Error, "A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags_8033", "A JSDoc '@typedef' comment may not contain multiple '@type' tags."),
+ The_tag_was_first_specified_here: diag(8034, ts.DiagnosticCategory.Error, "The_tag_was_first_specified_here_8034", "The tag was first specified here."),
Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clause: diag(9002, ts.DiagnosticCategory.Error, "Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_clas_9002", "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clause."),
class_expressions_are_not_currently_supported: diag(9003, ts.DiagnosticCategory.Error, "class_expressions_are_not_currently_supported_9003", "'class' expressions are not currently supported."),
Language_service_is_disabled: diag(9004, ts.DiagnosticCategory.Error, "Language_service_is_disabled_9004", "Language service is disabled."),
Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor: diag(17013, ts.DiagnosticCategory.Error, "Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constru_17013", "Meta-property '{0}' is only allowed in the body of a function declaration, function expression, or constructor."),
JSX_fragment_has_no_corresponding_closing_tag: diag(17014, ts.DiagnosticCategory.Error, "JSX_fragment_has_no_corresponding_closing_tag_17014", "JSX fragment has no corresponding closing tag."),
Expected_corresponding_closing_tag_for_JSX_fragment: diag(17015, ts.DiagnosticCategory.Error, "Expected_corresponding_closing_tag_for_JSX_fragment_17015", "Expected corresponding closing tag for JSX fragment."),
- JSX_fragment_is_not_supported_when_using_jsxFactory: diag(17016, ts.DiagnosticCategory.Error, "JSX_fragment_is_not_supported_when_using_jsxFactory_17016", "JSX fragment is not supported when using --jsxFactory"),
- JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma: diag(17017, ts.DiagnosticCategory.Error, "JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma_17017", "JSX fragment is not supported when using an inline JSX factory pragma"),
+ The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option: diag(17016, ts.DiagnosticCategory.Error, "The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_com_17016", "The 'jsxFragmentFactory' compiler option must be provided to use JSX fragments with the 'jsxFactory' compiler option."),
+ An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments: diag(17017, ts.DiagnosticCategory.Error, "An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments_17017", "An @jsxFrag pragma is required when using an @jsx pragma with JSX fragments."),
Unknown_type_acquisition_option_0_Did_you_mean_1: diag(17018, ts.DiagnosticCategory.Error, "Unknown_type_acquisition_option_0_Did_you_mean_1_17018", "Unknown type acquisition option '{0}'. Did you mean '{1}'?"),
Circularity_detected_while_resolving_configuration_Colon_0: diag(18000, ts.DiagnosticCategory.Error, "Circularity_detected_while_resolving_configuration_Colon_0_18000", "Circularity detected while resolving configuration: {0}"),
A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not: diag(18001, ts.DiagnosticCategory.Error, "A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not_18001", "A path in an 'extends' option must be relative or rooted, but '{0}' is not."),
Implement_interface_0: diag(90006, ts.DiagnosticCategory.Message, "Implement_interface_0_90006", "Implement interface '{0}'"),
Implement_inherited_abstract_class: diag(90007, ts.DiagnosticCategory.Message, "Implement_inherited_abstract_class_90007", "Implement inherited abstract class"),
Add_0_to_unresolved_variable: diag(90008, ts.DiagnosticCategory.Message, "Add_0_to_unresolved_variable_90008", "Add '{0}.' to unresolved variable"),
- Remove_destructuring: diag(90009, ts.DiagnosticCategory.Message, "Remove_destructuring_90009", "Remove destructuring"),
Remove_variable_statement: diag(90010, ts.DiagnosticCategory.Message, "Remove_variable_statement_90010", "Remove variable statement"),
Remove_template_tag: diag(90011, ts.DiagnosticCategory.Message, "Remove_template_tag_90011", "Remove template tag"),
Remove_type_parameters: diag(90012, ts.DiagnosticCategory.Message, "Remove_type_parameters_90012", "Remove type parameters"),
Add_default_import_0_to_existing_import_declaration_from_1: diag(90033, ts.DiagnosticCategory.Message, "Add_default_import_0_to_existing_import_declaration_from_1_90033", "Add default import '{0}' to existing import declaration from \"{1}\""),
Add_parameter_name: diag(90034, ts.DiagnosticCategory.Message, "Add_parameter_name_90034", "Add parameter name"),
Declare_private_property_0: diag(90035, ts.DiagnosticCategory.Message, "Declare_private_property_0_90035", "Declare private property '{0}'"),
+ Replace_0_with_Promise_1: diag(90036, ts.DiagnosticCategory.Message, "Replace_0_with_Promise_1_90036", "Replace '{0}' with 'Promise<{1}>'"),
+ Fix_all_incorrect_return_type_of_an_async_functions: diag(90037, ts.DiagnosticCategory.Message, "Fix_all_incorrect_return_type_of_an_async_functions_90037", "Fix all incorrect return type of an async functions"),
+ Declare_private_method_0: diag(90038, ts.DiagnosticCategory.Message, "Declare_private_method_0_90038", "Declare private method '{0}'"),
+ Remove_unused_destructuring_declaration: diag(90039, ts.DiagnosticCategory.Message, "Remove_unused_destructuring_declaration_90039", "Remove unused destructuring declaration"),
+ Remove_unused_declarations_for_Colon_0: diag(90041, ts.DiagnosticCategory.Message, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"),
Declare_a_private_field_named_0: diag(90053, ts.DiagnosticCategory.Message, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."),
Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
Convert_function_0_to_class: diag(95002, ts.DiagnosticCategory.Message, "Convert_function_0_to_class_95002", "Convert function '{0}' to class"),
+ Convert_0_to_1_in_0: diag(95003, ts.DiagnosticCategory.Message, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
Extract_function: diag(95005, ts.DiagnosticCategory.Message, "Extract_function_95005", "Extract function"),
Extract_constant: diag(95006, ts.DiagnosticCategory.Message, "Extract_constant_95006", "Extract constant"),
Add_undefined_type_to_property_0: diag(95018, ts.DiagnosticCategory.Message, "Add_undefined_type_to_property_0_95018", "Add 'undefined' type to property '{0}'"),
Add_initializer_to_property_0: diag(95019, ts.DiagnosticCategory.Message, "Add_initializer_to_property_0_95019", "Add initializer to property '{0}'"),
Add_definite_assignment_assertion_to_property_0: diag(95020, ts.DiagnosticCategory.Message, "Add_definite_assignment_assertion_to_property_0_95020", "Add definite assignment assertion to property '{0}'"),
+ Convert_all_type_literals_to_mapped_type: diag(95021, ts.DiagnosticCategory.Message, "Convert_all_type_literals_to_mapped_type_95021", "Convert all type literals to mapped type"),
Add_all_missing_members: diag(95022, ts.DiagnosticCategory.Message, "Add_all_missing_members_95022", "Add all missing members"),
Infer_all_types_from_usage: diag(95023, ts.DiagnosticCategory.Message, "Infer_all_types_from_usage_95023", "Infer all types from usage"),
Delete_all_unused_declarations: diag(95024, ts.DiagnosticCategory.Message, "Delete_all_unused_declarations_95024", "Delete all unused declarations"),
Wrap_all_invalid_characters_in_an_expression_container: diag(95109, ts.DiagnosticCategory.Message, "Wrap_all_invalid_characters_in_an_expression_container_95109", "Wrap all invalid characters in an expression container"),
Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_json_to_read_more_about_this_file: diag(95110, ts.DiagnosticCategory.Message, "Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_json_to_read_more_about_this_file_95110", "Visit https://aka.ms/tsconfig.json to read more about this file"),
Add_a_return_statement: diag(95111, ts.DiagnosticCategory.Message, "Add_a_return_statement_95111", "Add a return statement"),
- Remove_block_body_braces: diag(95112, ts.DiagnosticCategory.Message, "Remove_block_body_braces_95112", "Remove block body braces"),
+ Remove_braces_from_arrow_function_body: diag(95112, ts.DiagnosticCategory.Message, "Remove_braces_from_arrow_function_body_95112", "Remove braces from arrow function body"),
Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal: diag(95113, ts.DiagnosticCategory.Message, "Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal_95113", "Wrap the following body with parentheses which should be an object literal"),
Add_all_missing_return_statement: diag(95114, ts.DiagnosticCategory.Message, "Add_all_missing_return_statement_95114", "Add all missing return statement"),
- Remove_all_incorrect_body_block_braces: diag(95115, ts.DiagnosticCategory.Message, "Remove_all_incorrect_body_block_braces_95115", "Remove all incorrect body block braces"),
+ Remove_braces_from_all_arrow_function_bodies_with_relevant_issues: diag(95115, ts.DiagnosticCategory.Message, "Remove_braces_from_all_arrow_function_bodies_with_relevant_issues_95115", "Remove braces from all arrow function bodies with relevant issues"),
Wrap_all_object_literal_with_parentheses: diag(95116, ts.DiagnosticCategory.Message, "Wrap_all_object_literal_with_parentheses_95116", "Wrap all object literal with parentheses"),
+ Move_labeled_tuple_element_modifiers_to_labels: diag(95117, ts.DiagnosticCategory.Message, "Move_labeled_tuple_element_modifiers_to_labels_95117", "Move labeled tuple element modifiers to labels"),
+ Convert_overload_list_to_single_signature: diag(95118, ts.DiagnosticCategory.Message, "Convert_overload_list_to_single_signature_95118", "Convert overload list to single signature"),
+ Generate_get_and_set_accessors_for_all_overriding_properties: diag(95119, ts.DiagnosticCategory.Message, "Generate_get_and_set_accessors_for_all_overriding_properties_95119", "Generate 'get' and 'set' accessors for all overriding properties"),
+ Wrap_in_JSX_fragment: diag(95120, ts.DiagnosticCategory.Message, "Wrap_in_JSX_fragment_95120", "Wrap in JSX fragment"),
+ Wrap_all_unparented_JSX_in_JSX_fragment: diag(95121, ts.DiagnosticCategory.Message, "Wrap_all_unparented_JSX_in_JSX_fragment_95121", "Wrap all unparented JSX in JSX fragment"),
+ Convert_arrow_function_or_function_expression: diag(95122, ts.DiagnosticCategory.Message, "Convert_arrow_function_or_function_expression_95122", "Convert arrow function or function expression"),
+ Convert_to_anonymous_function: diag(95123, ts.DiagnosticCategory.Message, "Convert_to_anonymous_function_95123", "Convert to anonymous function"),
+ Convert_to_named_function: diag(95124, ts.DiagnosticCategory.Message, "Convert_to_named_function_95124", "Convert to named function"),
+ Convert_to_arrow_function: diag(95125, ts.DiagnosticCategory.Message, "Convert_to_arrow_function_95125", "Convert to arrow function"),
+ Remove_parentheses: diag(95126, ts.DiagnosticCategory.Message, "Remove_parentheses_95126", "Remove parentheses"),
+ Could_not_find_a_containing_arrow_function: diag(95127, ts.DiagnosticCategory.Message, "Could_not_find_a_containing_arrow_function_95127", "Could not find a containing arrow function"),
+ Containing_function_is_not_an_arrow_function: diag(95128, ts.DiagnosticCategory.Message, "Containing_function_is_not_an_arrow_function_95128", "Containing function is not an arrow function"),
+ Could_not_find_export_statement: diag(95129, ts.DiagnosticCategory.Message, "Could_not_find_export_statement_95129", "Could not find export statement"),
+ This_file_already_has_a_default_export: diag(95130, ts.DiagnosticCategory.Message, "This_file_already_has_a_default_export_95130", "This file already has a default export"),
+ Could_not_find_import_clause: diag(95131, ts.DiagnosticCategory.Message, "Could_not_find_import_clause_95131", "Could not find import clause"),
+ Could_not_find_namespace_import_or_named_imports: diag(95132, ts.DiagnosticCategory.Message, "Could_not_find_namespace_import_or_named_imports_95132", "Could not find namespace import or named imports"),
+ Selection_is_not_a_valid_type_node: diag(95133, ts.DiagnosticCategory.Message, "Selection_is_not_a_valid_type_node_95133", "Selection is not a valid type node"),
+ No_type_could_be_extracted_from_this_type_node: diag(95134, ts.DiagnosticCategory.Message, "No_type_could_be_extracted_from_this_type_node_95134", "No type could be extracted from this type node"),
+ Could_not_find_property_for_which_to_generate_accessor: diag(95135, ts.DiagnosticCategory.Message, "Could_not_find_property_for_which_to_generate_accessor_95135", "Could not find property for which to generate accessor"),
+ Name_is_not_valid: diag(95136, ts.DiagnosticCategory.Message, "Name_is_not_valid_95136", "Name is not valid"),
+ Can_only_convert_property_with_modifier: diag(95137, ts.DiagnosticCategory.Message, "Can_only_convert_property_with_modifier_95137", "Can only convert property with modifier"),
+ Switch_each_misused_0_to_1: diag(95138, ts.DiagnosticCategory.Message, "Switch_each_misused_0_to_1_95138", "Switch each misused '{0}' to '{1}'"),
+ Convert_to_optional_chain_expression: diag(95139, ts.DiagnosticCategory.Message, "Convert_to_optional_chain_expression_95139", "Convert to optional chain expression"),
+ Could_not_find_convertible_access_expression: diag(95140, ts.DiagnosticCategory.Message, "Could_not_find_convertible_access_expression_95140", "Could not find convertible access expression"),
+ Could_not_find_matching_access_expressions: diag(95141, ts.DiagnosticCategory.Message, "Could_not_find_matching_access_expressions_95141", "Could not find matching access expressions"),
+ Can_only_convert_logical_AND_access_chains: diag(95142, ts.DiagnosticCategory.Message, "Can_only_convert_logical_AND_access_chains_95142", "Can only convert logical AND access chains"),
+ Add_void_to_Promise_resolved_without_a_value: diag(95143, ts.DiagnosticCategory.Message, "Add_void_to_Promise_resolved_without_a_value_95143", "Add 'void' to Promise resolved without a value"),
+ Add_void_to_all_Promises_resolved_without_a_value: diag(95144, ts.DiagnosticCategory.Message, "Add_void_to_all_Promises_resolved_without_a_value_95144", "Add 'void' to all Promises resolved without a value"),
No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
- Private_identifiers_cannot_be_used_as_parameters: diag(18009, ts.DiagnosticCategory.Error, "Private_identifiers_cannot_be_used_as_parameters_18009", "Private identifiers cannot be used as parameters"),
+ Private_identifiers_cannot_be_used_as_parameters: diag(18009, ts.DiagnosticCategory.Error, "Private_identifiers_cannot_be_used_as_parameters_18009", "Private identifiers cannot be used as parameters."),
An_accessibility_modifier_cannot_be_used_with_a_private_identifier: diag(18010, ts.DiagnosticCategory.Error, "An_accessibility_modifier_cannot_be_used_with_a_private_identifier_18010", "An accessibility modifier cannot be used with a private identifier."),
The_operand_of_a_delete_operator_cannot_be_a_private_identifier: diag(18011, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_cannot_be_a_private_identifier_18011", "The operand of a 'delete' operator cannot be a private identifier."),
constructor_is_a_reserved_word: diag(18012, ts.DiagnosticCategory.Error, "constructor_is_a_reserved_word_18012", "'#constructor' is a reserved word."),
Private_identifiers_are_not_allowed_outside_class_bodies: diag(18016, ts.DiagnosticCategory.Error, "Private_identifiers_are_not_allowed_outside_class_bodies_18016", "Private identifiers are not allowed outside class bodies."),
The_shadowing_declaration_of_0_is_defined_here: diag(18017, ts.DiagnosticCategory.Error, "The_shadowing_declaration_of_0_is_defined_here_18017", "The shadowing declaration of '{0}' is defined here"),
The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here: diag(18018, ts.DiagnosticCategory.Error, "The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here_18018", "The declaration of '{0}' that you probably intended to use is defined here"),
- _0_modifier_cannot_be_used_with_a_private_identifier: diag(18019, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_a_private_identifier_18019", "'{0}' modifier cannot be used with a private identifier"),
+ _0_modifier_cannot_be_used_with_a_private_identifier: diag(18019, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_a_private_identifier_18019", "'{0}' modifier cannot be used with a private identifier."),
A_method_cannot_be_named_with_a_private_identifier: diag(18022, ts.DiagnosticCategory.Error, "A_method_cannot_be_named_with_a_private_identifier_18022", "A method cannot be named with a private identifier."),
An_accessor_cannot_be_named_with_a_private_identifier: diag(18023, ts.DiagnosticCategory.Error, "An_accessor_cannot_be_named_with_a_private_identifier_18023", "An accessor cannot be named with a private identifier."),
An_enum_member_cannot_be_named_with_a_private_identifier: diag(18024, ts.DiagnosticCategory.Error, "An_enum_member_cannot_be_named_with_a_private_identifier_18024", "An enum member cannot be named with a private identifier."),
The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents: diag(18031, ts.DiagnosticCategory.Error, "The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituent_18031", "The intersection '{0}' was reduced to 'never' because property '{1}' has conflicting types in some constituents."),
The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some: diag(18032, ts.DiagnosticCategory.Error, "The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_pr_18032", "The intersection '{0}' was reduced to 'never' because property '{1}' exists in multiple constituents and is private in some."),
Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhaustiveness_checks_consider_using_an_object_literal_instead: diag(18033, ts.DiagnosticCategory.Error, "Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhau_18033", "Only numeric enums can have computed members, but this expression has type '{0}'. If you do not need exhaustiveness checks, consider using an object literal instead."),
+ Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compiler_option_is_specified_e_g_Fragment: diag(18034, ts.DiagnosticCategory.Message, "Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compi_18034", "Specify the JSX fragment factory function to use when targeting 'react' JSX emit with 'jsxFactory' compiler option is specified, e.g. 'Fragment'."),
+ Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(18035, ts.DiagnosticCategory.Error, "Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name_18035", "Invalid value for 'jsxFragmentFactory'. '{0}' is not a valid identifier or qualified-name."),
};
})(ts || (ts = {}));
var ts;
(function (ts) {
var _a;
function tokenIsIdentifierOrKeyword(token) {
- return token >= 75;
+ return token >= 78;
}
ts.tokenIsIdentifierOrKeyword = tokenIsIdentifierOrKeyword;
function tokenIsIdentifierOrKeywordOrGreaterThan(token) {
}
ts.tokenIsIdentifierOrKeywordOrGreaterThan = tokenIsIdentifierOrKeywordOrGreaterThan;
var textToKeywordObj = (_a = {
- abstract: 122,
- any: 125,
- as: 123,
- asserts: 124,
- bigint: 151,
- boolean: 128,
- break: 77,
- case: 78,
- catch: 79,
- class: 80,
- continue: 82,
- const: 81
+ abstract: 125,
+ any: 128,
+ as: 126,
+ asserts: 127,
+ bigint: 155,
+ boolean: 131,
+ break: 80,
+ case: 81,
+ catch: 82,
+ class: 83,
+ continue: 85,
+ const: 84
},
- _a["" + "constructor"] = 129,
- _a.debugger = 83,
- _a.declare = 130,
- _a.default = 84,
- _a.delete = 85,
- _a.do = 86,
- _a.else = 87,
- _a.enum = 88,
- _a.export = 89,
- _a.extends = 90,
- _a.false = 91,
- _a.finally = 92,
- _a.for = 93,
- _a.from = 149,
- _a.function = 94,
- _a.get = 131,
- _a.if = 95,
- _a.implements = 113,
- _a.import = 96,
- _a.in = 97,
- _a.infer = 132,
- _a.instanceof = 98,
- _a.interface = 114,
- _a.is = 133,
- _a.keyof = 134,
- _a.let = 115,
- _a.module = 135,
- _a.namespace = 136,
- _a.never = 137,
- _a.new = 99,
- _a.null = 100,
- _a.number = 140,
- _a.object = 141,
- _a.package = 116,
- _a.private = 117,
- _a.protected = 118,
- _a.public = 119,
- _a.readonly = 138,
- _a.require = 139,
- _a.global = 150,
- _a.return = 101,
- _a.set = 142,
- _a.static = 120,
- _a.string = 143,
- _a.super = 102,
- _a.switch = 103,
- _a.symbol = 144,
- _a.this = 104,
- _a.throw = 105,
- _a.true = 106,
- _a.try = 107,
- _a.type = 145,
- _a.typeof = 108,
- _a.undefined = 146,
- _a.unique = 147,
- _a.unknown = 148,
- _a.var = 109,
- _a.void = 110,
- _a.while = 111,
- _a.with = 112,
- _a.yield = 121,
- _a.async = 126,
- _a.await = 127,
- _a.of = 152,
+ _a["" + "constructor"] = 132,
+ _a.debugger = 86,
+ _a.declare = 133,
+ _a.default = 87,
+ _a.delete = 88,
+ _a.do = 89,
+ _a.else = 90,
+ _a.enum = 91,
+ _a.export = 92,
+ _a.extends = 93,
+ _a.false = 94,
+ _a.finally = 95,
+ _a.for = 96,
+ _a.from = 153,
+ _a.function = 97,
+ _a.get = 134,
+ _a.if = 98,
+ _a.implements = 116,
+ _a.import = 99,
+ _a.in = 100,
+ _a.infer = 135,
+ _a.instanceof = 101,
+ _a.interface = 117,
+ _a.intrinsic = 136,
+ _a.is = 137,
+ _a.keyof = 138,
+ _a.let = 118,
+ _a.module = 139,
+ _a.namespace = 140,
+ _a.never = 141,
+ _a.new = 102,
+ _a.null = 103,
+ _a.number = 144,
+ _a.object = 145,
+ _a.package = 119,
+ _a.private = 120,
+ _a.protected = 121,
+ _a.public = 122,
+ _a.readonly = 142,
+ _a.require = 143,
+ _a.global = 154,
+ _a.return = 104,
+ _a.set = 146,
+ _a.static = 123,
+ _a.string = 147,
+ _a.super = 105,
+ _a.switch = 106,
+ _a.symbol = 148,
+ _a.this = 107,
+ _a.throw = 108,
+ _a.true = 109,
+ _a.try = 110,
+ _a.type = 149,
+ _a.typeof = 111,
+ _a.undefined = 150,
+ _a.unique = 151,
+ _a.unknown = 152,
+ _a.var = 112,
+ _a.void = 113,
+ _a.while = 114,
+ _a.with = 115,
+ _a.yield = 124,
+ _a.async = 129,
+ _a.await = 130,
+ _a.of = 156,
_a);
- var textToKeyword = ts.createMapFromTemplate(textToKeywordObj);
- var textToToken = ts.createMapFromTemplate(__assign(__assign({}, textToKeywordObj), { "{": 18, "}": 19, "(": 20, ")": 21, "[": 22, "]": 23, ".": 24, "...": 25, ";": 26, ",": 27, "<": 29, ">": 31, "<=": 32, ">=": 33, "==": 34, "!=": 35, "===": 36, "!==": 37, "=>": 38, "+": 39, "-": 40, "**": 42, "*": 41, "/": 43, "%": 44, "++": 45, "--": 46, "<<": 47, "</": 30, ">>": 48, ">>>": 49, "&": 50, "|": 51, "^": 52, "!": 53, "~": 54, "&&": 55, "||": 56, "?": 57, "??": 60, "?.": 28, ":": 58, "=": 62, "+=": 63, "-=": 64, "*=": 65, "**=": 66, "/=": 67, "%=": 68, "<<=": 69, ">>=": 70, ">>>=": 71, "&=": 72, "|=": 73, "^=": 74, "@": 59, "`": 61 }));
+ var textToKeyword = new ts.Map(ts.getEntries(textToKeywordObj));
+ var textToToken = new ts.Map(ts.getEntries(__assign(__assign({}, textToKeywordObj), { "{": 18, "}": 19, "(": 20, ")": 21, "[": 22, "]": 23, ".": 24, "...": 25, ";": 26, ",": 27, "<": 29, ">": 31, "<=": 32, ">=": 33, "==": 34, "!=": 35, "===": 36, "!==": 37, "=>": 38, "+": 39, "-": 40, "**": 42, "*": 41, "/": 43, "%": 44, "++": 45, "--": 46, "<<": 47, "</": 30, ">>": 48, ">>>": 49, "&": 50, "|": 51, "^": 52, "!": 53, "~": 54, "&&": 55, "||": 56, "?": 57, "??": 60, "?.": 28, ":": 58, "=": 62, "+=": 63, "-=": 64, "*=": 65, "**=": 66, "/=": 67, "%=": 68, "<<=": 69, ">>=": 70, ">>>=": 71, "&=": 72, "|=": 73, "^=": 77, "||=": 74, "&&=": 75, "??=": 76, "@": 59, "`": 61 })));
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, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
hasUnicodeEscape: function () { return (tokenFlags & 1024) !== 0; },
hasExtendedUnicodeEscape: function () { return (tokenFlags & 8) !== 0; },
hasPrecedingLineBreak: function () { return (tokenFlags & 1) !== 0; },
- isIdentifier: function () { return token === 75 || token > 112; },
- isReservedWord: function () { return token >= 77 && token <= 112; },
+ hasPrecedingJSDocComment: function () { return (tokenFlags & 2) !== 0; },
+ isIdentifier: function () { return token === 78 || token > 115; },
+ isReservedWord: function () { return token >= 80 && token <= 115; },
isUnterminated: function () { return (tokenFlags & 4) !== 0; },
getCommentDirectives: function () { return commentDirectives; },
+ getNumericLiteralFlags: function () { return tokenFlags & 1008; },
getTokenFlags: function () { return tokenFlags; },
reScanGreaterToken: reScanGreaterToken,
+ reScanAsteriskEqualsToken: reScanAsteriskEqualsToken,
reScanSlashToken: reScanSlashToken,
reScanTemplateToken: reScanTemplateToken,
reScanTemplateHeadOrNoSubstitutionTemplate: reScanTemplateHeadOrNoSubstitutionTemplate,
}
function getIdentifierToken() {
var len = tokenValue.length;
- if (len >= 2 && len <= 11) {
+ if (len >= 2 && len <= 12) {
var ch = tokenValue.charCodeAt(0);
if (ch >= 97 && ch <= 122) {
var keyword = textToKeyword.get(tokenValue);
}
}
}
- return token = 75;
+ return token = 78;
}
function scanBinaryOrOctalDigits(base) {
var value = "";
return token = 44;
case 38:
if (text.charCodeAt(pos + 1) === 38) {
+ if (text.charCodeAt(pos + 2) === 61) {
+ return pos += 3, token = 75;
+ }
return pos += 2, token = 55;
}
if (text.charCodeAt(pos + 1) === 61) {
pos++;
return token = 31;
case 63:
- pos++;
- if (text.charCodeAt(pos) === 46 && !isDigit(text.charCodeAt(pos + 1))) {
- pos++;
- return token = 28;
+ if (text.charCodeAt(pos + 1) === 46 && !isDigit(text.charCodeAt(pos + 2))) {
+ return pos += 2, token = 28;
}
- if (text.charCodeAt(pos) === 63) {
- pos++;
- return token = 60;
+ if (text.charCodeAt(pos + 1) === 63) {
+ if (text.charCodeAt(pos + 2) === 61) {
+ return pos += 3, token = 76;
+ }
+ return pos += 2, token = 60;
}
+ pos++;
return token = 57;
case 91:
pos++;
return token = 23;
case 94:
if (text.charCodeAt(pos + 1) === 61) {
- return pos += 2, token = 74;
+ return pos += 2, token = 77;
}
pos++;
return token = 52;
}
}
if (text.charCodeAt(pos + 1) === 124) {
+ if (text.charCodeAt(pos + 2) === 61) {
+ return pos += 3, token = 74;
+ }
return pos += 2, token = 56;
}
if (text.charCodeAt(pos + 1) === 61) {
tokenValue = "#";
error(ts.Diagnostics.Invalid_character);
}
- return token = 76;
+ return token = 79;
default:
if (isIdentifierStart(ch, languageVersion)) {
pos += charSize(ch);
}
return token;
}
+ function reScanAsteriskEqualsToken() {
+ ts.Debug.assert(token === 65, "'reScanAsteriskEqualsToken' should only be called on a '*='");
+ pos = tokenPos + 1;
+ return token = 62;
+ }
function reScanSlashToken() {
if (token === 43 || token === 67) {
var p = tokenPos + 1;
return token = 5;
case 64:
return token = 59;
- case 10:
case 13:
+ if (text.charCodeAt(pos) === 10) {
+ pos++;
+ }
+ case 10:
tokenFlags |= 1;
return token = 4;
case 42:
}
ts.collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions;
function getTypeParameterOwner(d) {
- if (d && d.kind === 155) {
+ if (d && d.kind === 159) {
for (var current = d; current; current = current.parent) {
- if (isFunctionLike(current) || isClassLike(current) || current.kind === 246) {
+ if (isFunctionLike(current) || isClassLike(current) || current.kind === 253) {
return current;
}
}
}
ts.getTypeParameterOwner = getTypeParameterOwner;
function isParameterPropertyDeclaration(node, parent) {
- return ts.hasModifier(node, 92) && parent.kind === 162;
+ return ts.hasSyntacticModifier(node, 92) && parent.kind === 166;
}
ts.isParameterPropertyDeclaration = isParameterPropertyDeclaration;
function isEmptyBindingPattern(node) {
}
ts.isEmptyBindingPattern = isEmptyBindingPattern;
function isEmptyBindingElement(node) {
- if (isOmittedExpression(node)) {
+ if (ts.isOmittedExpression(node)) {
return true;
}
return isEmptyBindingPattern(node.name);
ts.isEmptyBindingElement = isEmptyBindingElement;
function walkUpBindingElementsAndPatterns(binding) {
var node = binding.parent;
- while (isBindingElement(node.parent)) {
+ while (ts.isBindingElement(node.parent)) {
node = node.parent.parent;
}
return node.parent;
}
ts.walkUpBindingElementsAndPatterns = walkUpBindingElementsAndPatterns;
function getCombinedFlags(node, getFlags) {
- if (isBindingElement(node)) {
+ if (ts.isBindingElement(node)) {
node = walkUpBindingElementsAndPatterns(node);
}
var flags = getFlags(node);
- if (node.kind === 242) {
+ if (node.kind === 249) {
node = node.parent;
}
- if (node && node.kind === 243) {
+ if (node && node.kind === 250) {
flags |= getFlags(node);
node = node.parent;
}
- if (node && node.kind === 225) {
+ if (node && node.kind === 232) {
flags |= getFlags(node);
}
return flags;
}
function getCombinedModifierFlags(node) {
- return getCombinedFlags(node, ts.getModifierFlags);
+ return getCombinedFlags(node, ts.getEffectiveModifierFlags);
}
ts.getCombinedModifierFlags = getCombinedModifierFlags;
+ function getCombinedNodeFlagsAlwaysIncludeJSDoc(node) {
+ return getCombinedFlags(node, ts.getEffectiveModifierFlagsAlwaysIncludeJSDoc);
+ }
+ ts.getCombinedNodeFlagsAlwaysIncludeJSDoc = getCombinedNodeFlagsAlwaysIncludeJSDoc;
function getCombinedNodeFlags(node) {
return getCombinedFlags(node, function (n) { return n.flags; });
}
return !nodeTest || nodeTest(node) ? node : undefined;
}
ts.getOriginalNode = getOriginalNode;
+ function findAncestor(node, callback) {
+ while (node) {
+ var result = callback(node);
+ if (result === "quit") {
+ return undefined;
+ }
+ else if (result) {
+ return node;
+ }
+ node = node.parent;
+ }
+ return undefined;
+ }
+ ts.findAncestor = findAncestor;
function isParseTreeNode(node) {
return (node.flags & 8) === 0;
}
if (node === undefined || isParseTreeNode(node)) {
return node;
}
- node = getOriginalNode(node);
- if (isParseTreeNode(node) && (!nodeTest || nodeTest(node))) {
- return node;
+ node = node.original;
+ while (node) {
+ if (isParseTreeNode(node)) {
+ return !nodeTest || nodeTest(node) ? node : undefined;
+ }
+ node = node.original;
}
- return undefined;
}
ts.getParseTreeNode = getParseTreeNode;
function escapeLeadingUnderscores(identifier) {
return getDeclarationIdentifier(hostNode);
}
switch (hostNode.kind) {
- case 225:
+ case 232:
if (hostNode.declarationList && hostNode.declarationList.declarations[0]) {
return getDeclarationIdentifier(hostNode.declarationList.declarations[0]);
}
break;
- case 226:
+ case 233:
var expr = hostNode.expression;
- if (expr.kind === 209 && expr.operatorToken.kind === 62) {
+ if (expr.kind === 216 && expr.operatorToken.kind === 62) {
expr = expr.left;
}
switch (expr.kind) {
- case 194:
+ case 201:
return expr.name;
- case 195:
+ case 202:
var arg = expr.argumentExpression;
- if (isIdentifier(arg)) {
+ if (ts.isIdentifier(arg)) {
return arg;
}
}
break;
- case 200: {
+ case 207: {
return getDeclarationIdentifier(hostNode.expression);
}
- case 238: {
+ case 245: {
if (isDeclaration(hostNode.statement) || isExpression(hostNode.statement)) {
return getDeclarationIdentifier(hostNode.statement);
}
}
function getDeclarationIdentifier(node) {
var name = getNameOfDeclaration(node);
- return name && isIdentifier(name) ? name : undefined;
+ return name && ts.isIdentifier(name) ? name : undefined;
}
function nodeHasName(statement, name) {
- if (isNamedDeclaration(statement) && isIdentifier(statement.name) && idText(statement.name) === idText(name)) {
+ if (isNamedDeclaration(statement) && ts.isIdentifier(statement.name) && idText(statement.name) === idText(name)) {
return true;
}
- if (isVariableStatement(statement) && ts.some(statement.declarationList.declarations, function (d) { return nodeHasName(d, name); })) {
+ if (ts.isVariableStatement(statement) && ts.some(statement.declarationList.declarations, function (d) { return nodeHasName(d, name); })) {
return true;
}
return false;
ts.isNamedDeclaration = isNamedDeclaration;
function getNonAssignedNameOfDeclaration(declaration) {
switch (declaration.kind) {
- case 75:
+ case 78:
return declaration;
- case 323:
- case 317: {
+ case 333:
+ case 326: {
var name = declaration.name;
- if (name.kind === 153) {
+ if (name.kind === 157) {
return name.right;
}
break;
}
- case 196:
- case 209: {
+ case 203:
+ case 216: {
var expr_1 = declaration;
switch (ts.getAssignmentDeclarationKind(expr_1)) {
case 1:
return undefined;
}
}
- case 322:
+ case 331:
return getNameOfJSDocTypedef(declaration);
- case 316:
+ case 325:
return nameForNamelessJSDocTypedef(declaration);
- case 259: {
+ case 266: {
var expression = declaration.expression;
- return isIdentifier(expression) ? expression : undefined;
+ return ts.isIdentifier(expression) ? expression : undefined;
}
- case 195:
+ case 202:
var expr = declaration;
if (ts.isBindableStaticElementAccessExpression(expr)) {
return expr.argumentExpression;
if (declaration === undefined)
return undefined;
return getNonAssignedNameOfDeclaration(declaration) ||
- (isFunctionExpression(declaration) || isClassExpression(declaration) ? getAssignedName(declaration) : undefined);
+ (ts.isFunctionExpression(declaration) || ts.isClassExpression(declaration) ? getAssignedName(declaration) : undefined);
}
ts.getNameOfDeclaration = getNameOfDeclaration;
function getAssignedName(node) {
if (!node.parent) {
return undefined;
}
- else if (isPropertyAssignment(node.parent) || isBindingElement(node.parent)) {
+ else if (ts.isPropertyAssignment(node.parent) || ts.isBindingElement(node.parent)) {
return node.parent.name;
}
- else if (isBinaryExpression(node.parent) && node === node.parent.right) {
- if (isIdentifier(node.parent.left)) {
+ else if (ts.isBinaryExpression(node.parent) && node === node.parent.right) {
+ if (ts.isIdentifier(node.parent.left)) {
return node.parent.left;
}
else if (ts.isAccessExpression(node.parent.left)) {
return ts.getElementOrPropertyAccessArgumentExpressionOrName(node.parent.left);
}
}
- else if (isVariableDeclaration(node.parent) && isIdentifier(node.parent.name)) {
+ else if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
return node.parent.name;
}
}
- function getJSDocParameterTags(param) {
+ ts.getAssignedName = getAssignedName;
+ function getJSDocParameterTagsWorker(param, noCache) {
if (param.name) {
- if (isIdentifier(param.name)) {
+ if (ts.isIdentifier(param.name)) {
var name_1 = param.name.escapedText;
- return getJSDocTags(param.parent).filter(function (tag) { return isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name_1; });
+ return getJSDocTagsWorker(param.parent, noCache).filter(function (tag) { return ts.isJSDocParameterTag(tag) && ts.isIdentifier(tag.name) && tag.name.escapedText === name_1; });
}
else {
var i = param.parent.parameters.indexOf(param);
ts.Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
- var paramTags = getJSDocTags(param.parent).filter(isJSDocParameterTag);
+ var paramTags = getJSDocTagsWorker(param.parent, noCache).filter(ts.isJSDocParameterTag);
if (i < paramTags.length) {
return [paramTags[i]];
}
}
return ts.emptyArray;
}
+ function getJSDocParameterTags(param) {
+ return getJSDocParameterTagsWorker(param, false);
+ }
ts.getJSDocParameterTags = getJSDocParameterTags;
- function getJSDocTypeParameterTags(param) {
+ function getJSDocParameterTagsNoCache(param) {
+ return getJSDocParameterTagsWorker(param, true);
+ }
+ ts.getJSDocParameterTagsNoCache = getJSDocParameterTagsNoCache;
+ function getJSDocTypeParameterTagsWorker(param, noCache) {
var name = param.name.escapedText;
- return getJSDocTags(param.parent).filter(function (tag) {
- return isJSDocTemplateTag(tag) && tag.typeParameters.some(function (tp) { return tp.name.escapedText === name; });
+ return getJSDocTagsWorker(param.parent, noCache).filter(function (tag) {
+ return ts.isJSDocTemplateTag(tag) && tag.typeParameters.some(function (tp) { return tp.name.escapedText === name; });
});
}
+ function getJSDocTypeParameterTags(param) {
+ return getJSDocTypeParameterTagsWorker(param, false);
+ }
ts.getJSDocTypeParameterTags = getJSDocTypeParameterTags;
+ function getJSDocTypeParameterTagsNoCache(param) {
+ return getJSDocTypeParameterTagsWorker(param, true);
+ }
+ ts.getJSDocTypeParameterTagsNoCache = getJSDocTypeParameterTagsNoCache;
function hasJSDocParameterTags(node) {
- return !!getFirstJSDocTag(node, isJSDocParameterTag);
+ return !!getFirstJSDocTag(node, ts.isJSDocParameterTag);
}
ts.hasJSDocParameterTags = hasJSDocParameterTags;
function getJSDocAugmentsTag(node) {
- return getFirstJSDocTag(node, isJSDocAugmentsTag);
+ return getFirstJSDocTag(node, ts.isJSDocAugmentsTag);
}
ts.getJSDocAugmentsTag = getJSDocAugmentsTag;
function getJSDocImplementsTags(node) {
- return getAllJSDocTags(node, isJSDocImplementsTag);
+ return getAllJSDocTags(node, ts.isJSDocImplementsTag);
}
ts.getJSDocImplementsTags = getJSDocImplementsTags;
function getJSDocClassTag(node) {
- return getFirstJSDocTag(node, isJSDocClassTag);
+ return getFirstJSDocTag(node, ts.isJSDocClassTag);
}
ts.getJSDocClassTag = getJSDocClassTag;
function getJSDocPublicTag(node) {
- return getFirstJSDocTag(node, isJSDocPublicTag);
+ return getFirstJSDocTag(node, ts.isJSDocPublicTag);
}
ts.getJSDocPublicTag = getJSDocPublicTag;
+ function getJSDocPublicTagNoCache(node) {
+ return getFirstJSDocTag(node, ts.isJSDocPublicTag, true);
+ }
+ ts.getJSDocPublicTagNoCache = getJSDocPublicTagNoCache;
function getJSDocPrivateTag(node) {
- return getFirstJSDocTag(node, isJSDocPrivateTag);
+ return getFirstJSDocTag(node, ts.isJSDocPrivateTag);
}
ts.getJSDocPrivateTag = getJSDocPrivateTag;
+ function getJSDocPrivateTagNoCache(node) {
+ return getFirstJSDocTag(node, ts.isJSDocPrivateTag, true);
+ }
+ ts.getJSDocPrivateTagNoCache = getJSDocPrivateTagNoCache;
function getJSDocProtectedTag(node) {
- return getFirstJSDocTag(node, isJSDocProtectedTag);
+ return getFirstJSDocTag(node, ts.isJSDocProtectedTag);
}
ts.getJSDocProtectedTag = getJSDocProtectedTag;
+ function getJSDocProtectedTagNoCache(node) {
+ return getFirstJSDocTag(node, ts.isJSDocProtectedTag, true);
+ }
+ ts.getJSDocProtectedTagNoCache = getJSDocProtectedTagNoCache;
function getJSDocReadonlyTag(node) {
- return getFirstJSDocTag(node, isJSDocReadonlyTag);
+ return getFirstJSDocTag(node, ts.isJSDocReadonlyTag);
}
ts.getJSDocReadonlyTag = getJSDocReadonlyTag;
+ function getJSDocReadonlyTagNoCache(node) {
+ return getFirstJSDocTag(node, ts.isJSDocReadonlyTag, true);
+ }
+ ts.getJSDocReadonlyTagNoCache = getJSDocReadonlyTagNoCache;
+ function getJSDocDeprecatedTag(node) {
+ return getFirstJSDocTag(node, ts.isJSDocDeprecatedTag);
+ }
+ ts.getJSDocDeprecatedTag = getJSDocDeprecatedTag;
+ function getJSDocDeprecatedTagNoCache(node) {
+ return getFirstJSDocTag(node, ts.isJSDocDeprecatedTag, true);
+ }
+ ts.getJSDocDeprecatedTagNoCache = getJSDocDeprecatedTagNoCache;
function getJSDocEnumTag(node) {
- return getFirstJSDocTag(node, isJSDocEnumTag);
+ return getFirstJSDocTag(node, ts.isJSDocEnumTag);
}
ts.getJSDocEnumTag = getJSDocEnumTag;
function getJSDocThisTag(node) {
- return getFirstJSDocTag(node, isJSDocThisTag);
+ return getFirstJSDocTag(node, ts.isJSDocThisTag);
}
ts.getJSDocThisTag = getJSDocThisTag;
function getJSDocReturnTag(node) {
- return getFirstJSDocTag(node, isJSDocReturnTag);
+ return getFirstJSDocTag(node, ts.isJSDocReturnTag);
}
ts.getJSDocReturnTag = getJSDocReturnTag;
function getJSDocTemplateTag(node) {
- return getFirstJSDocTag(node, isJSDocTemplateTag);
+ return getFirstJSDocTag(node, ts.isJSDocTemplateTag);
}
ts.getJSDocTemplateTag = getJSDocTemplateTag;
function getJSDocTypeTag(node) {
- var tag = getFirstJSDocTag(node, isJSDocTypeTag);
+ var tag = getFirstJSDocTag(node, ts.isJSDocTypeTag);
if (tag && tag.typeExpression && tag.typeExpression.type) {
return tag;
}
}
ts.getJSDocTypeTag = getJSDocTypeTag;
function getJSDocType(node) {
- var tag = getFirstJSDocTag(node, isJSDocTypeTag);
- if (!tag && isParameter(node)) {
+ var tag = getFirstJSDocTag(node, ts.isJSDocTypeTag);
+ if (!tag && ts.isParameter(node)) {
tag = ts.find(getJSDocParameterTags(node), function (tag) { return !!tag.typeExpression; });
}
return tag && tag.typeExpression && tag.typeExpression.type;
var typeTag = getJSDocTypeTag(node);
if (typeTag && typeTag.typeExpression) {
var type = typeTag.typeExpression.type;
- if (isTypeLiteralNode(type)) {
- var sig = ts.find(type.members, isCallSignatureDeclaration);
+ if (ts.isTypeLiteralNode(type)) {
+ var sig = ts.find(type.members, ts.isCallSignatureDeclaration);
return sig && sig.type;
}
- if (isFunctionTypeNode(type) || isJSDocFunctionType(type)) {
+ if (ts.isFunctionTypeNode(type) || ts.isJSDocFunctionType(type)) {
return type.type;
}
}
}
ts.getJSDocReturnType = getJSDocReturnType;
- function getJSDocTags(node) {
+ function getJSDocTagsWorker(node, noCache) {
var tags = node.jsDocCache;
- if (tags === undefined) {
- var comments = ts.getJSDocCommentsAndTags(node);
+ if (tags === undefined || noCache) {
+ var comments = ts.getJSDocCommentsAndTags(node, noCache);
ts.Debug.assert(comments.length < 2 || comments[0] !== comments[1]);
- node.jsDocCache = tags = ts.flatMap(comments, function (j) { return isJSDoc(j) ? j.tags : j; });
+ tags = ts.flatMap(comments, function (j) { return ts.isJSDoc(j) ? j.tags : j; });
+ if (!noCache) {
+ node.jsDocCache = tags;
+ }
}
return tags;
}
+ function getJSDocTags(node) {
+ return getJSDocTagsWorker(node, false);
+ }
ts.getJSDocTags = getJSDocTags;
- function getFirstJSDocTag(node, predicate) {
- return ts.find(getJSDocTags(node), predicate);
+ function getJSDocTagsNoCache(node) {
+ return getJSDocTagsWorker(node, true);
+ }
+ ts.getJSDocTagsNoCache = getJSDocTagsNoCache;
+ function getFirstJSDocTag(node, predicate, noCache) {
+ return ts.find(getJSDocTagsWorker(node, noCache), predicate);
}
function getAllJSDocTags(node, predicate) {
return getJSDocTags(node).filter(predicate);
}
ts.getAllJSDocTagsOfKind = getAllJSDocTagsOfKind;
function getEffectiveTypeParameterDeclarations(node) {
- if (isJSDocSignature(node)) {
+ if (ts.isJSDocSignature(node)) {
return ts.emptyArray;
}
if (ts.isJSDocTypeAlias(node)) {
- ts.Debug.assert(node.parent.kind === 303);
- return ts.flatMap(node.parent.tags, function (tag) { return isJSDocTemplateTag(tag) ? tag.typeParameters : undefined; });
+ ts.Debug.assert(node.parent.kind === 311);
+ return ts.flatMap(node.parent.tags, function (tag) { return ts.isJSDocTemplateTag(tag) ? tag.typeParameters : undefined; });
}
if (node.typeParameters) {
return node.typeParameters;
return decls;
}
var typeTag = getJSDocType(node);
- if (typeTag && isFunctionTypeNode(typeTag) && typeTag.typeParameters) {
+ if (typeTag && ts.isFunctionTypeNode(typeTag) && typeTag.typeParameters) {
return typeTag.typeParameters;
}
}
ts.getEffectiveTypeParameterDeclarations = getEffectiveTypeParameterDeclarations;
function getEffectiveConstraintOfTypeParameter(node) {
return node.constraint ? node.constraint :
- isJSDocTemplateTag(node.parent) && node === node.parent.typeParameters[0] ? node.parent.constraint :
+ ts.isJSDocTemplateTag(node.parent) && node === node.parent.typeParameters[0] ? node.parent.constraint :
undefined;
}
ts.getEffectiveConstraintOfTypeParameter = getEffectiveConstraintOfTypeParameter;
- function isNumericLiteral(node) {
- return node.kind === 8;
- }
- ts.isNumericLiteral = isNumericLiteral;
- function isBigIntLiteral(node) {
- return node.kind === 9;
- }
- ts.isBigIntLiteral = isBigIntLiteral;
- function isStringLiteral(node) {
- return node.kind === 10;
- }
- ts.isStringLiteral = isStringLiteral;
- function isJsxText(node) {
- return node.kind === 11;
- }
- ts.isJsxText = isJsxText;
- function isRegularExpressionLiteral(node) {
- return node.kind === 13;
- }
- ts.isRegularExpressionLiteral = isRegularExpressionLiteral;
- function isNoSubstitutionTemplateLiteral(node) {
- return node.kind === 14;
- }
- ts.isNoSubstitutionTemplateLiteral = isNoSubstitutionTemplateLiteral;
- function isTemplateHead(node) {
- return node.kind === 15;
- }
- ts.isTemplateHead = isTemplateHead;
- function isTemplateMiddle(node) {
- return node.kind === 16;
- }
- ts.isTemplateMiddle = isTemplateMiddle;
- function isTemplateTail(node) {
- return node.kind === 17;
- }
- ts.isTemplateTail = isTemplateTail;
- function isIdentifier(node) {
- return node.kind === 75;
- }
- ts.isIdentifier = isIdentifier;
- function isQualifiedName(node) {
- return node.kind === 153;
- }
- ts.isQualifiedName = isQualifiedName;
- function isComputedPropertyName(node) {
- return node.kind === 154;
- }
- ts.isComputedPropertyName = isComputedPropertyName;
- function isPrivateIdentifier(node) {
- return node.kind === 76;
- }
- ts.isPrivateIdentifier = isPrivateIdentifier;
function isIdentifierOrPrivateIdentifier(node) {
- return node.kind === 75 || node.kind === 76;
+ return node.kind === 78 || node.kind === 79;
}
ts.isIdentifierOrPrivateIdentifier = isIdentifierOrPrivateIdentifier;
- function isTypeParameterDeclaration(node) {
- return node.kind === 155;
- }
- ts.isTypeParameterDeclaration = isTypeParameterDeclaration;
- function isParameter(node) {
- return node.kind === 156;
- }
- ts.isParameter = isParameter;
- function isDecorator(node) {
- return node.kind === 157;
- }
- ts.isDecorator = isDecorator;
- function isPropertySignature(node) {
- return node.kind === 158;
- }
- ts.isPropertySignature = isPropertySignature;
- function isPropertyDeclaration(node) {
- return node.kind === 159;
- }
- ts.isPropertyDeclaration = isPropertyDeclaration;
- function isMethodSignature(node) {
- return node.kind === 160;
- }
- ts.isMethodSignature = isMethodSignature;
- function isMethodDeclaration(node) {
- return node.kind === 161;
- }
- ts.isMethodDeclaration = isMethodDeclaration;
- function isConstructorDeclaration(node) {
- return node.kind === 162;
- }
- ts.isConstructorDeclaration = isConstructorDeclaration;
- function isGetAccessorDeclaration(node) {
- return node.kind === 163;
- }
- ts.isGetAccessorDeclaration = isGetAccessorDeclaration;
- function isSetAccessorDeclaration(node) {
- return node.kind === 164;
- }
- ts.isSetAccessorDeclaration = isSetAccessorDeclaration;
- function isCallSignatureDeclaration(node) {
- return node.kind === 165;
- }
- ts.isCallSignatureDeclaration = isCallSignatureDeclaration;
- function isConstructSignatureDeclaration(node) {
- return node.kind === 166;
- }
- ts.isConstructSignatureDeclaration = isConstructSignatureDeclaration;
- function isIndexSignatureDeclaration(node) {
- return node.kind === 167;
- }
- ts.isIndexSignatureDeclaration = isIndexSignatureDeclaration;
function isGetOrSetAccessorDeclaration(node) {
- return node.kind === 164 || node.kind === 163;
+ return node.kind === 168 || node.kind === 167;
}
ts.isGetOrSetAccessorDeclaration = isGetOrSetAccessorDeclaration;
- function isTypePredicateNode(node) {
- return node.kind === 168;
- }
- ts.isTypePredicateNode = isTypePredicateNode;
- function isTypeReferenceNode(node) {
- return node.kind === 169;
- }
- ts.isTypeReferenceNode = isTypeReferenceNode;
- function isFunctionTypeNode(node) {
- return node.kind === 170;
- }
- ts.isFunctionTypeNode = isFunctionTypeNode;
- function isConstructorTypeNode(node) {
- return node.kind === 171;
- }
- ts.isConstructorTypeNode = isConstructorTypeNode;
- function isTypeQueryNode(node) {
- return node.kind === 172;
- }
- ts.isTypeQueryNode = isTypeQueryNode;
- function isTypeLiteralNode(node) {
- return node.kind === 173;
- }
- ts.isTypeLiteralNode = isTypeLiteralNode;
- function isArrayTypeNode(node) {
- return node.kind === 174;
- }
- ts.isArrayTypeNode = isArrayTypeNode;
- function isTupleTypeNode(node) {
- return node.kind === 175;
- }
- ts.isTupleTypeNode = isTupleTypeNode;
- function isUnionTypeNode(node) {
- return node.kind === 178;
- }
- ts.isUnionTypeNode = isUnionTypeNode;
- function isIntersectionTypeNode(node) {
- return node.kind === 179;
- }
- ts.isIntersectionTypeNode = isIntersectionTypeNode;
- function isConditionalTypeNode(node) {
- return node.kind === 180;
- }
- ts.isConditionalTypeNode = isConditionalTypeNode;
- function isInferTypeNode(node) {
- return node.kind === 181;
- }
- ts.isInferTypeNode = isInferTypeNode;
- function isParenthesizedTypeNode(node) {
- return node.kind === 182;
- }
- ts.isParenthesizedTypeNode = isParenthesizedTypeNode;
- function isThisTypeNode(node) {
- return node.kind === 183;
- }
- ts.isThisTypeNode = isThisTypeNode;
- function isTypeOperatorNode(node) {
- return node.kind === 184;
- }
- ts.isTypeOperatorNode = isTypeOperatorNode;
- function isIndexedAccessTypeNode(node) {
- return node.kind === 185;
- }
- ts.isIndexedAccessTypeNode = isIndexedAccessTypeNode;
- function isMappedTypeNode(node) {
- return node.kind === 186;
- }
- ts.isMappedTypeNode = isMappedTypeNode;
- function isLiteralTypeNode(node) {
- return node.kind === 187;
- }
- ts.isLiteralTypeNode = isLiteralTypeNode;
- function isImportTypeNode(node) {
- return node.kind === 188;
- }
- ts.isImportTypeNode = isImportTypeNode;
- function isObjectBindingPattern(node) {
- return node.kind === 189;
- }
- ts.isObjectBindingPattern = isObjectBindingPattern;
- function isArrayBindingPattern(node) {
- return node.kind === 190;
- }
- ts.isArrayBindingPattern = isArrayBindingPattern;
- function isBindingElement(node) {
- return node.kind === 191;
- }
- ts.isBindingElement = isBindingElement;
- function isArrayLiteralExpression(node) {
- return node.kind === 192;
- }
- ts.isArrayLiteralExpression = isArrayLiteralExpression;
- function isObjectLiteralExpression(node) {
- return node.kind === 193;
- }
- ts.isObjectLiteralExpression = isObjectLiteralExpression;
- function isPropertyAccessExpression(node) {
- return node.kind === 194;
- }
- ts.isPropertyAccessExpression = isPropertyAccessExpression;
function isPropertyAccessChain(node) {
- return isPropertyAccessExpression(node) && !!(node.flags & 32);
+ return ts.isPropertyAccessExpression(node) && !!(node.flags & 32);
}
ts.isPropertyAccessChain = isPropertyAccessChain;
- function isElementAccessExpression(node) {
- return node.kind === 195;
- }
- ts.isElementAccessExpression = isElementAccessExpression;
function isElementAccessChain(node) {
- return isElementAccessExpression(node) && !!(node.flags & 32);
+ return ts.isElementAccessExpression(node) && !!(node.flags & 32);
}
ts.isElementAccessChain = isElementAccessChain;
- function isCallExpression(node) {
- return node.kind === 196;
- }
- ts.isCallExpression = isCallExpression;
function isCallChain(node) {
- return isCallExpression(node) && !!(node.flags & 32);
+ return ts.isCallExpression(node) && !!(node.flags & 32);
}
ts.isCallChain = isCallChain;
function isOptionalChain(node) {
var kind = node.kind;
return !!(node.flags & 32) &&
- (kind === 194
- || kind === 195
- || kind === 196
- || kind === 218);
+ (kind === 201
+ || kind === 202
+ || kind === 203
+ || kind === 225);
}
ts.isOptionalChain = isOptionalChain;
function isOptionalChainRoot(node) {
- return isOptionalChain(node) && !isNonNullExpression(node) && !!node.questionDotToken;
+ return isOptionalChain(node) && !ts.isNonNullExpression(node) && !!node.questionDotToken;
}
ts.isOptionalChainRoot = isOptionalChainRoot;
function isExpressionOfOptionalChainRoot(node) {
}
ts.isOutermostOptionalChain = isOutermostOptionalChain;
function isNullishCoalesce(node) {
- return node.kind === 209 && node.operatorToken.kind === 60;
+ return node.kind === 216 && node.operatorToken.kind === 60;
}
ts.isNullishCoalesce = isNullishCoalesce;
- function isNewExpression(node) {
- return node.kind === 197;
- }
- ts.isNewExpression = isNewExpression;
- function isTaggedTemplateExpression(node) {
- return node.kind === 198;
- }
- ts.isTaggedTemplateExpression = isTaggedTemplateExpression;
- function isTypeAssertion(node) {
- return node.kind === 199;
- }
- ts.isTypeAssertion = isTypeAssertion;
function isConstTypeReference(node) {
- return isTypeReferenceNode(node) && isIdentifier(node.typeName) &&
+ return ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) &&
node.typeName.escapedText === "const" && !node.typeArguments;
}
ts.isConstTypeReference = isConstTypeReference;
- function isParenthesizedExpression(node) {
- return node.kind === 200;
- }
- ts.isParenthesizedExpression = isParenthesizedExpression;
function skipPartiallyEmittedExpressions(node) {
return ts.skipOuterExpressions(node, 8);
}
ts.skipPartiallyEmittedExpressions = skipPartiallyEmittedExpressions;
- function isFunctionExpression(node) {
- return node.kind === 201;
- }
- ts.isFunctionExpression = isFunctionExpression;
- function isArrowFunction(node) {
- return node.kind === 202;
- }
- ts.isArrowFunction = isArrowFunction;
- function isDeleteExpression(node) {
- return node.kind === 203;
- }
- ts.isDeleteExpression = isDeleteExpression;
- function isTypeOfExpression(node) {
- return node.kind === 204;
- }
- ts.isTypeOfExpression = isTypeOfExpression;
- function isVoidExpression(node) {
- return node.kind === 205;
- }
- ts.isVoidExpression = isVoidExpression;
- function isAwaitExpression(node) {
- return node.kind === 206;
- }
- ts.isAwaitExpression = isAwaitExpression;
- function isPrefixUnaryExpression(node) {
- return node.kind === 207;
- }
- ts.isPrefixUnaryExpression = isPrefixUnaryExpression;
- function isPostfixUnaryExpression(node) {
- return node.kind === 208;
- }
- ts.isPostfixUnaryExpression = isPostfixUnaryExpression;
- function isBinaryExpression(node) {
- return node.kind === 209;
- }
- ts.isBinaryExpression = isBinaryExpression;
- function isConditionalExpression(node) {
- return node.kind === 210;
- }
- ts.isConditionalExpression = isConditionalExpression;
- function isTemplateExpression(node) {
- return node.kind === 211;
- }
- ts.isTemplateExpression = isTemplateExpression;
- function isYieldExpression(node) {
- return node.kind === 212;
- }
- ts.isYieldExpression = isYieldExpression;
- function isSpreadElement(node) {
- return node.kind === 213;
- }
- ts.isSpreadElement = isSpreadElement;
- function isClassExpression(node) {
- return node.kind === 214;
- }
- ts.isClassExpression = isClassExpression;
- function isOmittedExpression(node) {
- return node.kind === 215;
- }
- ts.isOmittedExpression = isOmittedExpression;
- function isExpressionWithTypeArguments(node) {
- return node.kind === 216;
- }
- ts.isExpressionWithTypeArguments = isExpressionWithTypeArguments;
- function isAsExpression(node) {
- return node.kind === 217;
- }
- ts.isAsExpression = isAsExpression;
- function isNonNullExpression(node) {
- return node.kind === 218;
- }
- ts.isNonNullExpression = isNonNullExpression;
function isNonNullChain(node) {
- return isNonNullExpression(node) && !!(node.flags & 32);
+ return ts.isNonNullExpression(node) && !!(node.flags & 32);
}
ts.isNonNullChain = isNonNullChain;
- function isMetaProperty(node) {
- return node.kind === 219;
- }
- ts.isMetaProperty = isMetaProperty;
- function isTemplateSpan(node) {
- return node.kind === 221;
- }
- ts.isTemplateSpan = isTemplateSpan;
- function isSemicolonClassElement(node) {
- return node.kind === 222;
- }
- ts.isSemicolonClassElement = isSemicolonClassElement;
- function isBlock(node) {
- return node.kind === 223;
- }
- ts.isBlock = isBlock;
- function isVariableStatement(node) {
- return node.kind === 225;
- }
- ts.isVariableStatement = isVariableStatement;
- function isEmptyStatement(node) {
- return node.kind === 224;
- }
- ts.isEmptyStatement = isEmptyStatement;
- function isExpressionStatement(node) {
- return node.kind === 226;
- }
- ts.isExpressionStatement = isExpressionStatement;
- function isIfStatement(node) {
- return node.kind === 227;
- }
- ts.isIfStatement = isIfStatement;
- function isDoStatement(node) {
- return node.kind === 228;
- }
- ts.isDoStatement = isDoStatement;
- function isWhileStatement(node) {
- return node.kind === 229;
- }
- ts.isWhileStatement = isWhileStatement;
- function isForStatement(node) {
- return node.kind === 230;
- }
- ts.isForStatement = isForStatement;
- function isForInStatement(node) {
- return node.kind === 231;
- }
- ts.isForInStatement = isForInStatement;
- function isForOfStatement(node) {
- return node.kind === 232;
- }
- ts.isForOfStatement = isForOfStatement;
- function isContinueStatement(node) {
- return node.kind === 233;
- }
- ts.isContinueStatement = isContinueStatement;
- function isBreakStatement(node) {
- return node.kind === 234;
- }
- ts.isBreakStatement = isBreakStatement;
function isBreakOrContinueStatement(node) {
- return node.kind === 234 || node.kind === 233;
+ return node.kind === 241 || node.kind === 240;
}
ts.isBreakOrContinueStatement = isBreakOrContinueStatement;
- function isReturnStatement(node) {
- return node.kind === 235;
- }
- ts.isReturnStatement = isReturnStatement;
- function isWithStatement(node) {
- return node.kind === 236;
- }
- ts.isWithStatement = isWithStatement;
- function isSwitchStatement(node) {
- return node.kind === 237;
- }
- ts.isSwitchStatement = isSwitchStatement;
- function isLabeledStatement(node) {
- return node.kind === 238;
- }
- ts.isLabeledStatement = isLabeledStatement;
- function isThrowStatement(node) {
- return node.kind === 239;
- }
- ts.isThrowStatement = isThrowStatement;
- function isTryStatement(node) {
- return node.kind === 240;
- }
- ts.isTryStatement = isTryStatement;
- function isDebuggerStatement(node) {
- return node.kind === 241;
- }
- ts.isDebuggerStatement = isDebuggerStatement;
- function isVariableDeclaration(node) {
- return node.kind === 242;
- }
- ts.isVariableDeclaration = isVariableDeclaration;
- function isVariableDeclarationList(node) {
- return node.kind === 243;
- }
- ts.isVariableDeclarationList = isVariableDeclarationList;
- function isFunctionDeclaration(node) {
- return node.kind === 244;
- }
- ts.isFunctionDeclaration = isFunctionDeclaration;
- function isClassDeclaration(node) {
- return node.kind === 245;
- }
- ts.isClassDeclaration = isClassDeclaration;
- function isInterfaceDeclaration(node) {
- return node.kind === 246;
- }
- ts.isInterfaceDeclaration = isInterfaceDeclaration;
- function isTypeAliasDeclaration(node) {
- return node.kind === 247;
- }
- ts.isTypeAliasDeclaration = isTypeAliasDeclaration;
- function isEnumDeclaration(node) {
- return node.kind === 248;
- }
- ts.isEnumDeclaration = isEnumDeclaration;
- function isModuleDeclaration(node) {
- return node.kind === 249;
- }
- ts.isModuleDeclaration = isModuleDeclaration;
- function isModuleBlock(node) {
- return node.kind === 250;
- }
- ts.isModuleBlock = isModuleBlock;
- function isCaseBlock(node) {
- return node.kind === 251;
- }
- ts.isCaseBlock = isCaseBlock;
- function isNamespaceExportDeclaration(node) {
- return node.kind === 252;
- }
- ts.isNamespaceExportDeclaration = isNamespaceExportDeclaration;
- function isImportEqualsDeclaration(node) {
- return node.kind === 253;
- }
- ts.isImportEqualsDeclaration = isImportEqualsDeclaration;
- function isImportDeclaration(node) {
- return node.kind === 254;
- }
- ts.isImportDeclaration = isImportDeclaration;
- function isImportClause(node) {
- return node.kind === 255;
- }
- ts.isImportClause = isImportClause;
- function isNamespaceImport(node) {
- return node.kind === 256;
- }
- ts.isNamespaceImport = isNamespaceImport;
- function isNamespaceExport(node) {
- return node.kind === 262;
- }
- ts.isNamespaceExport = isNamespaceExport;
function isNamedExportBindings(node) {
- return node.kind === 262 || node.kind === 261;
+ return node.kind === 269 || node.kind === 268;
}
ts.isNamedExportBindings = isNamedExportBindings;
- function isNamedImports(node) {
- return node.kind === 257;
- }
- ts.isNamedImports = isNamedImports;
- function isImportSpecifier(node) {
- return node.kind === 258;
- }
- ts.isImportSpecifier = isImportSpecifier;
- function isExportAssignment(node) {
- return node.kind === 259;
- }
- ts.isExportAssignment = isExportAssignment;
- function isExportDeclaration(node) {
- return node.kind === 260;
- }
- ts.isExportDeclaration = isExportDeclaration;
- function isNamedExports(node) {
- return node.kind === 261;
- }
- ts.isNamedExports = isNamedExports;
- function isExportSpecifier(node) {
- return node.kind === 263;
- }
- ts.isExportSpecifier = isExportSpecifier;
- function isMissingDeclaration(node) {
- return node.kind === 264;
- }
- ts.isMissingDeclaration = isMissingDeclaration;
- function isExternalModuleReference(node) {
- return node.kind === 265;
- }
- ts.isExternalModuleReference = isExternalModuleReference;
- function isJsxElement(node) {
- return node.kind === 266;
- }
- ts.isJsxElement = isJsxElement;
- function isJsxSelfClosingElement(node) {
- return node.kind === 267;
- }
- ts.isJsxSelfClosingElement = isJsxSelfClosingElement;
- function isJsxOpeningElement(node) {
- return node.kind === 268;
- }
- ts.isJsxOpeningElement = isJsxOpeningElement;
- function isJsxClosingElement(node) {
- return node.kind === 269;
- }
- ts.isJsxClosingElement = isJsxClosingElement;
- function isJsxFragment(node) {
- return node.kind === 270;
- }
- ts.isJsxFragment = isJsxFragment;
- function isJsxOpeningFragment(node) {
- return node.kind === 271;
- }
- ts.isJsxOpeningFragment = isJsxOpeningFragment;
- function isJsxClosingFragment(node) {
- return node.kind === 272;
- }
- ts.isJsxClosingFragment = isJsxClosingFragment;
- function isJsxAttribute(node) {
- return node.kind === 273;
- }
- ts.isJsxAttribute = isJsxAttribute;
- function isJsxAttributes(node) {
- return node.kind === 274;
- }
- ts.isJsxAttributes = isJsxAttributes;
- function isJsxSpreadAttribute(node) {
- return node.kind === 275;
- }
- ts.isJsxSpreadAttribute = isJsxSpreadAttribute;
- function isJsxExpression(node) {
- return node.kind === 276;
- }
- ts.isJsxExpression = isJsxExpression;
- function isCaseClause(node) {
- return node.kind === 277;
- }
- ts.isCaseClause = isCaseClause;
- function isDefaultClause(node) {
- return node.kind === 278;
- }
- ts.isDefaultClause = isDefaultClause;
- function isHeritageClause(node) {
- return node.kind === 279;
- }
- ts.isHeritageClause = isHeritageClause;
- function isCatchClause(node) {
- return node.kind === 280;
- }
- ts.isCatchClause = isCatchClause;
- function isPropertyAssignment(node) {
- return node.kind === 281;
- }
- ts.isPropertyAssignment = isPropertyAssignment;
- function isShorthandPropertyAssignment(node) {
- return node.kind === 282;
- }
- ts.isShorthandPropertyAssignment = isShorthandPropertyAssignment;
- function isSpreadAssignment(node) {
- return node.kind === 283;
- }
- ts.isSpreadAssignment = isSpreadAssignment;
- function isEnumMember(node) {
- return node.kind === 284;
- }
- ts.isEnumMember = isEnumMember;
- function isSourceFile(node) {
- return node.kind === 290;
- }
- ts.isSourceFile = isSourceFile;
- function isBundle(node) {
- return node.kind === 291;
- }
- ts.isBundle = isBundle;
- function isUnparsedSource(node) {
- return node.kind === 292;
- }
- ts.isUnparsedSource = isUnparsedSource;
- function isUnparsedPrepend(node) {
- return node.kind === 286;
- }
- ts.isUnparsedPrepend = isUnparsedPrepend;
function isUnparsedTextLike(node) {
switch (node.kind) {
- case 287:
- case 288:
+ case 294:
+ case 295:
return true;
default:
return false;
ts.isUnparsedTextLike = isUnparsedTextLike;
function isUnparsedNode(node) {
return isUnparsedTextLike(node) ||
- node.kind === 285 ||
- node.kind === 289;
+ node.kind === 292 ||
+ node.kind === 296;
}
ts.isUnparsedNode = isUnparsedNode;
- function isJSDocTypeExpression(node) {
- return node.kind === 294;
- }
- ts.isJSDocTypeExpression = isJSDocTypeExpression;
- function isJSDocAllType(node) {
- return node.kind === 295;
- }
- ts.isJSDocAllType = isJSDocAllType;
- function isJSDocUnknownType(node) {
- return node.kind === 296;
- }
- ts.isJSDocUnknownType = isJSDocUnknownType;
- function isJSDocNullableType(node) {
- return node.kind === 297;
- }
- ts.isJSDocNullableType = isJSDocNullableType;
- function isJSDocNonNullableType(node) {
- return node.kind === 298;
- }
- ts.isJSDocNonNullableType = isJSDocNonNullableType;
- function isJSDocOptionalType(node) {
- return node.kind === 299;
- }
- ts.isJSDocOptionalType = isJSDocOptionalType;
- function isJSDocFunctionType(node) {
- return node.kind === 300;
- }
- ts.isJSDocFunctionType = isJSDocFunctionType;
- function isJSDocVariadicType(node) {
- return node.kind === 301;
- }
- ts.isJSDocVariadicType = isJSDocVariadicType;
- function isJSDoc(node) {
- return node.kind === 303;
- }
- ts.isJSDoc = isJSDoc;
- function isJSDocAuthorTag(node) {
- return node.kind === 309;
- }
- ts.isJSDocAuthorTag = isJSDocAuthorTag;
- function isJSDocAugmentsTag(node) {
- return node.kind === 307;
- }
- ts.isJSDocAugmentsTag = isJSDocAugmentsTag;
- function isJSDocImplementsTag(node) {
- return node.kind === 308;
- }
- ts.isJSDocImplementsTag = isJSDocImplementsTag;
- function isJSDocClassTag(node) {
- return node.kind === 310;
- }
- ts.isJSDocClassTag = isJSDocClassTag;
- function isJSDocPublicTag(node) {
- return node.kind === 311;
- }
- ts.isJSDocPublicTag = isJSDocPublicTag;
- function isJSDocPrivateTag(node) {
- return node.kind === 312;
- }
- ts.isJSDocPrivateTag = isJSDocPrivateTag;
- function isJSDocProtectedTag(node) {
- return node.kind === 313;
- }
- ts.isJSDocProtectedTag = isJSDocProtectedTag;
- function isJSDocReadonlyTag(node) {
- return node.kind === 314;
- }
- ts.isJSDocReadonlyTag = isJSDocReadonlyTag;
- function isJSDocEnumTag(node) {
- return node.kind === 316;
- }
- ts.isJSDocEnumTag = isJSDocEnumTag;
- function isJSDocThisTag(node) {
- return node.kind === 319;
- }
- ts.isJSDocThisTag = isJSDocThisTag;
- function isJSDocParameterTag(node) {
- return node.kind === 317;
- }
- ts.isJSDocParameterTag = isJSDocParameterTag;
- function isJSDocReturnTag(node) {
- return node.kind === 318;
- }
- ts.isJSDocReturnTag = isJSDocReturnTag;
- function isJSDocTypeTag(node) {
- return node.kind === 320;
- }
- ts.isJSDocTypeTag = isJSDocTypeTag;
- function isJSDocTemplateTag(node) {
- return node.kind === 321;
- }
- ts.isJSDocTemplateTag = isJSDocTemplateTag;
- function isJSDocTypedefTag(node) {
- return node.kind === 322;
- }
- ts.isJSDocTypedefTag = isJSDocTypedefTag;
- function isJSDocPropertyTag(node) {
- return node.kind === 323;
- }
- ts.isJSDocPropertyTag = isJSDocPropertyTag;
function isJSDocPropertyLikeTag(node) {
- return node.kind === 323 || node.kind === 317;
+ return node.kind === 333 || node.kind === 326;
}
ts.isJSDocPropertyLikeTag = isJSDocPropertyLikeTag;
- function isJSDocTypeLiteral(node) {
- return node.kind === 304;
- }
- ts.isJSDocTypeLiteral = isJSDocTypeLiteral;
- function isJSDocCallbackTag(node) {
- return node.kind === 315;
- }
- ts.isJSDocCallbackTag = isJSDocCallbackTag;
- function isJSDocSignature(node) {
- return node.kind === 305;
- }
- ts.isJSDocSignature = isJSDocSignature;
- function isSyntaxList(n) {
- return n.kind === 324;
- }
- ts.isSyntaxList = isSyntaxList;
function isNode(node) {
return isNodeKind(node.kind);
}
ts.isNode = isNode;
function isNodeKind(kind) {
- return kind >= 153;
+ return kind >= 157;
}
ts.isNodeKind = isNodeKind;
function isToken(n) {
- return n.kind >= 0 && n.kind <= 152;
+ return n.kind >= 0 && n.kind <= 156;
}
ts.isToken = isToken;
function isNodeArray(array) {
}
ts.isTemplateMiddleOrTemplateTail = isTemplateMiddleOrTemplateTail;
function isImportOrExportSpecifier(node) {
- return isImportSpecifier(node) || isExportSpecifier(node);
+ return ts.isImportSpecifier(node) || ts.isExportSpecifier(node);
}
ts.isImportOrExportSpecifier = isImportOrExportSpecifier;
function isTypeOnlyImportOrExportDeclaration(node) {
switch (node.kind) {
- case 258:
- case 263:
+ case 265:
+ case 270:
return node.parent.parent.isTypeOnly;
- case 256:
+ case 263:
return node.parent.isTypeOnly;
- case 255:
+ case 262:
return node.isTypeOnly;
default:
return false;
}
ts.isStringTextContainingNode = isStringTextContainingNode;
function isGeneratedIdentifier(node) {
- return isIdentifier(node) && (node.autoGenerateFlags & 7) > 0;
+ return ts.isIdentifier(node) && (node.autoGenerateFlags & 7) > 0;
}
ts.isGeneratedIdentifier = isGeneratedIdentifier;
function isPrivateIdentifierPropertyDeclaration(node) {
- return isPropertyDeclaration(node) && isPrivateIdentifier(node.name);
+ return ts.isPropertyDeclaration(node) && ts.isPrivateIdentifier(node.name);
}
ts.isPrivateIdentifierPropertyDeclaration = isPrivateIdentifierPropertyDeclaration;
function isPrivateIdentifierPropertyAccessExpression(node) {
- return isPropertyAccessExpression(node) && isPrivateIdentifier(node.name);
+ return ts.isPropertyAccessExpression(node) && ts.isPrivateIdentifier(node.name);
}
ts.isPrivateIdentifierPropertyAccessExpression = isPrivateIdentifierPropertyAccessExpression;
function isModifierKind(token) {
switch (token) {
- case 122:
- case 126:
- case 81:
- case 130:
+ case 125:
+ case 129:
case 84:
- case 89:
- case 119:
- case 117:
- case 118:
- case 138:
+ case 133:
+ case 87:
+ case 92:
+ case 122:
case 120:
+ case 121:
+ case 142:
+ case 123:
return true;
}
return false;
}
ts.isParameterPropertyModifier = isParameterPropertyModifier;
function isClassMemberModifier(idToken) {
- return isParameterPropertyModifier(idToken) || idToken === 120;
+ return isParameterPropertyModifier(idToken) || idToken === 123;
}
ts.isClassMemberModifier = isClassMemberModifier;
function isModifier(node) {
ts.isModifier = isModifier;
function isEntityName(node) {
var kind = node.kind;
- return kind === 153
- || kind === 75;
+ return kind === 157
+ || kind === 78;
}
ts.isEntityName = isEntityName;
function isPropertyName(node) {
var kind = node.kind;
- return kind === 75
- || kind === 76
+ return kind === 78
+ || kind === 79
|| kind === 10
|| kind === 8
- || kind === 154;
+ || kind === 158;
}
ts.isPropertyName = isPropertyName;
function isBindingName(node) {
var kind = node.kind;
- return kind === 75
- || kind === 189
- || kind === 190;
+ return kind === 78
+ || kind === 196
+ || kind === 197;
}
ts.isBindingName = isBindingName;
function isFunctionLike(node) {
ts.isFunctionLikeDeclaration = isFunctionLikeDeclaration;
function isFunctionLikeDeclarationKind(kind) {
switch (kind) {
- case 244:
- case 161:
- case 162:
- case 163:
- case 164:
- case 201:
- case 202:
+ case 251:
+ case 165:
+ case 166:
+ case 167:
+ case 168:
+ case 208:
+ case 209:
return true;
default:
return false;
}
function isFunctionLikeKind(kind) {
switch (kind) {
- case 160:
- case 165:
- case 305:
- case 166:
- case 167:
+ case 164:
+ case 169:
+ case 313:
case 170:
- case 300:
case 171:
- return true;
- default:
+ case 174:
+ case 308:
+ case 175:
+ return true;
+ default:
return isFunctionLikeDeclarationKind(kind);
}
}
ts.isFunctionLikeKind = isFunctionLikeKind;
function isFunctionOrModuleBlock(node) {
- return isSourceFile(node) || isModuleBlock(node) || isBlock(node) && isFunctionLike(node.parent);
+ return ts.isSourceFile(node) || ts.isModuleBlock(node) || ts.isBlock(node) && isFunctionLike(node.parent);
}
ts.isFunctionOrModuleBlock = isFunctionOrModuleBlock;
function isClassElement(node) {
var kind = node.kind;
- return kind === 162
- || kind === 159
- || kind === 161
+ return kind === 166
|| kind === 163
- || kind === 164
+ || kind === 165
|| kind === 167
- || kind === 222;
+ || kind === 168
+ || kind === 171
+ || kind === 229;
}
ts.isClassElement = isClassElement;
function isClassLike(node) {
- return node && (node.kind === 245 || node.kind === 214);
+ return node && (node.kind === 252 || node.kind === 221);
}
ts.isClassLike = isClassLike;
function isAccessor(node) {
- return node && (node.kind === 163 || node.kind === 164);
+ return node && (node.kind === 167 || node.kind === 168);
}
ts.isAccessor = isAccessor;
function isMethodOrAccessor(node) {
switch (node.kind) {
- case 161:
- case 163:
- case 164:
+ case 165:
+ case 167:
+ case 168:
return true;
default:
return false;
ts.isMethodOrAccessor = isMethodOrAccessor;
function isTypeElement(node) {
var kind = node.kind;
- return kind === 166
- || kind === 165
- || kind === 158
- || kind === 160
- || kind === 167;
+ return kind === 170
+ || kind === 169
+ || kind === 162
+ || kind === 164
+ || kind === 171;
}
ts.isTypeElement = isTypeElement;
function isClassOrTypeElement(node) {
ts.isClassOrTypeElement = isClassOrTypeElement;
function isObjectLiteralElementLike(node) {
var kind = node.kind;
- return kind === 281
- || kind === 282
- || kind === 283
- || kind === 161
- || kind === 163
- || kind === 164;
+ return kind === 288
+ || kind === 289
+ || kind === 290
+ || kind === 165
+ || kind === 167
+ || kind === 168;
}
ts.isObjectLiteralElementLike = isObjectLiteralElementLike;
function isTypeNode(node) {
ts.isTypeNode = isTypeNode;
function isFunctionOrConstructorTypeNode(node) {
switch (node.kind) {
- case 170:
- case 171:
+ case 174:
+ case 175:
return true;
}
return false;
function isBindingPattern(node) {
if (node) {
var kind = node.kind;
- return kind === 190
- || kind === 189;
+ return kind === 197
+ || kind === 196;
}
return false;
}
ts.isBindingPattern = isBindingPattern;
function isAssignmentPattern(node) {
var kind = node.kind;
- return kind === 192
- || kind === 193;
+ return kind === 199
+ || kind === 200;
}
ts.isAssignmentPattern = isAssignmentPattern;
function isArrayBindingElement(node) {
var kind = node.kind;
- return kind === 191
- || kind === 215;
+ return kind === 198
+ || kind === 222;
}
ts.isArrayBindingElement = isArrayBindingElement;
function isDeclarationBindingElement(bindingElement) {
switch (bindingElement.kind) {
- case 242:
- case 156:
- case 191:
+ case 249:
+ case 160:
+ case 198:
return true;
}
return false;
ts.isBindingOrAssignmentPattern = isBindingOrAssignmentPattern;
function isObjectBindingOrAssignmentPattern(node) {
switch (node.kind) {
- case 189:
- case 193:
+ case 196:
+ case 200:
return true;
}
return false;
ts.isObjectBindingOrAssignmentPattern = isObjectBindingOrAssignmentPattern;
function isArrayBindingOrAssignmentPattern(node) {
switch (node.kind) {
- case 190:
- case 192:
+ case 197:
+ case 199:
return true;
}
return false;
ts.isArrayBindingOrAssignmentPattern = isArrayBindingOrAssignmentPattern;
function isPropertyAccessOrQualifiedNameOrImportTypeNode(node) {
var kind = node.kind;
- return kind === 194
- || kind === 153
- || kind === 188;
+ return kind === 201
+ || kind === 157
+ || kind === 195;
}
ts.isPropertyAccessOrQualifiedNameOrImportTypeNode = isPropertyAccessOrQualifiedNameOrImportTypeNode;
function isPropertyAccessOrQualifiedName(node) {
var kind = node.kind;
- return kind === 194
- || kind === 153;
+ return kind === 201
+ || kind === 157;
}
ts.isPropertyAccessOrQualifiedName = isPropertyAccessOrQualifiedName;
function isCallLikeExpression(node) {
switch (node.kind) {
- case 268:
- case 267:
- case 196:
- case 197:
- case 198:
- case 157:
+ case 275:
+ case 274:
+ case 203:
+ case 204:
+ case 205:
+ case 161:
return true;
default:
return false;
}
ts.isCallLikeExpression = isCallLikeExpression;
function isCallOrNewExpression(node) {
- return node.kind === 196 || node.kind === 197;
+ return node.kind === 203 || node.kind === 204;
}
ts.isCallOrNewExpression = isCallOrNewExpression;
function isTemplateLiteral(node) {
var kind = node.kind;
- return kind === 211
+ return kind === 218
|| kind === 14;
}
ts.isTemplateLiteral = isTemplateLiteral;
ts.isLeftHandSideExpression = isLeftHandSideExpression;
function isLeftHandSideExpressionKind(kind) {
switch (kind) {
- case 194:
- case 195:
- case 197:
- case 196:
- case 266:
- case 267:
- case 270:
- case 198:
- case 192:
- case 200:
- case 193:
- case 214:
case 201:
- case 75:
+ case 202:
+ case 204:
+ case 203:
+ case 273:
+ case 274:
+ case 277:
+ case 205:
+ case 199:
+ case 207:
+ case 200:
+ case 221:
+ case 208:
+ case 78:
case 13:
case 8:
case 9:
case 10:
case 14:
- case 211:
- case 91:
- case 100:
- case 104:
- case 106:
- case 102:
case 218:
- case 219:
- case 96:
+ case 94:
+ case 103:
+ case 107:
+ case 109:
+ case 105:
+ case 225:
+ case 226:
+ case 99:
return true;
default:
return false;
ts.isUnaryExpression = isUnaryExpression;
function isUnaryExpressionKind(kind) {
switch (kind) {
- case 207:
- case 208:
- case 203:
- case 204:
- case 205:
+ case 214:
+ case 215:
+ case 210:
+ case 211:
+ case 212:
+ case 213:
case 206:
- case 199:
return true;
default:
return isLeftHandSideExpressionKind(kind);
}
function isUnaryExpressionWithWrite(expr) {
switch (expr.kind) {
- case 208:
+ case 215:
return true;
- case 207:
+ case 214:
return expr.operator === 45 ||
expr.operator === 46;
default:
ts.isExpression = isExpression;
function isExpressionKind(kind) {
switch (kind) {
- case 210:
- case 212:
- case 202:
- case 209:
- case 213:
case 217:
- case 215:
- case 327:
- case 326:
+ case 219:
+ case 209:
+ case 216:
+ case 220:
+ case 224:
+ case 222:
+ case 337:
+ case 336:
return true;
default:
return isUnaryExpressionKind(kind);
}
function isAssertionExpression(node) {
var kind = node.kind;
- return kind === 199
- || kind === 217;
+ return kind === 206
+ || kind === 224;
}
ts.isAssertionExpression = isAssertionExpression;
- function isPartiallyEmittedExpression(node) {
- return node.kind === 326;
- }
- ts.isPartiallyEmittedExpression = isPartiallyEmittedExpression;
- function isNotEmittedStatement(node) {
- return node.kind === 325;
- }
- ts.isNotEmittedStatement = isNotEmittedStatement;
- function isSyntheticReference(node) {
- return node.kind === 330;
- }
- ts.isSyntheticReference = isSyntheticReference;
function isNotEmittedOrPartiallyEmittedNode(node) {
- return isNotEmittedStatement(node)
- || isPartiallyEmittedExpression(node);
+ return ts.isNotEmittedStatement(node)
+ || ts.isPartiallyEmittedExpression(node);
}
ts.isNotEmittedOrPartiallyEmittedNode = isNotEmittedOrPartiallyEmittedNode;
function isIterationStatement(node, lookInLabeledStatements) {
switch (node.kind) {
- case 230:
- case 231:
- case 232:
- case 228:
- case 229:
- return true;
+ case 237:
case 238:
+ case 239:
+ case 235:
+ case 236:
+ return true;
+ case 245:
return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements);
}
return false;
}
ts.isIterationStatement = isIterationStatement;
function isScopeMarker(node) {
- return isExportAssignment(node) || isExportDeclaration(node);
+ return ts.isExportAssignment(node) || ts.isExportDeclaration(node);
}
ts.isScopeMarker = isScopeMarker;
function hasScopeMarker(statements) {
}
ts.hasScopeMarker = hasScopeMarker;
function needsScopeMarker(result) {
- return !ts.isAnyImportOrReExport(result) && !isExportAssignment(result) && !ts.hasModifier(result, 1) && !ts.isAmbientModule(result);
+ return !ts.isAnyImportOrReExport(result) && !ts.isExportAssignment(result) && !ts.hasSyntacticModifier(result, 1) && !ts.isAmbientModule(result);
}
ts.needsScopeMarker = needsScopeMarker;
function isExternalModuleIndicator(result) {
- return ts.isAnyImportOrReExport(result) || isExportAssignment(result) || ts.hasModifier(result, 1);
+ return ts.isAnyImportOrReExport(result) || ts.isExportAssignment(result) || ts.hasSyntacticModifier(result, 1);
}
ts.isExternalModuleIndicator = isExternalModuleIndicator;
function isForInOrOfStatement(node) {
- return node.kind === 231 || node.kind === 232;
+ return node.kind === 238 || node.kind === 239;
}
ts.isForInOrOfStatement = isForInOrOfStatement;
function isConciseBody(node) {
- return isBlock(node)
+ return ts.isBlock(node)
|| isExpression(node);
}
ts.isConciseBody = isConciseBody;
function isFunctionBody(node) {
- return isBlock(node);
+ return ts.isBlock(node);
}
ts.isFunctionBody = isFunctionBody;
function isForInitializer(node) {
- return isVariableDeclarationList(node)
+ return ts.isVariableDeclarationList(node)
|| isExpression(node);
}
ts.isForInitializer = isForInitializer;
function isModuleBody(node) {
var kind = node.kind;
- return kind === 250
- || kind === 249
- || kind === 75;
+ return kind === 257
+ || kind === 256
+ || kind === 78;
}
ts.isModuleBody = isModuleBody;
function isNamespaceBody(node) {
var kind = node.kind;
- return kind === 250
- || kind === 249;
+ return kind === 257
+ || kind === 256;
}
ts.isNamespaceBody = isNamespaceBody;
function isJSDocNamespaceBody(node) {
var kind = node.kind;
- return kind === 75
- || kind === 249;
+ return kind === 78
+ || kind === 256;
}
ts.isJSDocNamespaceBody = isJSDocNamespaceBody;
function isNamedImportBindings(node) {
var kind = node.kind;
- return kind === 257
- || kind === 256;
+ return kind === 264
+ || kind === 263;
}
ts.isNamedImportBindings = isNamedImportBindings;
function isModuleOrEnumDeclaration(node) {
- return node.kind === 249 || node.kind === 248;
+ return node.kind === 256 || node.kind === 255;
}
ts.isModuleOrEnumDeclaration = isModuleOrEnumDeclaration;
function isDeclarationKind(kind) {
- return kind === 202
- || kind === 191
- || kind === 245
- || kind === 214
- || kind === 162
- || kind === 248
- || kind === 284
- || kind === 263
- || kind === 244
- || kind === 201
- || kind === 163
+ return kind === 209
+ || kind === 198
+ || kind === 252
+ || kind === 221
+ || kind === 166
|| kind === 255
+ || kind === 291
+ || kind === 270
+ || kind === 251
+ || kind === 208
+ || kind === 167
+ || kind === 262
+ || kind === 260
+ || kind === 265
|| kind === 253
- || kind === 258
- || kind === 246
- || kind === 273
- || kind === 161
- || kind === 160
- || kind === 249
- || kind === 252
+ || kind === 280
+ || kind === 165
+ || kind === 164
|| kind === 256
- || kind === 262
- || kind === 156
- || kind === 281
+ || kind === 259
+ || kind === 263
+ || kind === 269
+ || kind === 160
+ || kind === 288
+ || kind === 163
+ || kind === 162
+ || kind === 168
+ || kind === 289
+ || kind === 254
|| kind === 159
- || kind === 158
- || kind === 164
- || kind === 282
- || kind === 247
- || kind === 155
- || kind === 242
- || kind === 322
- || kind === 315
- || kind === 323;
+ || kind === 249
+ || kind === 331
+ || kind === 324
+ || kind === 333;
}
function isDeclarationStatementKind(kind) {
- return kind === 244
- || kind === 264
- || kind === 245
- || kind === 246
- || kind === 247
- || kind === 248
- || kind === 249
- || kind === 254
+ return kind === 251
+ || kind === 271
+ || kind === 252
|| kind === 253
+ || kind === 254
+ || kind === 255
+ || kind === 256
+ || kind === 261
|| kind === 260
- || kind === 259
- || kind === 252;
+ || kind === 267
+ || kind === 266
+ || kind === 259;
}
function isStatementKindButNotDeclarationKind(kind) {
- return kind === 234
+ return kind === 241
+ || kind === 240
+ || kind === 248
+ || kind === 235
|| kind === 233
- || kind === 241
- || kind === 228
- || kind === 226
- || kind === 224
|| kind === 231
- || kind === 232
- || kind === 230
- || kind === 227
|| kind === 238
- || kind === 235
- || kind === 237
|| kind === 239
- || kind === 240
- || kind === 225
- || kind === 229
+ || kind === 237
+ || kind === 234
+ || kind === 245
+ || kind === 242
+ || kind === 244
+ || kind === 246
+ || kind === 247
+ || kind === 232
|| kind === 236
- || kind === 325
- || kind === 329
- || kind === 328;
+ || kind === 243
+ || kind === 335
+ || kind === 339
+ || kind === 338;
}
function isDeclaration(node) {
- if (node.kind === 155) {
- return (node.parent && node.parent.kind !== 321) || ts.isInJSFile(node);
+ if (node.kind === 159) {
+ return (node.parent && node.parent.kind !== 330) || ts.isInJSFile(node);
}
return isDeclarationKind(node.kind);
}
}
ts.isStatement = isStatement;
function isBlockStatement(node) {
- if (node.kind !== 223)
+ if (node.kind !== 230)
return false;
if (node.parent !== undefined) {
- if (node.parent.kind === 240 || node.parent.kind === 280) {
+ if (node.parent.kind === 247 || node.parent.kind === 287) {
return false;
}
}
return !ts.isFunctionBlock(node);
}
+ function isStatementOrBlock(node) {
+ var kind = node.kind;
+ return isStatementKindButNotDeclarationKind(kind)
+ || isDeclarationStatementKind(kind)
+ || kind === 230;
+ }
+ ts.isStatementOrBlock = isStatementOrBlock;
function isModuleReference(node) {
var kind = node.kind;
- return kind === 265
- || kind === 153
- || kind === 75;
+ return kind === 272
+ || kind === 157
+ || kind === 78;
}
ts.isModuleReference = isModuleReference;
function isJsxTagNameExpression(node) {
var kind = node.kind;
- return kind === 104
- || kind === 75
- || kind === 194;
+ return kind === 107
+ || kind === 78
+ || kind === 201;
}
ts.isJsxTagNameExpression = isJsxTagNameExpression;
function isJsxChild(node) {
var kind = node.kind;
- return kind === 266
- || kind === 276
- || kind === 267
+ return kind === 273
+ || kind === 283
+ || kind === 274
|| kind === 11
- || kind === 270;
+ || kind === 277;
}
ts.isJsxChild = isJsxChild;
function isJsxAttributeLike(node) {
var kind = node.kind;
- return kind === 273
- || kind === 275;
+ return kind === 280
+ || kind === 282;
}
ts.isJsxAttributeLike = isJsxAttributeLike;
function isStringLiteralOrJsxExpression(node) {
var kind = node.kind;
return kind === 10
- || kind === 276;
+ || kind === 283;
}
ts.isStringLiteralOrJsxExpression = isStringLiteralOrJsxExpression;
function isJsxOpeningLikeElement(node) {
var kind = node.kind;
- return kind === 268
- || kind === 267;
+ return kind === 275
+ || kind === 274;
}
ts.isJsxOpeningLikeElement = isJsxOpeningLikeElement;
function isCaseOrDefaultClause(node) {
var kind = node.kind;
- return kind === 277
- || kind === 278;
+ return kind === 284
+ || kind === 285;
}
ts.isCaseOrDefaultClause = isCaseOrDefaultClause;
function isJSDocNode(node) {
- return node.kind >= 294 && node.kind <= 323;
+ return node.kind >= 301 && node.kind <= 333;
}
ts.isJSDocNode = isJSDocNode;
function isJSDocCommentContainingNode(node) {
- return node.kind === 303 || node.kind === 302 || isJSDocTag(node) || isJSDocTypeLiteral(node) || isJSDocSignature(node);
+ return node.kind === 311 || node.kind === 310 || isJSDocTag(node) || ts.isJSDocTypeLiteral(node) || ts.isJSDocSignature(node);
}
ts.isJSDocCommentContainingNode = isJSDocCommentContainingNode;
function isJSDocTag(node) {
- return node.kind >= 306 && node.kind <= 323;
+ return node.kind >= 314 && node.kind <= 333;
}
ts.isJSDocTag = isJSDocTag;
function isSetAccessor(node) {
- return node.kind === 164;
+ return node.kind === 168;
}
ts.isSetAccessor = isSetAccessor;
function isGetAccessor(node) {
- return node.kind === 163;
+ return node.kind === 167;
}
ts.isGetAccessor = isGetAccessor;
function hasJSDocNodes(node) {
ts.hasInitializer = hasInitializer;
function hasOnlyExpressionInitializer(node) {
switch (node.kind) {
- case 242:
- case 156:
- case 191:
- case 158:
- case 159:
- case 281:
- case 284:
+ case 249:
+ case 160:
+ case 198:
+ case 162:
+ case 163:
+ case 288:
+ case 291:
return true;
default:
return false;
}
ts.hasOnlyExpressionInitializer = hasOnlyExpressionInitializer;
function isObjectLiteralElement(node) {
- return node.kind === 273 || node.kind === 275 || isObjectLiteralElementLike(node);
+ return node.kind === 280 || node.kind === 282 || isObjectLiteralElementLike(node);
}
ts.isObjectLiteralElement = isObjectLiteralElement;
function isTypeReferenceType(node) {
- return node.kind === 169 || node.kind === 216;
+ return node.kind === 173 || node.kind === 223;
}
ts.isTypeReferenceType = isTypeReferenceType;
var MAX_SMI_X86 = 1073741823;
var ts;
(function (ts) {
ts.resolvingEmptyArray = [];
- ts.emptyMap = ts.createMap();
- ts.emptyUnderscoreEscapedMap = ts.emptyMap;
ts.externalHelpersModuleNameText = "tslib";
ts.defaultMaximumTruncationLength = 160;
ts.noTruncationMaximumTruncationLength = 1000000;
}
ts.hasEntries = hasEntries;
function createSymbolTable(symbols) {
- var result = ts.createMap();
+ var result = new ts.Map();
if (symbols) {
for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
var symbol = symbols_1[_i];
});
}
ts.optionsHaveModuleResolutionChanges = optionsHaveModuleResolutionChanges;
- function findAncestor(node, callback) {
- while (node) {
- var result = callback(node);
- if (result === "quit") {
- return undefined;
- }
- else if (result) {
- return node;
- }
- node = node.parent;
- }
- return undefined;
- }
- ts.findAncestor = findAncestor;
function forEachAncestor(node, callback) {
while (true) {
var res = callback(node);
});
}
ts.copyEntries = copyEntries;
- function arrayToSet(array, makeKey) {
- return ts.arrayToMap(array, makeKey || (function (s) { return s; }), ts.returnTrue);
- }
- ts.arrayToSet = arrayToSet;
- function cloneMap(map) {
- var clone = ts.createMap();
- copyEntries(map, clone);
- return clone;
- }
- ts.cloneMap = cloneMap;
function usingSingleLineStringWriter(action) {
var oldString = stringWriter.getText();
try {
ts.getResolvedModule = getResolvedModule;
function setResolvedModule(sourceFile, moduleNameText, resolvedModule) {
if (!sourceFile.resolvedModules) {
- sourceFile.resolvedModules = ts.createMap();
+ sourceFile.resolvedModules = new ts.Map();
}
sourceFile.resolvedModules.set(moduleNameText, resolvedModule);
}
ts.setResolvedModule = setResolvedModule;
function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective) {
if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
- sourceFile.resolvedTypeReferenceDirectiveNames = ts.createMap();
+ sourceFile.resolvedTypeReferenceDirectiveNames = new ts.Map();
}
sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, resolvedTypeReferenceDirective);
}
}
}
function getSourceFileOfNode(node) {
- while (node && node.kind !== 290) {
+ while (node && node.kind !== 297) {
node = node.parent;
}
return node;
ts.getSourceFileOfNode = getSourceFileOfNode;
function isStatementWithLocals(node) {
switch (node.kind) {
- case 223:
- case 251:
case 230:
- case 231:
- case 232:
+ case 258:
+ case 237:
+ case 238:
+ case 239:
return true;
}
return false;
}
ts.isPinnedComment = isPinnedComment;
function createCommentDirectivesMap(sourceFile, commentDirectives) {
- var directivesByLine = ts.createMapFromEntries(commentDirectives.map(function (commentDirective) { return ([
+ var directivesByLine = new ts.Map(commentDirectives.map(function (commentDirective) { return ([
"" + ts.getLineAndCharacterOfPosition(sourceFile, commentDirective.range.end).line,
commentDirective,
]); }));
- var usedLines = ts.createMap();
+ var usedLines = new ts.Map();
return { getUnusedExpectations: getUnusedExpectations, markUsed: markUsed };
function getUnusedExpectations() {
return ts.arrayFrom(directivesByLine.entries())
if (nodeIsMissing(node)) {
return node.pos;
}
- if (ts.isJSDocNode(node)) {
+ if (ts.isJSDocNode(node) || node.kind === 11) {
return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, false, true);
}
if (includeJsDoc && ts.hasJSDocNodes(node)) {
return getTokenPosOfNode(node.jsDoc[0], sourceFile);
}
- if (node.kind === 324 && node._children.length > 0) {
+ if (node.kind === 334 && node._children.length > 0) {
return getTokenPosOfNode(node._children[0], sourceFile, includeJsDoc);
}
return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos);
}
ts.getSourceTextOfNodeFromSourceFile = getSourceTextOfNodeFromSourceFile;
function isJSDocTypeExpressionOrChild(node) {
- return !!findAncestor(node, ts.isJSDocTypeExpression);
+ return !!ts.findAncestor(node, ts.isJSDocTypeExpression);
+ }
+ function isExportNamespaceAsDefaultDeclaration(node) {
+ return !!(ts.isExportDeclaration(node) && node.exportClause && ts.isNamespaceExport(node.exportClause) && node.exportClause.name.escapedText === "default");
}
+ ts.isExportNamespaceAsDefaultDeclaration = isExportNamespaceAsDefaultDeclaration;
function getTextOfNodeFromSourceText(sourceText, node, includeTrivia) {
if (includeTrivia === void 0) { includeTrivia = false; }
if (nodeIsMissing(node)) {
return emitNode && emitNode.flags || 0;
}
ts.getEmitFlags = getEmitFlags;
- function getLiteralText(node, sourceFile, neverAsciiEscape, jsxAttributeEscape) {
- if (!nodeIsSynthesized(node) && node.parent && !((ts.isNumericLiteral(node) && node.numericLiteralFlags & 512) ||
+ ;
+ function getScriptTargetFeatures() {
+ return {
+ es2015: {
+ Array: ["find", "findIndex", "fill", "copyWithin", "entries", "keys", "values"],
+ RegExp: ["flags", "sticky", "unicode"],
+ Reflect: ["apply", "construct", "defineProperty", "deleteProperty", "get", " getOwnPropertyDescriptor", "getPrototypeOf", "has", "isExtensible", "ownKeys", "preventExtensions", "set", "setPrototypeOf"],
+ ArrayConstructor: ["from", "of"],
+ ObjectConstructor: ["assign", "getOwnPropertySymbols", "keys", "is", "setPrototypeOf"],
+ NumberConstructor: ["isFinite", "isInteger", "isNaN", "isSafeInteger", "parseFloat", "parseInt"],
+ Math: ["clz32", "imul", "sign", "log10", "log2", "log1p", "expm1", "cosh", "sinh", "tanh", "acosh", "asinh", "atanh", "hypot", "trunc", "fround", "cbrt"],
+ Map: ["entries", "keys", "values"],
+ Set: ["entries", "keys", "values"],
+ Promise: ts.emptyArray,
+ PromiseConstructor: ["all", "race", "reject", "resolve"],
+ Symbol: ["for", "keyFor"],
+ WeakMap: ["entries", "keys", "values"],
+ WeakSet: ["entries", "keys", "values"],
+ Iterator: ts.emptyArray,
+ AsyncIterator: ts.emptyArray,
+ String: ["codePointAt", "includes", "endsWith", "normalize", "repeat", "startsWith", "anchor", "big", "blink", "bold", "fixed", "fontcolor", "fontsize", "italics", "link", "small", "strike", "sub", "sup"],
+ StringConstructor: ["fromCodePoint", "raw"]
+ },
+ es2016: {
+ Array: ["includes"]
+ },
+ es2017: {
+ Atomics: ts.emptyArray,
+ SharedArrayBuffer: ts.emptyArray,
+ String: ["padStart", "padEnd"],
+ ObjectConstructor: ["values", "entries", "getOwnPropertyDescriptors"],
+ DateTimeFormat: ["formatToParts"]
+ },
+ es2018: {
+ Promise: ["finally"],
+ RegExpMatchArray: ["groups"],
+ RegExpExecArray: ["groups"],
+ RegExp: ["dotAll"],
+ Intl: ["PluralRules"],
+ AsyncIterable: ts.emptyArray,
+ AsyncIterableIterator: ts.emptyArray,
+ AsyncGenerator: ts.emptyArray,
+ AsyncGeneratorFunction: ts.emptyArray,
+ },
+ es2019: {
+ Array: ["flat", "flatMap"],
+ ObjectConstructor: ["fromEntries"],
+ String: ["trimStart", "trimEnd", "trimLeft", "trimRight"],
+ Symbol: ["description"]
+ },
+ es2020: {
+ BigInt: ts.emptyArray,
+ BigInt64Array: ts.emptyArray,
+ BigUint64Array: ts.emptyArray,
+ PromiseConstructor: ["allSettled"],
+ SymbolConstructor: ["matchAll"],
+ String: ["matchAll"],
+ DataView: ["setBigInt64", "setBigUint64", "getBigInt64", "getBigUint64"],
+ RelativeTimeFormat: ["format", "formatToParts", "resolvedOptions"]
+ },
+ esnext: {
+ PromiseConstructor: ["any"],
+ String: ["replaceAll"],
+ NumberFormat: ["formatToParts"]
+ }
+ };
+ }
+ ts.getScriptTargetFeatures = getScriptTargetFeatures;
+ function getLiteralText(node, sourceFile, flags) {
+ if (!nodeIsSynthesized(node) && node.parent && !(flags & 4 && node.isUnterminated) && !((ts.isNumericLiteral(node) && node.numericLiteralFlags & 512) ||
ts.isBigIntLiteral(node))) {
return getSourceTextOfNodeFromSourceFile(sourceFile, node);
}
switch (node.kind) {
case 10: {
- var escapeText = jsxAttributeEscape ? escapeJsxAttributeString :
- neverAsciiEscape || (getEmitFlags(node) & 16777216) ? escapeString :
+ var escapeText = flags & 2 ? escapeJsxAttributeString :
+ flags & 1 || (getEmitFlags(node) & 16777216) ? escapeString :
escapeNonAsciiString;
if (node.singleQuote) {
return "'" + escapeText(node.text, 39) + "'";
case 15:
case 16:
case 17: {
- var escapeText = neverAsciiEscape || (getEmitFlags(node) & 16777216) ? escapeString :
+ var escapeText = flags & 1 || (getEmitFlags(node) & 16777216) ? escapeString :
escapeNonAsciiString;
var rawText = node.rawText || escapeTemplateSubstitution(escapeText(node.text, 96));
switch (node.kind) {
}
case 8:
case 9:
+ return node.text;
case 13:
+ if (flags & 4 && node.isUnterminated) {
+ return node.text + (node.text.charCodeAt(node.text.length - 1) === 92 ? " /" : "/");
+ }
return node.text;
}
return ts.Debug.fail("Literal kind '" + node.kind + "' not accounted for.");
ts.isBlockOrCatchScoped = isBlockOrCatchScoped;
function isCatchClauseVariableDeclarationOrBindingElement(declaration) {
var node = getRootDeclaration(declaration);
- return node.kind === 242 && node.parent.kind === 280;
+ return node.kind === 249 && node.parent.kind === 287;
}
ts.isCatchClauseVariableDeclarationOrBindingElement = isCatchClauseVariableDeclarationOrBindingElement;
function isAmbientModule(node) {
}
ts.isShorthandAmbientModuleSymbol = isShorthandAmbientModuleSymbol;
function isShorthandAmbientModule(node) {
- return node && node.kind === 249 && (!node.body);
+ return node && node.kind === 256 && (!node.body);
}
function isBlockScopedContainerTopLevel(node) {
- return node.kind === 290 ||
- node.kind === 249 ||
+ return node.kind === 297 ||
+ node.kind === 256 ||
ts.isFunctionLike(node);
}
ts.isBlockScopedContainerTopLevel = isBlockScopedContainerTopLevel;
ts.isExternalModuleAugmentation = isExternalModuleAugmentation;
function isModuleAugmentationExternal(node) {
switch (node.parent.kind) {
- case 290:
+ case 297:
return ts.isExternalModule(node.parent);
- case 250:
+ case 257:
return isAmbientModule(node.parent.parent) && ts.isSourceFile(node.parent.parent.parent) && !ts.isExternalModule(node.parent.parent.parent);
}
return false;
ts.isEffectiveStrictModeSourceFile = isEffectiveStrictModeSourceFile;
function isBlockScope(node, parentNode) {
switch (node.kind) {
- case 290:
+ case 297:
+ case 258:
+ case 287:
+ case 256:
+ case 237:
+ case 238:
+ case 239:
+ case 166:
+ case 165:
+ case 167:
+ case 168:
case 251:
- case 280:
- case 249:
- case 230:
- case 231:
- case 232:
- case 162:
- case 161:
- case 163:
- case 164:
- case 244:
- case 201:
- case 202:
+ case 208:
+ case 209:
return true;
- case 223:
+ case 230:
return !ts.isFunctionLike(parentNode);
}
return false;
ts.isBlockScope = isBlockScope;
function isDeclarationWithTypeParameters(node) {
switch (node.kind) {
- case 315:
- case 322:
- case 305:
+ case 324:
+ case 331:
+ case 313:
return true;
default:
ts.assertType(node);
ts.isDeclarationWithTypeParameters = isDeclarationWithTypeParameters;
function isDeclarationWithTypeParameterChildren(node) {
switch (node.kind) {
+ case 169:
+ case 170:
+ case 164:
+ case 171:
+ case 174:
+ case 175:
+ case 308:
+ case 252:
+ case 221:
+ case 253:
+ case 254:
+ case 330:
+ case 251:
case 165:
case 166:
- case 160:
case 167:
- case 170:
- case 171:
- case 300:
- case 245:
- case 214:
- case 246:
- case 247:
- case 321:
- case 244:
- case 161:
- case 162:
- case 163:
- case 164:
- case 201:
- case 202:
+ case 168:
+ case 208:
+ case 209:
return true;
default:
ts.assertType(node);
ts.isDeclarationWithTypeParameterChildren = isDeclarationWithTypeParameterChildren;
function isAnyImportSyntax(node) {
switch (node.kind) {
- case 254:
- case 253:
+ case 261:
+ case 260:
return true;
default:
return false;
ts.isAnyImportSyntax = isAnyImportSyntax;
function isLateVisibilityPaintedStatement(node) {
switch (node.kind) {
+ case 261:
+ case 260:
+ case 232:
+ case 252:
+ case 251:
+ case 256:
case 254:
case 253:
- case 225:
- case 245:
- case 244:
- case 249:
- case 247:
- case 246:
- case 248:
+ case 255:
return true;
default:
return false;
}
ts.isAnyImportOrReExport = isAnyImportOrReExport;
function getEnclosingBlockScopeContainer(node) {
- return findAncestor(node.parent, function (current) { return isBlockScope(current, current.parent); });
+ return ts.findAncestor(node.parent, function (current) { return isBlockScope(current, current.parent); });
}
ts.getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer;
function declarationNameToString(name) {
}
ts.getNameFromIndexInfo = getNameFromIndexInfo;
function isComputedNonLiteralName(name) {
- return name.kind === 154 && !isStringOrNumericLiteralLike(name.expression);
+ return name.kind === 158 && !isStringOrNumericLiteralLike(name.expression);
}
ts.isComputedNonLiteralName = isComputedNonLiteralName;
function getTextOfPropertyName(name) {
switch (name.kind) {
- case 75:
- case 76:
+ case 78:
+ case 79:
return name.escapedText;
case 10:
case 8:
case 14:
return ts.escapeLeadingUnderscores(name.text);
- case 154:
+ case 158:
if (isStringOrNumericLiteralLike(name.expression))
return ts.escapeLeadingUnderscores(name.expression.text);
return ts.Debug.fail("Text of property name cannot be read from non-literal-valued ComputedPropertyNames");
ts.getTextOfPropertyName = getTextOfPropertyName;
function entityNameToString(name) {
switch (name.kind) {
- case 104:
+ case 107:
return "this";
- case 76:
- case 75:
+ case 79:
+ case 78:
return getFullWidth(name) === 0 ? ts.idText(name) : getTextOfNode(name);
- case 153:
+ case 157:
return entityNameToString(name.left) + "." + entityNameToString(name.right);
- case 194:
+ case 201:
if (ts.isIdentifier(name.name) || ts.isPrivateIdentifier(name.name)) {
return entityNameToString(name.expression) + "." + entityNameToString(name.name);
}
};
}
ts.createDiagnosticForNodeFromMessageChain = createDiagnosticForNodeFromMessageChain;
+ function createDiagnosticForFileFromMessageChain(sourceFile, messageChain, relatedInformation) {
+ return {
+ file: sourceFile,
+ start: 0,
+ length: 0,
+ code: messageChain.code,
+ category: messageChain.category,
+ messageText: messageChain.next ? messageChain : messageChain.messageText,
+ relatedInformation: relatedInformation
+ };
+ }
+ ts.createDiagnosticForFileFromMessageChain = createDiagnosticForFileFromMessageChain;
function createDiagnosticForRange(sourceFile, range, message) {
return {
file: sourceFile,
ts.getSpanOfTokenAtPosition = getSpanOfTokenAtPosition;
function getErrorSpanForArrowFunction(sourceFile, node) {
var pos = ts.skipTrivia(sourceFile.text, node.pos);
- if (node.body && node.body.kind === 223) {
+ if (node.body && node.body.kind === 230) {
var startLine = ts.getLineAndCharacterOfPosition(sourceFile, node.body.pos).line;
var endLine = ts.getLineAndCharacterOfPosition(sourceFile, node.body.end).line;
if (startLine < endLine) {
function getErrorSpanForNode(sourceFile, node) {
var errorNode = node;
switch (node.kind) {
- case 290:
+ case 297:
var pos_1 = ts.skipTrivia(sourceFile.text, 0, false);
if (pos_1 === sourceFile.text.length) {
return ts.createTextSpan(0, 0);
}
return getSpanOfTokenAtPosition(sourceFile, pos_1);
- case 242:
- case 191:
- case 245:
- case 214:
- case 246:
case 249:
- case 248:
- case 284:
- case 244:
- case 201:
- case 161:
+ case 198:
+ case 252:
+ case 221:
+ case 253:
+ case 256:
+ case 255:
+ case 291:
+ case 251:
+ case 208:
+ case 165:
+ case 167:
+ case 168:
+ case 254:
case 163:
- case 164:
- case 247:
- case 159:
- case 158:
+ case 162:
errorNode = node.name;
break;
- case 202:
+ case 209:
return getErrorSpanForArrowFunction(sourceFile, node);
- case 277:
- case 278:
+ case 284:
+ case 285:
var start = ts.skipTrivia(sourceFile.text, node.pos);
var end = node.statements.length > 0 ? node.statements[0].pos : node.end;
return ts.createTextSpanFromBounds(start, end);
}
ts.isLet = isLet;
function isSuperCall(n) {
- return n.kind === 196 && n.expression.kind === 102;
+ return n.kind === 203 && n.expression.kind === 105;
}
ts.isSuperCall = isSuperCall;
function isImportCall(n) {
- return n.kind === 196 && n.expression.kind === 96;
+ return n.kind === 203 && n.expression.kind === 99;
}
ts.isImportCall = isImportCall;
function isImportMeta(n) {
return ts.isMetaProperty(n)
- && n.keywordToken === 96
+ && n.keywordToken === 99
&& n.name.escapedText === "meta";
}
ts.isImportMeta = isImportMeta;
}
ts.isLiteralImportTypeNode = isLiteralImportTypeNode;
function isPrologueDirective(node) {
- return node.kind === 226
+ return node.kind === 233
&& node.expression.kind === 10;
}
ts.isPrologueDirective = isPrologueDirective;
}
ts.getLeadingCommentRangesOfNode = getLeadingCommentRangesOfNode;
function getJSDocCommentRanges(node, text) {
- var commentRanges = (node.kind === 156 ||
- node.kind === 155 ||
- node.kind === 201 ||
- node.kind === 202 ||
- node.kind === 200) ?
+ var commentRanges = (node.kind === 160 ||
+ node.kind === 159 ||
+ node.kind === 208 ||
+ node.kind === 209 ||
+ node.kind === 207) ?
ts.concatenate(ts.getTrailingCommentRanges(text, node.pos), ts.getLeadingCommentRanges(text, node.pos)) :
ts.getLeadingCommentRanges(text, node.pos);
return ts.filter(commentRanges, function (comment) {
ts.fullTripleSlashAMDReferencePathRegEx = /^(\/\/\/\s*<amd-dependency\s+path\s*=\s*)('|")(.+?)\2.*?\/>/;
var defaultLibReferenceRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)('|")(.+?)\2\s*\/>/;
function isPartOfTypeNode(node) {
- if (168 <= node.kind && node.kind <= 188) {
+ if (172 <= node.kind && node.kind <= 195) {
return true;
}
switch (node.kind) {
- case 125:
- case 148:
- case 140:
- case 151:
- case 143:
case 128:
+ case 152:
case 144:
+ case 155:
+ case 147:
+ case 131:
+ case 148:
+ case 145:
+ case 150:
case 141:
- case 146:
- case 137:
return true;
- case 110:
- return node.parent.kind !== 205;
- case 216:
+ case 113:
+ return node.parent.kind !== 212;
+ case 223:
return !isExpressionWithTypeArgumentsInClassExtendsClause(node);
- case 155:
- return node.parent.kind === 186 || node.parent.kind === 181;
- case 75:
- if (node.parent.kind === 153 && node.parent.right === node) {
+ case 159:
+ return node.parent.kind === 190 || node.parent.kind === 185;
+ case 78:
+ if (node.parent.kind === 157 && node.parent.right === node) {
node = node.parent;
}
- else if (node.parent.kind === 194 && node.parent.name === node) {
+ else if (node.parent.kind === 201 && node.parent.name === node) {
node = node.parent;
}
- ts.Debug.assert(node.kind === 75 || node.kind === 153 || node.kind === 194, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'.");
- case 153:
- case 194:
- case 104: {
+ ts.Debug.assert(node.kind === 78 || node.kind === 157 || node.kind === 201, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'.");
+ case 157:
+ case 201:
+ case 107: {
var parent = node.parent;
- if (parent.kind === 172) {
+ if (parent.kind === 176) {
return false;
}
- if (parent.kind === 188) {
+ if (parent.kind === 195) {
return !parent.isTypeOf;
}
- if (168 <= parent.kind && parent.kind <= 188) {
+ if (172 <= parent.kind && parent.kind <= 195) {
return true;
}
switch (parent.kind) {
- case 216:
+ case 223:
return !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
- case 155:
+ case 159:
return node === parent.constraint;
- case 321:
+ case 330:
return node === parent.constraint;
- case 159:
- case 158:
- case 156:
- case 242:
- return node === parent.type;
- case 244:
- case 201:
- case 202:
+ case 163:
case 162:
- case 161:
case 160:
- case 163:
- case 164:
+ case 249:
return node === parent.type;
- case 165:
+ case 251:
+ case 208:
+ case 209:
case 166:
+ case 165:
+ case 164:
case 167:
+ case 168:
return node === parent.type;
- case 199:
+ case 169:
+ case 170:
+ case 171:
return node === parent.type;
- case 196:
- case 197:
+ case 206:
+ return node === parent.type;
+ case 203:
+ case 204:
return ts.contains(parent.typeArguments, node);
- case 198:
+ case 205:
return false;
}
}
return traverse(body);
function traverse(node) {
switch (node.kind) {
- case 235:
+ case 242:
return visitor(node);
- case 251:
- case 223:
- case 227:
- case 228:
- case 229:
+ case 258:
case 230:
- case 231:
- case 232:
+ case 234:
+ case 235:
case 236:
case 237:
- case 277:
- case 278:
case 238:
- case 240:
- case 280:
+ case 239:
+ case 243:
+ case 244:
+ case 284:
+ case 285:
+ case 245:
+ case 247:
+ case 287:
return ts.forEachChild(node, traverse);
}
}
return traverse(body);
function traverse(node) {
switch (node.kind) {
- case 212:
+ case 219:
visitor(node);
var operand = node.expression;
if (operand) {
traverse(operand);
}
return;
- case 248:
- case 246:
- case 249:
- case 247:
+ case 255:
+ case 253:
+ case 256:
+ case 254:
return;
default:
if (ts.isFunctionLike(node)) {
- if (node.name && node.name.kind === 154) {
+ if (node.name && node.name.kind === 158) {
traverse(node.name.expression);
return;
}
}
ts.forEachYieldExpression = forEachYieldExpression;
function getRestParameterElementType(node) {
- if (node && node.kind === 174) {
+ if (node && node.kind === 178) {
return node.elementType;
}
- else if (node && node.kind === 169) {
+ else if (node && node.kind === 173) {
return ts.singleOrUndefined(node.typeArguments);
}
else {
ts.getRestParameterElementType = getRestParameterElementType;
function getMembersOfDeclaration(node) {
switch (node.kind) {
- case 246:
- case 245:
- case 214:
- case 173:
+ case 253:
+ case 252:
+ case 221:
+ case 177:
return node.members;
- case 193:
+ case 200:
return node.properties;
}
}
function isVariableLike(node) {
if (node) {
switch (node.kind) {
- case 191:
- case 284:
- case 156:
- case 281:
- case 159:
- case 158:
- case 282:
- case 242:
+ case 198:
+ case 291:
+ case 160:
+ case 288:
+ case 163:
+ case 162:
+ case 289:
+ case 249:
return true;
}
}
}
ts.isVariableLikeOrAccessor = isVariableLikeOrAccessor;
function isVariableDeclarationInVariableStatement(node) {
- return node.parent.kind === 243
- && node.parent.parent.kind === 225;
+ return node.parent.kind === 250
+ && node.parent.parent.kind === 232;
}
ts.isVariableDeclarationInVariableStatement = isVariableDeclarationInVariableStatement;
function isValidESSymbolDeclaration(node) {
return ts.isVariableDeclaration(node) ? isVarConst(node) && ts.isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) :
- ts.isPropertyDeclaration(node) ? hasReadonlyModifier(node) && hasStaticModifier(node) :
- ts.isPropertySignature(node) && hasReadonlyModifier(node);
+ ts.isPropertyDeclaration(node) ? hasEffectiveReadonlyModifier(node) && hasStaticModifier(node) :
+ ts.isPropertySignature(node) && hasEffectiveReadonlyModifier(node);
}
ts.isValidESSymbolDeclaration = isValidESSymbolDeclaration;
function introducesArgumentsExoticObject(node) {
switch (node.kind) {
- case 161:
- case 160:
- case 162:
- case 163:
+ case 165:
case 164:
- case 244:
- case 201:
+ case 166:
+ case 167:
+ case 168:
+ case 251:
+ case 208:
return true;
}
return false;
if (beforeUnwrapLabelCallback) {
beforeUnwrapLabelCallback(node);
}
- if (node.statement.kind !== 238) {
+ if (node.statement.kind !== 245) {
return node.statement;
}
node = node.statement;
}
ts.unwrapInnermostStatementOfLabel = unwrapInnermostStatementOfLabel;
function isFunctionBlock(node) {
- return node && node.kind === 223 && ts.isFunctionLike(node.parent);
+ return node && node.kind === 230 && ts.isFunctionLike(node.parent);
}
ts.isFunctionBlock = isFunctionBlock;
function isObjectLiteralMethod(node) {
- return node && node.kind === 161 && node.parent.kind === 193;
+ return node && node.kind === 165 && node.parent.kind === 200;
}
ts.isObjectLiteralMethod = isObjectLiteralMethod;
function isObjectLiteralOrClassExpressionMethod(node) {
- return node.kind === 161 &&
- (node.parent.kind === 193 ||
- node.parent.kind === 214);
+ return node.kind === 165 &&
+ (node.parent.kind === 200 ||
+ node.parent.kind === 221);
}
ts.isObjectLiteralOrClassExpressionMethod = isObjectLiteralOrClassExpressionMethod;
function isIdentifierTypePredicate(predicate) {
ts.isThisTypePredicate = isThisTypePredicate;
function getPropertyAssignment(objectLiteral, key, key2) {
return objectLiteral.properties.filter(function (property) {
- if (property.kind === 281) {
+ if (property.kind === 288) {
var propName = getTextOfPropertyName(property.name);
return key === propName || (!!key2 && key2 === propName);
}
}
ts.getTsConfigPropArray = getTsConfigPropArray;
function getContainingFunction(node) {
- return findAncestor(node.parent, ts.isFunctionLike);
+ return ts.findAncestor(node.parent, ts.isFunctionLike);
}
ts.getContainingFunction = getContainingFunction;
function getContainingFunctionDeclaration(node) {
- return findAncestor(node.parent, ts.isFunctionLikeDeclaration);
+ return ts.findAncestor(node.parent, ts.isFunctionLikeDeclaration);
}
ts.getContainingFunctionDeclaration = getContainingFunctionDeclaration;
function getContainingClass(node) {
- return findAncestor(node.parent, ts.isClassLike);
+ return ts.findAncestor(node.parent, ts.isClassLike);
}
ts.getContainingClass = getContainingClass;
function getThisContainer(node, includeArrowFunctions) {
- ts.Debug.assert(node.kind !== 290);
+ ts.Debug.assert(node.kind !== 297);
while (true) {
node = node.parent;
if (!node) {
return ts.Debug.fail();
}
switch (node.kind) {
- case 154:
+ case 158:
if (ts.isClassLike(node.parent.parent)) {
return node;
}
node = node.parent;
break;
- case 157:
- if (node.parent.kind === 156 && ts.isClassElement(node.parent.parent)) {
+ case 161:
+ if (node.parent.kind === 160 && ts.isClassElement(node.parent.parent)) {
node = node.parent.parent;
}
else if (ts.isClassElement(node.parent)) {
node = node.parent;
}
break;
- case 202:
+ case 209:
if (!includeArrowFunctions) {
continue;
}
- case 244:
- case 201:
- case 249:
- case 159:
- case 158:
- case 161:
- case 160:
- case 162:
+ case 251:
+ case 208:
+ case 256:
case 163:
- case 164:
+ case 162:
case 165:
+ case 164:
case 166:
case 167:
- case 248:
- case 290:
+ case 168:
+ case 169:
+ case 170:
+ case 171:
+ case 255:
+ case 297:
return node;
}
}
}
ts.getThisContainer = getThisContainer;
+ function isInTopLevelContext(node) {
+ if (ts.isIdentifier(node) && (ts.isClassDeclaration(node.parent) || ts.isFunctionDeclaration(node.parent)) && node.parent.name === node) {
+ node = node.parent;
+ }
+ var container = getThisContainer(node, true);
+ return ts.isSourceFile(container);
+ }
+ ts.isInTopLevelContext = isInTopLevelContext;
function getNewTargetContainer(node) {
var container = getThisContainer(node, false);
if (container) {
switch (container.kind) {
- case 162:
- case 244:
- case 201:
+ case 166:
+ case 251:
+ case 208:
return container;
}
}
return node;
}
switch (node.kind) {
- case 154:
+ case 158:
node = node.parent;
break;
- case 244:
- case 201:
- case 202:
+ case 251:
+ case 208:
+ case 209:
if (!stopOnFunctions) {
continue;
}
- case 159:
- case 158:
- case 161:
- case 160:
- case 162:
case 163:
+ case 162:
+ case 165:
case 164:
+ case 166:
+ case 167:
+ case 168:
return node;
- case 157:
- if (node.parent.kind === 156 && ts.isClassElement(node.parent.parent)) {
+ case 161:
+ if (node.parent.kind === 160 && ts.isClassElement(node.parent.parent)) {
node = node.parent.parent;
}
else if (ts.isClassElement(node.parent)) {
}
ts.getSuperContainer = getSuperContainer;
function getImmediatelyInvokedFunctionExpression(func) {
- if (func.kind === 201 || func.kind === 202) {
+ if (func.kind === 208 || func.kind === 209) {
var prev = func;
var parent = func.parent;
- while (parent.kind === 200) {
+ while (parent.kind === 207) {
prev = parent;
parent = parent.parent;
}
- if (parent.kind === 196 && parent.expression === prev) {
+ if (parent.kind === 203 && parent.expression === prev) {
return parent;
}
}
}
ts.getImmediatelyInvokedFunctionExpression = getImmediatelyInvokedFunctionExpression;
function isSuperOrSuperProperty(node) {
- return node.kind === 102
+ return node.kind === 105
|| isSuperProperty(node);
}
ts.isSuperOrSuperProperty = isSuperOrSuperProperty;
function isSuperProperty(node) {
var kind = node.kind;
- return (kind === 194 || kind === 195)
- && node.expression.kind === 102;
+ return (kind === 201 || kind === 202)
+ && node.expression.kind === 105;
}
ts.isSuperProperty = isSuperProperty;
function isThisProperty(node) {
var kind = node.kind;
- return (kind === 194 || kind === 195)
- && node.expression.kind === 104;
+ return (kind === 201 || kind === 202)
+ && node.expression.kind === 107;
}
ts.isThisProperty = isThisProperty;
+ function isThisInitializedDeclaration(node) {
+ var _a;
+ return !!node && ts.isVariableDeclaration(node) && ((_a = node.initializer) === null || _a === void 0 ? void 0 : _a.kind) === 107;
+ }
+ ts.isThisInitializedDeclaration = isThisInitializedDeclaration;
function getEntityNameFromTypeNode(node) {
switch (node.kind) {
- case 169:
+ case 173:
return node.typeName;
- case 216:
+ case 223:
return isEntityNameExpression(node.expression)
? node.expression
: undefined;
- case 75:
- case 153:
+ case 78:
+ case 157:
return node;
}
return undefined;
ts.getEntityNameFromTypeNode = getEntityNameFromTypeNode;
function getInvokedExpression(node) {
switch (node.kind) {
- case 198:
+ case 205:
return node.tag;
- case 268:
- case 267:
+ case 275:
+ case 274:
return node.tagName;
default:
return node.expression;
return false;
}
switch (node.kind) {
- case 245:
+ case 252:
return true;
- case 159:
- return parent.kind === 245;
case 163:
- case 164:
- case 161:
+ return parent.kind === 252;
+ case 167:
+ case 168:
+ case 165:
return node.body !== undefined
- && parent.kind === 245;
- case 156:
+ && parent.kind === 252;
+ case 160:
return parent.body !== undefined
- && (parent.kind === 162
- || parent.kind === 161
- || parent.kind === 164)
- && grandparent.kind === 245;
+ && (parent.kind === 166
+ || parent.kind === 165
+ || parent.kind === 168)
+ && grandparent.kind === 252;
}
return false;
}
ts.nodeOrChildIsDecorated = nodeOrChildIsDecorated;
function childIsDecorated(node, parent) {
switch (node.kind) {
- case 245:
+ case 252:
return ts.some(node.members, function (m) { return nodeOrChildIsDecorated(m, node, parent); });
- case 161:
- case 164:
+ case 165:
+ case 168:
return ts.some(node.parameters, function (p) { return nodeIsDecorated(p, node, parent); });
default:
return false;
ts.childIsDecorated = childIsDecorated;
function isJSXTagName(node) {
var parent = node.parent;
- if (parent.kind === 268 ||
- parent.kind === 267 ||
- parent.kind === 269) {
+ if (parent.kind === 275 ||
+ parent.kind === 274 ||
+ parent.kind === 276) {
return parent.tagName === node;
}
return false;
ts.isJSXTagName = isJSXTagName;
function isExpressionNode(node) {
switch (node.kind) {
- case 102:
- case 100:
- case 106:
- case 91:
+ case 105:
+ case 103:
+ case 109:
+ case 94:
case 13:
- case 192:
- case 193:
- case 194:
- case 195:
- case 196:
- case 197:
- case 198:
- case 217:
case 199:
- case 218:
case 200:
case 201:
- case 214:
case 202:
- case 205:
case 203:
case 204:
+ case 205:
+ case 224:
+ case 206:
+ case 225:
case 207:
case 208:
+ case 221:
case 209:
+ case 212:
case 210:
- case 213:
case 211:
+ case 214:
case 215:
- case 266:
- case 267:
- case 270:
- case 212:
- case 206:
+ case 216:
+ case 217:
+ case 220:
+ case 218:
+ case 222:
+ case 273:
+ case 274:
+ case 277:
case 219:
+ case 213:
+ case 226:
return true;
- case 153:
- while (node.parent.kind === 153) {
+ case 157:
+ while (node.parent.kind === 157) {
node = node.parent;
}
- return node.parent.kind === 172 || isJSXTagName(node);
- case 75:
- if (node.parent.kind === 172 || isJSXTagName(node)) {
+ return node.parent.kind === 176 || isJSXTagName(node);
+ case 78:
+ if (node.parent.kind === 176 || isJSXTagName(node)) {
return true;
}
case 8:
case 9:
case 10:
case 14:
- case 104:
+ case 107:
return isInExpressionContext(node);
default:
return false;
function isInExpressionContext(node) {
var parent = node.parent;
switch (parent.kind) {
- case 242:
- case 156:
- case 159:
- case 158:
- case 284:
- case 281:
- case 191:
+ case 249:
+ case 160:
+ case 163:
+ case 162:
+ case 291:
+ case 288:
+ case 198:
return parent.initializer === node;
- case 226:
- case 227:
- case 228:
- case 229:
+ case 233:
+ case 234:
case 235:
case 236:
- case 237:
- case 277:
- case 239:
+ case 242:
+ case 243:
+ case 244:
+ case 284:
+ case 246:
return parent.expression === node;
- case 230:
+ case 237:
var forStatement = parent;
- return (forStatement.initializer === node && forStatement.initializer.kind !== 243) ||
+ return (forStatement.initializer === node && forStatement.initializer.kind !== 250) ||
forStatement.condition === node ||
forStatement.incrementor === node;
- case 231:
- case 232:
+ case 238:
+ case 239:
var forInStatement = parent;
- return (forInStatement.initializer === node && forInStatement.initializer.kind !== 243) ||
+ return (forInStatement.initializer === node && forInStatement.initializer.kind !== 250) ||
forInStatement.expression === node;
- case 199:
- case 217:
+ case 206:
+ case 224:
return node === parent.expression;
- case 221:
+ case 228:
return node === parent.expression;
- case 154:
+ case 158:
return node === parent.expression;
- case 157:
- case 276:
- case 275:
+ case 161:
case 283:
+ case 282:
+ case 290:
return true;
- case 216:
+ case 223:
return parent.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent);
- case 282:
+ case 289:
return parent.objectAssignmentInitializer === node;
default:
return isExpressionNode(parent);
}
ts.isInExpressionContext = isInExpressionContext;
function isPartOfTypeQuery(node) {
- while (node.kind === 153 || node.kind === 75) {
+ while (node.kind === 157 || node.kind === 78) {
node = node.parent;
}
- return node.kind === 172;
+ return node.kind === 176;
}
ts.isPartOfTypeQuery = isPartOfTypeQuery;
function isExternalModuleImportEqualsDeclaration(node) {
- return node.kind === 253 && node.moduleReference.kind === 265;
+ return node.kind === 260 && node.moduleReference.kind === 272;
}
ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration;
function getExternalModuleImportEqualsDeclarationExpression(node) {
return node.moduleReference.expression;
}
ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression;
+ function getExternalModuleRequireArgument(node) {
+ return isRequireVariableDeclaration(node, true)
+ && getLeftmostAccessExpression(node.initializer).arguments[0];
+ }
+ ts.getExternalModuleRequireArgument = getExternalModuleRequireArgument;
function isInternalModuleImportEqualsDeclaration(node) {
- return node.kind === 253 && node.moduleReference.kind !== 265;
+ return node.kind === 260 && node.moduleReference.kind !== 272;
}
ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration;
function isSourceFileJS(file) {
ts.isIdentifier(node.typeName) &&
node.typeName.escapedText === "Object" &&
node.typeArguments && node.typeArguments.length === 2 &&
- (node.typeArguments[0].kind === 143 || node.typeArguments[0].kind === 140);
+ (node.typeArguments[0].kind === 147 || node.typeArguments[0].kind === 144);
}
ts.isJSDocIndexSignature = isJSDocIndexSignature;
function isRequireCall(callExpression, requireStringLiteralLikeArgument) {
- if (callExpression.kind !== 196) {
+ if (callExpression.kind !== 203) {
return false;
}
var _a = callExpression, expression = _a.expression, args = _a.arguments;
- if (expression.kind !== 75 || expression.escapedText !== "require") {
+ if (expression.kind !== 78 || expression.escapedText !== "require") {
return false;
}
if (args.length !== 1) {
}
ts.isRequireCall = isRequireCall;
function isRequireVariableDeclaration(node, requireStringLiteralLikeArgument) {
- return ts.isVariableDeclaration(node) && !!node.initializer && isRequireCall(node.initializer, requireStringLiteralLikeArgument);
+ if (node.kind === 198) {
+ node = node.parent.parent;
+ }
+ return ts.isVariableDeclaration(node) && !!node.initializer && isRequireCall(getLeftmostAccessExpression(node.initializer), requireStringLiteralLikeArgument);
}
ts.isRequireVariableDeclaration = isRequireVariableDeclaration;
- function isRequireVariableDeclarationStatement(node, requireStringLiteralLikeArgument) {
+ function isRequireVariableStatement(node, requireStringLiteralLikeArgument) {
if (requireStringLiteralLikeArgument === void 0) { requireStringLiteralLikeArgument = true; }
- return ts.isVariableStatement(node) && ts.every(node.declarationList.declarations, function (decl) { return isRequireVariableDeclaration(decl, requireStringLiteralLikeArgument); });
+ return ts.isVariableStatement(node)
+ && node.declarationList.declarations.length > 0
+ && ts.every(node.declarationList.declarations, function (decl) { return isRequireVariableDeclaration(decl, requireStringLiteralLikeArgument); });
}
- ts.isRequireVariableDeclarationStatement = isRequireVariableDeclarationStatement;
+ ts.isRequireVariableStatement = isRequireVariableStatement;
function isSingleOrDoubleQuote(charCode) {
return charCode === 39 || charCode === 34;
}
return getSourceTextOfNodeFromSourceFile(sourceFile, str).charCodeAt(0) === 34;
}
ts.isStringDoubleQuoted = isStringDoubleQuoted;
- function getDeclarationOfExpando(node) {
- if (!node.parent) {
- return undefined;
- }
- var name;
- var decl;
- if (ts.isVariableDeclaration(node.parent) && node.parent.initializer === node) {
- if (!isInJSFile(node) && !isVarConst(node.parent)) {
- return undefined;
- }
- name = node.parent.name;
- decl = node.parent;
- }
- else if (ts.isBinaryExpression(node.parent)) {
- var parentNode = node.parent;
- var parentNodeOperator = node.parent.operatorToken.kind;
- if (parentNodeOperator === 62 && parentNode.right === node) {
- name = parentNode.left;
- decl = name;
- }
- else if (parentNodeOperator === 56 || parentNodeOperator === 60) {
- if (ts.isVariableDeclaration(parentNode.parent) && parentNode.parent.initializer === parentNode) {
- name = parentNode.parent.name;
- decl = parentNode.parent;
- }
- else if (ts.isBinaryExpression(parentNode.parent) && parentNode.parent.operatorToken.kind === 62 && parentNode.parent.right === parentNode) {
- name = parentNode.parent.left;
- decl = name;
- }
- if (!name || !isBindableStaticNameExpression(name) || !isSameEntityName(name, parentNode.left)) {
- return undefined;
- }
- }
- }
- if (!name || !getExpandoInitializer(node, isPrototypeAccess(name))) {
- return undefined;
- }
- return decl;
- }
- ts.getDeclarationOfExpando = getDeclarationOfExpando;
function isAssignmentDeclaration(decl) {
return ts.isBinaryExpression(decl) || isAccessExpression(decl) || ts.isIdentifier(decl) || ts.isCallExpression(decl);
}
function getExpandoInitializer(initializer, isPrototypeAssignment) {
if (ts.isCallExpression(initializer)) {
var e = skipParentheses(initializer.expression);
- return e.kind === 201 || e.kind === 202 ? initializer : undefined;
+ return e.kind === 208 || e.kind === 209 ? initializer : undefined;
}
- if (initializer.kind === 201 ||
- initializer.kind === 214 ||
- initializer.kind === 202) {
+ if (initializer.kind === 208 ||
+ initializer.kind === 221 ||
+ initializer.kind === 209) {
return initializer;
}
if (ts.isObjectLiteralExpression(initializer) && (initializer.properties.length === 0 || isPrototypeAssignment)) {
ts.getNameOfExpando = getNameOfExpando;
function isSameEntityName(name, initializer) {
if (isPropertyNameLiteral(name) && isPropertyNameLiteral(initializer)) {
- return getTextOfIdentifierOrLiteral(name) === getTextOfIdentifierOrLiteral(name);
+ return getTextOfIdentifierOrLiteral(name) === getTextOfIdentifierOrLiteral(initializer);
}
if (ts.isIdentifier(name) && isLiteralLikeAccess(initializer) &&
- (initializer.expression.kind === 104 ||
+ (initializer.expression.kind === 107 ||
ts.isIdentifier(initializer.expression) &&
(initializer.expression.escapedText === "window" ||
initializer.expression.escapedText === "self" ||
}
return false;
}
+ ts.isSameEntityName = isSameEntityName;
function getRightMostAssignedExpression(node) {
while (isAssignmentExpression(node, true)) {
node = node.right;
}
ts.isLiteralLikeElementAccess = isLiteralLikeElementAccess;
function isBindableStaticAccessExpression(node, excludeThisKeyword) {
- return ts.isPropertyAccessExpression(node) && (!excludeThisKeyword && node.expression.kind === 104 || ts.isIdentifier(node.name) && isBindableStaticNameExpression(node.expression, true))
+ return ts.isPropertyAccessExpression(node) && (!excludeThisKeyword && node.expression.kind === 107 || ts.isIdentifier(node.name) && isBindableStaticNameExpression(node.expression, true))
|| isBindableStaticElementAccessExpression(node, excludeThisKeyword);
}
ts.isBindableStaticAccessExpression = isBindableStaticAccessExpression;
function isBindableStaticElementAccessExpression(node, excludeThisKeyword) {
return isLiteralLikeElementAccess(node)
- && ((!excludeThisKeyword && node.expression.kind === 104) ||
+ && ((!excludeThisKeyword && node.expression.kind === 107) ||
isEntityNameExpression(node.expression) ||
isBindableStaticAccessExpression(node.expression, true));
}
}
return 7;
}
- if (expr.operatorToken.kind !== 62 || !isAccessExpression(expr.left)) {
+ if (expr.operatorToken.kind !== 62 || !isAccessExpression(expr.left) || isVoidZero(getRightMostAssignedExpression(expr))) {
return 0;
}
if (isBindableStaticNameExpression(expr.left.expression, true) && getElementOrPropertyAccessName(expr.left) === "prototype" && ts.isObjectLiteralExpression(getInitializerOfBinaryExpression(expr))) {
}
return getAssignmentDeclarationPropertyAccessKind(expr.left);
}
+ function isVoidZero(node) {
+ return ts.isVoidExpression(node) && ts.isNumericLiteral(node.expression) && node.expression.text === "0";
+ }
function getElementOrPropertyAccessArgumentExpressionOrName(node) {
if (ts.isPropertyAccessExpression(node)) {
return node.name;
}
ts.getElementOrPropertyAccessName = getElementOrPropertyAccessName;
function getAssignmentDeclarationPropertyAccessKind(lhs) {
- if (lhs.expression.kind === 104) {
+ if (lhs.expression.kind === 107) {
return 4;
}
else if (isModuleExportsAccessExpression(lhs)) {
ts.isPrototypePropertyAssignment = isPrototypePropertyAssignment;
function isSpecialPropertyDeclaration(expr) {
return isInJSFile(expr) &&
- expr.parent && expr.parent.kind === 226 &&
+ expr.parent && expr.parent.kind === 233 &&
(!ts.isElementAccessExpression(expr) || isLiteralLikeElementAccess(expr)) &&
!!ts.getJSDocTypeTag(expr.parent);
}
return false;
}
var decl = symbol.valueDeclaration;
- return decl.kind === 244 || ts.isVariableDeclaration(decl) && decl.initializer && ts.isFunctionLike(decl.initializer);
+ return decl.kind === 251 || ts.isVariableDeclaration(decl) && decl.initializer && ts.isFunctionLike(decl.initializer);
}
ts.isFunctionSymbol = isFunctionSymbol;
function importFromModuleSpecifier(node) {
ts.importFromModuleSpecifier = importFromModuleSpecifier;
function tryGetImportFromModuleSpecifier(node) {
switch (node.parent.kind) {
- case 254:
- case 260:
+ case 261:
+ case 267:
return node.parent;
- case 265:
+ case 272:
return node.parent.parent;
- case 196:
+ case 203:
return isImportCall(node.parent) || isRequireCall(node.parent, false) ? node.parent : undefined;
- case 187:
+ case 191:
ts.Debug.assert(ts.isStringLiteral(node));
return ts.tryCast(node.parent.parent, ts.isImportTypeNode);
default:
ts.tryGetImportFromModuleSpecifier = tryGetImportFromModuleSpecifier;
function getExternalModuleName(node) {
switch (node.kind) {
- case 254:
- case 260:
+ case 261:
+ case 267:
return node.moduleSpecifier;
- case 253:
- return node.moduleReference.kind === 265 ? node.moduleReference.expression : undefined;
- case 188:
+ case 260:
+ return node.moduleReference.kind === 272 ? node.moduleReference.expression : undefined;
+ case 195:
return isLiteralImportTypeNode(node) ? node.argument.literal : undefined;
default:
return ts.Debug.assertNever(node);
ts.getExternalModuleName = getExternalModuleName;
function getNamespaceDeclarationNode(node) {
switch (node.kind) {
- case 254:
+ case 261:
return node.importClause && ts.tryCast(node.importClause.namedBindings, ts.isNamespaceImport);
- case 253:
- return node;
case 260:
+ return node;
+ case 267:
return node.exportClause && ts.tryCast(node.exportClause, ts.isNamespaceExport);
default:
return ts.Debug.assertNever(node);
}
ts.getNamespaceDeclarationNode = getNamespaceDeclarationNode;
function isDefaultImport(node) {
- return node.kind === 254 && !!node.importClause && !!node.importClause.name;
+ return node.kind === 261 && !!node.importClause && !!node.importClause.name;
}
ts.isDefaultImport = isDefaultImport;
function forEachImportClauseDeclaration(node, action) {
function hasQuestionToken(node) {
if (node) {
switch (node.kind) {
- case 156:
- case 161:
case 160:
- case 282:
- case 281:
- case 159:
- case 158:
+ case 165:
+ case 164:
+ case 289:
+ case 288:
+ case 163:
+ case 162:
return node.questionToken !== undefined;
}
}
}
ts.isJSDocConstructSignature = isJSDocConstructSignature;
function isJSDocTypeAlias(node) {
- return node.kind === 322 || node.kind === 315 || node.kind === 316;
+ return node.kind === 331 || node.kind === 324 || node.kind === 325;
}
ts.isJSDocTypeAlias = isJSDocTypeAlias;
function isTypeAlias(node) {
}
function getSingleInitializerOfVariableStatementOrPropertyDeclaration(node) {
switch (node.kind) {
- case 225:
+ case 232:
var v = getSingleVariableOfVariableStatement(node);
return v && v.initializer;
- case 159:
+ case 163:
return node.initializer;
- case 281:
+ case 288:
return node.initializer;
}
}
function getSingleVariableOfVariableStatement(node) {
return ts.isVariableStatement(node) ? ts.firstOrUndefined(node.declarationList.declarations) : undefined;
}
+ ts.getSingleVariableOfVariableStatement = getSingleVariableOfVariableStatement;
function getNestedModuleDeclaration(node) {
return ts.isModuleDeclaration(node) &&
node.body &&
- node.body.kind === 249
+ node.body.kind === 256
? node.body
: undefined;
}
- function getJSDocCommentsAndTags(hostNode) {
+ function getJSDocCommentsAndTags(hostNode, noCache) {
var result;
if (isVariableLike(hostNode) && ts.hasInitializer(hostNode) && ts.hasJSDocNodes(hostNode.initializer)) {
result = ts.append(result, ts.last(hostNode.initializer.jsDoc));
if (ts.hasJSDocNodes(node)) {
result = ts.append(result, ts.last(node.jsDoc));
}
- if (node.kind === 156) {
- result = ts.addRange(result, ts.getJSDocParameterTags(node));
+ if (node.kind === 160) {
+ result = ts.addRange(result, (noCache ? ts.getJSDocParameterTagsNoCache : ts.getJSDocParameterTags)(node));
break;
}
- if (node.kind === 155) {
- result = ts.addRange(result, ts.getJSDocTypeParameterTags(node));
+ if (node.kind === 159) {
+ result = ts.addRange(result, (noCache ? ts.getJSDocTypeParameterTagsNoCache : ts.getJSDocTypeParameterTags)(node));
break;
}
node = getNextJSDocCommentLocation(node);
ts.getJSDocCommentsAndTags = getJSDocCommentsAndTags;
function getNextJSDocCommentLocation(node) {
var parent = node.parent;
- if (parent.kind === 281 ||
- parent.kind === 259 ||
- parent.kind === 159 ||
- parent.kind === 226 && node.kind === 194 ||
+ if (parent.kind === 288 ||
+ parent.kind === 266 ||
+ parent.kind === 163 ||
+ parent.kind === 233 && node.kind === 201 ||
getNestedModuleDeclaration(parent) ||
ts.isBinaryExpression(node) && node.operatorToken.kind === 62) {
return parent;
if (!decl) {
return undefined;
}
- var parameter = ts.find(decl.parameters, function (p) { return p.name.kind === 75 && p.name.escapedText === name; });
+ var parameter = ts.find(decl.parameters, function (p) { return p.name.kind === 78 && p.name.escapedText === name; });
return parameter && parameter.symbol;
}
ts.getParameterSymbolFromJSDoc = getParameterSymbolFromJSDoc;
}
ts.getEffectiveJSDocHost = getEffectiveJSDocHost;
function getJSDocHost(node) {
- return ts.Debug.checkDefined(findAncestor(node.parent, ts.isJSDoc)).parent;
+ return ts.Debug.checkDefined(ts.findAncestor(node.parent, ts.isJSDoc)).parent;
}
ts.getJSDocHost = getJSDocHost;
function getTypeParameterFromJsDoc(node) {
ts.hasRestParameter = hasRestParameter;
function isRestParameter(node) {
var type = ts.isJSDocParameterTag(node) ? (node.typeExpression && node.typeExpression.type) : node.type;
- return node.dotDotDotToken !== undefined || !!type && type.kind === 301;
+ return node.dotDotDotToken !== undefined || !!type && type.kind === 309;
}
ts.isRestParameter = isRestParameter;
function hasTypeArguments(node) {
var parent = node.parent;
while (true) {
switch (parent.kind) {
- case 209:
+ case 216:
var binaryOperator = parent.operatorToken.kind;
return isAssignmentOperator(binaryOperator) && parent.left === node ?
- binaryOperator === 62 ? 1 : 2 :
+ binaryOperator === 62 || isLogicalOrCoalescingAssignmentOperator(binaryOperator) ? 1 : 2 :
0;
- case 207:
- case 208:
+ case 214:
+ case 215:
var unaryOperator = parent.operator;
return unaryOperator === 45 || unaryOperator === 46 ? 2 : 0;
- case 231:
- case 232:
+ case 238:
+ case 239:
return parent.initializer === node ? 1 : 0;
- case 200:
- case 192:
- case 213:
- case 218:
+ case 207:
+ case 199:
+ case 220:
+ case 225:
node = parent;
break;
- case 282:
+ case 289:
if (parent.name !== node) {
return 0;
}
node = parent.parent;
break;
- case 281:
+ case 288:
if (parent.name === node) {
return 0;
}
ts.isAssignmentTarget = isAssignmentTarget;
function isNodeWithPossibleHoistedDeclaration(node) {
switch (node.kind) {
- case 223:
- case 225:
- case 236:
- case 227:
- case 237:
- case 251:
- case 277:
- case 278:
- case 238:
case 230:
- case 231:
case 232:
- case 228:
- case 229:
- case 240:
- case 280:
+ case 243:
+ case 234:
+ case 244:
+ case 258:
+ case 284:
+ case 285:
+ case 245:
+ case 237:
+ case 238:
+ case 239:
+ case 235:
+ case 236:
+ case 247:
+ case 287:
return true;
}
return false;
return node;
}
function walkUpParenthesizedTypes(node) {
- return walkUp(node, 182);
+ return walkUp(node, 186);
}
ts.walkUpParenthesizedTypes = walkUpParenthesizedTypes;
function walkUpParenthesizedExpressions(node) {
- return walkUp(node, 200);
+ return walkUp(node, 207);
}
ts.walkUpParenthesizedExpressions = walkUpParenthesizedExpressions;
+ function walkUpParenthesizedTypesAndGetParentAndChild(node) {
+ var child;
+ while (node && node.kind === 186) {
+ child = node;
+ node = node.parent;
+ }
+ return [child, node];
+ }
+ ts.walkUpParenthesizedTypesAndGetParentAndChild = walkUpParenthesizedTypesAndGetParentAndChild;
function skipParentheses(node) {
return ts.skipOuterExpressions(node, 1);
}
ts.skipParentheses = skipParentheses;
function skipParenthesesUp(node) {
- while (node.kind === 200) {
+ while (node.kind === 207) {
node = node.parent;
}
return node;
}
function isDeleteTarget(node) {
- if (node.kind !== 194 && node.kind !== 195) {
+ if (node.kind !== 201 && node.kind !== 202) {
return false;
}
node = walkUpParenthesizedExpressions(node.parent);
- return node && node.kind === 203;
+ return node && node.kind === 210;
}
ts.isDeleteTarget = isDeleteTarget;
function isNodeDescendantOf(node, ancestor) {
case 8:
if (ts.isComputedPropertyName(parent))
return parent.parent;
- case 75:
+ case 78:
if (ts.isDeclaration(parent)) {
return parent.name === name ? parent : undefined;
}
? binExp
: undefined;
}
- case 76:
+ case 79:
return ts.isDeclaration(parent) && parent.name === name ? parent : undefined;
default:
return undefined;
ts.getDeclarationFromName = getDeclarationFromName;
function isLiteralComputedPropertyDeclarationName(node) {
return isStringOrNumericLiteralLike(node) &&
- node.parent.kind === 154 &&
+ node.parent.kind === 158 &&
ts.isDeclaration(node.parent.parent);
}
ts.isLiteralComputedPropertyDeclarationName = isLiteralComputedPropertyDeclarationName;
function isIdentifierName(node) {
var parent = node.parent;
switch (parent.kind) {
- case 159:
- case 158:
- case 161:
- case 160:
case 163:
+ case 162:
+ case 165:
case 164:
- case 284:
- case 281:
- case 194:
+ case 167:
+ case 168:
+ case 291:
+ case 288:
+ case 201:
return parent.name === node;
- case 153:
- if (parent.right === node) {
- while (parent.kind === 153) {
- parent = parent.parent;
- }
- return parent.kind === 172 || parent.kind === 169;
- }
- return false;
- case 191:
- case 258:
+ case 157:
+ return parent.right === node;
+ case 198:
+ case 265:
return parent.propertyName === node;
- case 263:
- case 273:
+ case 270:
+ case 280:
return true;
}
return false;
}
ts.isIdentifierName = isIdentifierName;
function isAliasSymbolDeclaration(node) {
- return node.kind === 253 ||
- node.kind === 252 ||
- node.kind === 255 && !!node.name ||
- node.kind === 256 ||
- node.kind === 262 ||
- node.kind === 258 ||
+ return node.kind === 260 ||
+ node.kind === 259 ||
+ node.kind === 262 && !!node.name ||
node.kind === 263 ||
- node.kind === 259 && exportAssignmentIsAlias(node) ||
+ node.kind === 269 ||
+ node.kind === 265 ||
+ node.kind === 270 ||
+ node.kind === 266 && exportAssignmentIsAlias(node) ||
ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 && exportAssignmentIsAlias(node) ||
ts.isPropertyAccessExpression(node) && ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 62 && isAliasableExpression(node.parent.right) ||
- node.kind === 282 ||
- node.kind === 281 && isAliasableExpression(node.initializer);
+ node.kind === 289 ||
+ node.kind === 288 && isAliasableExpression(node.initializer);
}
ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration;
function getAliasDeclarationFromName(node) {
switch (node.parent.kind) {
- case 255:
- case 258:
- case 256:
+ case 262:
+ case 265:
case 263:
- case 259:
- case 253:
+ case 270:
+ case 266:
+ case 260:
return node.parent;
- case 153:
+ case 157:
do {
node = node.parent;
- } while (node.parent.kind === 153);
+ } while (node.parent.kind === 157);
return getAliasDeclarationFromName(node);
}
}
}
ts.getExportAssignmentExpression = getExportAssignmentExpression;
function getPropertyAssignmentAliasLikeExpression(node) {
- return node.kind === 282 ? node.name : node.kind === 281 ? node.initializer :
+ return node.kind === 289 ? node.name : node.kind === 288 ? node.initializer :
node.parent.right;
}
ts.getPropertyAssignmentAliasLikeExpression = getPropertyAssignmentAliasLikeExpression;
}
ts.getEffectiveBaseTypeNode = getEffectiveBaseTypeNode;
function getClassExtendsHeritageElement(node) {
- var heritageClause = getHeritageClause(node.heritageClauses, 90);
+ var heritageClause = getHeritageClause(node.heritageClauses, 93);
return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined;
}
ts.getClassExtendsHeritageElement = getClassExtendsHeritageElement;
return ts.getJSDocImplementsTags(node).map(function (n) { return n.class; });
}
else {
- var heritageClause = getHeritageClause(node.heritageClauses, 113);
+ var heritageClause = getHeritageClause(node.heritageClauses, 116);
return heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.types;
}
}
}
ts.getAllSuperTypeNodes = getAllSuperTypeNodes;
function getInterfaceBaseTypeNodes(node) {
- var heritageClause = getHeritageClause(node.heritageClauses, 90);
+ var heritageClause = getHeritageClause(node.heritageClauses, 93);
return heritageClause ? heritageClause.types : undefined;
}
ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes;
}
ts.getAncestor = getAncestor;
function isKeyword(token) {
- return 77 <= token && token <= 152;
+ return 80 <= token && token <= 156;
}
ts.isKeyword = isKeyword;
function isContextualKeyword(token) {
- return 122 <= token && token <= 152;
+ return 125 <= token && token <= 156;
}
ts.isContextualKeyword = isContextualKeyword;
function isNonContextualKeyword(token) {
}
ts.isNonContextualKeyword = isNonContextualKeyword;
function isFutureReservedKeyword(token) {
- return 113 <= token && token <= 121;
+ return 116 <= token && token <= 124;
}
ts.isFutureReservedKeyword = isFutureReservedKeyword;
function isStringANonContextualKeyword(name) {
}
var flags = 0;
switch (node.kind) {
- case 244:
- case 201:
- case 161:
+ case 251:
+ case 208:
+ case 165:
if (node.asteriskToken) {
flags |= 1;
}
- case 202:
- if (hasModifier(node, 256)) {
+ case 209:
+ if (hasSyntacticModifier(node, 256)) {
flags |= 2;
}
break;
ts.getFunctionFlags = getFunctionFlags;
function isAsyncFunction(node) {
switch (node.kind) {
- case 244:
- case 201:
- case 202:
- case 161:
+ case 251:
+ case 208:
+ case 209:
+ case 165:
return node.body !== undefined
&& node.asteriskToken === undefined
- && hasModifier(node, 256);
+ && hasSyntacticModifier(node, 256);
}
return false;
}
}
ts.hasDynamicName = hasDynamicName;
function isDynamicName(name) {
- if (!(name.kind === 154 || name.kind === 195)) {
+ if (!(name.kind === 158 || name.kind === 202)) {
return false;
}
- var expr = ts.isElementAccessExpression(name) ? name.argumentExpression : name.expression;
+ var expr = ts.isElementAccessExpression(name) ? skipParentheses(name.argumentExpression) : name.expression;
return !isStringOrNumericLiteralLike(expr) &&
!isSignedNumericLiteral(expr) &&
!isWellKnownSymbolSyntactically(expr);
ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically;
function getPropertyNameForPropertyNameNode(name) {
switch (name.kind) {
- case 75:
- case 76:
+ case 78:
+ case 79:
return name.escapedText;
case 10:
case 8:
return ts.escapeLeadingUnderscores(name.text);
- case 154:
+ case 158:
var nameExpression = name.expression;
if (isWellKnownSymbolSyntactically(nameExpression)) {
return getPropertyNameForKnownSymbolName(ts.idText(nameExpression.name));
else if (isStringOrNumericLiteralLike(nameExpression)) {
return ts.escapeLeadingUnderscores(nameExpression.text);
}
+ else if (isSignedNumericLiteral(nameExpression)) {
+ if (nameExpression.operator === 40) {
+ return ts.tokenToString(nameExpression.operator) + nameExpression.operand.text;
+ }
+ return nameExpression.operand.text;
+ }
return undefined;
default:
return ts.Debug.assertNever(name);
ts.getPropertyNameForPropertyNameNode = getPropertyNameForPropertyNameNode;
function isPropertyNameLiteral(node) {
switch (node.kind) {
- case 75:
+ case 78:
case 10:
case 14:
case 8:
}
ts.isKnownSymbol = isKnownSymbol;
function isESSymbolIdentifier(node) {
- return node.kind === 75 && node.escapedText === "Symbol";
+ return node.kind === 78 && node.escapedText === "Symbol";
}
ts.isESSymbolIdentifier = isESSymbolIdentifier;
function isPushOrUnshiftIdentifier(node) {
ts.isPushOrUnshiftIdentifier = isPushOrUnshiftIdentifier;
function isParameterDeclaration(node) {
var root = getRootDeclaration(node);
- return root.kind === 156;
+ return root.kind === 160;
}
ts.isParameterDeclaration = isParameterDeclaration;
function getRootDeclaration(node) {
- while (node.kind === 191) {
+ while (node.kind === 198) {
node = node.parent.parent;
}
return node;
ts.getRootDeclaration = getRootDeclaration;
function nodeStartsNewLexicalEnvironment(node) {
var kind = node.kind;
- return kind === 162
- || kind === 201
- || kind === 244
- || kind === 202
- || kind === 161
- || kind === 163
- || kind === 164
- || kind === 249
- || kind === 290;
+ return kind === 166
+ || kind === 208
+ || kind === 251
+ || kind === 209
+ || kind === 165
+ || kind === 167
+ || kind === 168
+ || kind === 256
+ || kind === 297;
}
ts.nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment;
function nodeIsSynthesized(range) {
ts.getOriginalSourceFile = getOriginalSourceFile;
function getExpressionAssociativity(expression) {
var operator = getOperator(expression);
- var hasArguments = expression.kind === 197 && expression.arguments !== undefined;
+ var hasArguments = expression.kind === 204 && expression.arguments !== undefined;
return getOperatorAssociativity(expression.kind, operator, hasArguments);
}
ts.getExpressionAssociativity = getExpressionAssociativity;
function getOperatorAssociativity(kind, operator, hasArguments) {
switch (kind) {
- case 197:
- return hasArguments ? 0 : 1;
- case 207:
case 204:
- case 205:
- case 203:
- case 206:
- case 210:
+ return hasArguments ? 0 : 1;
+ case 214:
+ case 211:
case 212:
+ case 210:
+ case 213:
+ case 217:
+ case 219:
return 1;
- case 209:
+ case 216:
switch (operator) {
case 42:
case 62:
case 70:
case 71:
case 72:
- case 74:
+ case 77:
case 73:
+ case 74:
+ case 75:
+ case 76:
return 1;
}
}
ts.getOperatorAssociativity = getOperatorAssociativity;
function getExpressionPrecedence(expression) {
var operator = getOperator(expression);
- var hasArguments = expression.kind === 197 && expression.arguments !== undefined;
+ var hasArguments = expression.kind === 204 && expression.arguments !== undefined;
return getOperatorPrecedence(expression.kind, operator, hasArguments);
}
ts.getExpressionPrecedence = getExpressionPrecedence;
function getOperator(expression) {
- if (expression.kind === 209) {
+ if (expression.kind === 216) {
return expression.operatorToken.kind;
}
- else if (expression.kind === 207 || expression.kind === 208) {
+ else if (expression.kind === 214 || expression.kind === 215) {
return expression.operator;
}
else {
ts.getOperator = getOperator;
function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) {
switch (nodeKind) {
- case 327:
+ case 337:
return 0;
- case 213:
+ case 220:
return 1;
- case 212:
+ case 219:
return 2;
- case 210:
+ case 217:
return 4;
- case 209:
+ case 216:
switch (operatorKind) {
case 27:
return 0;
case 70:
case 71:
case 72:
- case 74:
+ case 77:
case 73:
+ case 74:
+ case 75:
+ case 76:
return 3;
default:
return getBinaryOperatorPrecedence(operatorKind);
}
- case 207:
- case 204:
- case 205:
- case 203:
- case 206:
+ case 214:
+ case 211:
+ case 212:
+ case 210:
+ case 213:
return 16;
- case 208:
+ case 215:
return 17;
- case 196:
+ case 203:
return 18;
- case 197:
+ case 204:
return hasArguments ? 19 : 18;
- case 198:
- case 194:
- case 195:
+ case 205:
+ case 201:
+ case 202:
return 19;
- case 104:
- case 102:
- case 75:
- case 100:
- case 106:
- case 91:
+ case 107:
+ case 105:
+ case 78:
+ case 103:
+ case 109:
+ case 94:
case 8:
case 9:
case 10:
- case 192:
- case 193:
- case 201:
- case 202:
- case 214:
- case 266:
- case 267:
- case 270:
+ case 199:
+ case 200:
+ case 208:
+ case 209:
+ case 221:
case 13:
case 14:
- case 211:
- case 200:
- case 215:
+ case 218:
+ case 207:
+ case 222:
+ case 273:
+ case 274:
+ case 277:
return 20;
default:
return -1;
case 31:
case 32:
case 33:
- case 98:
- case 97:
- case 123:
+ case 101:
+ case 100:
+ case 126:
return 11;
case 47:
case 48:
return -1;
}
ts.getBinaryOperatorPrecedence = getBinaryOperatorPrecedence;
+ function getSemanticJsxChildren(children) {
+ return ts.filter(children, function (i) {
+ switch (i.kind) {
+ case 283:
+ return !!i.expression;
+ case 11:
+ return !i.containsOnlyTriviaWhiteSpaces;
+ default:
+ return true;
+ }
+ });
+ }
+ ts.getSemanticJsxChildren = getSemanticJsxChildren;
function createDiagnosticCollection() {
var nonFileDiagnostics = [];
var filesWithDiagnostics = [];
- var fileDiagnostics = ts.createMap();
+ var fileDiagnostics = new ts.Map();
var hasReadNonFileDiagnostics = false;
return {
add: add,
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 = /[\\`]/g;
- var escapedCharsMap = ts.createMapFromTemplate({
+ var escapedCharsMap = new ts.Map(ts.getEntries({
"\t": "\\t",
"\v": "\\v",
"\f": "\\f",
"\u2028": "\\u2028",
"\u2029": "\\u2029",
"\u0085": "\\u0085"
- });
+ }));
function encodeUtf16EscapeSequence(charCode) {
var hexCharCode = charCode.toString(16).toUpperCase();
var paddedHexCode = ("0000" + hexCharCode).slice(-4);
ts.escapeNonAsciiString = escapeNonAsciiString;
var jsxDoubleQuoteEscapedCharsRegExp = /[\"\u0000-\u001f\u2028\u2029\u0085]/g;
var jsxSingleQuoteEscapedCharsRegExp = /[\'\u0000-\u001f\u2028\u2029\u0085]/g;
- var jsxEscapedCharsMap = ts.createMapFromTemplate({
+ var jsxEscapedCharsMap = new ts.Map(ts.getEntries({
"\"": """,
"\'": "'"
- });
+ }));
function encodeJsxCharacterEntity(charCode) {
var hexCharCode = charCode.toString(16).toUpperCase();
return "&#x" + hexCharCode + ";";
ts.isIntrinsicJsxName = isIntrinsicJsxName;
var indentStrings = ["", " "];
function getIndentString(level) {
- if (indentStrings[level] === undefined) {
- indentStrings[level] = getIndentString(level - 1) + indentStrings[1];
+ var singleLevel = indentStrings[1];
+ for (var current = indentStrings.length; current <= level; current++) {
+ indentStrings.push(indentStrings[current - 1] + singleLevel);
}
return indentStrings[level];
}
return removeFileExtension(path) + ".d.ts";
}
ts.getDeclarationEmitOutputFilePathWorker = getDeclarationEmitOutputFilePathWorker;
+ function outFile(options) {
+ return options.outFile || options.out;
+ }
+ ts.outFile = outFile;
+ function getPathsBasePath(options, host) {
+ var _a, _b;
+ if (!options.paths)
+ return undefined;
+ return (_a = options.baseUrl) !== null && _a !== void 0 ? _a : ts.Debug.checkDefined(options.pathsBasePath || ((_b = host.getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(host)), "Encountered 'paths' without a 'baseUrl', config file, or host 'getCurrentDirectory'.");
+ }
+ ts.getPathsBasePath = getPathsBasePath;
function getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit) {
var options = host.getCompilerOptions();
- if (options.outFile || options.out) {
+ if (outFile(options)) {
var moduleKind = getEmitModuleKind(options);
var moduleEmitEnabled_1 = options.emitDeclarationOnly || moduleKind === ts.ModuleKind.AMD || moduleKind === ts.ModuleKind.System;
return ts.filter(host.getSourceFiles(), function (sourceFile) {
}
ts.parameterIsThisKeyword = parameterIsThisKeyword;
function isThisIdentifier(node) {
- return !!node && node.kind === 75 && identifierIsThisKeyword(node);
+ return !!node && node.kind === 78 && identifierIsThisKeyword(node);
}
ts.isThisIdentifier = isThisIdentifier;
function identifierIsThisKeyword(id) {
- return id.originalKeywordKind === 104;
+ return id.originalKeywordKind === 107;
}
ts.identifierIsThisKeyword = identifierIsThisKeyword;
function getAllAccessorDeclarations(declarations, accessor) {
var setAccessor;
if (hasDynamicName(accessor)) {
firstAccessor = accessor;
- if (accessor.kind === 163) {
+ if (accessor.kind === 167) {
getAccessor = accessor;
}
- else if (accessor.kind === 164) {
+ else if (accessor.kind === 168) {
setAccessor = accessor;
}
else {
else {
ts.forEach(declarations, function (member) {
if (ts.isAccessor(member)
- && hasModifier(member, 32) === hasModifier(accessor, 32)) {
+ && hasSyntacticModifier(member, 32) === hasSyntacticModifier(accessor, 32)) {
var memberName = getPropertyNameForPropertyNameNode(member.name);
var accessorName = getPropertyNameForPropertyNameNode(accessor.name);
if (memberName === accessorName) {
else if (!secondAccessor) {
secondAccessor = member;
}
- if (member.kind === 163 && !getAccessor) {
+ if (member.kind === 167 && !getAccessor) {
getAccessor = member;
}
- if (member.kind === 164 && !setAccessor) {
+ if (member.kind === 168 && !setAccessor) {
setAccessor = member;
}
}
}
ts.getJSDocTypeParameterDeclarations = getJSDocTypeParameterDeclarations;
function isNonTypeAliasTemplate(tag) {
- return ts.isJSDocTemplateTag(tag) && !(tag.parent.kind === 303 && tag.parent.tags.some(isJSDocTypeAlias));
+ return ts.isJSDocTemplateTag(tag) && !(tag.parent.kind === 311 && tag.parent.tags.some(isJSDocTypeAlias));
}
function getEffectiveSetAccessorTypeAnnotationNode(node) {
var parameter = getSetAccessorValueParameter(node);
}
return currentLineIndent;
}
- function hasModifiers(node) {
- return getModifierFlags(node) !== 0;
+ function hasEffectiveModifiers(node) {
+ return getEffectiveModifierFlags(node) !== 0;
+ }
+ ts.hasEffectiveModifiers = hasEffectiveModifiers;
+ function hasSyntacticModifiers(node) {
+ return getSyntacticModifierFlags(node) !== 0;
+ }
+ ts.hasSyntacticModifiers = hasSyntacticModifiers;
+ function hasEffectiveModifier(node, flags) {
+ return !!getSelectedEffectiveModifierFlags(node, flags);
}
- ts.hasModifiers = hasModifiers;
- function hasModifier(node, flags) {
- return !!getSelectedModifierFlags(node, flags);
+ ts.hasEffectiveModifier = hasEffectiveModifier;
+ function hasSyntacticModifier(node, flags) {
+ return !!getSelectedSyntacticModifierFlags(node, flags);
}
- ts.hasModifier = hasModifier;
+ ts.hasSyntacticModifier = hasSyntacticModifier;
function hasStaticModifier(node) {
- return hasModifier(node, 32);
+ return hasSyntacticModifier(node, 32);
}
ts.hasStaticModifier = hasStaticModifier;
- function hasReadonlyModifier(node) {
- return hasModifier(node, 64);
+ function hasEffectiveReadonlyModifier(node) {
+ return hasEffectiveModifier(node, 64);
}
- ts.hasReadonlyModifier = hasReadonlyModifier;
- function getSelectedModifierFlags(node, flags) {
- return getModifierFlags(node) & flags;
+ ts.hasEffectiveReadonlyModifier = hasEffectiveReadonlyModifier;
+ function getSelectedEffectiveModifierFlags(node, flags) {
+ return getEffectiveModifierFlags(node) & flags;
}
- ts.getSelectedModifierFlags = getSelectedModifierFlags;
- function getModifierFlags(node) {
- if (node.kind >= 0 && node.kind <= 152) {
+ ts.getSelectedEffectiveModifierFlags = getSelectedEffectiveModifierFlags;
+ function getSelectedSyntacticModifierFlags(node, flags) {
+ return getSyntacticModifierFlags(node) & flags;
+ }
+ ts.getSelectedSyntacticModifierFlags = getSelectedSyntacticModifierFlags;
+ function getModifierFlagsWorker(node, includeJSDoc, alwaysIncludeJSDoc) {
+ if (node.kind >= 0 && node.kind <= 156) {
return 0;
}
- if (node.modifierFlagsCache & 536870912) {
- return node.modifierFlagsCache & ~536870912;
+ if (!(node.modifierFlagsCache & 536870912)) {
+ node.modifierFlagsCache = getSyntacticModifierFlagsNoCache(node) | 536870912;
}
- var flags = getModifierFlagsNoCache(node);
- node.modifierFlagsCache = flags | 536870912;
- return flags;
+ if (includeJSDoc && !(node.modifierFlagsCache & 4096) && (alwaysIncludeJSDoc || isInJSFile(node)) && node.parent) {
+ node.modifierFlagsCache |= getJSDocModifierFlagsNoCache(node) | 4096;
+ }
+ return node.modifierFlagsCache & ~(536870912 | 4096);
+ }
+ function getEffectiveModifierFlags(node) {
+ return getModifierFlagsWorker(node, true);
}
- ts.getModifierFlags = getModifierFlags;
- function getModifierFlagsNoCache(node) {
+ ts.getEffectiveModifierFlags = getEffectiveModifierFlags;
+ function getEffectiveModifierFlagsAlwaysIncludeJSDoc(node) {
+ return getModifierFlagsWorker(node, true, true);
+ }
+ ts.getEffectiveModifierFlagsAlwaysIncludeJSDoc = getEffectiveModifierFlagsAlwaysIncludeJSDoc;
+ function getSyntacticModifierFlags(node) {
+ return getModifierFlagsWorker(node, false);
+ }
+ ts.getSyntacticModifierFlags = getSyntacticModifierFlags;
+ function getJSDocModifierFlagsNoCache(node) {
var flags = 0;
- if (node.modifiers) {
- for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
- var modifier = _a[_i];
- flags |= modifierToFlag(modifier.kind);
+ if (!!node.parent && !ts.isParameter(node)) {
+ if (isInJSFile(node)) {
+ if (ts.getJSDocPublicTagNoCache(node))
+ flags |= 4;
+ if (ts.getJSDocPrivateTagNoCache(node))
+ flags |= 8;
+ if (ts.getJSDocProtectedTagNoCache(node))
+ flags |= 16;
+ if (ts.getJSDocReadonlyTagNoCache(node))
+ flags |= 64;
}
+ if (ts.getJSDocDeprecatedTagNoCache(node))
+ flags |= 8192;
}
- if (isInJSFile(node) && !!node.parent) {
- var tags = (ts.getJSDocPublicTag(node) ? 4 : 0)
- | (ts.getJSDocPrivateTag(node) ? 8 : 0)
- | (ts.getJSDocProtectedTag(node) ? 16 : 0)
- | (ts.getJSDocReadonlyTag(node) ? 64 : 0);
- flags |= tags;
- }
- if (node.flags & 4 || (node.kind === 75 && node.isInJSDocNamespace)) {
+ return flags;
+ }
+ function getEffectiveModifierFlagsNoCache(node) {
+ return getSyntacticModifierFlagsNoCache(node) | getJSDocModifierFlagsNoCache(node);
+ }
+ ts.getEffectiveModifierFlagsNoCache = getEffectiveModifierFlagsNoCache;
+ function getSyntacticModifierFlagsNoCache(node) {
+ var flags = modifiersToFlags(node.modifiers);
+ if (node.flags & 4 || (node.kind === 78 && node.isInJSDocNamespace)) {
flags |= 1;
}
return flags;
}
- ts.getModifierFlagsNoCache = getModifierFlagsNoCache;
+ ts.getSyntacticModifierFlagsNoCache = getSyntacticModifierFlagsNoCache;
+ function modifiersToFlags(modifiers) {
+ var flags = 0;
+ if (modifiers) {
+ for (var _i = 0, modifiers_1 = modifiers; _i < modifiers_1.length; _i++) {
+ var modifier = modifiers_1[_i];
+ flags |= modifierToFlag(modifier.kind);
+ }
+ }
+ return flags;
+ }
+ ts.modifiersToFlags = modifiersToFlags;
function modifierToFlag(token) {
switch (token) {
- case 120: return 32;
- case 119: return 4;
- case 118: return 16;
- case 117: return 8;
- case 122: return 128;
- case 89: return 1;
- case 130: return 2;
- case 81: return 2048;
- case 84: return 512;
- case 126: return 256;
- case 138: return 64;
+ case 123: return 32;
+ case 122: return 4;
+ case 121: return 16;
+ case 120: return 8;
+ case 125: return 128;
+ case 92: return 1;
+ case 133: return 2;
+ case 84: return 2048;
+ case 87: return 512;
+ case 129: return 256;
+ case 142: return 64;
}
return 0;
}
|| token === 53;
}
ts.isLogicalOperator = isLogicalOperator;
+ function isLogicalOrCoalescingAssignmentOperator(token) {
+ return token === 74
+ || token === 75
+ || token === 76;
+ }
+ ts.isLogicalOrCoalescingAssignmentOperator = isLogicalOrCoalescingAssignmentOperator;
+ function isLogicalOrCoalescingAssignmentExpression(expr) {
+ return isLogicalOrCoalescingAssignmentOperator(expr.operatorToken.kind);
+ }
+ ts.isLogicalOrCoalescingAssignmentExpression = isLogicalOrCoalescingAssignmentExpression;
function isAssignmentOperator(token) {
- return token >= 62 && token <= 74;
+ return token >= 62 && token <= 77;
}
ts.isAssignmentOperator = isAssignmentOperator;
function tryGetClassExtendingExpressionWithTypeArguments(node) {
return ts.isExpressionWithTypeArguments(node)
&& ts.isHeritageClause(node.parent)
&& ts.isClassLike(node.parent.parent)
- ? { class: node.parent.parent, isImplements: node.parent.token === 113 }
+ ? { class: node.parent.parent, isImplements: node.parent.token === 116 }
: undefined;
}
ts.tryGetClassImplementingOrExtendingExpressionWithTypeArguments = tryGetClassImplementingOrExtendingExpressionWithTypeArguments;
function isDestructuringAssignment(node) {
if (isAssignmentExpression(node, true)) {
var kind = node.left.kind;
- return kind === 193
- || kind === 192;
+ return kind === 200
+ || kind === 199;
}
return false;
}
}
ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause;
function isEntityNameExpression(node) {
- return node.kind === 75 || isPropertyAccessEntityNameExpression(node);
+ return node.kind === 78 || isPropertyAccessEntityNameExpression(node);
}
ts.isEntityNameExpression = isEntityNameExpression;
function getFirstIdentifier(node) {
switch (node.kind) {
- case 75:
+ case 78:
return node;
- case 153:
+ case 157:
do {
node = node.left;
- } while (node.kind !== 75);
+ } while (node.kind !== 78);
return node;
- case 194:
+ case 201:
do {
node = node.expression;
- } while (node.kind !== 75);
+ } while (node.kind !== 78);
return node;
}
}
ts.getFirstIdentifier = getFirstIdentifier;
function isDottedName(node) {
- return node.kind === 75 || node.kind === 104 || node.kind === 102 ||
- node.kind === 194 && isDottedName(node.expression) ||
- node.kind === 200 && isDottedName(node.expression);
+ return node.kind === 78 || node.kind === 107 || node.kind === 105 ||
+ node.kind === 201 && isDottedName(node.expression) ||
+ node.kind === 207 && isDottedName(node.expression);
}
ts.isDottedName = isDottedName;
function isPropertyAccessEntityNameExpression(node) {
if (ts.isPropertyAccessExpression(expr)) {
var baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression);
if (baseStr !== undefined) {
- return baseStr + "." + expr.name;
+ return baseStr + "." + entityNameToString(expr.name);
}
}
else if (ts.isIdentifier(expr)) {
}
ts.isPrototypeAccess = isPrototypeAccess;
function isRightSideOfQualifiedNameOrPropertyAccess(node) {
- return (node.parent.kind === 153 && node.parent.right === node) ||
- (node.parent.kind === 194 && node.parent.name === node);
+ return (node.parent.kind === 157 && node.parent.right === node) ||
+ (node.parent.kind === 201 && node.parent.name === node);
}
ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess;
function isEmptyObjectLiteral(expression) {
- return expression.kind === 193 &&
+ return expression.kind === 200 &&
expression.properties.length === 0;
}
ts.isEmptyObjectLiteral = isEmptyObjectLiteral;
function isEmptyArrayLiteral(expression) {
- return expression.kind === 192 &&
+ return expression.kind === 199 &&
expression.elements.length === 0;
}
ts.isEmptyArrayLiteral = isEmptyArrayLiteral;
function getLocalSymbolForExportDefault(symbol) {
- return isExportDefaultSymbol(symbol) ? symbol.declarations[0].localSymbol : undefined;
+ if (!isExportDefaultSymbol(symbol))
+ return undefined;
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ if (decl.localSymbol)
+ return decl.localSymbol;
+ }
+ return undefined;
}
ts.getLocalSymbolForExportDefault = getLocalSymbolForExportDefault;
function isExportDefaultSymbol(symbol) {
- return symbol && ts.length(symbol.declarations) > 0 && hasModifier(symbol.declarations[0], 512);
+ return symbol && ts.length(symbol.declarations) > 0 && hasSyntacticModifier(symbol.declarations[0], 512);
}
function tryExtractTSExtension(fileName) {
return ts.find(ts.supportedTSExtensionsForExtractExtension, function (extension) { return ts.fileExtensionIs(fileName, extension); });
var parseNode = ts.getParseTreeNode(node);
if (parseNode) {
switch (parseNode.parent.kind) {
- case 248:
- case 249:
+ case 255:
+ case 256:
return parseNode === parseNode.parent.name;
}
}
if (!parent)
return 0;
switch (parent.kind) {
- case 200:
- return accessKind(parent);
- case 208:
case 207:
+ return accessKind(parent);
+ case 215:
+ case 214:
var operator = parent.operator;
return operator === 45 || operator === 46 ? writeOrReadWrite() : 0;
- case 209:
+ case 216:
var _a = parent, left = _a.left, operatorToken = _a.operatorToken;
return left === node && isAssignmentOperator(operatorToken.kind) ?
operatorToken.kind === 62 ? 1 : writeOrReadWrite()
: 0;
- case 194:
+ case 201:
return parent.name !== node ? 0 : accessKind(parent);
- case 281: {
+ case 288: {
var parentAccess = accessKind(parent.parent);
return node === parent.name ? reverseAccessKind(parentAccess) : parentAccess;
}
- case 282:
+ case 289:
return node === parent.objectAssignmentInitializer ? 0 : accessKind(parent.parent);
- case 192:
+ case 199:
return accessKind(parent);
default:
return 0;
}
function writeOrReadWrite() {
- return parent.parent && skipParenthesesUp(parent.parent).kind === 226 ? 1 : 2;
+ return parent.parent && skipParenthesesUp(parent.parent).kind === 233 ? 1 : 2;
}
}
function reverseAccessKind(a) {
function isAbstractConstructorSymbol(symbol) {
if (symbol.flags & 32) {
var declaration = getClassLikeDeclarationOfSymbol(symbol);
- return !!declaration && hasModifier(declaration, 128);
+ return !!declaration && hasSyntacticModifier(declaration, 128);
}
return false;
}
}
ts.isObjectTypeDeclaration = isObjectTypeDeclaration;
function isTypeNodeKind(kind) {
- return (kind >= 168 && kind <= 188)
- || kind === 125
- || kind === 148
- || kind === 140
- || kind === 151
- || kind === 141
+ return (kind >= 172 && kind <= 195)
|| kind === 128
- || kind === 143
+ || kind === 152
|| kind === 144
- || kind === 104
- || kind === 110
- || kind === 146
- || kind === 100
- || kind === 137
- || kind === 216
- || kind === 295
- || kind === 296
- || kind === 297
- || kind === 298
- || kind === 299
- || kind === 300
- || kind === 301;
+ || kind === 155
+ || kind === 145
+ || kind === 131
+ || kind === 147
+ || kind === 148
+ || kind === 113
+ || kind === 150
+ || kind === 141
+ || kind === 223
+ || kind === 303
+ || kind === 304
+ || kind === 305
+ || kind === 306
+ || kind === 307
+ || kind === 308
+ || kind === 309;
}
ts.isTypeNodeKind = isTypeNodeKind;
function isAccessExpression(node) {
- return node.kind === 194 || node.kind === 195;
+ return node.kind === 201 || node.kind === 202;
}
ts.isAccessExpression = isAccessExpression;
function getNameOfAccessExpression(node) {
- if (node.kind === 194) {
+ if (node.kind === 201) {
return node.name;
}
- ts.Debug.assert(node.kind === 195);
+ ts.Debug.assert(node.kind === 202);
return node.argumentExpression;
}
ts.getNameOfAccessExpression = getNameOfAccessExpression;
}
ts.isBundleFileTextLike = isBundleFileTextLike;
function isNamedImportsOrExports(node) {
- return node.kind === 257 || node.kind === 261;
+ return node.kind === 264 || node.kind === 268;
}
ts.isNamedImportsOrExports = isNamedImportsOrExports;
+ function getLeftmostAccessExpression(expr) {
+ while (isAccessExpression(expr)) {
+ expr = expr.expression;
+ }
+ return expr;
+ }
+ ts.getLeftmostAccessExpression = getLeftmostAccessExpression;
+ function getLeftmostExpression(node, stopAtCallExpressions) {
+ while (true) {
+ switch (node.kind) {
+ case 215:
+ node = node.operand;
+ continue;
+ case 216:
+ node = node.left;
+ continue;
+ case 217:
+ node = node.condition;
+ continue;
+ case 205:
+ node = node.tag;
+ continue;
+ case 203:
+ if (stopAtCallExpressions) {
+ return node;
+ }
+ case 224:
+ case 202:
+ case 201:
+ case 225:
+ case 336:
+ node = node.expression;
+ continue;
+ }
+ return node;
+ }
+ }
+ ts.getLeftmostExpression = getLeftmostExpression;
function Symbol(flags, name) {
this.flags = flags;
this.escapedName = name;
}
function Type(checker, flags) {
this.flags = flags;
- if (ts.Debug.isDebugging) {
+ if (ts.Debug.isDebugging || ts.tracing.isTracing()) {
this.checker = checker;
}
}
return ts.localizedDiagnosticMessages && ts.localizedDiagnosticMessages[message.key] || message.message;
}
ts.getLocaleSpecificMessage = getLocaleSpecificMessage;
+ function createDetachedDiagnostic(fileName, start, length, message) {
+ ts.Debug.assertGreaterThanOrEqual(start, 0);
+ ts.Debug.assertGreaterThanOrEqual(length, 0);
+ var text = getLocaleSpecificMessage(message);
+ if (arguments.length > 4) {
+ text = formatStringFromArgs(text, arguments, 4);
+ }
+ return {
+ file: undefined,
+ start: start,
+ length: length,
+ messageText: text,
+ category: message.category,
+ code: message.code,
+ reportsUnnecessary: message.reportsUnnecessary,
+ fileName: fileName,
+ };
+ }
+ ts.createDetachedDiagnostic = createDetachedDiagnostic;
+ function isDiagnosticWithDetachedLocation(diagnostic) {
+ return diagnostic.file === undefined
+ && diagnostic.start !== undefined
+ && diagnostic.length !== undefined
+ && typeof diagnostic.fileName === "string";
+ }
+ function attachFileToDiagnostic(diagnostic, file) {
+ var fileName = file.fileName || "";
+ var length = file.text.length;
+ ts.Debug.assertEqual(diagnostic.fileName, fileName);
+ ts.Debug.assertLessThanOrEqual(diagnostic.start, length);
+ ts.Debug.assertLessThanOrEqual(diagnostic.start + diagnostic.length, length);
+ var diagnosticWithLocation = {
+ file: file,
+ start: diagnostic.start,
+ length: diagnostic.length,
+ messageText: diagnostic.messageText,
+ category: diagnostic.category,
+ code: diagnostic.code,
+ reportsUnnecessary: diagnostic.reportsUnnecessary
+ };
+ if (diagnostic.relatedInformation) {
+ diagnosticWithLocation.relatedInformation = [];
+ for (var _i = 0, _a = diagnostic.relatedInformation; _i < _a.length; _i++) {
+ var related = _a[_i];
+ if (isDiagnosticWithDetachedLocation(related) && related.fileName === fileName) {
+ ts.Debug.assertLessThanOrEqual(related.start, length);
+ ts.Debug.assertLessThanOrEqual(related.start + related.length, length);
+ diagnosticWithLocation.relatedInformation.push(attachFileToDiagnostic(related, file));
+ }
+ else {
+ diagnosticWithLocation.relatedInformation.push(related);
+ }
+ }
+ }
+ return diagnosticWithLocation;
+ }
+ function attachFileToDiagnostics(diagnostics, file) {
+ var diagnosticsWithLocation = [];
+ for (var _i = 0, diagnostics_1 = diagnostics; _i < diagnostics_1.length; _i++) {
+ var diagnostic = diagnostics_1[_i];
+ diagnosticsWithLocation.push(attachFileToDiagnostic(diagnostic, file));
+ }
+ return diagnosticsWithLocation;
+ }
+ ts.attachFileToDiagnostics = attachFileToDiagnostics;
function createFileDiagnostic(file, start, length, message) {
ts.Debug.assertGreaterThanOrEqual(start, 0);
ts.Debug.assertGreaterThanOrEqual(length, 0);
category: message.category,
code: message.code,
reportsUnnecessary: message.reportsUnnecessary,
+ reportsDeprecated: message.reportsDeprecated
};
}
ts.createFileDiagnostic = createFileDiagnostic;
category: message.category,
code: message.code,
reportsUnnecessary: message.reportsUnnecessary,
+ reportsDeprecated: message.reportsDeprecated
};
}
ts.createCompilerDiagnostic = createCompilerDiagnostic;
}
return 0;
}
+ function getLanguageVariant(scriptKind) {
+ return scriptKind === 4 || scriptKind === 2 || scriptKind === 1 || scriptKind === 6 ? 1 : 0;
+ }
+ ts.getLanguageVariant = getLanguageVariant;
function getEmitScriptTarget(compilerOptions) {
return compilerOptions.target || 0;
}
return compilerOptions[flag] === undefined ? !!compilerOptions.strict : !!compilerOptions[flag];
}
ts.getStrictOptionValue = getStrictOptionValue;
+ function getAllowJSCompilerOption(compilerOptions) {
+ return compilerOptions.allowJs === undefined ? !!compilerOptions.checkJs : compilerOptions.allowJs;
+ }
+ ts.getAllowJSCompilerOption = getAllowJSCompilerOption;
function compilerOptionsAffectSemanticDiagnostics(newOptions, oldOptions) {
return oldOptions !== newOptions &&
ts.semanticDiagnosticsOptionDeclarations.some(function (option) { return !isJsonEqual(getCompilerOptionValue(oldOptions, option), getCompilerOptionValue(newOptions, option)); });
return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name];
}
ts.getCompilerOptionValue = getCompilerOptionValue;
+ function getJSXTransformEnabled(options) {
+ var jsx = options.jsx;
+ return jsx === 2 || jsx === 4 || jsx === 5;
+ }
+ ts.getJSXTransformEnabled = getJSXTransformEnabled;
+ function getJSXImplicitImportBase(compilerOptions, file) {
+ var jsxImportSourcePragmas = file === null || file === void 0 ? void 0 : file.pragmas.get("jsximportsource");
+ var jsxImportSourcePragma = ts.isArray(jsxImportSourcePragmas) ? jsxImportSourcePragmas[0] : jsxImportSourcePragmas;
+ return compilerOptions.jsx === 4 ||
+ compilerOptions.jsx === 5 ||
+ compilerOptions.jsxImportSource ||
+ jsxImportSourcePragma ?
+ (jsxImportSourcePragma === null || jsxImportSourcePragma === void 0 ? void 0 : jsxImportSourcePragma.arguments.factory) || compilerOptions.jsxImportSource || "react" :
+ undefined;
+ }
+ ts.getJSXImplicitImportBase = getJSXImplicitImportBase;
+ function getJSXRuntimeImport(base, options) {
+ return base ? base + "/" + (options.jsx === 5 ? "jsx-dev-runtime" : "jsx-runtime") : undefined;
+ }
+ ts.getJSXRuntimeImport = getJSXRuntimeImport;
function hasZeroOrOneAsteriskCharacter(str) {
var seenAsterisk = false;
for (var i = 0; i < str.length; i++) {
return true;
}
ts.hasZeroOrOneAsteriskCharacter = hasZeroOrOneAsteriskCharacter;
+ function createSymlinkCache() {
+ var symlinkedDirectories;
+ var symlinkedFiles;
+ return {
+ getSymlinkedFiles: function () { return symlinkedFiles; },
+ getSymlinkedDirectories: function () { return symlinkedDirectories; },
+ setSymlinkedFile: function (path, real) { return (symlinkedFiles || (symlinkedFiles = new ts.Map())).set(path, real); },
+ setSymlinkedDirectory: function (path, directory) { return (symlinkedDirectories || (symlinkedDirectories = new ts.Map())).set(path, directory); },
+ };
+ }
+ ts.createSymlinkCache = createSymlinkCache;
function discoverProbableSymlinks(files, getCanonicalFileName, cwd) {
- var result = ts.createMap();
+ var cache = createSymlinkCache();
var symlinks = ts.flatten(ts.mapDefined(files, function (sf) {
return sf.resolvedModules && ts.compact(ts.arrayFrom(ts.mapIterator(sf.resolvedModules.values(), function (res) {
return res && res.originalPath && res.resolvedFileName !== res.originalPath ? [res.resolvedFileName, res.originalPath] : undefined;
}));
for (var _i = 0, symlinks_1 = symlinks; _i < symlinks_1.length; _i++) {
var _a = symlinks_1[_i], resolvedPath = _a[0], originalPath = _a[1];
- var _b = guessDirectorySymlink(resolvedPath, originalPath, cwd, getCanonicalFileName), commonResolved = _b[0], commonOriginal = _b[1];
- result.set(commonOriginal, commonResolved);
+ var _b = guessDirectorySymlink(resolvedPath, originalPath, cwd, getCanonicalFileName) || ts.emptyArray, commonResolved = _b[0], commonOriginal = _b[1];
+ if (commonResolved && commonOriginal) {
+ cache.setSymlinkedDirectory(ts.toPath(commonOriginal, cwd, getCanonicalFileName), { real: commonResolved, realPath: ts.toPath(commonResolved, cwd, getCanonicalFileName) });
+ }
}
- return result;
+ return cache;
}
ts.discoverProbableSymlinks = discoverProbableSymlinks;
function guessDirectorySymlink(a, b, cwd, getCanonicalFileName) {
var aParts = ts.getPathComponents(ts.toPath(a, cwd, getCanonicalFileName));
var bParts = ts.getPathComponents(ts.toPath(b, cwd, getCanonicalFileName));
+ var isDirectory = false;
while (!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 [ts.getPathFromPathComponents(aParts), ts.getPathFromPathComponents(bParts)];
+ return isDirectory ? [ts.getPathFromPathComponents(aParts), ts.getPathFromPathComponents(bParts)] : undefined;
}
function isNodeModulesOrScopedPackageDirectory(s, getCanonicalFileName) {
return getCanonicalFileName(s) === "node_modules" || ts.startsWith(s, "@");
var includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames);
var excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames);
var results = includeFileRegexes ? includeFileRegexes.map(function () { return []; }) : [[]];
- var visited = ts.createMap();
+ var visited = new ts.Map();
var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) {
var basePath = _a[_i];
var allSupportedExtensions = __spreadArrays(ts.supportedTSExtensions, ts.supportedJSExtensions);
var allSupportedExtensionsWithJson = __spreadArrays(ts.supportedTSExtensions, ts.supportedJSExtensions, [".json"]);
function getSupportedExtensions(options, extraFileExtensions) {
- var needJsExtensions = options && options.allowJs;
+ var needJsExtensions = options && getAllowJSCompilerOption(options);
if (!extraFileExtensions || extraFileExtensions.length === 0) {
return needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions;
}
if (!diagnostic.relatedInformation) {
diagnostic.relatedInformation = [];
}
+ ts.Debug.assert(diagnostic.relatedInformation !== ts.emptyArray, "Diagnostic had empty array singleton for related info, but is still being constructed!");
(_a = diagnostic.relatedInformation).push.apply(_a, relatedInformation);
return diagnostic;
}
return { min: min, max: max };
}
ts.minAndMax = minAndMax;
- var NodeSet = (function () {
- function NodeSet() {
- this.map = ts.createMap();
- }
- NodeSet.prototype.add = function (node) {
- this.map.set(String(ts.getNodeId(node)), node);
- };
- NodeSet.prototype.tryAdd = function (node) {
- if (this.has(node))
- return false;
- this.add(node);
- return true;
- };
- NodeSet.prototype.has = function (node) {
- return this.map.has(String(ts.getNodeId(node)));
- };
- NodeSet.prototype.forEach = function (cb) {
- this.map.forEach(cb);
- };
- NodeSet.prototype.some = function (pred) {
- return forEachEntry(this.map, pred) || false;
- };
- return NodeSet;
- }());
- ts.NodeSet = NodeSet;
- var NodeMap = (function () {
- function NodeMap() {
- this.map = ts.createMap();
- }
- NodeMap.prototype.get = function (node) {
- var res = this.map.get(String(ts.getNodeId(node)));
- return res && res.value;
- };
- NodeMap.prototype.getOrUpdate = function (node, setValue) {
- var res = this.get(node);
- if (res)
- return res;
- var value = setValue();
- this.set(node, value);
- return value;
- };
- NodeMap.prototype.set = function (node, value) {
- this.map.set(String(ts.getNodeId(node)), { node: node, value: value });
- };
- NodeMap.prototype.has = function (node) {
- return this.map.has(String(ts.getNodeId(node)));
- };
- NodeMap.prototype.forEach = function (cb) {
- this.map.forEach(function (_a) {
- var node = _a.node, value = _a.value;
- return cb(value, node);
- });
- };
- return NodeMap;
- }());
- ts.NodeMap = NodeMap;
function rangeOfNode(node) {
return { pos: getTokenPosOfNode(node), end: node.end };
}
return a === b || typeof a === "object" && a !== null && typeof b === "object" && b !== null && ts.equalOwnProperties(a, b, isJsonEqual);
}
ts.isJsonEqual = isJsonEqual;
- function getOrUpdate(map, key, getDefault) {
- var got = map.get(key);
- if (got === undefined) {
- var value = getDefault();
- map.set(key, value);
- return value;
- }
- else {
- return got;
- }
- }
- ts.getOrUpdate = getOrUpdate;
function parsePseudoBigInt(stringValue) {
var log2Base;
switch (stringValue.charCodeAt(1)) {
}
ts.isValidTypeOnlyAliasUseSite = isValidTypeOnlyAliasUseSite;
function typeOnlyDeclarationIsExport(typeOnlyDeclaration) {
- return typeOnlyDeclaration.kind === 263;
+ return typeOnlyDeclaration.kind === 270;
}
ts.typeOnlyDeclarationIsExport = typeOnlyDeclarationIsExport;
function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) {
- while (node.kind === 75 || node.kind === 194) {
+ while (node.kind === 78 || node.kind === 201) {
node = node.parent;
}
- if (node.kind !== 154) {
+ if (node.kind !== 158) {
return false;
}
- if (hasModifier(node.parent, 128)) {
+ if (hasSyntacticModifier(node.parent, 128)) {
return true;
}
var containerKind = node.parent.parent.kind;
- return containerKind === 246 || containerKind === 173;
+ return containerKind === 253 || containerKind === 177;
}
function isIdentifierInNonEmittingHeritageClause(node) {
- if (node.kind !== 75)
+ if (node.kind !== 78)
return false;
- var heritageClause = findAncestor(node.parent, function (parent) {
+ var heritageClause = ts.findAncestor(node.parent, function (parent) {
switch (parent.kind) {
- case 279:
+ case 286:
return true;
- case 194:
- case 216:
+ case 201:
+ case 223:
return false;
default:
return "quit";
}
});
- return (heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.token) === 113 || (heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.parent.kind) === 246;
+ return (heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.token) === 116 || (heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.parent.kind) === 253;
}
function isIdentifierTypeReference(node) {
return ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName);
return true;
}
ts.arrayIsHomogeneous = arrayIsHomogeneous;
+ function setTextRangePos(range, pos) {
+ range.pos = pos;
+ return range;
+ }
+ ts.setTextRangePos = setTextRangePos;
+ function setTextRangeEnd(range, end) {
+ range.end = end;
+ return range;
+ }
+ ts.setTextRangeEnd = setTextRangeEnd;
+ function setTextRangePosEnd(range, pos, end) {
+ return setTextRangeEnd(setTextRangePos(range, pos), end);
+ }
+ ts.setTextRangePosEnd = setTextRangePosEnd;
+ function setTextRangePosWidth(range, pos, width) {
+ return setTextRangePosEnd(range, pos, pos + width);
+ }
+ ts.setTextRangePosWidth = setTextRangePosWidth;
+ function setNodeFlags(node, newFlags) {
+ if (node) {
+ node.flags = newFlags;
+ }
+ return node;
+ }
+ ts.setNodeFlags = setNodeFlags;
+ function setParent(child, parent) {
+ if (child && parent) {
+ child.parent = parent;
+ }
+ return child;
+ }
+ ts.setParent = setParent;
+ function setEachParent(children, parent) {
+ if (children) {
+ for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+ var child = children_1[_i];
+ setParent(child, parent);
+ }
+ }
+ return children;
+ }
+ ts.setEachParent = setEachParent;
+ function setParentRecursive(rootNode, incremental) {
+ if (!rootNode)
+ return rootNode;
+ ts.forEachChildRecursively(rootNode, ts.isJSDocNode(rootNode) ? bindParentToChildIgnoringJSDoc : bindParentToChild);
+ return rootNode;
+ function bindParentToChildIgnoringJSDoc(child, parent) {
+ if (incremental && child.parent === parent) {
+ return "skip";
+ }
+ setParent(child, parent);
+ }
+ function bindJSDoc(child) {
+ if (ts.hasJSDocNodes(child)) {
+ for (var _i = 0, _a = child.jsDoc; _i < _a.length; _i++) {
+ var doc = _a[_i];
+ bindParentToChildIgnoringJSDoc(doc, child);
+ ts.forEachChildRecursively(doc, bindParentToChildIgnoringJSDoc);
+ }
+ }
+ }
+ function bindParentToChild(child, parent) {
+ return bindParentToChildIgnoringJSDoc(child, parent) || bindJSDoc(child);
+ }
+ }
+ ts.setParentRecursive = setParentRecursive;
})(ts || (ts = {}));
var ts;
(function (ts) {
- var NodeConstructor;
- var TokenConstructor;
- var IdentifierConstructor;
- var PrivateIdentifierConstructor;
- var SourceFileConstructor;
- function createNode(kind, pos, end) {
- if (kind === 290) {
- return new (SourceFileConstructor || (SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor()))(kind, pos, end);
+ function createBaseNodeFactory() {
+ var NodeConstructor;
+ var TokenConstructor;
+ var IdentifierConstructor;
+ var PrivateIdentifierConstructor;
+ var SourceFileConstructor;
+ return {
+ createBaseSourceFileNode: createBaseSourceFileNode,
+ createBaseIdentifierNode: createBaseIdentifierNode,
+ createBasePrivateIdentifierNode: createBasePrivateIdentifierNode,
+ createBaseTokenNode: createBaseTokenNode,
+ createBaseNode: createBaseNode
+ };
+ function createBaseSourceFileNode(kind) {
+ return new (SourceFileConstructor || (SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor()))(kind, -1, -1);
}
- else if (kind === 75) {
- return new (IdentifierConstructor || (IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor()))(kind, pos, end);
+ function createBaseIdentifierNode(kind) {
+ return new (IdentifierConstructor || (IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor()))(kind, -1, -1);
}
- else if (kind === 76) {
- return new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor()))(kind, pos, end);
+ function createBasePrivateIdentifierNode(kind) {
+ return new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor()))(kind, -1, -1);
}
- else if (!ts.isNodeKind(kind)) {
- return new (TokenConstructor || (TokenConstructor = ts.objectAllocator.getTokenConstructor()))(kind, pos, end);
+ function createBaseTokenNode(kind) {
+ return new (TokenConstructor || (TokenConstructor = ts.objectAllocator.getTokenConstructor()))(kind, -1, -1);
}
- else {
- return new (NodeConstructor || (NodeConstructor = ts.objectAllocator.getNodeConstructor()))(kind, pos, end);
+ function createBaseNode(kind) {
+ return new (NodeConstructor || (NodeConstructor = ts.objectAllocator.getNodeConstructor()))(kind, -1, -1);
}
}
- ts.createNode = createNode;
- function visitNode(cbNode, node) {
- return node && cbNode(node);
- }
- function visitNodes(cbNode, cbNodes, nodes) {
- if (nodes) {
- if (cbNodes) {
- return cbNodes(nodes);
+ ts.createBaseNodeFactory = createBaseNodeFactory;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function createParenthesizerRules(factory) {
+ return {
+ parenthesizeLeftSideOfBinary: parenthesizeLeftSideOfBinary,
+ parenthesizeRightSideOfBinary: parenthesizeRightSideOfBinary,
+ parenthesizeExpressionOfComputedPropertyName: parenthesizeExpressionOfComputedPropertyName,
+ parenthesizeConditionOfConditionalExpression: parenthesizeConditionOfConditionalExpression,
+ parenthesizeBranchOfConditionalExpression: parenthesizeBranchOfConditionalExpression,
+ parenthesizeExpressionOfExportDefault: parenthesizeExpressionOfExportDefault,
+ parenthesizeExpressionOfNew: parenthesizeExpressionOfNew,
+ parenthesizeLeftSideOfAccess: parenthesizeLeftSideOfAccess,
+ parenthesizeOperandOfPostfixUnary: parenthesizeOperandOfPostfixUnary,
+ parenthesizeOperandOfPrefixUnary: parenthesizeOperandOfPrefixUnary,
+ parenthesizeExpressionsOfCommaDelimitedList: parenthesizeExpressionsOfCommaDelimitedList,
+ parenthesizeExpressionForDisallowedComma: parenthesizeExpressionForDisallowedComma,
+ parenthesizeExpressionOfExpressionStatement: parenthesizeExpressionOfExpressionStatement,
+ parenthesizeConciseBodyOfArrowFunction: parenthesizeConciseBodyOfArrowFunction,
+ parenthesizeMemberOfConditionalType: parenthesizeMemberOfConditionalType,
+ parenthesizeMemberOfElementType: parenthesizeMemberOfElementType,
+ parenthesizeElementTypeOfArrayType: parenthesizeElementTypeOfArrayType,
+ parenthesizeConstituentTypesOfUnionOrIntersectionType: parenthesizeConstituentTypesOfUnionOrIntersectionType,
+ parenthesizeTypeArguments: parenthesizeTypeArguments,
+ };
+ function binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
+ var binaryOperatorPrecedence = ts.getOperatorPrecedence(216, binaryOperator);
+ var binaryOperatorAssociativity = ts.getOperatorAssociativity(216, binaryOperator);
+ var emittedOperand = ts.skipPartiallyEmittedExpressions(operand);
+ if (!isLeftSideOfBinary && operand.kind === 209 && binaryOperatorPrecedence > 3) {
+ return true;
}
- for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
- var node = nodes_1[_i];
- var result = cbNode(node);
- if (result) {
- return result;
+ var operandPrecedence = ts.getExpressionPrecedence(emittedOperand);
+ switch (ts.compareValues(operandPrecedence, binaryOperatorPrecedence)) {
+ case -1:
+ if (!isLeftSideOfBinary
+ && binaryOperatorAssociativity === 1
+ && operand.kind === 219) {
+ return false;
+ }
+ return true;
+ case 1:
+ return false;
+ case 0:
+ if (isLeftSideOfBinary) {
+ return binaryOperatorAssociativity === 1;
+ }
+ else {
+ if (ts.isBinaryExpression(emittedOperand)
+ && emittedOperand.operatorToken.kind === binaryOperator) {
+ if (operatorHasAssociativeProperty(binaryOperator)) {
+ return false;
+ }
+ if (binaryOperator === 39) {
+ var leftKind = leftOperand ? getLiteralKindOfBinaryPlusOperand(leftOperand) : 0;
+ if (ts.isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(emittedOperand)) {
+ return false;
+ }
+ }
+ }
+ var operandAssociativity = ts.getExpressionAssociativity(emittedOperand);
+ return operandAssociativity === 0;
+ }
+ }
+ }
+ function operatorHasAssociativeProperty(binaryOperator) {
+ return binaryOperator === 41
+ || binaryOperator === 51
+ || binaryOperator === 50
+ || binaryOperator === 52;
+ }
+ function getLiteralKindOfBinaryPlusOperand(node) {
+ node = ts.skipPartiallyEmittedExpressions(node);
+ if (ts.isLiteralKind(node.kind)) {
+ return node.kind;
+ }
+ if (node.kind === 216 && node.operatorToken.kind === 39) {
+ if (node.cachedLiteralKind !== undefined) {
+ return node.cachedLiteralKind;
}
+ var leftKind = getLiteralKindOfBinaryPlusOperand(node.left);
+ var literalKind = ts.isLiteralKind(leftKind)
+ && leftKind === getLiteralKindOfBinaryPlusOperand(node.right)
+ ? leftKind
+ : 0;
+ node.cachedLiteralKind = literalKind;
+ return literalKind;
}
+ return 0;
+ }
+ function parenthesizeBinaryOperand(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
+ var skipped = ts.skipPartiallyEmittedExpressions(operand);
+ if (skipped.kind === 207) {
+ return operand;
+ }
+ return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand)
+ ? factory.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 ts.isCommaSequence(expression) ? factory.createParenthesizedExpression(expression) : expression;
+ }
+ function parenthesizeConditionOfConditionalExpression(condition) {
+ var conditionalPrecedence = ts.getOperatorPrecedence(217, 57);
+ var emittedCondition = ts.skipPartiallyEmittedExpressions(condition);
+ var conditionPrecedence = ts.getExpressionPrecedence(emittedCondition);
+ if (ts.compareValues(conditionPrecedence, conditionalPrecedence) !== 1) {
+ return factory.createParenthesizedExpression(condition);
+ }
+ return condition;
+ }
+ function parenthesizeBranchOfConditionalExpression(branch) {
+ var emittedExpression = ts.skipPartiallyEmittedExpressions(branch);
+ return ts.isCommaSequence(emittedExpression)
+ ? factory.createParenthesizedExpression(branch)
+ : branch;
+ }
+ function parenthesizeExpressionOfExportDefault(expression) {
+ var check = ts.skipPartiallyEmittedExpressions(expression);
+ var needsParens = ts.isCommaSequence(check);
+ if (!needsParens) {
+ switch (ts.getLeftmostExpression(check, false).kind) {
+ case 221:
+ case 208:
+ needsParens = true;
+ }
+ }
+ return needsParens ? factory.createParenthesizedExpression(expression) : expression;
+ }
+ function parenthesizeExpressionOfNew(expression) {
+ var leftmostExpr = ts.getLeftmostExpression(expression, true);
+ switch (leftmostExpr.kind) {
+ case 203:
+ return factory.createParenthesizedExpression(expression);
+ case 204:
+ return !leftmostExpr.arguments
+ ? factory.createParenthesizedExpression(expression)
+ : expression;
+ }
+ return parenthesizeLeftSideOfAccess(expression);
+ }
+ function parenthesizeLeftSideOfAccess(expression) {
+ var emittedExpression = ts.skipPartiallyEmittedExpressions(expression);
+ if (ts.isLeftHandSideExpression(emittedExpression)
+ && (emittedExpression.kind !== 204 || emittedExpression.arguments)) {
+ return expression;
+ }
+ return ts.setTextRange(factory.createParenthesizedExpression(expression), expression);
+ }
+ function parenthesizeOperandOfPostfixUnary(operand) {
+ return ts.isLeftHandSideExpression(operand) ? operand : ts.setTextRange(factory.createParenthesizedExpression(operand), operand);
+ }
+ function parenthesizeOperandOfPrefixUnary(operand) {
+ return ts.isUnaryExpression(operand) ? operand : ts.setTextRange(factory.createParenthesizedExpression(operand), operand);
+ }
+ function parenthesizeExpressionsOfCommaDelimitedList(elements) {
+ var result = ts.sameMap(elements, parenthesizeExpressionForDisallowedComma);
+ return ts.setTextRange(factory.createNodeArray(result, elements.hasTrailingComma), elements);
+ }
+ function parenthesizeExpressionForDisallowedComma(expression) {
+ var emittedExpression = ts.skipPartiallyEmittedExpressions(expression);
+ var expressionPrecedence = ts.getExpressionPrecedence(emittedExpression);
+ var commaPrecedence = ts.getOperatorPrecedence(216, 27);
+ return expressionPrecedence > commaPrecedence ? expression : ts.setTextRange(factory.createParenthesizedExpression(expression), expression);
+ }
+ function parenthesizeExpressionOfExpressionStatement(expression) {
+ var emittedExpression = ts.skipPartiallyEmittedExpressions(expression);
+ if (ts.isCallExpression(emittedExpression)) {
+ var callee = emittedExpression.expression;
+ var kind = ts.skipPartiallyEmittedExpressions(callee).kind;
+ if (kind === 208 || kind === 209) {
+ var updated = factory.updateCallExpression(emittedExpression, ts.setTextRange(factory.createParenthesizedExpression(callee), callee), emittedExpression.typeArguments, emittedExpression.arguments);
+ return factory.restoreOuterExpressions(expression, updated, 8);
+ }
+ }
+ var leftmostExpressionKind = ts.getLeftmostExpression(emittedExpression, false).kind;
+ if (leftmostExpressionKind === 200 || leftmostExpressionKind === 208) {
+ return ts.setTextRange(factory.createParenthesizedExpression(expression), expression);
+ }
+ return expression;
+ }
+ function parenthesizeConciseBodyOfArrowFunction(body) {
+ if (!ts.isBlock(body) && (ts.isCommaSequence(body) || ts.getLeftmostExpression(body, false).kind === 200)) {
+ return ts.setTextRange(factory.createParenthesizedExpression(body), body);
+ }
+ return body;
+ }
+ function parenthesizeMemberOfConditionalType(member) {
+ return member.kind === 184 ? factory.createParenthesizedType(member) : member;
+ }
+ function parenthesizeMemberOfElementType(member) {
+ switch (member.kind) {
+ case 182:
+ case 183:
+ case 174:
+ case 175:
+ return factory.createParenthesizedType(member);
+ }
+ return parenthesizeMemberOfConditionalType(member);
+ }
+ function parenthesizeElementTypeOfArrayType(member) {
+ switch (member.kind) {
+ case 176:
+ case 188:
+ case 185:
+ return factory.createParenthesizedType(member);
+ }
+ return parenthesizeMemberOfElementType(member);
+ }
+ function parenthesizeConstituentTypesOfUnionOrIntersectionType(members) {
+ return factory.createNodeArray(ts.sameMap(members, parenthesizeMemberOfElementType));
+ }
+ function parenthesizeOrdinalTypeArgument(node, i) {
+ return i === 0 && ts.isFunctionOrConstructorTypeNode(node) && node.typeParameters ? factory.createParenthesizedType(node) : node;
+ }
+ function parenthesizeTypeArguments(typeArguments) {
+ if (ts.some(typeArguments)) {
+ return factory.createNodeArray(ts.sameMap(typeArguments, parenthesizeOrdinalTypeArgument));
+ }
+ }
+ }
+ ts.createParenthesizerRules = createParenthesizerRules;
+ ts.nullParenthesizerRules = {
+ parenthesizeLeftSideOfBinary: function (_binaryOperator, leftSide) { return leftSide; },
+ parenthesizeRightSideOfBinary: function (_binaryOperator, _leftSide, rightSide) { return rightSide; },
+ parenthesizeExpressionOfComputedPropertyName: ts.identity,
+ parenthesizeConditionOfConditionalExpression: ts.identity,
+ parenthesizeBranchOfConditionalExpression: ts.identity,
+ parenthesizeExpressionOfExportDefault: ts.identity,
+ parenthesizeExpressionOfNew: function (expression) { return ts.cast(expression, ts.isLeftHandSideExpression); },
+ parenthesizeLeftSideOfAccess: function (expression) { return ts.cast(expression, ts.isLeftHandSideExpression); },
+ parenthesizeOperandOfPostfixUnary: function (operand) { return ts.cast(operand, ts.isLeftHandSideExpression); },
+ parenthesizeOperandOfPrefixUnary: function (operand) { return ts.cast(operand, ts.isUnaryExpression); },
+ parenthesizeExpressionsOfCommaDelimitedList: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
+ parenthesizeExpressionForDisallowedComma: ts.identity,
+ parenthesizeExpressionOfExpressionStatement: ts.identity,
+ parenthesizeConciseBodyOfArrowFunction: ts.identity,
+ parenthesizeMemberOfConditionalType: ts.identity,
+ parenthesizeMemberOfElementType: ts.identity,
+ parenthesizeElementTypeOfArrayType: ts.identity,
+ parenthesizeConstituentTypesOfUnionOrIntersectionType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
+ parenthesizeTypeArguments: function (nodes) { return nodes && ts.cast(nodes, ts.isNodeArray); },
+ };
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function createNodeConverters(factory) {
+ return {
+ convertToFunctionBlock: convertToFunctionBlock,
+ convertToFunctionExpression: convertToFunctionExpression,
+ convertToArrayAssignmentElement: convertToArrayAssignmentElement,
+ convertToObjectAssignmentElement: convertToObjectAssignmentElement,
+ convertToAssignmentPattern: convertToAssignmentPattern,
+ convertToObjectAssignmentPattern: convertToObjectAssignmentPattern,
+ convertToArrayAssignmentPattern: convertToArrayAssignmentPattern,
+ convertToAssignmentElementTarget: convertToAssignmentElementTarget,
+ };
+ function convertToFunctionBlock(node, multiLine) {
+ if (ts.isBlock(node))
+ return node;
+ var returnStatement = factory.createReturnStatement(node);
+ ts.setTextRange(returnStatement, node);
+ var body = factory.createBlock([returnStatement], multiLine);
+ ts.setTextRange(body, node);
+ return body;
+ }
+ function convertToFunctionExpression(node) {
+ if (!node.body)
+ return ts.Debug.fail("Cannot convert a FunctionDeclaration without a body");
+ var updated = factory.createFunctionExpression(node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body);
+ ts.setOriginalNode(updated, node);
+ ts.setTextRange(updated, node);
+ if (ts.getStartsOnNewLine(node)) {
+ ts.setStartsOnNewLine(updated, true);
+ }
+ return updated;
+ }
+ function convertToArrayAssignmentElement(element) {
+ if (ts.isBindingElement(element)) {
+ if (element.dotDotDotToken) {
+ ts.Debug.assertNode(element.name, ts.isIdentifier);
+ return ts.setOriginalNode(ts.setTextRange(factory.createSpreadElement(element.name), element), element);
+ }
+ var expression = convertToAssignmentElementTarget(element.name);
+ return element.initializer
+ ? ts.setOriginalNode(ts.setTextRange(factory.createAssignment(expression, element.initializer), element), element)
+ : expression;
+ }
+ return ts.cast(element, ts.isExpression);
+ }
+ function convertToObjectAssignmentElement(element) {
+ if (ts.isBindingElement(element)) {
+ if (element.dotDotDotToken) {
+ ts.Debug.assertNode(element.name, ts.isIdentifier);
+ return ts.setOriginalNode(ts.setTextRange(factory.createSpreadAssignment(element.name), element), element);
+ }
+ if (element.propertyName) {
+ var expression = convertToAssignmentElementTarget(element.name);
+ return ts.setOriginalNode(ts.setTextRange(factory.createPropertyAssignment(element.propertyName, element.initializer ? factory.createAssignment(expression, element.initializer) : expression), element), element);
+ }
+ ts.Debug.assertNode(element.name, ts.isIdentifier);
+ return ts.setOriginalNode(ts.setTextRange(factory.createShorthandPropertyAssignment(element.name, element.initializer), element), element);
+ }
+ return ts.cast(element, ts.isObjectLiteralElementLike);
+ }
+ function convertToAssignmentPattern(node) {
+ switch (node.kind) {
+ case 197:
+ case 199:
+ return convertToArrayAssignmentPattern(node);
+ case 196:
+ case 200:
+ return convertToObjectAssignmentPattern(node);
+ }
+ }
+ function convertToObjectAssignmentPattern(node) {
+ if (ts.isObjectBindingPattern(node)) {
+ return ts.setOriginalNode(ts.setTextRange(factory.createObjectLiteralExpression(ts.map(node.elements, convertToObjectAssignmentElement)), node), node);
+ }
+ return ts.cast(node, ts.isObjectLiteralExpression);
+ }
+ function convertToArrayAssignmentPattern(node) {
+ if (ts.isArrayBindingPattern(node)) {
+ return ts.setOriginalNode(ts.setTextRange(factory.createArrayLiteralExpression(ts.map(node.elements, convertToArrayAssignmentElement)), node), node);
+ }
+ return ts.cast(node, ts.isArrayLiteralExpression);
+ }
+ function convertToAssignmentElementTarget(node) {
+ if (ts.isBindingPattern(node)) {
+ return convertToAssignmentPattern(node);
+ }
+ return ts.cast(node, ts.isExpression);
}
}
- function isJSDocLikeText(text, start) {
- return text.charCodeAt(start + 1) === 42 &&
- text.charCodeAt(start + 2) === 42 &&
- text.charCodeAt(start + 3) !== 47;
- }
- ts.isJSDocLikeText = isJSDocLikeText;
- function forEachChild(node, cbNode, cbNodes) {
- if (!node || node.kind <= 152) {
- return;
+ ts.createNodeConverters = createNodeConverters;
+ ts.nullNodeConverters = {
+ convertToFunctionBlock: ts.notImplemented,
+ convertToFunctionExpression: ts.notImplemented,
+ convertToArrayAssignmentElement: ts.notImplemented,
+ convertToObjectAssignmentElement: ts.notImplemented,
+ convertToAssignmentPattern: ts.notImplemented,
+ convertToObjectAssignmentPattern: ts.notImplemented,
+ convertToArrayAssignmentPattern: ts.notImplemented,
+ convertToAssignmentElementTarget: ts.notImplemented,
+ };
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ var nextAutoGenerateId = 0;
+ function createNodeFactory(flags, baseFactory) {
+ var update = flags & 8 ? updateWithoutOriginal : updateWithOriginal;
+ var parenthesizerRules = ts.memoize(function () { return flags & 1 ? ts.nullParenthesizerRules : ts.createParenthesizerRules(factory); });
+ var converters = ts.memoize(function () { return flags & 2 ? ts.nullNodeConverters : ts.createNodeConverters(factory); });
+ var getBinaryCreateFunction = ts.memoizeOne(function (operator) { return function (left, right) { return createBinaryExpression(left, operator, right); }; });
+ var getPrefixUnaryCreateFunction = ts.memoizeOne(function (operator) { return function (operand) { return createPrefixUnaryExpression(operator, operand); }; });
+ var getPostfixUnaryCreateFunction = ts.memoizeOne(function (operator) { return function (operand) { return createPostfixUnaryExpression(operand, operator); }; });
+ var getJSDocPrimaryTypeCreateFunction = ts.memoizeOne(function (kind) { return function () { return createJSDocPrimaryTypeWorker(kind); }; });
+ var getJSDocUnaryTypeCreateFunction = ts.memoizeOne(function (kind) { return function (type) { return createJSDocUnaryTypeWorker(kind, type); }; });
+ var getJSDocUnaryTypeUpdateFunction = ts.memoizeOne(function (kind) { return function (node, type) { return updateJSDocUnaryTypeWorker(kind, node, type); }; });
+ var getJSDocSimpleTagCreateFunction = ts.memoizeOne(function (kind) { return function (tagName, comment) { return createJSDocSimpleTagWorker(kind, tagName, comment); }; });
+ var getJSDocSimpleTagUpdateFunction = ts.memoizeOne(function (kind) { return function (node, tagName, comment) { return updateJSDocSimpleTagWorker(kind, node, tagName, comment); }; });
+ var getJSDocTypeLikeTagCreateFunction = ts.memoizeOne(function (kind) { return function (tagName, typeExpression, comment) { return createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment); }; });
+ var getJSDocTypeLikeTagUpdateFunction = ts.memoizeOne(function (kind) { return function (node, tagName, typeExpression, comment) { return updateJSDocTypeLikeTagWorker(kind, node, tagName, typeExpression, comment); }; });
+ var factory = {
+ get parenthesizer() { return parenthesizerRules(); },
+ get converters() { return converters(); },
+ createNodeArray: createNodeArray,
+ createNumericLiteral: createNumericLiteral,
+ createBigIntLiteral: createBigIntLiteral,
+ createStringLiteral: createStringLiteral,
+ createStringLiteralFromNode: createStringLiteralFromNode,
+ createRegularExpressionLiteral: createRegularExpressionLiteral,
+ createLiteralLikeNode: createLiteralLikeNode,
+ createIdentifier: createIdentifier,
+ updateIdentifier: updateIdentifier,
+ createTempVariable: createTempVariable,
+ createLoopVariable: createLoopVariable,
+ createUniqueName: createUniqueName,
+ getGeneratedNameForNode: getGeneratedNameForNode,
+ createPrivateIdentifier: createPrivateIdentifier,
+ createToken: createToken,
+ createSuper: createSuper,
+ createThis: createThis,
+ createNull: createNull,
+ createTrue: createTrue,
+ createFalse: createFalse,
+ createModifier: createModifier,
+ createModifiersFromModifierFlags: createModifiersFromModifierFlags,
+ createQualifiedName: createQualifiedName,
+ updateQualifiedName: updateQualifiedName,
+ createComputedPropertyName: createComputedPropertyName,
+ updateComputedPropertyName: updateComputedPropertyName,
+ createTypeParameterDeclaration: createTypeParameterDeclaration,
+ updateTypeParameterDeclaration: updateTypeParameterDeclaration,
+ createParameterDeclaration: createParameterDeclaration,
+ updateParameterDeclaration: updateParameterDeclaration,
+ createDecorator: createDecorator,
+ updateDecorator: updateDecorator,
+ createPropertySignature: createPropertySignature,
+ updatePropertySignature: updatePropertySignature,
+ createPropertyDeclaration: createPropertyDeclaration,
+ updatePropertyDeclaration: updatePropertyDeclaration,
+ createMethodSignature: createMethodSignature,
+ updateMethodSignature: updateMethodSignature,
+ createMethodDeclaration: createMethodDeclaration,
+ updateMethodDeclaration: updateMethodDeclaration,
+ createConstructorDeclaration: createConstructorDeclaration,
+ updateConstructorDeclaration: updateConstructorDeclaration,
+ createGetAccessorDeclaration: createGetAccessorDeclaration,
+ updateGetAccessorDeclaration: updateGetAccessorDeclaration,
+ createSetAccessorDeclaration: createSetAccessorDeclaration,
+ updateSetAccessorDeclaration: updateSetAccessorDeclaration,
+ createCallSignature: createCallSignature,
+ updateCallSignature: updateCallSignature,
+ createConstructSignature: createConstructSignature,
+ updateConstructSignature: updateConstructSignature,
+ createIndexSignature: createIndexSignature,
+ updateIndexSignature: updateIndexSignature,
+ createTemplateLiteralTypeSpan: createTemplateLiteralTypeSpan,
+ updateTemplateLiteralTypeSpan: updateTemplateLiteralTypeSpan,
+ createKeywordTypeNode: createKeywordTypeNode,
+ createTypePredicateNode: createTypePredicateNode,
+ updateTypePredicateNode: updateTypePredicateNode,
+ createTypeReferenceNode: createTypeReferenceNode,
+ updateTypeReferenceNode: updateTypeReferenceNode,
+ createFunctionTypeNode: createFunctionTypeNode,
+ updateFunctionTypeNode: updateFunctionTypeNode,
+ createConstructorTypeNode: createConstructorTypeNode,
+ updateConstructorTypeNode: updateConstructorTypeNode,
+ createTypeQueryNode: createTypeQueryNode,
+ updateTypeQueryNode: updateTypeQueryNode,
+ createTypeLiteralNode: createTypeLiteralNode,
+ updateTypeLiteralNode: updateTypeLiteralNode,
+ createArrayTypeNode: createArrayTypeNode,
+ updateArrayTypeNode: updateArrayTypeNode,
+ createTupleTypeNode: createTupleTypeNode,
+ updateTupleTypeNode: updateTupleTypeNode,
+ createNamedTupleMember: createNamedTupleMember,
+ updateNamedTupleMember: updateNamedTupleMember,
+ createOptionalTypeNode: createOptionalTypeNode,
+ updateOptionalTypeNode: updateOptionalTypeNode,
+ createRestTypeNode: createRestTypeNode,
+ updateRestTypeNode: updateRestTypeNode,
+ createUnionTypeNode: createUnionTypeNode,
+ updateUnionTypeNode: updateUnionTypeNode,
+ createIntersectionTypeNode: createIntersectionTypeNode,
+ updateIntersectionTypeNode: updateIntersectionTypeNode,
+ createConditionalTypeNode: createConditionalTypeNode,
+ updateConditionalTypeNode: updateConditionalTypeNode,
+ createInferTypeNode: createInferTypeNode,
+ updateInferTypeNode: updateInferTypeNode,
+ createImportTypeNode: createImportTypeNode,
+ updateImportTypeNode: updateImportTypeNode,
+ createParenthesizedType: createParenthesizedType,
+ updateParenthesizedType: updateParenthesizedType,
+ createThisTypeNode: createThisTypeNode,
+ createTypeOperatorNode: createTypeOperatorNode,
+ updateTypeOperatorNode: updateTypeOperatorNode,
+ createIndexedAccessTypeNode: createIndexedAccessTypeNode,
+ updateIndexedAccessTypeNode: updateIndexedAccessTypeNode,
+ createMappedTypeNode: createMappedTypeNode,
+ updateMappedTypeNode: updateMappedTypeNode,
+ createLiteralTypeNode: createLiteralTypeNode,
+ updateLiteralTypeNode: updateLiteralTypeNode,
+ createTemplateLiteralType: createTemplateLiteralType,
+ updateTemplateLiteralType: updateTemplateLiteralType,
+ createObjectBindingPattern: createObjectBindingPattern,
+ updateObjectBindingPattern: updateObjectBindingPattern,
+ createArrayBindingPattern: createArrayBindingPattern,
+ updateArrayBindingPattern: updateArrayBindingPattern,
+ createBindingElement: createBindingElement,
+ updateBindingElement: updateBindingElement,
+ createArrayLiteralExpression: createArrayLiteralExpression,
+ updateArrayLiteralExpression: updateArrayLiteralExpression,
+ createObjectLiteralExpression: createObjectLiteralExpression,
+ updateObjectLiteralExpression: updateObjectLiteralExpression,
+ createPropertyAccessExpression: flags & 4 ?
+ function (expression, name) { return ts.setEmitFlags(createPropertyAccessExpression(expression, name), 131072); } :
+ createPropertyAccessExpression,
+ updatePropertyAccessExpression: updatePropertyAccessExpression,
+ createPropertyAccessChain: flags & 4 ?
+ function (expression, questionDotToken, name) { return ts.setEmitFlags(createPropertyAccessChain(expression, questionDotToken, name), 131072); } :
+ createPropertyAccessChain,
+ updatePropertyAccessChain: updatePropertyAccessChain,
+ createElementAccessExpression: createElementAccessExpression,
+ updateElementAccessExpression: updateElementAccessExpression,
+ createElementAccessChain: createElementAccessChain,
+ updateElementAccessChain: updateElementAccessChain,
+ createCallExpression: createCallExpression,
+ updateCallExpression: updateCallExpression,
+ createCallChain: createCallChain,
+ updateCallChain: updateCallChain,
+ createNewExpression: createNewExpression,
+ updateNewExpression: updateNewExpression,
+ createTaggedTemplateExpression: createTaggedTemplateExpression,
+ updateTaggedTemplateExpression: updateTaggedTemplateExpression,
+ createTypeAssertion: createTypeAssertion,
+ updateTypeAssertion: updateTypeAssertion,
+ createParenthesizedExpression: createParenthesizedExpression,
+ updateParenthesizedExpression: updateParenthesizedExpression,
+ createFunctionExpression: createFunctionExpression,
+ updateFunctionExpression: updateFunctionExpression,
+ createArrowFunction: createArrowFunction,
+ updateArrowFunction: updateArrowFunction,
+ createDeleteExpression: createDeleteExpression,
+ updateDeleteExpression: updateDeleteExpression,
+ createTypeOfExpression: createTypeOfExpression,
+ updateTypeOfExpression: updateTypeOfExpression,
+ createVoidExpression: createVoidExpression,
+ updateVoidExpression: updateVoidExpression,
+ createAwaitExpression: createAwaitExpression,
+ updateAwaitExpression: updateAwaitExpression,
+ createPrefixUnaryExpression: createPrefixUnaryExpression,
+ updatePrefixUnaryExpression: updatePrefixUnaryExpression,
+ createPostfixUnaryExpression: createPostfixUnaryExpression,
+ updatePostfixUnaryExpression: updatePostfixUnaryExpression,
+ createBinaryExpression: createBinaryExpression,
+ updateBinaryExpression: updateBinaryExpression,
+ createConditionalExpression: createConditionalExpression,
+ updateConditionalExpression: updateConditionalExpression,
+ createTemplateExpression: createTemplateExpression,
+ updateTemplateExpression: updateTemplateExpression,
+ createTemplateHead: createTemplateHead,
+ createTemplateMiddle: createTemplateMiddle,
+ createTemplateTail: createTemplateTail,
+ createNoSubstitutionTemplateLiteral: createNoSubstitutionTemplateLiteral,
+ createTemplateLiteralLikeNode: createTemplateLiteralLikeNode,
+ createYieldExpression: createYieldExpression,
+ updateYieldExpression: updateYieldExpression,
+ createSpreadElement: createSpreadElement,
+ updateSpreadElement: updateSpreadElement,
+ createClassExpression: createClassExpression,
+ updateClassExpression: updateClassExpression,
+ createOmittedExpression: createOmittedExpression,
+ createExpressionWithTypeArguments: createExpressionWithTypeArguments,
+ updateExpressionWithTypeArguments: updateExpressionWithTypeArguments,
+ createAsExpression: createAsExpression,
+ updateAsExpression: updateAsExpression,
+ createNonNullExpression: createNonNullExpression,
+ updateNonNullExpression: updateNonNullExpression,
+ createNonNullChain: createNonNullChain,
+ updateNonNullChain: updateNonNullChain,
+ createMetaProperty: createMetaProperty,
+ updateMetaProperty: updateMetaProperty,
+ createTemplateSpan: createTemplateSpan,
+ updateTemplateSpan: updateTemplateSpan,
+ createSemicolonClassElement: createSemicolonClassElement,
+ createBlock: createBlock,
+ updateBlock: updateBlock,
+ createVariableStatement: createVariableStatement,
+ updateVariableStatement: updateVariableStatement,
+ createEmptyStatement: createEmptyStatement,
+ createExpressionStatement: createExpressionStatement,
+ updateExpressionStatement: updateExpressionStatement,
+ createIfStatement: createIfStatement,
+ updateIfStatement: updateIfStatement,
+ createDoStatement: createDoStatement,
+ updateDoStatement: updateDoStatement,
+ createWhileStatement: createWhileStatement,
+ updateWhileStatement: updateWhileStatement,
+ createForStatement: createForStatement,
+ updateForStatement: updateForStatement,
+ createForInStatement: createForInStatement,
+ updateForInStatement: updateForInStatement,
+ createForOfStatement: createForOfStatement,
+ updateForOfStatement: updateForOfStatement,
+ createContinueStatement: createContinueStatement,
+ updateContinueStatement: updateContinueStatement,
+ createBreakStatement: createBreakStatement,
+ updateBreakStatement: updateBreakStatement,
+ createReturnStatement: createReturnStatement,
+ updateReturnStatement: updateReturnStatement,
+ createWithStatement: createWithStatement,
+ updateWithStatement: updateWithStatement,
+ createSwitchStatement: createSwitchStatement,
+ updateSwitchStatement: updateSwitchStatement,
+ createLabeledStatement: createLabeledStatement,
+ updateLabeledStatement: updateLabeledStatement,
+ createThrowStatement: createThrowStatement,
+ updateThrowStatement: updateThrowStatement,
+ createTryStatement: createTryStatement,
+ updateTryStatement: updateTryStatement,
+ createDebuggerStatement: createDebuggerStatement,
+ createVariableDeclaration: createVariableDeclaration,
+ updateVariableDeclaration: updateVariableDeclaration,
+ createVariableDeclarationList: createVariableDeclarationList,
+ updateVariableDeclarationList: updateVariableDeclarationList,
+ createFunctionDeclaration: createFunctionDeclaration,
+ updateFunctionDeclaration: updateFunctionDeclaration,
+ createClassDeclaration: createClassDeclaration,
+ updateClassDeclaration: updateClassDeclaration,
+ createInterfaceDeclaration: createInterfaceDeclaration,
+ updateInterfaceDeclaration: updateInterfaceDeclaration,
+ createTypeAliasDeclaration: createTypeAliasDeclaration,
+ updateTypeAliasDeclaration: updateTypeAliasDeclaration,
+ createEnumDeclaration: createEnumDeclaration,
+ updateEnumDeclaration: updateEnumDeclaration,
+ createModuleDeclaration: createModuleDeclaration,
+ updateModuleDeclaration: updateModuleDeclaration,
+ createModuleBlock: createModuleBlock,
+ updateModuleBlock: updateModuleBlock,
+ createCaseBlock: createCaseBlock,
+ updateCaseBlock: updateCaseBlock,
+ createNamespaceExportDeclaration: createNamespaceExportDeclaration,
+ updateNamespaceExportDeclaration: updateNamespaceExportDeclaration,
+ createImportEqualsDeclaration: createImportEqualsDeclaration,
+ updateImportEqualsDeclaration: updateImportEqualsDeclaration,
+ createImportDeclaration: createImportDeclaration,
+ updateImportDeclaration: updateImportDeclaration,
+ createImportClause: createImportClause,
+ updateImportClause: updateImportClause,
+ createNamespaceImport: createNamespaceImport,
+ updateNamespaceImport: updateNamespaceImport,
+ createNamespaceExport: createNamespaceExport,
+ updateNamespaceExport: updateNamespaceExport,
+ createNamedImports: createNamedImports,
+ updateNamedImports: updateNamedImports,
+ createImportSpecifier: createImportSpecifier,
+ updateImportSpecifier: updateImportSpecifier,
+ createExportAssignment: createExportAssignment,
+ updateExportAssignment: updateExportAssignment,
+ createExportDeclaration: createExportDeclaration,
+ updateExportDeclaration: updateExportDeclaration,
+ createNamedExports: createNamedExports,
+ updateNamedExports: updateNamedExports,
+ createExportSpecifier: createExportSpecifier,
+ updateExportSpecifier: updateExportSpecifier,
+ createMissingDeclaration: createMissingDeclaration,
+ createExternalModuleReference: createExternalModuleReference,
+ updateExternalModuleReference: updateExternalModuleReference,
+ get createJSDocAllType() { return getJSDocPrimaryTypeCreateFunction(303); },
+ get createJSDocUnknownType() { return getJSDocPrimaryTypeCreateFunction(304); },
+ get createJSDocNonNullableType() { return getJSDocUnaryTypeCreateFunction(306); },
+ get updateJSDocNonNullableType() { return getJSDocUnaryTypeUpdateFunction(306); },
+ get createJSDocNullableType() { return getJSDocUnaryTypeCreateFunction(305); },
+ get updateJSDocNullableType() { return getJSDocUnaryTypeUpdateFunction(305); },
+ get createJSDocOptionalType() { return getJSDocUnaryTypeCreateFunction(307); },
+ get updateJSDocOptionalType() { return getJSDocUnaryTypeUpdateFunction(307); },
+ get createJSDocVariadicType() { return getJSDocUnaryTypeCreateFunction(309); },
+ get updateJSDocVariadicType() { return getJSDocUnaryTypeUpdateFunction(309); },
+ get createJSDocNamepathType() { return getJSDocUnaryTypeCreateFunction(310); },
+ get updateJSDocNamepathType() { return getJSDocUnaryTypeUpdateFunction(310); },
+ createJSDocFunctionType: createJSDocFunctionType,
+ updateJSDocFunctionType: updateJSDocFunctionType,
+ createJSDocTypeLiteral: createJSDocTypeLiteral,
+ updateJSDocTypeLiteral: updateJSDocTypeLiteral,
+ createJSDocTypeExpression: createJSDocTypeExpression,
+ updateJSDocTypeExpression: updateJSDocTypeExpression,
+ createJSDocSignature: createJSDocSignature,
+ updateJSDocSignature: updateJSDocSignature,
+ createJSDocTemplateTag: createJSDocTemplateTag,
+ updateJSDocTemplateTag: updateJSDocTemplateTag,
+ createJSDocTypedefTag: createJSDocTypedefTag,
+ updateJSDocTypedefTag: updateJSDocTypedefTag,
+ createJSDocParameterTag: createJSDocParameterTag,
+ updateJSDocParameterTag: updateJSDocParameterTag,
+ createJSDocPropertyTag: createJSDocPropertyTag,
+ updateJSDocPropertyTag: updateJSDocPropertyTag,
+ createJSDocCallbackTag: createJSDocCallbackTag,
+ updateJSDocCallbackTag: updateJSDocCallbackTag,
+ createJSDocAugmentsTag: createJSDocAugmentsTag,
+ updateJSDocAugmentsTag: updateJSDocAugmentsTag,
+ createJSDocImplementsTag: createJSDocImplementsTag,
+ updateJSDocImplementsTag: updateJSDocImplementsTag,
+ createJSDocSeeTag: createJSDocSeeTag,
+ updateJSDocSeeTag: updateJSDocSeeTag,
+ createJSDocNameReference: createJSDocNameReference,
+ updateJSDocNameReference: updateJSDocNameReference,
+ get createJSDocTypeTag() { return getJSDocTypeLikeTagCreateFunction(329); },
+ get updateJSDocTypeTag() { return getJSDocTypeLikeTagUpdateFunction(329); },
+ get createJSDocReturnTag() { return getJSDocTypeLikeTagCreateFunction(327); },
+ get updateJSDocReturnTag() { return getJSDocTypeLikeTagUpdateFunction(327); },
+ get createJSDocThisTag() { return getJSDocTypeLikeTagCreateFunction(328); },
+ get updateJSDocThisTag() { return getJSDocTypeLikeTagUpdateFunction(328); },
+ get createJSDocEnumTag() { return getJSDocTypeLikeTagCreateFunction(325); },
+ get updateJSDocEnumTag() { return getJSDocTypeLikeTagUpdateFunction(325); },
+ get createJSDocAuthorTag() { return getJSDocSimpleTagCreateFunction(317); },
+ get updateJSDocAuthorTag() { return getJSDocSimpleTagUpdateFunction(317); },
+ get createJSDocClassTag() { return getJSDocSimpleTagCreateFunction(319); },
+ get updateJSDocClassTag() { return getJSDocSimpleTagUpdateFunction(319); },
+ get createJSDocPublicTag() { return getJSDocSimpleTagCreateFunction(320); },
+ get updateJSDocPublicTag() { return getJSDocSimpleTagUpdateFunction(320); },
+ get createJSDocPrivateTag() { return getJSDocSimpleTagCreateFunction(321); },
+ get updateJSDocPrivateTag() { return getJSDocSimpleTagUpdateFunction(321); },
+ get createJSDocProtectedTag() { return getJSDocSimpleTagCreateFunction(322); },
+ get updateJSDocProtectedTag() { return getJSDocSimpleTagUpdateFunction(322); },
+ get createJSDocReadonlyTag() { return getJSDocSimpleTagCreateFunction(323); },
+ get updateJSDocReadonlyTag() { return getJSDocSimpleTagUpdateFunction(323); },
+ get createJSDocDeprecatedTag() { return getJSDocSimpleTagCreateFunction(318); },
+ get updateJSDocDeprecatedTag() { return getJSDocSimpleTagUpdateFunction(318); },
+ createJSDocUnknownTag: createJSDocUnknownTag,
+ updateJSDocUnknownTag: updateJSDocUnknownTag,
+ createJSDocComment: createJSDocComment,
+ updateJSDocComment: updateJSDocComment,
+ createJsxElement: createJsxElement,
+ updateJsxElement: updateJsxElement,
+ createJsxSelfClosingElement: createJsxSelfClosingElement,
+ updateJsxSelfClosingElement: updateJsxSelfClosingElement,
+ createJsxOpeningElement: createJsxOpeningElement,
+ updateJsxOpeningElement: updateJsxOpeningElement,
+ createJsxClosingElement: createJsxClosingElement,
+ updateJsxClosingElement: updateJsxClosingElement,
+ createJsxFragment: createJsxFragment,
+ createJsxText: createJsxText,
+ updateJsxText: updateJsxText,
+ createJsxOpeningFragment: createJsxOpeningFragment,
+ createJsxJsxClosingFragment: createJsxJsxClosingFragment,
+ updateJsxFragment: updateJsxFragment,
+ createJsxAttribute: createJsxAttribute,
+ updateJsxAttribute: updateJsxAttribute,
+ createJsxAttributes: createJsxAttributes,
+ updateJsxAttributes: updateJsxAttributes,
+ createJsxSpreadAttribute: createJsxSpreadAttribute,
+ updateJsxSpreadAttribute: updateJsxSpreadAttribute,
+ createJsxExpression: createJsxExpression,
+ updateJsxExpression: updateJsxExpression,
+ createCaseClause: createCaseClause,
+ updateCaseClause: updateCaseClause,
+ createDefaultClause: createDefaultClause,
+ updateDefaultClause: updateDefaultClause,
+ createHeritageClause: createHeritageClause,
+ updateHeritageClause: updateHeritageClause,
+ createCatchClause: createCatchClause,
+ updateCatchClause: updateCatchClause,
+ createPropertyAssignment: createPropertyAssignment,
+ updatePropertyAssignment: updatePropertyAssignment,
+ createShorthandPropertyAssignment: createShorthandPropertyAssignment,
+ updateShorthandPropertyAssignment: updateShorthandPropertyAssignment,
+ createSpreadAssignment: createSpreadAssignment,
+ updateSpreadAssignment: updateSpreadAssignment,
+ createEnumMember: createEnumMember,
+ updateEnumMember: updateEnumMember,
+ createSourceFile: createSourceFile,
+ updateSourceFile: updateSourceFile,
+ createBundle: createBundle,
+ updateBundle: updateBundle,
+ createUnparsedSource: createUnparsedSource,
+ createUnparsedPrologue: createUnparsedPrologue,
+ createUnparsedPrepend: createUnparsedPrepend,
+ createUnparsedTextLike: createUnparsedTextLike,
+ createUnparsedSyntheticReference: createUnparsedSyntheticReference,
+ createInputFiles: createInputFiles,
+ createSyntheticExpression: createSyntheticExpression,
+ createSyntaxList: createSyntaxList,
+ createNotEmittedStatement: createNotEmittedStatement,
+ createPartiallyEmittedExpression: createPartiallyEmittedExpression,
+ updatePartiallyEmittedExpression: updatePartiallyEmittedExpression,
+ createCommaListExpression: createCommaListExpression,
+ updateCommaListExpression: updateCommaListExpression,
+ createEndOfDeclarationMarker: createEndOfDeclarationMarker,
+ createMergeDeclarationMarker: createMergeDeclarationMarker,
+ createSyntheticReferenceExpression: createSyntheticReferenceExpression,
+ updateSyntheticReferenceExpression: updateSyntheticReferenceExpression,
+ cloneNode: cloneNode,
+ get createComma() { return getBinaryCreateFunction(27); },
+ get createAssignment() { return getBinaryCreateFunction(62); },
+ get createLogicalOr() { return getBinaryCreateFunction(56); },
+ get createLogicalAnd() { return getBinaryCreateFunction(55); },
+ get createBitwiseOr() { return getBinaryCreateFunction(51); },
+ get createBitwiseXor() { return getBinaryCreateFunction(52); },
+ get createBitwiseAnd() { return getBinaryCreateFunction(50); },
+ get createStrictEquality() { return getBinaryCreateFunction(36); },
+ get createStrictInequality() { return getBinaryCreateFunction(37); },
+ get createEquality() { return getBinaryCreateFunction(34); },
+ get createInequality() { return getBinaryCreateFunction(35); },
+ get createLessThan() { return getBinaryCreateFunction(29); },
+ get createLessThanEquals() { return getBinaryCreateFunction(32); },
+ get createGreaterThan() { return getBinaryCreateFunction(31); },
+ get createGreaterThanEquals() { return getBinaryCreateFunction(33); },
+ get createLeftShift() { return getBinaryCreateFunction(47); },
+ get createRightShift() { return getBinaryCreateFunction(48); },
+ get createUnsignedRightShift() { return getBinaryCreateFunction(49); },
+ get createAdd() { return getBinaryCreateFunction(39); },
+ get createSubtract() { return getBinaryCreateFunction(40); },
+ get createMultiply() { return getBinaryCreateFunction(41); },
+ get createDivide() { return getBinaryCreateFunction(43); },
+ get createModulo() { return getBinaryCreateFunction(44); },
+ get createExponent() { return getBinaryCreateFunction(42); },
+ get createPrefixPlus() { return getPrefixUnaryCreateFunction(39); },
+ get createPrefixMinus() { return getPrefixUnaryCreateFunction(40); },
+ get createPrefixIncrement() { return getPrefixUnaryCreateFunction(45); },
+ get createPrefixDecrement() { return getPrefixUnaryCreateFunction(46); },
+ get createBitwiseNot() { return getPrefixUnaryCreateFunction(54); },
+ get createLogicalNot() { return getPrefixUnaryCreateFunction(53); },
+ get createPostfixIncrement() { return getPostfixUnaryCreateFunction(45); },
+ get createPostfixDecrement() { return getPostfixUnaryCreateFunction(46); },
+ createImmediatelyInvokedFunctionExpression: createImmediatelyInvokedFunctionExpression,
+ createImmediatelyInvokedArrowFunction: createImmediatelyInvokedArrowFunction,
+ createVoidZero: createVoidZero,
+ createExportDefault: createExportDefault,
+ createExternalModuleExport: createExternalModuleExport,
+ createTypeCheck: createTypeCheck,
+ createMethodCall: createMethodCall,
+ createGlobalMethodCall: createGlobalMethodCall,
+ createFunctionBindCall: createFunctionBindCall,
+ createFunctionCallCall: createFunctionCallCall,
+ createFunctionApplyCall: createFunctionApplyCall,
+ createArraySliceCall: createArraySliceCall,
+ createArrayConcatCall: createArrayConcatCall,
+ createObjectDefinePropertyCall: createObjectDefinePropertyCall,
+ createPropertyDescriptor: createPropertyDescriptor,
+ createCallBinding: createCallBinding,
+ inlineExpressions: inlineExpressions,
+ getInternalName: getInternalName,
+ getLocalName: getLocalName,
+ getExportName: getExportName,
+ getDeclarationName: getDeclarationName,
+ getNamespaceMemberName: getNamespaceMemberName,
+ getExternalModuleOrNamespaceExportName: getExternalModuleOrNamespaceExportName,
+ restoreOuterExpressions: restoreOuterExpressions,
+ restoreEnclosingLabel: restoreEnclosingLabel,
+ createUseStrictPrologue: createUseStrictPrologue,
+ copyPrologue: copyPrologue,
+ copyStandardPrologue: copyStandardPrologue,
+ copyCustomPrologue: copyCustomPrologue,
+ ensureUseStrict: ensureUseStrict,
+ liftToBlock: liftToBlock,
+ mergeLexicalEnvironment: mergeLexicalEnvironment,
+ updateModifiers: updateModifiers,
+ };
+ return factory;
+ function createNodeArray(elements, hasTrailingComma) {
+ if (elements === undefined || elements === ts.emptyArray) {
+ elements = [];
+ }
+ else if (ts.isNodeArray(elements)) {
+ if (elements.transformFlags === undefined) {
+ aggregateChildrenFlags(elements);
+ }
+ ts.Debug.attachNodeArrayDebugInfo(elements);
+ return elements;
+ }
+ var length = elements.length;
+ var array = (length >= 1 && length <= 4 ? elements.slice() : elements);
+ ts.setTextRangePosEnd(array, -1, -1);
+ array.hasTrailingComma = !!hasTrailingComma;
+ aggregateChildrenFlags(array);
+ ts.Debug.attachNodeArrayDebugInfo(array);
+ return array;
}
- switch (node.kind) {
- case 153:
- return visitNode(cbNode, node.left) ||
- visitNode(cbNode, node.right);
- case 155:
- return visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.constraint) ||
- visitNode(cbNode, node.default) ||
- visitNode(cbNode, node.expression);
- case 282:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.questionToken) ||
- visitNode(cbNode, node.exclamationToken) ||
- visitNode(cbNode, node.equalsToken) ||
- visitNode(cbNode, node.objectAssignmentInitializer);
- case 283:
- return visitNode(cbNode, node.expression);
- case 156:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.dotDotDotToken) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.questionToken) ||
- visitNode(cbNode, node.type) ||
- visitNode(cbNode, node.initializer);
- case 159:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.questionToken) ||
- visitNode(cbNode, node.exclamationToken) ||
- visitNode(cbNode, node.type) ||
- visitNode(cbNode, node.initializer);
- case 158:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.questionToken) ||
- visitNode(cbNode, node.type) ||
- visitNode(cbNode, node.initializer);
- case 281:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.questionToken) ||
- visitNode(cbNode, node.initializer);
- case 242:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.exclamationToken) ||
- visitNode(cbNode, node.type) ||
- visitNode(cbNode, node.initializer);
- case 191:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.dotDotDotToken) ||
- visitNode(cbNode, node.propertyName) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.initializer);
- case 170:
- case 171:
- case 165:
- case 166:
- case 167:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNodes(cbNode, cbNodes, node.typeParameters) ||
- visitNodes(cbNode, cbNodes, node.parameters) ||
- visitNode(cbNode, node.type);
- case 161:
- case 160:
- case 162:
- case 163:
- case 164:
- case 201:
- case 244:
- case 202:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.asteriskToken) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.questionToken) ||
- visitNode(cbNode, node.exclamationToken) ||
- visitNodes(cbNode, cbNodes, node.typeParameters) ||
- visitNodes(cbNode, cbNodes, node.parameters) ||
- visitNode(cbNode, node.type) ||
- visitNode(cbNode, node.equalsGreaterThanToken) ||
- visitNode(cbNode, node.body);
- case 169:
- return visitNode(cbNode, node.typeName) ||
- visitNodes(cbNode, cbNodes, node.typeArguments);
- case 168:
- return visitNode(cbNode, node.assertsModifier) ||
- visitNode(cbNode, node.parameterName) ||
- visitNode(cbNode, node.type);
- case 172:
- return visitNode(cbNode, node.exprName);
- case 173:
- return visitNodes(cbNode, cbNodes, node.members);
- case 174:
- return visitNode(cbNode, node.elementType);
- case 175:
- return visitNodes(cbNode, cbNodes, node.elementTypes);
- case 178:
- case 179:
- return visitNodes(cbNode, cbNodes, node.types);
- case 180:
- return visitNode(cbNode, node.checkType) ||
- visitNode(cbNode, node.extendsType) ||
- visitNode(cbNode, node.trueType) ||
- visitNode(cbNode, node.falseType);
- case 181:
- return visitNode(cbNode, node.typeParameter);
- case 188:
- return visitNode(cbNode, node.argument) ||
- visitNode(cbNode, node.qualifier) ||
- visitNodes(cbNode, cbNodes, node.typeArguments);
- case 182:
- case 184:
- return visitNode(cbNode, node.type);
- case 185:
- return visitNode(cbNode, node.objectType) ||
- visitNode(cbNode, node.indexType);
- case 186:
- return visitNode(cbNode, node.readonlyToken) ||
- visitNode(cbNode, node.typeParameter) ||
- visitNode(cbNode, node.questionToken) ||
- visitNode(cbNode, node.type);
- case 187:
- return visitNode(cbNode, node.literal);
- case 189:
- case 190:
- return visitNodes(cbNode, cbNodes, node.elements);
- case 192:
- return visitNodes(cbNode, cbNodes, node.elements);
- case 193:
- return visitNodes(cbNode, cbNodes, node.properties);
- case 194:
- return visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.questionDotToken) ||
- visitNode(cbNode, node.name);
- case 195:
- return visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.questionDotToken) ||
- visitNode(cbNode, node.argumentExpression);
- case 196:
- case 197:
- return visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.questionDotToken) ||
- visitNodes(cbNode, cbNodes, node.typeArguments) ||
- visitNodes(cbNode, cbNodes, node.arguments);
- case 198:
- return visitNode(cbNode, node.tag) ||
- visitNode(cbNode, node.questionDotToken) ||
- visitNodes(cbNode, cbNodes, node.typeArguments) ||
- visitNode(cbNode, node.template);
- case 199:
- return visitNode(cbNode, node.type) ||
- visitNode(cbNode, node.expression);
- case 200:
- return visitNode(cbNode, node.expression);
- case 203:
- return visitNode(cbNode, node.expression);
- case 204:
- return visitNode(cbNode, node.expression);
- case 205:
- return visitNode(cbNode, node.expression);
- case 207:
- return visitNode(cbNode, node.operand);
- case 212:
- return visitNode(cbNode, node.asteriskToken) ||
- visitNode(cbNode, node.expression);
- case 206:
- return visitNode(cbNode, node.expression);
- case 208:
- return visitNode(cbNode, node.operand);
- case 209:
- return visitNode(cbNode, node.left) ||
- visitNode(cbNode, node.operatorToken) ||
- visitNode(cbNode, node.right);
- case 217:
- return visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.type);
- case 218:
- return visitNode(cbNode, node.expression);
- case 219:
- return visitNode(cbNode, node.name);
- case 210:
- return visitNode(cbNode, node.condition) ||
- visitNode(cbNode, node.questionToken) ||
- visitNode(cbNode, node.whenTrue) ||
- visitNode(cbNode, node.colonToken) ||
- visitNode(cbNode, node.whenFalse);
- case 213:
- return visitNode(cbNode, node.expression);
- case 223:
- case 250:
- return visitNodes(cbNode, cbNodes, node.statements);
- case 290:
- return visitNodes(cbNode, cbNodes, node.statements) ||
- visitNode(cbNode, node.endOfFileToken);
- case 225:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.declarationList);
- case 243:
- return visitNodes(cbNode, cbNodes, node.declarations);
- case 226:
- return visitNode(cbNode, node.expression);
- case 227:
- return visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.thenStatement) ||
- visitNode(cbNode, node.elseStatement);
- case 228:
- return visitNode(cbNode, node.statement) ||
- visitNode(cbNode, node.expression);
- case 229:
- return visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.statement);
- case 230:
- return visitNode(cbNode, node.initializer) ||
- visitNode(cbNode, node.condition) ||
- visitNode(cbNode, node.incrementor) ||
- visitNode(cbNode, node.statement);
- case 231:
- return visitNode(cbNode, node.initializer) ||
- visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.statement);
- case 232:
- return visitNode(cbNode, node.awaitModifier) ||
- visitNode(cbNode, node.initializer) ||
- visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.statement);
- case 233:
- case 234:
- return visitNode(cbNode, node.label);
- case 235:
- return visitNode(cbNode, node.expression);
- case 236:
- return visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.statement);
- case 237:
- return visitNode(cbNode, node.expression) ||
- visitNode(cbNode, node.caseBlock);
- case 251:
- return visitNodes(cbNode, cbNodes, node.clauses);
- case 277:
- return visitNode(cbNode, node.expression) ||
- visitNodes(cbNode, cbNodes, node.statements);
- case 278:
- return visitNodes(cbNode, cbNodes, node.statements);
- case 238:
- return visitNode(cbNode, node.label) ||
- visitNode(cbNode, node.statement);
- case 239:
- return visitNode(cbNode, node.expression);
- case 240:
- return visitNode(cbNode, node.tryBlock) ||
- visitNode(cbNode, node.catchClause) ||
- visitNode(cbNode, node.finallyBlock);
- case 280:
- return visitNode(cbNode, node.variableDeclaration) ||
- visitNode(cbNode, node.block);
- case 157:
- return visitNode(cbNode, node.expression);
- case 245:
- case 214:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNodes(cbNode, cbNodes, node.typeParameters) ||
- visitNodes(cbNode, cbNodes, node.heritageClauses) ||
- visitNodes(cbNode, cbNodes, node.members);
- case 246:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNodes(cbNode, cbNodes, node.typeParameters) ||
- visitNodes(cbNode, cbNodes, node.heritageClauses) ||
- visitNodes(cbNode, cbNodes, node.members);
- case 247:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNodes(cbNode, cbNodes, node.typeParameters) ||
- visitNode(cbNode, node.type);
- case 248:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNodes(cbNode, cbNodes, node.members);
- case 284:
- return visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.initializer);
- case 249:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.body);
- case 253:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.moduleReference);
- case 254:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.importClause) ||
- visitNode(cbNode, node.moduleSpecifier);
- case 255:
- return visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.namedBindings);
- case 252:
- return visitNode(cbNode, node.name);
- case 256:
- return visitNode(cbNode, node.name);
- case 262:
- return visitNode(cbNode, node.name);
- case 257:
- case 261:
- return visitNodes(cbNode, cbNodes, node.elements);
- case 260:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.exportClause) ||
- visitNode(cbNode, node.moduleSpecifier);
- case 258:
- case 263:
- return visitNode(cbNode, node.propertyName) ||
- visitNode(cbNode, node.name);
- case 259:
- return visitNodes(cbNode, cbNodes, node.decorators) ||
- visitNodes(cbNode, cbNodes, node.modifiers) ||
- visitNode(cbNode, node.expression);
- case 211:
- return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans);
- case 221:
- return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal);
- case 154:
- return visitNode(cbNode, node.expression);
- case 279:
- return visitNodes(cbNode, cbNodes, node.types);
- case 216:
- return visitNode(cbNode, node.expression) ||
- visitNodes(cbNode, cbNodes, node.typeArguments);
- case 265:
- return visitNode(cbNode, node.expression);
- case 264:
- return visitNodes(cbNode, cbNodes, node.decorators);
- case 327:
- return visitNodes(cbNode, cbNodes, node.elements);
- case 266:
- return visitNode(cbNode, node.openingElement) ||
- visitNodes(cbNode, cbNodes, node.children) ||
- visitNode(cbNode, node.closingElement);
- case 270:
- return visitNode(cbNode, node.openingFragment) ||
- visitNodes(cbNode, cbNodes, node.children) ||
- visitNode(cbNode, node.closingFragment);
- case 267:
- case 268:
- return visitNode(cbNode, node.tagName) ||
- visitNodes(cbNode, cbNodes, node.typeArguments) ||
- visitNode(cbNode, node.attributes);
- case 274:
- return visitNodes(cbNode, cbNodes, node.properties);
- case 273:
- return visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.initializer);
- case 275:
- return visitNode(cbNode, node.expression);
- case 276:
- return visitNode(cbNode, node.dotDotDotToken) ||
- visitNode(cbNode, node.expression);
- case 269:
- return visitNode(cbNode, node.tagName);
- case 176:
- case 177:
- case 294:
- case 298:
- case 297:
- case 299:
- case 301:
- return visitNode(cbNode, node.type);
- case 300:
- return visitNodes(cbNode, cbNodes, node.parameters) ||
- visitNode(cbNode, node.type);
- case 303:
- return visitNodes(cbNode, cbNodes, node.tags);
- case 317:
- case 323:
- return visitNode(cbNode, node.tagName) ||
- (node.isNameFirst
- ? visitNode(cbNode, node.name) ||
- visitNode(cbNode, node.typeExpression)
- : visitNode(cbNode, node.typeExpression) ||
- visitNode(cbNode, node.name));
- case 309:
- return visitNode(cbNode, node.tagName);
- case 308:
- return visitNode(cbNode, node.tagName) ||
- visitNode(cbNode, node.class);
- case 307:
- return visitNode(cbNode, node.tagName) ||
- visitNode(cbNode, node.class);
- case 321:
- return visitNode(cbNode, node.tagName) ||
- visitNode(cbNode, node.constraint) ||
- visitNodes(cbNode, cbNodes, node.typeParameters);
- case 322:
- return visitNode(cbNode, node.tagName) ||
- (node.typeExpression &&
- node.typeExpression.kind === 294
- ? visitNode(cbNode, node.typeExpression) ||
- visitNode(cbNode, node.fullName)
- : visitNode(cbNode, node.fullName) ||
- visitNode(cbNode, node.typeExpression));
- case 315:
- return visitNode(cbNode, node.tagName) ||
- visitNode(cbNode, node.fullName) ||
- visitNode(cbNode, node.typeExpression);
- case 318:
- case 320:
- case 319:
- case 316:
- return visitNode(cbNode, node.tagName) ||
- visitNode(cbNode, node.typeExpression);
- case 305:
- return ts.forEach(node.typeParameters, cbNode) ||
- ts.forEach(node.parameters, cbNode) ||
- visitNode(cbNode, node.type);
- case 304:
- return ts.forEach(node.jsDocPropertyTags, cbNode);
- case 306:
- case 310:
- case 311:
- case 312:
- case 313:
- case 314:
- return visitNode(cbNode, node.tagName);
- case 326:
- return visitNode(cbNode, node.expression);
- }
- }
- ts.forEachChild = forEachChild;
- function forEachChildRecursively(rootNode, cbNode, cbNodes) {
- var stack = [rootNode];
- while (stack.length) {
- var parent = stack.pop();
- var res = visitAllPossibleChildren(parent, gatherPossibleChildren(parent));
- if (res) {
- return res;
- }
- }
- return;
- function gatherPossibleChildren(node) {
- var children = [];
- forEachChild(node, addWorkItem, addWorkItem);
- return children;
- function addWorkItem(n) {
- children.unshift(n);
- }
+ function createBaseNode(kind) {
+ return baseFactory.createBaseNode(kind);
+ }
+ function createBaseDeclaration(kind, decorators, modifiers) {
+ var node = createBaseNode(kind);
+ node.decorators = asNodeArray(decorators);
+ node.modifiers = asNodeArray(modifiers);
+ node.transformFlags |=
+ propagateChildrenFlags(node.decorators) |
+ propagateChildrenFlags(node.modifiers);
+ node.symbol = undefined;
+ node.localSymbol = undefined;
+ node.locals = undefined;
+ node.nextContainer = undefined;
+ return node;
}
- function visitAllPossibleChildren(parent, children) {
- for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
- var child = children_1[_i];
- if (ts.isArray(child)) {
- if (cbNodes) {
- var res = cbNodes(child, parent);
- if (res) {
- if (res === "skip")
- continue;
- return res;
- }
- }
- for (var i = child.length - 1; i >= 0; i--) {
- var realChild = child[i];
- var res = cbNode(realChild, parent);
- if (res) {
- if (res === "skip")
- continue;
- return res;
+ function createBaseNamedDeclaration(kind, decorators, modifiers, name) {
+ var node = createBaseDeclaration(kind, decorators, modifiers);
+ name = asName(name);
+ node.name = name;
+ if (name) {
+ switch (node.kind) {
+ case 165:
+ case 167:
+ case 168:
+ case 163:
+ case 288:
+ if (ts.isIdentifier(name)) {
+ node.transformFlags |= propagateIdentifierNameFlags(name);
+ break;
}
- stack.push(realChild);
- }
- }
- else {
- stack.push(child);
- var res = cbNode(child, parent);
- if (res) {
- if (res === "skip")
- continue;
- return res;
- }
+ default:
+ node.transformFlags |= propagateChildFlags(name);
+ break;
}
}
+ return node;
}
- }
- ts.forEachChildRecursively = forEachChildRecursively;
- function createSourceFile(fileName, sourceText, languageVersion, setParentNodes, scriptKind) {
- if (setParentNodes === void 0) { setParentNodes = false; }
- ts.performance.mark("beforeParse");
- var result;
- ts.perfLogger.logStartParseSourceFile(fileName);
- if (languageVersion === 100) {
- result = Parser.parseSourceFile(fileName, sourceText, languageVersion, undefined, setParentNodes, 6);
+ function createBaseGenericNamedDeclaration(kind, decorators, modifiers, name, typeParameters) {
+ var node = createBaseNamedDeclaration(kind, decorators, modifiers, name);
+ node.typeParameters = asNodeArray(typeParameters);
+ node.transformFlags |= propagateChildrenFlags(node.typeParameters);
+ if (typeParameters)
+ node.transformFlags |= 1;
+ return node;
}
- else {
- result = Parser.parseSourceFile(fileName, sourceText, languageVersion, undefined, setParentNodes, scriptKind);
+ function createBaseSignatureDeclaration(kind, decorators, modifiers, name, typeParameters, parameters, type) {
+ var node = createBaseGenericNamedDeclaration(kind, decorators, modifiers, name, typeParameters);
+ node.parameters = createNodeArray(parameters);
+ node.type = type;
+ node.transformFlags |=
+ propagateChildrenFlags(node.parameters) |
+ propagateChildFlags(node.type);
+ if (type)
+ node.transformFlags |= 1;
+ return node;
}
- ts.perfLogger.logStopParseSourceFile();
- ts.performance.mark("afterParse");
- ts.performance.measure("Parse", "beforeParse", "afterParse");
- return result;
- }
- ts.createSourceFile = createSourceFile;
- function parseIsolatedEntityName(text, languageVersion) {
- return Parser.parseIsolatedEntityName(text, languageVersion);
- }
- ts.parseIsolatedEntityName = parseIsolatedEntityName;
- function parseJsonText(fileName, sourceText) {
- return Parser.parseJsonText(fileName, sourceText);
- }
- ts.parseJsonText = parseJsonText;
- function isExternalModule(file) {
- return file.externalModuleIndicator !== undefined;
- }
- ts.isExternalModule = isExternalModule;
- function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) {
- if (aggressiveChecks === void 0) { aggressiveChecks = false; }
- var newSourceFile = IncrementalParser.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
- newSourceFile.flags |= (sourceFile.flags & 3145728);
- return newSourceFile;
- }
- ts.updateSourceFile = updateSourceFile;
- function parseIsolatedJSDocComment(content, start, length) {
- var result = Parser.JSDocParser.parseIsolatedJSDocComment(content, start, length);
- if (result && result.jsDoc) {
- Parser.fixupParentReferences(result.jsDoc);
+ function updateBaseSignatureDeclaration(updated, original) {
+ if (original.typeArguments)
+ updated.typeArguments = original.typeArguments;
+ return update(updated, original);
}
- return result;
- }
- ts.parseIsolatedJSDocComment = parseIsolatedJSDocComment;
- function parseJSDocTypeExpressionForTests(content, start, length) {
- return Parser.JSDocParser.parseJSDocTypeExpressionForTests(content, start, length);
- }
- ts.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests;
- var Parser;
- (function (Parser) {
- var scanner = ts.createScanner(99, true);
- var disallowInAndDecoratorContext = 4096 | 16384;
- var NodeConstructor;
- var TokenConstructor;
- var IdentifierConstructor;
- var PrivateIdentifierConstructor;
- var SourceFileConstructor;
- var sourceFile;
- var parseDiagnostics;
- var syntaxCursor;
- var currentToken;
- var sourceText;
- var nodeCount;
- var identifiers;
- var privateIdentifiers;
- var identifierCount;
- var parsingContext;
- var notParenthesizedArrow;
- var contextFlags;
- var parseErrorBeforeNextFinishedNode = false;
- function parseSourceFile(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes, scriptKind) {
- if (setParentNodes === void 0) { setParentNodes = false; }
- scriptKind = ts.ensureScriptKind(fileName, scriptKind);
- if (scriptKind === 6) {
- var result_2 = parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes);
- ts.convertToObjectWorker(result_2, result_2.parseDiagnostics, false, undefined, undefined);
- result_2.referencedFiles = ts.emptyArray;
- result_2.typeReferenceDirectives = ts.emptyArray;
- result_2.libReferenceDirectives = ts.emptyArray;
- result_2.amdDependencies = ts.emptyArray;
- result_2.hasNoDefaultLib = false;
- result_2.pragmas = ts.emptyMap;
- return result_2;
+ function createBaseFunctionLikeDeclaration(kind, decorators, modifiers, name, typeParameters, parameters, type, body) {
+ var node = createBaseSignatureDeclaration(kind, decorators, modifiers, name, typeParameters, parameters, type);
+ node.body = body;
+ node.transformFlags |= propagateChildFlags(node.body) & ~8388608;
+ if (!body)
+ node.transformFlags |= 1;
+ return node;
+ }
+ function updateBaseFunctionLikeDeclaration(updated, original) {
+ if (original.exclamationToken)
+ updated.exclamationToken = original.exclamationToken;
+ if (original.typeArguments)
+ updated.typeArguments = original.typeArguments;
+ return updateBaseSignatureDeclaration(updated, original);
+ }
+ function createBaseInterfaceOrClassLikeDeclaration(kind, decorators, modifiers, name, typeParameters, heritageClauses) {
+ var node = createBaseGenericNamedDeclaration(kind, decorators, modifiers, name, typeParameters);
+ node.heritageClauses = asNodeArray(heritageClauses);
+ node.transformFlags |= propagateChildrenFlags(node.heritageClauses);
+ return node;
+ }
+ function createBaseClassLikeDeclaration(kind, decorators, modifiers, name, typeParameters, heritageClauses, members) {
+ var node = createBaseInterfaceOrClassLikeDeclaration(kind, decorators, modifiers, name, typeParameters, heritageClauses);
+ node.members = createNodeArray(members);
+ node.transformFlags |= propagateChildrenFlags(node.members);
+ return node;
+ }
+ function createBaseBindingLikeDeclaration(kind, decorators, modifiers, name, initializer) {
+ var node = createBaseNamedDeclaration(kind, decorators, modifiers, name);
+ node.initializer = initializer;
+ node.transformFlags |= propagateChildFlags(node.initializer);
+ return node;
+ }
+ function createBaseVariableLikeDeclaration(kind, decorators, modifiers, name, type, initializer) {
+ var node = createBaseBindingLikeDeclaration(kind, decorators, modifiers, name, initializer);
+ node.type = type;
+ node.transformFlags |= propagateChildFlags(type);
+ if (type)
+ node.transformFlags |= 1;
+ return node;
+ }
+ function createBaseLiteral(kind, text) {
+ var node = createBaseToken(kind);
+ node.text = text;
+ return node;
+ }
+ function createNumericLiteral(value, numericLiteralFlags) {
+ if (numericLiteralFlags === void 0) { numericLiteralFlags = 0; }
+ var node = createBaseLiteral(8, typeof value === "number" ? value + "" : value);
+ node.numericLiteralFlags = numericLiteralFlags;
+ if (numericLiteralFlags & 384)
+ node.transformFlags |= 256;
+ return node;
+ }
+ function createBigIntLiteral(value) {
+ var node = createBaseLiteral(9, typeof value === "string" ? value : ts.pseudoBigIntToString(value) + "n");
+ node.transformFlags |= 4;
+ return node;
+ }
+ function createBaseStringLiteral(text, isSingleQuote) {
+ var node = createBaseLiteral(10, text);
+ node.singleQuote = isSingleQuote;
+ return node;
+ }
+ function createStringLiteral(text, isSingleQuote, hasExtendedUnicodeEscape) {
+ var node = createBaseStringLiteral(text, isSingleQuote);
+ node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
+ if (hasExtendedUnicodeEscape)
+ node.transformFlags |= 256;
+ return node;
+ }
+ function createStringLiteralFromNode(sourceNode) {
+ var node = createBaseStringLiteral(ts.getTextOfIdentifierOrLiteral(sourceNode), undefined);
+ node.textSourceNode = sourceNode;
+ return node;
+ }
+ function createRegularExpressionLiteral(text) {
+ var node = createBaseLiteral(13, text);
+ return node;
+ }
+ function createLiteralLikeNode(kind, text) {
+ switch (kind) {
+ case 8: return createNumericLiteral(text, 0);
+ case 9: return createBigIntLiteral(text);
+ case 10: return createStringLiteral(text, undefined);
+ case 11: return createJsxText(text, false);
+ case 12: return createJsxText(text, true);
+ case 13: return createRegularExpressionLiteral(text);
+ case 14: return createTemplateLiteralLikeNode(kind, text, undefined, 0);
}
- initializeState(sourceText, languageVersion, syntaxCursor, scriptKind);
- var result = parseSourceFileWorker(fileName, languageVersion, setParentNodes, scriptKind);
- clearState();
- return result;
}
- Parser.parseSourceFile = parseSourceFile;
- function parseIsolatedEntityName(content, languageVersion) {
- initializeState(content, languageVersion, undefined, 1);
- nextToken();
- var entityName = parseEntityName(true);
- var isInvalid = token() === 1 && !parseDiagnostics.length;
- clearState();
- return isInvalid ? entityName : undefined;
+ function createBaseIdentifier(text, originalKeywordKind) {
+ if (originalKeywordKind === undefined && text) {
+ originalKeywordKind = ts.stringToToken(text);
+ }
+ if (originalKeywordKind === 78) {
+ originalKeywordKind = undefined;
+ }
+ var node = baseFactory.createBaseIdentifierNode(78);
+ node.originalKeywordKind = originalKeywordKind;
+ node.escapedText = ts.escapeLeadingUnderscores(text);
+ return node;
}
- Parser.parseIsolatedEntityName = parseIsolatedEntityName;
- function parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes) {
- if (languageVersion === void 0) { languageVersion = 2; }
- initializeState(sourceText, languageVersion, syntaxCursor, 6);
- sourceFile = createSourceFile(fileName, 2, 6, false);
- sourceFile.flags = contextFlags;
- nextToken();
- var pos = getNodePos();
- if (token() === 1) {
- sourceFile.statements = createNodeArray([], pos, pos);
- sourceFile.endOfFileToken = parseTokenNode();
+ function createBaseGeneratedIdentifier(text, autoGenerateFlags) {
+ var node = createBaseIdentifier(text, undefined);
+ node.autoGenerateFlags = autoGenerateFlags;
+ node.autoGenerateId = nextAutoGenerateId;
+ nextAutoGenerateId++;
+ return node;
+ }
+ function createIdentifier(text, typeArguments, originalKeywordKind) {
+ var node = createBaseIdentifier(text, originalKeywordKind);
+ if (typeArguments) {
+ node.typeArguments = createNodeArray(typeArguments);
}
- else {
- var statement = createNode(226);
- switch (token()) {
- case 22:
- statement.expression = parseArrayLiteralExpression();
- break;
- case 106:
- case 91:
- case 100:
- statement.expression = parseTokenNode();
- break;
- case 40:
- if (lookAhead(function () { return nextToken() === 8 && nextToken() !== 58; })) {
- statement.expression = parsePrefixUnaryExpression();
- }
- else {
- statement.expression = parseObjectLiteralExpression();
- }
- break;
- case 8:
- case 10:
- if (lookAhead(function () { return nextToken() !== 58; })) {
- statement.expression = parseLiteralNode();
- break;
- }
- default:
- statement.expression = parseObjectLiteralExpression();
- break;
- }
- finishNode(statement);
- sourceFile.statements = createNodeArray([statement], pos);
- sourceFile.endOfFileToken = parseExpectedToken(1, ts.Diagnostics.Unexpected_token);
+ if (node.originalKeywordKind === 130) {
+ node.transformFlags |= 8388608;
}
- if (setParentNodes) {
- fixupParentReferences(sourceFile);
+ return node;
+ }
+ function updateIdentifier(node, typeArguments) {
+ return node.typeArguments !== typeArguments
+ ? update(createIdentifier(ts.idText(node), typeArguments), node)
+ : node;
+ }
+ function createTempVariable(recordTempVariable, reservedInNestedScopes) {
+ var flags = 1;
+ if (reservedInNestedScopes)
+ flags |= 8;
+ var name = createBaseGeneratedIdentifier("", flags);
+ if (recordTempVariable) {
+ recordTempVariable(name);
}
- sourceFile.nodeCount = nodeCount;
- sourceFile.identifierCount = identifierCount;
- sourceFile.identifiers = identifiers;
- sourceFile.parseDiagnostics = parseDiagnostics;
- var result = sourceFile;
- clearState();
- return result;
+ return name;
}
- Parser.parseJsonText = parseJsonText;
- function getLanguageVariant(scriptKind) {
- return scriptKind === 4 || scriptKind === 2 || scriptKind === 1 || scriptKind === 6 ? 1 : 0;
+ function createLoopVariable() {
+ return createBaseGeneratedIdentifier("", 2);
}
- function initializeState(_sourceText, languageVersion, _syntaxCursor, scriptKind) {
- NodeConstructor = ts.objectAllocator.getNodeConstructor();
- TokenConstructor = ts.objectAllocator.getTokenConstructor();
- IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor();
- PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor();
- SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor();
- sourceText = _sourceText;
- syntaxCursor = _syntaxCursor;
- parseDiagnostics = [];
- parsingContext = 0;
- identifiers = ts.createMap();
- privateIdentifiers = ts.createMap();
- identifierCount = 0;
- nodeCount = 0;
- switch (scriptKind) {
- case 1:
- case 2:
- contextFlags = 131072;
+ function createUniqueName(text, flags) {
+ if (flags === void 0) { flags = 0; }
+ ts.Debug.assert(!(flags & 7), "Argument out of range: flags");
+ ts.Debug.assert((flags & (16 | 32)) !== 32, "GeneratedIdentifierFlags.FileLevel cannot be set without also setting GeneratedIdentifierFlags.Optimistic");
+ return createBaseGeneratedIdentifier(text, 3 | flags);
+ }
+ function getGeneratedNameForNode(node, flags) {
+ if (flags === void 0) { flags = 0; }
+ ts.Debug.assert(!(flags & 7), "Argument out of range: flags");
+ var name = createBaseGeneratedIdentifier(node && ts.isIdentifier(node) ? ts.idText(node) : "", 4 | flags);
+ name.original = node;
+ return name;
+ }
+ function createPrivateIdentifier(text) {
+ if (!ts.startsWith(text, "#"))
+ ts.Debug.fail("First character of private identifier must be #: " + text);
+ var node = baseFactory.createBasePrivateIdentifierNode(79);
+ node.escapedText = ts.escapeLeadingUnderscores(text);
+ node.transformFlags |= 4194304;
+ return node;
+ }
+ function createBaseToken(kind) {
+ return baseFactory.createBaseTokenNode(kind);
+ }
+ function createToken(token) {
+ ts.Debug.assert(token >= 0 && token <= 156, "Invalid token");
+ ts.Debug.assert(token <= 14 || token >= 17, "Invalid token. Use 'createTemplateLiteralLikeNode' to create template literals.");
+ ts.Debug.assert(token <= 8 || token >= 14, "Invalid token. Use 'createLiteralLikeNode' to create literals.");
+ ts.Debug.assert(token !== 78, "Invalid token. Use 'createIdentifier' to create identifiers");
+ var node = createBaseToken(token);
+ var transformFlags = 0;
+ switch (token) {
+ case 129:
+ transformFlags =
+ 64 |
+ 32;
break;
- case 6:
- contextFlags = 131072 | 33554432;
+ case 122:
+ case 120:
+ case 121:
+ case 142:
+ case 125:
+ case 133:
+ case 84:
+ case 128:
+ case 144:
+ case 155:
+ case 141:
+ case 145:
+ case 147:
+ case 131:
+ case 148:
+ case 113:
+ case 152:
+ case 150:
+ transformFlags = 1;
break;
- default:
- contextFlags = 0;
+ case 123:
+ case 105:
+ transformFlags = 256;
+ break;
+ case 107:
+ transformFlags = 4096;
break;
}
- parseErrorBeforeNextFinishedNode = false;
- scanner.setText(sourceText);
- scanner.setOnError(scanError);
- scanner.setScriptTarget(languageVersion);
- scanner.setLanguageVariant(getLanguageVariant(scriptKind));
+ if (transformFlags) {
+ node.transformFlags |= transformFlags;
+ }
+ return node;
}
- function clearState() {
- scanner.clearCommentDirectives();
- scanner.setText("");
- scanner.setOnError(undefined);
- parseDiagnostics = undefined;
- sourceFile = undefined;
- identifiers = undefined;
- syntaxCursor = undefined;
- sourceText = undefined;
- notParenthesizedArrow = undefined;
+ function createSuper() {
+ return createToken(105);
}
- function parseSourceFileWorker(fileName, languageVersion, setParentNodes, scriptKind) {
- var isDeclarationFile = isDeclarationFileName(fileName);
- if (isDeclarationFile) {
- contextFlags |= 8388608;
+ function createThis() {
+ return createToken(107);
+ }
+ function createNull() {
+ return createToken(103);
+ }
+ function createTrue() {
+ return createToken(109);
+ }
+ function createFalse() {
+ return createToken(94);
+ }
+ function createModifier(kind) {
+ return createToken(kind);
+ }
+ function createModifiersFromModifierFlags(flags) {
+ var result = [];
+ if (flags & 1) {
+ result.push(createModifier(92));
}
- sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile);
- sourceFile.flags = contextFlags;
- nextToken();
- processCommentPragmas(sourceFile, sourceText);
- processPragmasIntoFields(sourceFile, reportPragmaDiagnostic);
- sourceFile.statements = parseList(0, parseStatement);
- ts.Debug.assert(token() === 1);
- sourceFile.endOfFileToken = addJSDocComment(parseTokenNode());
- setExternalModuleIndicator(sourceFile);
- sourceFile.commentDirectives = scanner.getCommentDirectives();
- sourceFile.nodeCount = nodeCount;
- sourceFile.identifierCount = identifierCount;
- sourceFile.identifiers = identifiers;
- sourceFile.parseDiagnostics = parseDiagnostics;
- if (setParentNodes) {
- fixupParentReferences(sourceFile);
+ if (flags & 2) {
+ result.push(createModifier(133));
}
- return sourceFile;
- function reportPragmaDiagnostic(pos, end, diagnostic) {
- parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, pos, end, diagnostic));
+ if (flags & 512) {
+ result.push(createModifier(87));
+ }
+ if (flags & 2048) {
+ result.push(createModifier(84));
+ }
+ if (flags & 4) {
+ result.push(createModifier(122));
+ }
+ if (flags & 8) {
+ result.push(createModifier(120));
+ }
+ if (flags & 16) {
+ result.push(createModifier(121));
+ }
+ if (flags & 128) {
+ result.push(createModifier(125));
+ }
+ if (flags & 32) {
+ result.push(createModifier(123));
+ }
+ if (flags & 64) {
+ result.push(createModifier(142));
+ }
+ if (flags & 256) {
+ result.push(createModifier(129));
}
+ return result;
}
- function addJSDocComment(node) {
- ts.Debug.assert(!node.jsDoc);
- var jsDoc = ts.mapDefined(ts.getJSDocCommentRanges(node, sourceFile.text), function (comment) { return JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos); });
- if (jsDoc.length)
- node.jsDoc = jsDoc;
+ function createQualifiedName(left, right) {
+ var node = createBaseNode(157);
+ node.left = left;
+ node.right = asName(right);
+ node.transformFlags |=
+ propagateChildFlags(node.left) |
+ propagateIdentifierNameFlags(node.right);
return node;
}
- function fixupParentReferences(rootNode) {
- forEachChildRecursively(rootNode, bindParentToChild);
- function bindParentToChild(child, parent) {
- child.parent = parent;
- if (ts.hasJSDocNodes(child)) {
- for (var _i = 0, _a = child.jsDoc; _i < _a.length; _i++) {
- var doc = _a[_i];
- bindParentToChild(doc, child);
- forEachChildRecursively(doc, bindParentToChild);
- }
- }
- }
+ function updateQualifiedName(node, left, right) {
+ return node.left !== left
+ || node.right !== right
+ ? update(createQualifiedName(left, right), node)
+ : node;
+ }
+ function createComputedPropertyName(expression) {
+ var node = createBaseNode(158);
+ node.expression = parenthesizerRules().parenthesizeExpressionOfComputedPropertyName(expression);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 256 |
+ 32768;
+ return node;
}
- Parser.fixupParentReferences = fixupParentReferences;
- function createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile) {
- var sourceFile = new SourceFileConstructor(290, 0, sourceText.length);
- nodeCount++;
- sourceFile.text = sourceText;
- sourceFile.bindDiagnostics = [];
- sourceFile.bindSuggestionDiagnostics = undefined;
- sourceFile.languageVersion = languageVersion;
- sourceFile.fileName = ts.normalizePath(fileName);
- sourceFile.languageVariant = getLanguageVariant(scriptKind);
- sourceFile.isDeclarationFile = isDeclarationFile;
- sourceFile.scriptKind = scriptKind;
- return sourceFile;
+ function updateComputedPropertyName(node, expression) {
+ return node.expression !== expression
+ ? update(createComputedPropertyName(expression), node)
+ : node;
}
- function setContextFlag(val, flag) {
- if (val) {
- contextFlags |= flag;
+ function createTypeParameterDeclaration(name, constraint, defaultType) {
+ var node = createBaseNamedDeclaration(159, undefined, undefined, name);
+ node.constraint = constraint;
+ node.default = defaultType;
+ node.transformFlags = 1;
+ return node;
+ }
+ function updateTypeParameterDeclaration(node, name, constraint, defaultType) {
+ return node.name !== name
+ || node.constraint !== constraint
+ || node.default !== defaultType
+ ? update(createTypeParameterDeclaration(name, constraint, defaultType), node)
+ : node;
+ }
+ function createParameterDeclaration(decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) {
+ var node = createBaseVariableLikeDeclaration(160, decorators, modifiers, name, type, initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer));
+ node.dotDotDotToken = dotDotDotToken;
+ node.questionToken = questionToken;
+ if (ts.isThisIdentifier(node.name)) {
+ node.transformFlags = 1;
}
else {
- contextFlags &= ~flag;
+ node.transformFlags |=
+ propagateChildFlags(node.dotDotDotToken) |
+ propagateChildFlags(node.questionToken);
+ if (questionToken)
+ node.transformFlags |= 1;
+ if (ts.modifiersToFlags(node.modifiers) & 92)
+ node.transformFlags |= 2048;
+ if (initializer || dotDotDotToken)
+ node.transformFlags |= 256;
}
+ return node;
}
- function setDisallowInContext(val) {
- setContextFlag(val, 4096);
- }
- function setYieldContext(val) {
- setContextFlag(val, 8192);
+ function updateParameterDeclaration(node, decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.dotDotDotToken !== dotDotDotToken
+ || node.name !== name
+ || node.questionToken !== questionToken
+ || node.type !== type
+ || node.initializer !== initializer
+ ? update(createParameterDeclaration(decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer), node)
+ : node;
+ }
+ function createDecorator(expression) {
+ var node = createBaseNode(161);
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 1 |
+ 2048;
+ return node;
}
- function setDecoratorContext(val) {
- setContextFlag(val, 16384);
+ function updateDecorator(node, expression) {
+ return node.expression !== expression
+ ? update(createDecorator(expression), node)
+ : node;
}
- function setAwaitContext(val) {
- setContextFlag(val, 32768);
+ function createPropertySignature(modifiers, name, questionToken, type) {
+ var node = createBaseNamedDeclaration(162, undefined, modifiers, name);
+ node.type = type;
+ node.questionToken = questionToken;
+ node.transformFlags = 1;
+ return node;
}
- function doOutsideOfContext(context, func) {
- var contextFlagsToClear = context & contextFlags;
- if (contextFlagsToClear) {
- setContextFlag(false, contextFlagsToClear);
- var result = func();
- setContextFlag(true, contextFlagsToClear);
- return result;
+ function updatePropertySignature(node, modifiers, name, questionToken, type) {
+ return node.modifiers !== modifiers
+ || node.name !== name
+ || node.questionToken !== questionToken
+ || node.type !== type
+ ? update(createPropertySignature(modifiers, name, questionToken, type), node)
+ : node;
+ }
+ function createPropertyDeclaration(decorators, modifiers, name, questionOrExclamationToken, type, initializer) {
+ var node = createBaseVariableLikeDeclaration(163, decorators, modifiers, name, type, initializer);
+ node.questionToken = questionOrExclamationToken && ts.isQuestionToken(questionOrExclamationToken) ? questionOrExclamationToken : undefined;
+ node.exclamationToken = questionOrExclamationToken && ts.isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : undefined;
+ node.transformFlags |=
+ propagateChildFlags(node.questionToken) |
+ propagateChildFlags(node.exclamationToken) |
+ 4194304;
+ if (ts.isComputedPropertyName(node.name) || (ts.hasStaticModifier(node) && node.initializer)) {
+ node.transformFlags |= 2048;
+ }
+ if (questionOrExclamationToken || ts.modifiersToFlags(node.modifiers) & 2) {
+ node.transformFlags |= 1;
}
- return func();
+ return node;
}
- function doInsideOfContext(context, func) {
- var contextFlagsToSet = context & ~contextFlags;
- if (contextFlagsToSet) {
- setContextFlag(true, contextFlagsToSet);
- var result = func();
- setContextFlag(false, contextFlagsToSet);
- return result;
+ function updatePropertyDeclaration(node, decorators, modifiers, name, questionOrExclamationToken, type, initializer) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.questionToken !== (questionOrExclamationToken !== undefined && ts.isQuestionToken(questionOrExclamationToken) ? questionOrExclamationToken : undefined)
+ || node.exclamationToken !== (questionOrExclamationToken !== undefined && ts.isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : undefined)
+ || node.type !== type
+ || node.initializer !== initializer
+ ? update(createPropertyDeclaration(decorators, modifiers, name, questionOrExclamationToken, type, initializer), node)
+ : node;
+ }
+ function createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type) {
+ var node = createBaseSignatureDeclaration(164, undefined, modifiers, name, typeParameters, parameters, type);
+ node.questionToken = questionToken;
+ node.transformFlags = 1;
+ 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
+ ? updateBaseSignatureDeclaration(createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type), node)
+ : node;
+ }
+ function createMethodDeclaration(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
+ var node = createBaseFunctionLikeDeclaration(165, decorators, modifiers, name, typeParameters, parameters, type, body);
+ node.asteriskToken = asteriskToken;
+ node.questionToken = questionToken;
+ node.transformFlags |=
+ propagateChildFlags(node.asteriskToken) |
+ propagateChildFlags(node.questionToken) |
+ 256;
+ if (questionToken) {
+ node.transformFlags |= 1;
}
- return func();
+ if (ts.modifiersToFlags(node.modifiers) & 256) {
+ if (asteriskToken) {
+ node.transformFlags |= 32;
+ }
+ else {
+ node.transformFlags |= 64;
+ }
+ }
+ else if (asteriskToken) {
+ node.transformFlags |= 512;
+ }
+ return node;
}
- function allowInAnd(func) {
- return doOutsideOfContext(4096, func);
+ function updateMethodDeclaration(node, decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.asteriskToken !== asteriskToken
+ || node.name !== name
+ || node.questionToken !== questionToken
+ || node.typeParameters !== typeParameters
+ || node.parameters !== parameters
+ || node.type !== type
+ || node.body !== body
+ ? updateBaseFunctionLikeDeclaration(createMethodDeclaration(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body), node)
+ : node;
+ }
+ function createConstructorDeclaration(decorators, modifiers, parameters, body) {
+ var node = createBaseFunctionLikeDeclaration(166, decorators, modifiers, undefined, undefined, parameters, undefined, body);
+ node.transformFlags |= 256;
+ return node;
}
- function disallowInAnd(func) {
- return doInsideOfContext(4096, func);
+ function updateConstructorDeclaration(node, decorators, modifiers, parameters, body) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.parameters !== parameters
+ || node.body !== body
+ ? updateBaseFunctionLikeDeclaration(createConstructorDeclaration(decorators, modifiers, parameters, body), node)
+ : node;
+ }
+ function createGetAccessorDeclaration(decorators, modifiers, name, parameters, type, body) {
+ return createBaseFunctionLikeDeclaration(167, decorators, modifiers, name, undefined, parameters, type, body);
+ }
+ function updateGetAccessorDeclaration(node, decorators, modifiers, name, parameters, type, body) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.parameters !== parameters
+ || node.type !== type
+ || node.body !== body
+ ? updateBaseFunctionLikeDeclaration(createGetAccessorDeclaration(decorators, modifiers, name, parameters, type, body), node)
+ : node;
+ }
+ function createSetAccessorDeclaration(decorators, modifiers, name, parameters, body) {
+ return createBaseFunctionLikeDeclaration(168, decorators, modifiers, name, undefined, parameters, undefined, body);
+ }
+ function updateSetAccessorDeclaration(node, decorators, modifiers, name, parameters, body) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.parameters !== parameters
+ || node.body !== body
+ ? updateBaseFunctionLikeDeclaration(createSetAccessorDeclaration(decorators, modifiers, name, parameters, body), node)
+ : node;
+ }
+ function createCallSignature(typeParameters, parameters, type) {
+ var node = createBaseSignatureDeclaration(169, undefined, undefined, undefined, typeParameters, parameters, type);
+ node.transformFlags = 1;
+ return node;
}
- function doInYieldContext(func) {
- return doInsideOfContext(8192, func);
+ function updateCallSignature(node, typeParameters, parameters, type) {
+ return node.typeParameters !== typeParameters
+ || node.parameters !== parameters
+ || node.type !== type
+ ? updateBaseSignatureDeclaration(createCallSignature(typeParameters, parameters, type), node)
+ : node;
}
- function doInDecoratorContext(func) {
- return doInsideOfContext(16384, func);
+ function createConstructSignature(typeParameters, parameters, type) {
+ var node = createBaseSignatureDeclaration(170, undefined, undefined, undefined, typeParameters, parameters, type);
+ node.transformFlags = 1;
+ return node;
}
- function doInAwaitContext(func) {
- return doInsideOfContext(32768, func);
+ function updateConstructSignature(node, typeParameters, parameters, type) {
+ return node.typeParameters !== typeParameters
+ || node.parameters !== parameters
+ || node.type !== type
+ ? updateBaseSignatureDeclaration(createConstructSignature(typeParameters, parameters, type), node)
+ : node;
}
- function doOutsideOfAwaitContext(func) {
- return doOutsideOfContext(32768, func);
+ function createIndexSignature(decorators, modifiers, parameters, type) {
+ var node = createBaseSignatureDeclaration(171, decorators, modifiers, undefined, undefined, parameters, type);
+ node.transformFlags = 1;
+ return node;
}
- function doInYieldAndAwaitContext(func) {
- return doInsideOfContext(8192 | 32768, func);
+ function updateIndexSignature(node, decorators, modifiers, parameters, type) {
+ return node.parameters !== parameters
+ || node.type !== type
+ || node.decorators !== decorators
+ || node.modifiers !== modifiers
+ ? updateBaseSignatureDeclaration(createIndexSignature(decorators, modifiers, parameters, type), node)
+ : node;
+ }
+ function createTemplateLiteralTypeSpan(type, literal) {
+ var node = createBaseNode(194);
+ node.type = type;
+ node.literal = literal;
+ node.transformFlags = 1;
+ return node;
}
- function doOutsideOfYieldAndAwaitContext(func) {
- return doOutsideOfContext(8192 | 32768, func);
+ 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) {
+ var node = createBaseNode(172);
+ node.assertsModifier = assertsModifier;
+ node.parameterName = asName(parameterName);
+ node.type = type;
+ node.transformFlags = 1;
+ return node;
}
- function inContext(flags) {
- return (contextFlags & flags) !== 0;
+ 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) {
+ var node = createBaseNode(173);
+ node.typeName = asName(typeName);
+ node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(createNodeArray(typeArguments));
+ node.transformFlags = 1;
+ return node;
}
- function inYieldContext() {
- return inContext(8192);
+ function updateTypeReferenceNode(node, typeName, typeArguments) {
+ return node.typeName !== typeName
+ || node.typeArguments !== typeArguments
+ ? update(createTypeReferenceNode(typeName, typeArguments), node)
+ : node;
}
- function inDisallowInContext() {
- return inContext(4096);
+ function createFunctionTypeNode(typeParameters, parameters, type) {
+ var node = createBaseSignatureDeclaration(174, undefined, undefined, undefined, typeParameters, parameters, type);
+ node.transformFlags = 1;
+ return node;
}
- function inDecoratorContext() {
- return inContext(16384);
+ function updateFunctionTypeNode(node, typeParameters, parameters, type) {
+ return node.typeParameters !== typeParameters
+ || node.parameters !== parameters
+ || node.type !== type
+ ? updateBaseSignatureDeclaration(createFunctionTypeNode(typeParameters, parameters, type), node)
+ : node;
}
- function inAwaitContext() {
- return inContext(32768);
+ function createConstructorTypeNode(typeParameters, parameters, type) {
+ var node = createBaseSignatureDeclaration(175, undefined, undefined, undefined, typeParameters, parameters, type);
+ node.transformFlags = 1;
+ return node;
}
- function parseErrorAtCurrentToken(message, arg0) {
- parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0);
+ function updateConstructorTypeNode(node, typeParameters, parameters, type) {
+ return node.typeParameters !== typeParameters
+ || node.parameters !== parameters
+ || node.type !== type
+ ? updateBaseSignatureDeclaration(createConstructorTypeNode(typeParameters, parameters, type), node)
+ : node;
+ }
+ function createTypeQueryNode(exprName) {
+ var node = createBaseNode(176);
+ node.exprName = exprName;
+ node.transformFlags = 1;
+ return node;
}
- function parseErrorAtPosition(start, length, message, arg0) {
- var lastError = ts.lastOrUndefined(parseDiagnostics);
- if (!lastError || start !== lastError.start) {
- parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, start, length, message, arg0));
- }
- parseErrorBeforeNextFinishedNode = true;
+ function updateTypeQueryNode(node, exprName) {
+ return node.exprName !== exprName
+ ? update(createTypeQueryNode(exprName), node)
+ : node;
}
- function parseErrorAt(start, end, message, arg0) {
- parseErrorAtPosition(start, end - start, message, arg0);
+ function createTypeLiteralNode(members) {
+ var node = createBaseNode(177);
+ node.members = createNodeArray(members);
+ node.transformFlags = 1;
+ return node;
}
- function parseErrorAtRange(range, message, arg0) {
- parseErrorAt(range.pos, range.end, message, arg0);
+ function updateTypeLiteralNode(node, members) {
+ return node.members !== members
+ ? update(createTypeLiteralNode(members), node)
+ : node;
}
- function scanError(message, length) {
- parseErrorAtPosition(scanner.getTextPos(), length, message);
+ function createArrayTypeNode(elementType) {
+ var node = createBaseNode(178);
+ node.elementType = parenthesizerRules().parenthesizeElementTypeOfArrayType(elementType);
+ node.transformFlags = 1;
+ return node;
}
- function getNodePos() {
- return scanner.getStartPos();
+ function updateArrayTypeNode(node, elementType) {
+ return node.elementType !== elementType
+ ? update(createArrayTypeNode(elementType), node)
+ : node;
}
- function token() {
- return currentToken;
+ function createTupleTypeNode(elements) {
+ var node = createBaseNode(179);
+ node.elements = createNodeArray(elements);
+ node.transformFlags = 1;
+ return node;
}
- function nextTokenWithoutCheck() {
- return currentToken = scanner.scan();
+ function updateTupleTypeNode(node, elements) {
+ return node.elements !== elements
+ ? update(createTupleTypeNode(elements), node)
+ : node;
}
- function nextToken() {
- if (ts.isKeyword(currentToken) && (scanner.hasUnicodeEscape() || scanner.hasExtendedUnicodeEscape())) {
- parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), ts.Diagnostics.Keywords_cannot_contain_escape_characters);
- }
- return nextTokenWithoutCheck();
+ function createNamedTupleMember(dotDotDotToken, name, questionToken, type) {
+ var node = createBaseNode(192);
+ node.dotDotDotToken = dotDotDotToken;
+ node.name = name;
+ node.questionToken = questionToken;
+ node.type = type;
+ node.transformFlags = 1;
+ return node;
}
- function nextTokenJSDoc() {
- return currentToken = scanner.scanJsDocToken();
+ 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) {
+ var node = createBaseNode(180);
+ node.type = parenthesizerRules().parenthesizeElementTypeOfArrayType(type);
+ node.transformFlags = 1;
+ return node;
}
- function reScanGreaterToken() {
- return currentToken = scanner.reScanGreaterToken();
+ function updateOptionalTypeNode(node, type) {
+ return node.type !== type
+ ? update(createOptionalTypeNode(type), node)
+ : node;
}
- function reScanSlashToken() {
- return currentToken = scanner.reScanSlashToken();
+ function createRestTypeNode(type) {
+ var node = createBaseNode(181);
+ node.type = type;
+ node.transformFlags = 1;
+ return node;
}
- function reScanTemplateToken(isTaggedTemplate) {
- return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
+ function updateRestTypeNode(node, type) {
+ return node.type !== type
+ ? update(createRestTypeNode(type), node)
+ : node;
}
- function reScanTemplateHeadOrNoSubstitutionTemplate() {
- return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
+ function createUnionOrIntersectionTypeNode(kind, types) {
+ var node = createBaseNode(kind);
+ node.types = parenthesizerRules().parenthesizeConstituentTypesOfUnionOrIntersectionType(types);
+ node.transformFlags = 1;
+ return node;
}
- function reScanLessThanToken() {
- return currentToken = scanner.reScanLessThanToken();
+ function updateUnionOrIntersectionTypeNode(node, types) {
+ return node.types !== types
+ ? update(createUnionOrIntersectionTypeNode(node.kind, types), node)
+ : node;
}
- function scanJsxIdentifier() {
- return currentToken = scanner.scanJsxIdentifier();
+ function createUnionTypeNode(types) {
+ return createUnionOrIntersectionTypeNode(182, types);
}
- function scanJsxText() {
- return currentToken = scanner.scanJsxToken();
+ function updateUnionTypeNode(node, types) {
+ return updateUnionOrIntersectionTypeNode(node, types);
}
- function scanJsxAttributeValue() {
- return currentToken = scanner.scanJsxAttributeValue();
+ function createIntersectionTypeNode(types) {
+ return createUnionOrIntersectionTypeNode(183, types);
}
- function speculationHelper(callback, isLookAhead) {
- var saveToken = currentToken;
- var saveParseDiagnosticsLength = parseDiagnostics.length;
- var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
- var saveContextFlags = contextFlags;
- var result = isLookAhead
- ? scanner.lookAhead(callback)
- : scanner.tryScan(callback);
- ts.Debug.assert(saveContextFlags === contextFlags);
- if (!result || isLookAhead) {
- currentToken = saveToken;
- parseDiagnostics.length = saveParseDiagnosticsLength;
- parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
- }
- return result;
+ function updateIntersectionTypeNode(node, types) {
+ return updateUnionOrIntersectionTypeNode(node, types);
}
- function lookAhead(callback) {
- return speculationHelper(callback, true);
+ function createConditionalTypeNode(checkType, extendsType, trueType, falseType) {
+ var node = createBaseNode(184);
+ node.checkType = parenthesizerRules().parenthesizeMemberOfConditionalType(checkType);
+ node.extendsType = parenthesizerRules().parenthesizeMemberOfConditionalType(extendsType);
+ node.trueType = trueType;
+ node.falseType = falseType;
+ node.transformFlags = 1;
+ return node;
}
- function tryParse(callback) {
- return speculationHelper(callback, false);
+ 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) {
+ var node = createBaseNode(185);
+ node.typeParameter = typeParameter;
+ node.transformFlags = 1;
+ return node;
}
- function isIdentifier() {
- if (token() === 75) {
- return true;
- }
- if (token() === 121 && inYieldContext()) {
- return false;
- }
- if (token() === 127 && inAwaitContext()) {
- return false;
- }
- return token() > 112;
+ function updateInferTypeNode(node, typeParameter) {
+ return node.typeParameter !== typeParameter
+ ? update(createInferTypeNode(typeParameter), node)
+ : node;
}
- function parseExpected(kind, diagnosticMessage, shouldAdvance) {
- if (shouldAdvance === void 0) { shouldAdvance = true; }
- if (token() === kind) {
- if (shouldAdvance) {
- nextToken();
- }
- return true;
- }
- if (diagnosticMessage) {
- parseErrorAtCurrentToken(diagnosticMessage);
- }
- else {
- parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind));
- }
- return false;
+ function createTemplateLiteralType(head, templateSpans) {
+ var node = createBaseNode(193);
+ node.head = head;
+ node.templateSpans = createNodeArray(templateSpans);
+ node.transformFlags = 1;
+ return node;
}
- function parseExpectedJSDoc(kind) {
- if (token() === kind) {
- nextTokenJSDoc();
- return true;
- }
- parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind));
- return false;
+ function updateTemplateLiteralType(node, head, templateSpans) {
+ return node.head !== head
+ || node.templateSpans !== templateSpans
+ ? update(createTemplateLiteralType(head, templateSpans), node)
+ : node;
+ }
+ function createImportTypeNode(argument, qualifier, typeArguments, isTypeOf) {
+ if (isTypeOf === void 0) { isTypeOf = false; }
+ var node = createBaseNode(195);
+ node.argument = argument;
+ node.qualifier = qualifier;
+ node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
+ node.isTypeOf = isTypeOf;
+ node.transformFlags = 1;
+ return node;
}
- function parseOptional(t) {
- if (token() === t) {
- nextToken();
- return true;
- }
- return false;
+ function updateImportTypeNode(node, argument, qualifier, typeArguments, isTypeOf) {
+ if (isTypeOf === void 0) { isTypeOf = node.isTypeOf; }
+ return node.argument !== argument
+ || node.qualifier !== qualifier
+ || node.typeArguments !== typeArguments
+ || node.isTypeOf !== isTypeOf
+ ? update(createImportTypeNode(argument, qualifier, typeArguments, isTypeOf), node)
+ : node;
+ }
+ function createParenthesizedType(type) {
+ var node = createBaseNode(186);
+ node.type = type;
+ node.transformFlags = 1;
+ return node;
}
- function parseOptionalToken(t) {
- if (token() === t) {
- return parseTokenNode();
- }
- return undefined;
+ function updateParenthesizedType(node, type) {
+ return node.type !== type
+ ? update(createParenthesizedType(type), node)
+ : node;
}
- function parseOptionalTokenJSDoc(t) {
- if (token() === t) {
- return parseTokenNodeJSDoc();
- }
- return undefined;
+ function createThisTypeNode() {
+ var node = createBaseNode(187);
+ node.transformFlags = 1;
+ return node;
}
- function parseExpectedToken(t, diagnosticMessage, arg0) {
- return parseOptionalToken(t) ||
- createMissingNode(t, false, diagnosticMessage || ts.Diagnostics._0_expected, arg0 || ts.tokenToString(t));
+ function createTypeOperatorNode(operator, type) {
+ var node = createBaseNode(188);
+ node.operator = operator;
+ node.type = parenthesizerRules().parenthesizeMemberOfElementType(type);
+ node.transformFlags = 1;
+ return node;
}
- function parseExpectedTokenJSDoc(t) {
- return parseOptionalTokenJSDoc(t) ||
- createMissingNode(t, false, ts.Diagnostics._0_expected, ts.tokenToString(t));
+ function updateTypeOperatorNode(node, type) {
+ return node.type !== type
+ ? update(createTypeOperatorNode(node.operator, type), node)
+ : node;
}
- function parseTokenNode() {
- var node = createNode(token());
- nextToken();
- return finishNode(node);
+ function createIndexedAccessTypeNode(objectType, indexType) {
+ var node = createBaseNode(189);
+ node.objectType = parenthesizerRules().parenthesizeMemberOfElementType(objectType);
+ node.indexType = indexType;
+ node.transformFlags = 1;
+ return node;
}
- function parseTokenNodeJSDoc() {
- var node = createNode(token());
- nextTokenJSDoc();
- return finishNode(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) {
+ var node = createBaseNode(190);
+ node.readonlyToken = readonlyToken;
+ node.typeParameter = typeParameter;
+ node.nameType = nameType;
+ node.questionToken = questionToken;
+ node.type = type;
+ node.transformFlags = 1;
+ return node;
}
- function canParseSemicolon() {
- if (token() === 26) {
- return true;
- }
- return token() === 19 || token() === 1 || scanner.hasPrecedingLineBreak();
+ function updateMappedTypeNode(node, readonlyToken, typeParameter, nameType, questionToken, type) {
+ return node.readonlyToken !== readonlyToken
+ || node.typeParameter !== typeParameter
+ || node.nameType !== nameType
+ || node.questionToken !== questionToken
+ || node.type !== type
+ ? update(createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type), node)
+ : node;
+ }
+ function createLiteralTypeNode(literal) {
+ var node = createBaseNode(191);
+ node.literal = literal;
+ node.transformFlags = 1;
+ return node;
}
- function parseSemicolon() {
- if (canParseSemicolon()) {
- if (token() === 26) {
- nextToken();
- }
- return true;
- }
- else {
- return parseExpected(26);
+ function updateLiteralTypeNode(node, literal) {
+ return node.literal !== literal
+ ? update(createLiteralTypeNode(literal), node)
+ : node;
+ }
+ function createObjectBindingPattern(elements) {
+ var node = createBaseNode(196);
+ node.elements = createNodeArray(elements);
+ node.transformFlags |=
+ propagateChildrenFlags(node.elements) |
+ 256 |
+ 131072;
+ if (node.transformFlags & 8192) {
+ node.transformFlags |=
+ 32 |
+ 16384;
}
+ return node;
}
- function createNode(kind, pos) {
- nodeCount++;
- var p = pos >= 0 ? pos : scanner.getStartPos();
- return ts.isNodeKind(kind) || kind === 0 ? new NodeConstructor(kind, p, p) :
- kind === 75 ? new IdentifierConstructor(kind, p, p) :
- kind === 76 ? new PrivateIdentifierConstructor(kind, p, p) :
- new TokenConstructor(kind, p, p);
+ function updateObjectBindingPattern(node, elements) {
+ return node.elements !== elements
+ ? update(createObjectBindingPattern(elements), node)
+ : node;
+ }
+ function createArrayBindingPattern(elements) {
+ var node = createBaseNode(197);
+ node.elements = createNodeArray(elements);
+ node.transformFlags |=
+ propagateChildrenFlags(node.elements) |
+ 256 |
+ 131072;
+ return node;
}
- function createNodeWithJSDoc(kind, pos) {
- var node = createNode(kind, pos);
- if (scanner.getTokenFlags() & 2 && (kind !== 226 || token() !== 20)) {
- addJSDocComment(node);
+ function updateArrayBindingPattern(node, elements) {
+ return node.elements !== elements
+ ? update(createArrayBindingPattern(elements), node)
+ : node;
+ }
+ function createBindingElement(dotDotDotToken, propertyName, name, initializer) {
+ var node = createBaseBindingLikeDeclaration(198, undefined, undefined, name, initializer);
+ node.propertyName = asName(propertyName);
+ node.dotDotDotToken = dotDotDotToken;
+ node.transformFlags |=
+ propagateChildFlags(node.dotDotDotToken) |
+ 256;
+ if (node.propertyName) {
+ node.transformFlags |= ts.isIdentifier(node.propertyName) ?
+ propagateIdentifierNameFlags(node.propertyName) :
+ propagateChildFlags(node.propertyName);
}
+ if (dotDotDotToken)
+ node.transformFlags |= 8192;
return node;
}
- function createNodeArray(elements, pos, end) {
- var length = elements.length;
- var array = (length >= 1 && length <= 4 ? elements.slice() : elements);
- array.pos = pos;
- array.end = end === undefined ? scanner.getStartPos() : end;
- return array;
+ 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 finishNode(node, end) {
- node.end = end === undefined ? scanner.getStartPos() : end;
- if (contextFlags) {
- node.flags |= contextFlags;
+ function createBaseExpression(kind) {
+ var node = createBaseNode(kind);
+ return node;
+ }
+ function createArrayLiteralExpression(elements, multiLine) {
+ var node = createBaseExpression(199);
+ node.elements = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(createNodeArray(elements));
+ 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) {
+ var node = createBaseExpression(200);
+ 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) {
+ var node = createBaseExpression(201);
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ node.name = asName(name);
+ node.transformFlags =
+ propagateChildFlags(node.expression) |
+ (ts.isIdentifier(node.name) ?
+ propagateIdentifierNameFlags(node.name) :
+ propagateChildFlags(node.name));
+ if (ts.isSuperKeyword(expression)) {
+ node.transformFlags |=
+ 64 |
+ 32;
}
- if (parseErrorBeforeNextFinishedNode) {
- parseErrorBeforeNextFinishedNode = false;
- node.flags |= 65536;
+ return node;
+ }
+ function updatePropertyAccessExpression(node, expression, name) {
+ if (ts.isPropertyAccessChain(node)) {
+ return updatePropertyAccessChain(node, expression, node.questionDotToken, ts.cast(name, ts.isIdentifier));
+ }
+ return node.expression !== expression
+ || node.name !== name
+ ? update(createPropertyAccessExpression(expression, name), node)
+ : node;
+ }
+ function createPropertyAccessChain(expression, questionDotToken, name) {
+ var node = createBaseExpression(201);
+ node.flags |= 32;
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ node.questionDotToken = questionDotToken;
+ node.name = asName(name);
+ node.transformFlags |=
+ 8 |
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.questionDotToken) |
+ (ts.isIdentifier(node.name) ?
+ propagateIdentifierNameFlags(node.name) :
+ propagateChildFlags(node.name));
+ return node;
+ }
+ function updatePropertyAccessChain(node, expression, questionDotToken, name) {
+ ts.Debug.assert(!!(node.flags & 32), "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) {
+ var node = createBaseExpression(202);
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ node.argumentExpression = asExpression(index);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.argumentExpression);
+ if (ts.isSuperKeyword(expression)) {
+ node.transformFlags |=
+ 64 |
+ 32;
}
return node;
}
- function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
- if (reportAtCurrentPosition) {
- parseErrorAtPosition(scanner.getStartPos(), 0, diagnosticMessage, arg0);
+ function updateElementAccessExpression(node, expression, argumentExpression) {
+ if (ts.isElementAccessChain(node)) {
+ return updateElementAccessChain(node, expression, node.questionDotToken, argumentExpression);
+ }
+ return node.expression !== expression
+ || node.argumentExpression !== argumentExpression
+ ? update(createElementAccessExpression(expression, argumentExpression), node)
+ : node;
+ }
+ function createElementAccessChain(expression, questionDotToken, index) {
+ var node = createBaseExpression(202);
+ node.flags |= 32;
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ node.questionDotToken = questionDotToken;
+ node.argumentExpression = asExpression(index);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.questionDotToken) |
+ propagateChildFlags(node.argumentExpression) |
+ 8;
+ return node;
+ }
+ function updateElementAccessChain(node, expression, questionDotToken, argumentExpression) {
+ ts.Debug.assert(!!(node.flags & 32), "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) {
+ var node = createBaseExpression(203);
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ 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;
}
- else if (diagnosticMessage) {
- parseErrorAtCurrentToken(diagnosticMessage, arg0);
+ if (ts.isImportKeyword(node.expression)) {
+ node.transformFlags |= 2097152;
}
- var result = createNode(kind);
- if (kind === 75) {
- result.escapedText = "";
+ else if (ts.isSuperProperty(node.expression)) {
+ node.transformFlags |= 4096;
+ }
+ return node;
+ }
+ function updateCallExpression(node, expression, typeArguments, argumentsArray) {
+ if (ts.isCallChain(node)) {
+ return updateCallChain(node, expression, node.questionDotToken, typeArguments, argumentsArray);
+ }
+ return node.expression !== expression
+ || node.typeArguments !== typeArguments
+ || node.arguments !== argumentsArray
+ ? update(createCallExpression(expression, typeArguments, argumentsArray), node)
+ : node;
+ }
+ function createCallChain(expression, questionDotToken, typeArguments, argumentsArray) {
+ var node = createBaseExpression(203);
+ node.flags |= 32;
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ 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) |
+ 8;
+ if (node.typeArguments) {
+ node.transformFlags |= 1;
}
- else if (ts.isLiteralKind(kind) || ts.isTemplateLiteralKind(kind)) {
- result.text = "";
+ if (ts.isSuperProperty(node.expression)) {
+ node.transformFlags |= 4096;
}
- return finishNode(result);
+ return node;
}
- function internIdentifier(text) {
- var identifier = identifiers.get(text);
- if (identifier === undefined) {
- identifiers.set(text, identifier = text);
+ function updateCallChain(node, expression, questionDotToken, typeArguments, argumentsArray) {
+ ts.Debug.assert(!!(node.flags & 32), "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) {
+ var node = createBaseExpression(204);
+ node.expression = parenthesizerRules().parenthesizeExpressionOfNew(expression);
+ node.typeArguments = asNodeArray(typeArguments);
+ node.arguments = argumentsArray ? parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(argumentsArray) : undefined;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildrenFlags(node.typeArguments) |
+ propagateChildrenFlags(node.arguments) |
+ 8;
+ if (node.typeArguments) {
+ node.transformFlags |= 1;
}
- return identifier;
+ return node;
}
- function createIdentifier(isIdentifier, diagnosticMessage, privateIdentifierDiagnosticMessage) {
- identifierCount++;
- if (isIdentifier) {
- var node = createNode(75);
- if (token() !== 75) {
- node.originalKeywordKind = token();
- }
- node.escapedText = ts.escapeLeadingUnderscores(internIdentifier(scanner.getTokenValue()));
- nextTokenWithoutCheck();
- return finishNode(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) {
+ var node = createBaseExpression(205);
+ node.tag = parenthesizerRules().parenthesizeLeftSideOfAccess(tag);
+ node.typeArguments = asNodeArray(typeArguments);
+ node.template = template;
+ node.transformFlags |=
+ propagateChildFlags(node.tag) |
+ propagateChildrenFlags(node.typeArguments) |
+ propagateChildFlags(node.template) |
+ 256;
+ if (node.typeArguments) {
+ node.transformFlags |= 1;
}
- if (token() === 76) {
- parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage || ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
- return createIdentifier(true);
+ if (ts.hasInvalidEscape(node.template)) {
+ node.transformFlags |= 32;
}
- var reportAtCurrentPosition = token() === 1;
- var isReservedWord = scanner.isReservedWord();
- var msgArg = scanner.getTokenText();
- var defaultMessage = isReservedWord ?
- ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here :
- ts.Diagnostics.Identifier_expected;
- return createMissingNode(75, reportAtCurrentPosition, diagnosticMessage || defaultMessage, msgArg);
+ return node;
}
- function parseIdentifier(diagnosticMessage, privateIdentifierDiagnosticMessage) {
- return createIdentifier(isIdentifier(), diagnosticMessage, privateIdentifierDiagnosticMessage);
+ 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) {
+ var node = createBaseExpression(206);
+ node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
+ node.type = type;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.type) |
+ 1;
+ return node;
}
- function parseIdentifierName(diagnosticMessage) {
- return createIdentifier(ts.tokenIsIdentifierOrKeyword(token()), diagnosticMessage);
+ function updateTypeAssertion(node, type, expression) {
+ return node.type !== type
+ || node.expression !== expression
+ ? update(createTypeAssertion(type, expression), node)
+ : node;
}
- function isLiteralPropertyName() {
- return ts.tokenIsIdentifierOrKeyword(token()) ||
- token() === 10 ||
- token() === 8;
+ function createParenthesizedExpression(expression) {
+ var node = createBaseExpression(207);
+ node.expression = expression;
+ node.transformFlags = propagateChildFlags(node.expression);
+ return node;
}
- function parsePropertyNameWorker(allowComputedPropertyNames) {
- if (token() === 10 || token() === 8) {
- var node = parseLiteralNode();
- node.text = internIdentifier(node.text);
- return node;
+ function updateParenthesizedExpression(node, expression) {
+ return node.expression !== expression
+ ? update(createParenthesizedExpression(expression), node)
+ : node;
+ }
+ function createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
+ var node = createBaseFunctionLikeDeclaration(208, undefined, modifiers, name, typeParameters, parameters, type, body);
+ node.asteriskToken = asteriskToken;
+ node.transformFlags |= propagateChildFlags(node.asteriskToken);
+ if (node.typeParameters) {
+ node.transformFlags |= 1;
}
- if (allowComputedPropertyNames && token() === 22) {
- return parseComputedPropertyName();
+ if (ts.modifiersToFlags(node.modifiers) & 256) {
+ if (node.asteriskToken) {
+ node.transformFlags |= 32;
+ }
+ else {
+ node.transformFlags |= 64;
+ }
}
- if (token() === 76) {
- return parsePrivateIdentifier();
+ else if (node.asteriskToken) {
+ node.transformFlags |= 512;
}
- return parseIdentifierName();
+ return node;
}
- function parsePropertyName() {
- return parsePropertyNameWorker(true);
+ 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
+ ? updateBaseFunctionLikeDeclaration(createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body), node)
+ : node;
+ }
+ function createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) {
+ var node = createBaseFunctionLikeDeclaration(209, undefined, modifiers, undefined, typeParameters, parameters, type, parenthesizerRules().parenthesizeConciseBodyOfArrowFunction(body));
+ node.equalsGreaterThanToken = equalsGreaterThanToken !== null && equalsGreaterThanToken !== void 0 ? equalsGreaterThanToken : createToken(38);
+ node.transformFlags |=
+ propagateChildFlags(node.equalsGreaterThanToken) |
+ 256;
+ if (ts.modifiersToFlags(node.modifiers) & 256) {
+ node.transformFlags |= 64;
+ }
+ return node;
}
- function parseComputedPropertyName() {
- var node = createNode(154);
- parseExpected(22);
- node.expression = allowInAnd(parseExpression);
- parseExpected(23);
- return finishNode(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
+ ? updateBaseFunctionLikeDeclaration(createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body), node)
+ : node;
+ }
+ function createDeleteExpression(expression) {
+ var node = createBaseExpression(210);
+ node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
+ node.transformFlags |= propagateChildFlags(node.expression);
+ return node;
}
- function internPrivateIdentifier(text) {
- var privateIdentifier = privateIdentifiers.get(text);
- if (privateIdentifier === undefined) {
- privateIdentifiers.set(text, privateIdentifier = text);
- }
- return privateIdentifier;
+ function updateDeleteExpression(node, expression) {
+ return node.expression !== expression
+ ? update(createDeleteExpression(expression), node)
+ : node;
}
- function parsePrivateIdentifier() {
- var node = createNode(76);
- node.escapedText = ts.escapeLeadingUnderscores(internPrivateIdentifier(scanner.getTokenText()));
- nextToken();
- return finishNode(node);
+ function createTypeOfExpression(expression) {
+ var node = createBaseExpression(211);
+ node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
+ node.transformFlags |= propagateChildFlags(node.expression);
+ return node;
}
- function parseContextualModifier(t) {
- return token() === t && tryParse(nextTokenCanFollowModifier);
+ function updateTypeOfExpression(node, expression) {
+ return node.expression !== expression
+ ? update(createTypeOfExpression(expression), node)
+ : node;
}
- function nextTokenIsOnSameLineAndCanFollowModifier() {
- nextToken();
- if (scanner.hasPrecedingLineBreak()) {
- return false;
- }
- return canFollowModifier();
+ function createVoidExpression(expression) {
+ var node = createBaseExpression(212);
+ node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
+ node.transformFlags |= propagateChildFlags(node.expression);
+ return node;
}
- function nextTokenCanFollowModifier() {
- switch (token()) {
- case 81:
- return nextToken() === 88;
- case 89:
- nextToken();
- if (token() === 84) {
- return lookAhead(nextTokenCanFollowDefaultKeyword);
- }
- if (token() === 145) {
- return lookAhead(nextTokenCanFollowExportModifier);
- }
- return canFollowExportModifier();
- case 84:
- return nextTokenCanFollowDefaultKeyword();
- case 120:
- case 131:
- case 142:
- nextToken();
- return canFollowModifier();
- default:
- return nextTokenIsOnSameLineAndCanFollowModifier();
- }
+ function updateVoidExpression(node, expression) {
+ return node.expression !== expression
+ ? update(createVoidExpression(expression), node)
+ : node;
+ }
+ function createAwaitExpression(expression) {
+ var node = createBaseExpression(213);
+ node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 64 |
+ 32 |
+ 524288;
+ return node;
}
- function canFollowExportModifier() {
- return token() !== 41
- && token() !== 123
- && token() !== 18
- && canFollowModifier();
+ function updateAwaitExpression(node, expression) {
+ return node.expression !== expression
+ ? update(createAwaitExpression(expression), node)
+ : node;
}
- function nextTokenCanFollowExportModifier() {
- nextToken();
- return canFollowExportModifier();
+ function createPrefixUnaryExpression(operator, operand) {
+ var node = createBaseExpression(214);
+ node.operator = operator;
+ node.operand = parenthesizerRules().parenthesizeOperandOfPrefixUnary(operand);
+ node.transformFlags |= propagateChildFlags(node.operand);
+ return node;
}
- function parseAnyContextualModifier() {
- return ts.isModifierKind(token()) && tryParse(nextTokenCanFollowModifier);
+ function updatePrefixUnaryExpression(node, operand) {
+ return node.operand !== operand
+ ? update(createPrefixUnaryExpression(node.operator, operand), node)
+ : node;
}
- function canFollowModifier() {
- return token() === 22
- || token() === 18
- || token() === 41
- || token() === 25
- || isLiteralPropertyName();
+ function createPostfixUnaryExpression(operand, operator) {
+ var node = createBaseExpression(215);
+ node.operator = operator;
+ node.operand = parenthesizerRules().parenthesizeOperandOfPostfixUnary(operand);
+ node.transformFlags = propagateChildFlags(node.operand);
+ return node;
}
- function nextTokenCanFollowDefaultKeyword() {
- nextToken();
- return token() === 80 || token() === 94 ||
- token() === 114 ||
- (token() === 122 && lookAhead(nextTokenIsClassKeywordOnSameLine)) ||
- (token() === 126 && lookAhead(nextTokenIsFunctionKeywordOnSameLine));
+ function updatePostfixUnaryExpression(node, operand) {
+ return node.operand !== operand
+ ? update(createPostfixUnaryExpression(operand, node.operator), node)
+ : node;
}
- function isListElement(parsingContext, inErrorRecovery) {
- var node = currentNode(parsingContext);
- if (node) {
- return true;
+ function createBinaryExpression(left, operator, right) {
+ var node = createBaseExpression(216);
+ var operatorToken = asToken(operator);
+ var operatorKind = operatorToken.kind;
+ node.left = parenthesizerRules().parenthesizeLeftSideOfBinary(operatorKind, left);
+ node.operatorToken = operatorToken;
+ node.right = parenthesizerRules().parenthesizeRightSideOfBinary(operatorKind, node.left, right);
+ node.transformFlags |=
+ propagateChildFlags(node.left) |
+ propagateChildFlags(node.operatorToken) |
+ propagateChildFlags(node.right);
+ if (operatorKind === 60) {
+ node.transformFlags |= 8;
+ }
+ else if (operatorKind === 62) {
+ if (ts.isObjectLiteralExpression(node.left)) {
+ node.transformFlags |=
+ 256 |
+ 32 |
+ 1024 |
+ propagateAssignmentPatternFlags(node.left);
+ }
+ else if (ts.isArrayLiteralExpression(node.left)) {
+ node.transformFlags |=
+ 256 |
+ 1024 |
+ propagateAssignmentPatternFlags(node.left);
+ }
+ }
+ else if (operatorKind === 42 || operatorKind === 66) {
+ node.transformFlags |= 128;
+ }
+ else if (ts.isLogicalOrCoalescingAssignmentOperator(operatorKind)) {
+ node.transformFlags |= 4;
}
- switch (parsingContext) {
- case 0:
- case 1:
- case 3:
- return !(token() === 26 && inErrorRecovery) && isStartOfStatement();
- case 2:
- return token() === 78 || token() === 84;
- case 4:
- return lookAhead(isTypeMemberStart);
- case 5:
- return lookAhead(isClassMemberStart) || (token() === 26 && !inErrorRecovery);
- case 6:
- return token() === 22 || isLiteralPropertyName();
- case 12:
- switch (token()) {
- case 22:
- case 41:
- case 25:
- case 24:
- return true;
- default:
- return isLiteralPropertyName();
- }
- case 18:
- return isLiteralPropertyName();
- case 9:
- return token() === 22 || token() === 25 || isLiteralPropertyName();
- case 7:
- if (token() === 18) {
- return lookAhead(isValidHeritageClauseObjectLiteral);
- }
- if (!inErrorRecovery) {
- return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
- }
- else {
- return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword();
- }
- case 8:
- return isIdentifierOrPrivateIdentifierOrPattern();
- case 10:
- return token() === 27 || token() === 25 || isIdentifierOrPrivateIdentifierOrPattern();
- case 19:
- return isIdentifier();
- case 15:
- switch (token()) {
- case 27:
- case 24:
- return true;
+ return node;
+ }
+ function propagateAssignmentPatternFlags(node) {
+ if (node.transformFlags & 16384)
+ return 16384;
+ if (node.transformFlags & 32) {
+ for (var _i = 0, _a = ts.getElementsOfBindingOrAssignmentPattern(node); _i < _a.length; _i++) {
+ var element = _a[_i];
+ var target = ts.getTargetOfBindingOrAssignmentElement(element);
+ if (target && ts.isAssignmentPattern(target)) {
+ if (target.transformFlags & 16384) {
+ return 16384;
+ }
+ if (target.transformFlags & 32) {
+ var flags_1 = propagateAssignmentPatternFlags(target);
+ if (flags_1)
+ return flags_1;
+ }
}
- case 11:
- return token() === 25 || isStartOfExpression();
- case 16:
- return isStartOfParameter(false);
- case 17:
- return isStartOfParameter(true);
- case 20:
- case 21:
- return token() === 27 || isStartOfType();
- case 22:
- return isHeritageClause();
- case 23:
- return ts.tokenIsIdentifierOrKeyword(token());
- case 13:
- return ts.tokenIsIdentifierOrKeyword(token()) || token() === 18;
- case 14:
- return true;
+ }
}
- return ts.Debug.fail("Non-exhaustive case in 'isListElement'.");
+ return 0;
}
- function isValidHeritageClauseObjectLiteral() {
- ts.Debug.assert(token() === 18);
- if (nextToken() === 19) {
- var next = nextToken();
- return next === 27 || next === 18 || next === 90 || next === 113;
- }
- return true;
+ 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) {
+ var node = createBaseExpression(217);
+ node.condition = parenthesizerRules().parenthesizeConditionOfConditionalExpression(condition);
+ node.questionToken = questionToken !== null && questionToken !== void 0 ? questionToken : createToken(57);
+ node.whenTrue = parenthesizerRules().parenthesizeBranchOfConditionalExpression(whenTrue);
+ node.colonToken = colonToken !== null && colonToken !== void 0 ? colonToken : createToken(58);
+ 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 nextTokenIsIdentifier() {
- nextToken();
- return isIdentifier();
+ 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) {
+ var node = createBaseExpression(218);
+ node.head = head;
+ node.templateSpans = createNodeArray(templateSpans);
+ node.transformFlags |=
+ propagateChildFlags(node.head) |
+ propagateChildrenFlags(node.templateSpans) |
+ 256;
+ return node;
}
- function nextTokenIsIdentifierOrKeyword() {
- nextToken();
- return ts.tokenIsIdentifierOrKeyword(token());
+ function updateTemplateExpression(node, head, templateSpans) {
+ return node.head !== head
+ || node.templateSpans !== templateSpans
+ ? update(createTemplateExpression(head, templateSpans), node)
+ : node;
}
- function nextTokenIsIdentifierOrKeywordOrGreaterThan() {
- nextToken();
- return ts.tokenIsIdentifierOrKeywordOrGreaterThan(token());
+ function createTemplateLiteralLikeNodeChecked(kind, text, rawText, templateFlags) {
+ if (templateFlags === void 0) { templateFlags = 0; }
+ ts.Debug.assert(!(templateFlags & ~2048), "Unsupported template flags.");
+ var cooked = undefined;
+ if (rawText !== undefined && rawText !== text) {
+ cooked = getCookedText(kind, rawText);
+ if (typeof cooked === "object") {
+ return ts.Debug.fail("Invalid raw text");
+ }
+ }
+ if (text === undefined) {
+ if (cooked === undefined) {
+ return ts.Debug.fail("Arguments 'text' and 'rawText' may not both be undefined.");
+ }
+ text = cooked;
+ }
+ else if (cooked !== undefined) {
+ ts.Debug.assert(text === cooked, "Expected argument 'text' to be the normalized (i.e. 'cooked') version of argument 'rawText'.");
+ }
+ return createTemplateLiteralLikeNode(kind, text, rawText, templateFlags);
}
- function isHeritageClauseExtendsOrImplementsKeyword() {
- if (token() === 113 ||
- token() === 90) {
- return lookAhead(nextTokenIsStartOfExpression);
+ function createTemplateLiteralLikeNode(kind, text, rawText, templateFlags) {
+ var node = createBaseToken(kind);
+ node.text = text;
+ node.rawText = rawText;
+ node.templateFlags = templateFlags & 2048;
+ node.transformFlags |= 256;
+ if (node.templateFlags) {
+ node.transformFlags |= 32;
}
- return false;
+ return node;
}
- function nextTokenIsStartOfExpression() {
- nextToken();
- return isStartOfExpression();
+ function createTemplateHead(text, rawText, templateFlags) {
+ return createTemplateLiteralLikeNodeChecked(15, text, rawText, templateFlags);
}
- function nextTokenIsStartOfType() {
- nextToken();
- return isStartOfType();
+ function createTemplateMiddle(text, rawText, templateFlags) {
+ return createTemplateLiteralLikeNodeChecked(16, text, rawText, templateFlags);
}
- function isListTerminator(kind) {
- if (token() === 1) {
- return true;
- }
- switch (kind) {
- case 1:
- case 2:
- case 4:
- case 5:
- case 6:
- case 12:
- case 9:
- case 23:
- return token() === 19;
- case 3:
- return token() === 19 || token() === 78 || token() === 84;
- case 7:
- return token() === 18 || token() === 90 || token() === 113;
- case 8:
- return isVariableDeclaratorListTerminator();
- case 19:
- return token() === 31 || token() === 20 || token() === 18 || token() === 90 || token() === 113;
- case 11:
- return token() === 21 || token() === 26;
- case 15:
- case 21:
- case 10:
- return token() === 23;
- case 17:
- case 16:
- case 18:
- return token() === 21 || token() === 23;
- case 20:
- return token() !== 27;
- case 22:
- return token() === 18 || token() === 19;
- case 13:
- return token() === 31 || token() === 43;
- case 14:
- return token() === 29 && lookAhead(nextTokenIsSlash);
- default:
- return false;
- }
+ function createTemplateTail(text, rawText, templateFlags) {
+ return createTemplateLiteralLikeNodeChecked(17, text, rawText, templateFlags);
}
- function isVariableDeclaratorListTerminator() {
- if (canParseSemicolon()) {
- return true;
- }
- if (isInOrOfKeyword(token())) {
- return true;
- }
- if (token() === 38) {
- return true;
- }
- return false;
+ function createNoSubstitutionTemplateLiteral(text, rawText, templateFlags) {
+ return createTemplateLiteralLikeNodeChecked(14, text, rawText, templateFlags);
}
- function isInSomeParsingContext() {
- for (var kind = 0; kind < 24; kind++) {
- if (parsingContext & (1 << kind)) {
- if (isListElement(kind, true) || isListTerminator(kind)) {
- return true;
- }
- }
- }
- return false;
+ function createYieldExpression(asteriskToken, expression) {
+ ts.Debug.assert(!asteriskToken || !!expression, "A `YieldExpression` with an asteriskToken must have an expression.");
+ var node = createBaseExpression(219);
+ node.expression = expression && parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
+ node.asteriskToken = asteriskToken;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.asteriskToken) |
+ 256 |
+ 32 |
+ 262144;
+ return node;
}
- function parseList(kind, parseElement) {
- var saveParsingContext = parsingContext;
- parsingContext |= 1 << kind;
- var list = [];
- var listPos = getNodePos();
- while (!isListTerminator(kind)) {
- if (isListElement(kind, false)) {
- var element = parseListElement(kind, parseElement);
- list.push(element);
- continue;
- }
- if (abortParsingListOrMoveToNextToken(kind)) {
+ function updateYieldExpression(node, asteriskToken, expression) {
+ return node.expression !== expression
+ || node.asteriskToken !== asteriskToken
+ ? update(createYieldExpression(asteriskToken, expression), node)
+ : node;
+ }
+ function createSpreadElement(expression) {
+ var node = createBaseExpression(220);
+ node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 256 |
+ 8192;
+ return node;
+ }
+ function updateSpreadElement(node, expression) {
+ return node.expression !== expression
+ ? update(createSpreadElement(expression), node)
+ : node;
+ }
+ function createClassExpression(decorators, modifiers, name, typeParameters, heritageClauses, members) {
+ var node = createBaseClassLikeDeclaration(221, decorators, modifiers, name, typeParameters, heritageClauses, members);
+ node.transformFlags |= 256;
+ return node;
+ }
+ function updateClassExpression(node, decorators, modifiers, name, typeParameters, heritageClauses, members) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.typeParameters !== typeParameters
+ || node.heritageClauses !== heritageClauses
+ || node.members !== members
+ ? update(createClassExpression(decorators, modifiers, name, typeParameters, heritageClauses, members), node)
+ : node;
+ }
+ function createOmittedExpression() {
+ return createBaseExpression(222);
+ }
+ function createExpressionWithTypeArguments(expression, typeArguments) {
+ var node = createBaseNode(223);
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildrenFlags(node.typeArguments) |
+ 256;
+ return node;
+ }
+ function updateExpressionWithTypeArguments(node, expression, typeArguments) {
+ return node.expression !== expression
+ || node.typeArguments !== typeArguments
+ ? update(createExpressionWithTypeArguments(expression, typeArguments), node)
+ : node;
+ }
+ function createAsExpression(expression, type) {
+ var node = createBaseExpression(224);
+ node.expression = expression;
+ node.type = type;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.type) |
+ 1;
+ return node;
+ }
+ function updateAsExpression(node, expression, type) {
+ return node.expression !== expression
+ || node.type !== type
+ ? update(createAsExpression(expression, type), node)
+ : node;
+ }
+ function createNonNullExpression(expression) {
+ var node = createBaseExpression(225);
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 1;
+ return node;
+ }
+ function updateNonNullExpression(node, expression) {
+ if (ts.isNonNullChain(node)) {
+ return updateNonNullChain(node, expression);
+ }
+ return node.expression !== expression
+ ? update(createNonNullExpression(expression), node)
+ : node;
+ }
+ function createNonNullChain(expression) {
+ var node = createBaseExpression(225);
+ node.flags |= 32;
+ node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 1;
+ return node;
+ }
+ function updateNonNullChain(node, expression) {
+ ts.Debug.assert(!!(node.flags & 32), "Cannot update a NonNullExpression using updateNonNullChain. Use updateNonNullExpression instead.");
+ return node.expression !== expression
+ ? update(createNonNullChain(expression), node)
+ : node;
+ }
+ function createMetaProperty(keywordToken, name) {
+ var node = createBaseExpression(226);
+ node.keywordToken = keywordToken;
+ node.name = name;
+ node.transformFlags |= propagateChildFlags(node.name);
+ switch (keywordToken) {
+ case 102:
+ node.transformFlags |= 256;
break;
- }
+ case 99:
+ node.transformFlags |= 4;
+ break;
+ default:
+ return ts.Debug.assertNever(keywordToken);
}
- parsingContext = saveParsingContext;
- return createNodeArray(list, listPos);
+ return node;
}
- function parseListElement(parsingContext, parseElement) {
- var node = currentNode(parsingContext);
- if (node) {
- return consumeNode(node);
- }
- return parseElement();
+ function updateMetaProperty(node, name) {
+ return node.name !== name
+ ? update(createMetaProperty(node.keywordToken, name), node)
+ : node;
}
- function currentNode(parsingContext) {
- if (!syntaxCursor || !isReusableParsingContext(parsingContext) || parseErrorBeforeNextFinishedNode) {
- return undefined;
- }
- var node = syntaxCursor.currentNode(scanner.getStartPos());
- if (ts.nodeIsMissing(node) || node.intersectsChange || ts.containsParseError(node)) {
- return undefined;
- }
- var nodeContextFlags = node.flags & 25358336;
- if (nodeContextFlags !== contextFlags) {
- return undefined;
- }
- if (!canReuseNode(node, parsingContext)) {
- return undefined;
- }
- if (node.jsDocCache) {
- node.jsDocCache = undefined;
- }
+ function createTemplateSpan(expression, literal) {
+ var node = createBaseNode(228);
+ node.expression = expression;
+ node.literal = literal;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.literal) |
+ 256;
return node;
}
- function consumeNode(node) {
- scanner.setTextPos(node.end);
- nextToken();
+ function updateTemplateSpan(node, expression, literal) {
+ return node.expression !== expression
+ || node.literal !== literal
+ ? update(createTemplateSpan(expression, literal), node)
+ : node;
+ }
+ function createSemicolonClassElement() {
+ var node = createBaseNode(229);
+ node.transformFlags |= 256;
return node;
}
- function isReusableParsingContext(parsingContext) {
- switch (parsingContext) {
- case 5:
- case 2:
- case 0:
- case 1:
- case 3:
- case 6:
- case 4:
- case 8:
- case 17:
- case 16:
- return true;
- }
- return false;
+ function createBlock(statements, multiLine) {
+ var node = createBaseNode(230);
+ node.statements = createNodeArray(statements);
+ node.multiLine = multiLine;
+ node.transformFlags |= propagateChildrenFlags(node.statements);
+ return node;
}
- function canReuseNode(node, parsingContext) {
- switch (parsingContext) {
- case 5:
- return isReusableClassMember(node);
- case 2:
- return isReusableSwitchClause(node);
- case 0:
- case 1:
- case 3:
- return isReusableStatement(node);
- case 6:
- return isReusableEnumMember(node);
- case 4:
- return isReusableTypeMember(node);
- case 8:
- return isReusableVariableDeclaration(node);
- case 17:
- case 16:
- return isReusableParameter(node);
- }
- return false;
+ function updateBlock(node, statements) {
+ return node.statements !== statements
+ ? update(createBlock(statements, node.multiLine), node)
+ : node;
}
- function isReusableClassMember(node) {
- if (node) {
- switch (node.kind) {
- case 162:
- case 167:
- case 163:
- case 164:
- case 159:
- case 222:
- return true;
- case 161:
- var methodDeclaration = node;
- var nameIsConstructor = methodDeclaration.name.kind === 75 &&
- methodDeclaration.name.originalKeywordKind === 129;
- return !nameIsConstructor;
- }
+ function createVariableStatement(modifiers, declarationList) {
+ var node = createBaseDeclaration(232, undefined, modifiers);
+ node.declarationList = ts.isArray(declarationList) ? createVariableDeclarationList(declarationList) : declarationList;
+ node.transformFlags |=
+ propagateChildFlags(node.declarationList);
+ if (ts.modifiersToFlags(node.modifiers) & 2) {
+ node.transformFlags = 1;
}
- return false;
+ return node;
}
- function isReusableSwitchClause(node) {
- if (node) {
- switch (node.kind) {
- case 277:
- case 278:
- return true;
- }
- }
- return false;
+ function updateVariableStatement(node, modifiers, declarationList) {
+ return node.modifiers !== modifiers
+ || node.declarationList !== declarationList
+ ? update(createVariableStatement(modifiers, declarationList), node)
+ : node;
}
- function isReusableStatement(node) {
- if (node) {
- switch (node.kind) {
- case 244:
- case 225:
- case 223:
- case 227:
- case 226:
- case 239:
- case 235:
- case 237:
- case 234:
- case 233:
- case 231:
- case 232:
- case 230:
- case 229:
- case 236:
- case 224:
- case 240:
- case 238:
- case 228:
- case 241:
- case 254:
- case 253:
- case 260:
- case 259:
- case 249:
- case 245:
- case 246:
- case 248:
- case 247:
- return true;
- }
- }
- return false;
+ function createEmptyStatement() {
+ return createBaseNode(231);
}
- function isReusableEnumMember(node) {
- return node.kind === 284;
+ function createExpressionStatement(expression) {
+ var node = createBaseNode(233);
+ node.expression = parenthesizerRules().parenthesizeExpressionOfExpressionStatement(expression);
+ node.transformFlags |= propagateChildFlags(node.expression);
+ return node;
}
- function isReusableTypeMember(node) {
- if (node) {
- switch (node.kind) {
- case 166:
- case 160:
- case 167:
- case 158:
- case 165:
- return true;
- }
- }
- return false;
+ function updateExpressionStatement(node, expression) {
+ return node.expression !== expression
+ ? update(createExpressionStatement(expression), node)
+ : node;
}
- function isReusableVariableDeclaration(node) {
- if (node.kind !== 242) {
- return false;
- }
- var variableDeclarator = node;
- return variableDeclarator.initializer === undefined;
+ function createIfStatement(expression, thenStatement, elseStatement) {
+ var node = createBaseNode(234);
+ 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 isReusableParameter(node) {
- if (node.kind !== 156) {
- return false;
- }
- var parameter = node;
- return parameter.initializer === undefined;
+ function updateIfStatement(node, expression, thenStatement, elseStatement) {
+ return node.expression !== expression
+ || node.thenStatement !== thenStatement
+ || node.elseStatement !== elseStatement
+ ? update(createIfStatement(expression, thenStatement, elseStatement), node)
+ : node;
}
- function abortParsingListOrMoveToNextToken(kind) {
- parseErrorAtCurrentToken(parsingContextErrors(kind));
- if (isInSomeParsingContext()) {
- return true;
- }
- nextToken();
- return false;
+ function createDoStatement(statement, expression) {
+ var node = createBaseNode(235);
+ node.statement = asEmbeddedStatement(statement);
+ node.expression = expression;
+ node.transformFlags |=
+ propagateChildFlags(node.statement) |
+ propagateChildFlags(node.expression);
+ return node;
}
- function parsingContextErrors(context) {
- switch (context) {
- case 0: return ts.Diagnostics.Declaration_or_statement_expected;
- case 1: return ts.Diagnostics.Declaration_or_statement_expected;
- case 2: return ts.Diagnostics.case_or_default_expected;
- case 3: return ts.Diagnostics.Statement_expected;
- case 18:
- case 4: return ts.Diagnostics.Property_or_signature_expected;
- case 5: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected;
- case 6: return ts.Diagnostics.Enum_member_expected;
- case 7: return ts.Diagnostics.Expression_expected;
- case 8: return ts.Diagnostics.Variable_declaration_expected;
- case 9: return ts.Diagnostics.Property_destructuring_pattern_expected;
- case 10: return ts.Diagnostics.Array_element_destructuring_pattern_expected;
- case 11: return ts.Diagnostics.Argument_expression_expected;
- case 12: return ts.Diagnostics.Property_assignment_expected;
- case 15: return ts.Diagnostics.Expression_or_comma_expected;
- case 17: return ts.Diagnostics.Parameter_declaration_expected;
- case 16: return ts.Diagnostics.Parameter_declaration_expected;
- case 19: return ts.Diagnostics.Type_parameter_declaration_expected;
- case 20: return ts.Diagnostics.Type_argument_expected;
- case 21: return ts.Diagnostics.Type_expected;
- case 22: return ts.Diagnostics.Unexpected_token_expected;
- case 23: return ts.Diagnostics.Identifier_expected;
- case 13: return ts.Diagnostics.Identifier_expected;
- case 14: return ts.Diagnostics.Identifier_expected;
- default: return undefined;
- }
+ function updateDoStatement(node, statement, expression) {
+ return node.statement !== statement
+ || node.expression !== expression
+ ? update(createDoStatement(statement, expression), node)
+ : node;
}
- function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
- var saveParsingContext = parsingContext;
- parsingContext |= 1 << kind;
- var list = [];
- var listPos = getNodePos();
- var commaStart = -1;
- while (true) {
- if (isListElement(kind, false)) {
- var startPos = scanner.getStartPos();
- list.push(parseListElement(kind, parseElement));
- commaStart = scanner.getTokenPos();
- if (parseOptional(27)) {
- continue;
- }
- commaStart = -1;
- if (isListTerminator(kind)) {
- break;
- }
- parseExpected(27, getExpectedCommaDiagnostic(kind));
- if (considerSemicolonAsDelimiter && token() === 26 && !scanner.hasPrecedingLineBreak()) {
- nextToken();
- }
- if (startPos === scanner.getStartPos()) {
- nextToken();
- }
- continue;
- }
- if (isListTerminator(kind)) {
- break;
- }
- if (abortParsingListOrMoveToNextToken(kind)) {
- break;
- }
- }
- parsingContext = saveParsingContext;
- var result = createNodeArray(list, listPos);
- if (commaStart >= 0) {
- result.hasTrailingComma = true;
- }
- return result;
+ function createWhileStatement(expression, statement) {
+ var node = createBaseNode(236);
+ node.expression = expression;
+ node.statement = asEmbeddedStatement(statement);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.statement);
+ return node;
}
- function getExpectedCommaDiagnostic(kind) {
- return kind === 6 ? ts.Diagnostics.An_enum_member_name_must_be_followed_by_a_or : undefined;
+ function updateWhileStatement(node, expression, statement) {
+ return node.expression !== expression
+ || node.statement !== statement
+ ? update(createWhileStatement(expression, statement), node)
+ : node;
+ }
+ function createForStatement(initializer, condition, incrementor, statement) {
+ var node = createBaseNode(237);
+ 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 createMissingList() {
- var list = createNodeArray([], getNodePos());
- list.isMissingList = true;
- return list;
+ 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) {
+ var node = createBaseNode(238);
+ node.initializer = initializer;
+ node.expression = expression;
+ node.statement = asEmbeddedStatement(statement);
+ node.transformFlags |=
+ propagateChildFlags(node.initializer) |
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.statement);
+ return node;
}
- function isMissingList(arr) {
- return !!arr.isMissingList;
+ 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) {
+ var node = createBaseNode(239);
+ 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) |
+ 256;
+ if (awaitModifier)
+ node.transformFlags |= 32;
+ return node;
}
- function parseBracketedList(kind, parseElement, open, close) {
- if (parseExpected(open)) {
- var result = parseDelimitedList(kind, parseElement);
- parseExpected(close);
- return result;
- }
- return createMissingList();
+ 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) {
+ var node = createBaseNode(240);
+ node.label = asName(label);
+ node.transformFlags |=
+ propagateChildFlags(node.label) |
+ 1048576;
+ return node;
}
- function parseEntityName(allowReservedWords, diagnosticMessage) {
- var entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage);
- var dotPos = scanner.getStartPos();
- while (parseOptional(24)) {
- if (token() === 29) {
- entity.jsdocDotPos = dotPos;
- break;
- }
- dotPos = scanner.getStartPos();
- entity = createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, false));
- }
- return entity;
+ function updateContinueStatement(node, label) {
+ return node.label !== label
+ ? update(createContinueStatement(label), node)
+ : node;
+ }
+ function createBreakStatement(label) {
+ var node = createBaseNode(241);
+ node.label = asName(label);
+ node.transformFlags |=
+ propagateChildFlags(node.label) |
+ 1048576;
+ return node;
}
- function createQualifiedName(entity, name) {
- var node = createNode(153, entity.pos);
- node.left = entity;
- node.right = name;
- return finishNode(node);
+ function updateBreakStatement(node, label) {
+ return node.label !== label
+ ? update(createBreakStatement(label), node)
+ : node;
}
- function parseRightSideOfDot(allowIdentifierNames, allowPrivateIdentifiers) {
- if (scanner.hasPrecedingLineBreak() && ts.tokenIsIdentifierOrKeyword(token())) {
- var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
- if (matchesPattern) {
- return createMissingNode(75, true, ts.Diagnostics.Identifier_expected);
- }
- }
- if (token() === 76) {
- var node = parsePrivateIdentifier();
- return allowPrivateIdentifiers ? node : createMissingNode(75, true, ts.Diagnostics.Identifier_expected);
- }
- return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
+ function createReturnStatement(expression) {
+ var node = createBaseNode(242);
+ node.expression = expression;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 32 |
+ 1048576;
+ return node;
}
- function parseTemplateExpression(isTaggedTemplate) {
- var template = createNode(211);
- template.head = parseTemplateHead(isTaggedTemplate);
- ts.Debug.assert(template.head.kind === 15, "Template head has wrong token kind");
- var list = [];
- var listPos = getNodePos();
- do {
- list.push(parseTemplateSpan(isTaggedTemplate));
- } while (ts.last(list).literal.kind === 16);
- template.templateSpans = createNodeArray(list, listPos);
- return finishNode(template);
+ function updateReturnStatement(node, expression) {
+ return node.expression !== expression
+ ? update(createReturnStatement(expression), node)
+ : node;
}
- function parseTemplateSpan(isTaggedTemplate) {
- var span = createNode(221);
- span.expression = allowInAnd(parseExpression);
- var literal;
- if (token() === 19) {
- reScanTemplateToken(isTaggedTemplate);
- literal = parseTemplateMiddleOrTemplateTail();
- }
- else {
- literal = parseExpectedToken(17, ts.Diagnostics._0_expected, ts.tokenToString(19));
- }
- span.literal = literal;
- return finishNode(span);
+ function createWithStatement(expression, statement) {
+ var node = createBaseNode(243);
+ node.expression = expression;
+ node.statement = asEmbeddedStatement(statement);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.statement);
+ return node;
}
- function parseLiteralNode() {
- return parseLiteralLikeNode(token());
+ function updateWithStatement(node, expression, statement) {
+ return node.expression !== expression
+ || node.statement !== statement
+ ? update(createWithStatement(expression, statement), node)
+ : node;
+ }
+ function createSwitchStatement(expression, caseBlock) {
+ var node = createBaseNode(244);
+ node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
+ node.caseBlock = caseBlock;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.caseBlock);
+ return node;
}
- function parseTemplateHead(isTaggedTemplate) {
- if (isTaggedTemplate) {
- reScanTemplateHeadOrNoSubstitutionTemplate();
- }
- var fragment = parseLiteralLikeNode(token());
- ts.Debug.assert(fragment.kind === 15, "Template head has wrong token kind");
- return fragment;
+ function updateSwitchStatement(node, expression, caseBlock) {
+ return node.expression !== expression
+ || node.caseBlock !== caseBlock
+ ? update(createSwitchStatement(expression, caseBlock), node)
+ : node;
+ }
+ function createLabeledStatement(label, statement) {
+ var node = createBaseNode(245);
+ node.label = asName(label);
+ node.statement = asEmbeddedStatement(statement);
+ node.transformFlags |=
+ propagateChildFlags(node.label) |
+ propagateChildFlags(node.statement);
+ return node;
}
- function parseTemplateMiddleOrTemplateTail() {
- var fragment = parseLiteralLikeNode(token());
- ts.Debug.assert(fragment.kind === 16 || fragment.kind === 17, "Template fragment has wrong token kind");
- return fragment;
+ function updateLabeledStatement(node, label, statement) {
+ return node.label !== label
+ || node.statement !== statement
+ ? update(createLabeledStatement(label, statement), node)
+ : node;
}
- function parseLiteralLikeNode(kind) {
- var node = createNode(kind);
- node.text = scanner.getTokenValue();
- switch (kind) {
- case 14:
- case 15:
- case 16:
- case 17:
- var isLast = kind === 14 || kind === 17;
- var tokenText = scanner.getTokenText();
- node.rawText = tokenText.substring(1, tokenText.length - (scanner.isUnterminated() ? 0 : isLast ? 1 : 2));
- break;
- }
- if (scanner.hasExtendedUnicodeEscape()) {
- node.hasExtendedUnicodeEscape = true;
- }
- if (scanner.isUnterminated()) {
- node.isUnterminated = true;
- }
- if (node.kind === 8) {
- node.numericLiteralFlags = scanner.getTokenFlags() & 1008;
- }
- if (ts.isTemplateLiteralKind(node.kind)) {
- node.templateFlags = scanner.getTokenFlags() & 2048;
- }
- nextToken();
- finishNode(node);
+ function createThrowStatement(expression) {
+ var node = createBaseNode(246);
+ node.expression = expression;
+ node.transformFlags |= propagateChildFlags(node.expression);
return node;
}
- function parseTypeReference() {
- var node = createNode(169);
- node.typeName = parseEntityName(true, ts.Diagnostics.Type_expected);
- if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29) {
- node.typeArguments = parseBracketedList(20, parseType, 29, 31);
- }
- return finishNode(node);
- }
- function typeHasArrowFunctionBlockingParseError(node) {
- switch (node.kind) {
- case 169:
- return ts.nodeIsMissing(node.typeName);
- case 170:
- case 171: {
- var _a = node, parameters = _a.parameters, type = _a.type;
- return isMissingList(parameters) || typeHasArrowFunctionBlockingParseError(type);
- }
- case 182:
- return typeHasArrowFunctionBlockingParseError(node.type);
- default:
- return false;
- }
+ function updateThrowStatement(node, expression) {
+ return node.expression !== expression
+ ? update(createThrowStatement(expression), node)
+ : node;
+ }
+ function createTryStatement(tryBlock, catchClause, finallyBlock) {
+ var node = createBaseNode(247);
+ node.tryBlock = tryBlock;
+ node.catchClause = catchClause;
+ node.finallyBlock = finallyBlock;
+ node.transformFlags |=
+ propagateChildFlags(node.tryBlock) |
+ propagateChildFlags(node.catchClause) |
+ propagateChildFlags(node.finallyBlock);
+ return node;
}
- function parseThisTypePredicate(lhs) {
- nextToken();
- var node = createNode(168, lhs.pos);
- node.parameterName = lhs;
- node.type = parseType();
- return finishNode(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 parseThisTypeNode() {
- var node = createNode(183);
- nextToken();
- return finishNode(node);
+ function createDebuggerStatement() {
+ return createBaseNode(248);
}
- function parseJSDocAllType(postFixEquals) {
- var result = createNode(295);
- if (postFixEquals) {
- return createPostfixType(299, result);
- }
- else {
- nextToken();
+ function createVariableDeclaration(name, exclamationToken, type, initializer) {
+ var node = createBaseVariableLikeDeclaration(249, undefined, undefined, name, type, initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer));
+ node.exclamationToken = exclamationToken;
+ node.transformFlags |= propagateChildFlags(node.exclamationToken);
+ if (exclamationToken) {
+ node.transformFlags |= 1;
}
- return finishNode(result);
+ return node;
}
- function parseJSDocNonNullableType() {
- var result = createNode(298);
- nextToken();
- result.type = parseNonArrayType();
- return finishNode(result);
+ 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 parseJSDocUnknownOrNullableType() {
- var pos = scanner.getStartPos();
- nextToken();
- if (token() === 27 ||
- token() === 19 ||
- token() === 21 ||
- token() === 31 ||
- token() === 62 ||
- token() === 51) {
- var result = createNode(296, pos);
- return finishNode(result);
- }
- else {
- var result = createNode(297, pos);
- result.type = parseType();
- return finishNode(result);
+ function createVariableDeclarationList(declarations, flags) {
+ if (flags === void 0) { flags = 0; }
+ var node = createBaseNode(250);
+ node.flags |= flags & 3;
+ node.declarations = createNodeArray(declarations);
+ node.transformFlags |=
+ propagateChildrenFlags(node.declarations) |
+ 1048576;
+ if (flags & 3) {
+ node.transformFlags |=
+ 256 |
+ 65536;
}
+ return node;
}
- function parseJSDocFunctionType() {
- if (lookAhead(nextTokenIsOpenParen)) {
- var result = createNodeWithJSDoc(300);
- nextToken();
- fillSignature(58, 4 | 32, result);
- return finishNode(result);
- }
- var node = createNode(169);
- node.typeName = parseIdentifierName();
- return finishNode(node);
+ function updateVariableDeclarationList(node, declarations) {
+ return node.declarations !== declarations
+ ? update(createVariableDeclarationList(declarations, node.flags), node)
+ : node;
}
- function parseJSDocParameter() {
- var parameter = createNode(156);
- if (token() === 104 || token() === 99) {
- parameter.name = parseIdentifierName();
- parseExpected(58);
+ function createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
+ var node = createBaseFunctionLikeDeclaration(251, decorators, modifiers, name, typeParameters, parameters, type, body);
+ node.asteriskToken = asteriskToken;
+ if (!node.body || ts.modifiersToFlags(node.modifiers) & 2) {
+ node.transformFlags = 1;
}
- parameter.type = parseJSDocType();
- return finishNode(parameter);
- }
- function parseJSDocType() {
- scanner.setInJSDocType(true);
- var moduleSpecifier = parseOptionalToken(135);
- if (moduleSpecifier) {
- var moduleTag = createNode(302, moduleSpecifier.pos);
- terminate: while (true) {
- switch (token()) {
- case 19:
- case 1:
- case 27:
- case 5:
- break terminate;
- default:
- nextTokenJSDoc();
+ else {
+ node.transformFlags |=
+ propagateChildFlags(node.asteriskToken) |
+ 1048576;
+ if (ts.modifiersToFlags(node.modifiers) & 256) {
+ if (node.asteriskToken) {
+ node.transformFlags |= 32;
+ }
+ else {
+ node.transformFlags |= 64;
}
}
- scanner.setInJSDocType(false);
- return finishNode(moduleTag);
- }
- var dotdotdot = parseOptionalToken(25);
- var type = parseTypeOrTypePredicate();
- scanner.setInJSDocType(false);
- if (dotdotdot) {
- var variadic = createNode(301, dotdotdot.pos);
- variadic.type = type;
- type = finishNode(variadic);
- }
- if (token() === 62) {
- return createPostfixType(299, type);
+ else if (node.asteriskToken) {
+ node.transformFlags |= 512;
+ }
}
- return type;
- }
- function parseTypeQuery() {
- var node = createNode(172);
- parseExpected(108);
- node.exprName = parseEntityName(true);
- return finishNode(node);
+ return node;
}
- function parseTypeParameter() {
- var node = createNode(155);
- node.name = parseIdentifier();
- if (parseOptional(90)) {
- if (isStartOfType() || !isStartOfExpression()) {
- node.constraint = parseType();
- }
- else {
- node.expression = parseUnaryExpressionOrHigher();
- }
+ function updateFunctionDeclaration(node, decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.asteriskToken !== asteriskToken
+ || node.name !== name
+ || node.typeParameters !== typeParameters
+ || node.parameters !== parameters
+ || node.type !== type
+ || node.body !== body
+ ? updateBaseFunctionLikeDeclaration(createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body), node)
+ : node;
+ }
+ function createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members) {
+ var node = createBaseClassLikeDeclaration(252, decorators, modifiers, name, typeParameters, heritageClauses, members);
+ if (ts.modifiersToFlags(node.modifiers) & 2) {
+ node.transformFlags = 1;
}
- if (parseOptional(62)) {
- node.default = parseType();
+ else {
+ node.transformFlags |= 256;
+ if (node.transformFlags & 2048) {
+ node.transformFlags |= 1;
+ }
}
- return finishNode(node);
+ return node;
}
- function parseTypeParameters() {
- if (token() === 29) {
- return parseBracketedList(19, parseTypeParameter, 29, 31);
- }
+ function updateClassDeclaration(node, decorators, modifiers, name, typeParameters, heritageClauses, members) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.typeParameters !== typeParameters
+ || node.heritageClauses !== heritageClauses
+ || node.members !== members
+ ? update(createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members), node)
+ : node;
+ }
+ function createInterfaceDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members) {
+ var node = createBaseInterfaceOrClassLikeDeclaration(253, decorators, modifiers, name, typeParameters, heritageClauses);
+ node.members = createNodeArray(members);
+ node.transformFlags = 1;
+ return node;
}
- function parseParameterType() {
- if (parseOptional(58)) {
- return parseType();
- }
- return undefined;
+ function updateInterfaceDeclaration(node, decorators, modifiers, name, typeParameters, heritageClauses, members) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.typeParameters !== typeParameters
+ || node.heritageClauses !== heritageClauses
+ || node.members !== members
+ ? update(createInterfaceDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members), node)
+ : node;
+ }
+ function createTypeAliasDeclaration(decorators, modifiers, name, typeParameters, type) {
+ var node = createBaseGenericNamedDeclaration(254, decorators, modifiers, name, typeParameters);
+ node.type = type;
+ node.transformFlags = 1;
+ return node;
}
- function isStartOfParameter(isJSDocParameter) {
- return token() === 25 ||
- isIdentifierOrPrivateIdentifierOrPattern() ||
- ts.isModifierKind(token()) ||
- token() === 59 ||
- isStartOfType(!isJSDocParameter);
+ function updateTypeAliasDeclaration(node, decorators, modifiers, name, typeParameters, type) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.typeParameters !== typeParameters
+ || node.type !== type
+ ? update(createTypeAliasDeclaration(decorators, modifiers, name, typeParameters, type), node)
+ : node;
+ }
+ function createEnumDeclaration(decorators, modifiers, name, members) {
+ var node = createBaseNamedDeclaration(255, decorators, modifiers, name);
+ node.members = createNodeArray(members);
+ node.transformFlags |=
+ propagateChildrenFlags(node.members) |
+ 1;
+ node.transformFlags &= ~8388608;
+ return node;
}
- function parseParameter() {
- var node = createNodeWithJSDoc(156);
- if (token() === 104) {
- node.name = createIdentifier(true);
- node.type = parseParameterType();
- return finishNode(node);
- }
- node.decorators = parseDecorators();
- node.modifiers = parseModifiers();
- node.dotDotDotToken = parseOptionalToken(25);
- node.name = parseIdentifierOrPattern(ts.Diagnostics.Private_identifiers_cannot_be_used_as_parameters);
- if (ts.getFullWidth(node.name) === 0 && !node.modifiers && ts.isModifierKind(token())) {
- nextToken();
- }
- node.questionToken = parseOptionalToken(57);
- node.type = parseParameterType();
- node.initializer = parseInitializer();
- return finishNode(node);
+ function updateEnumDeclaration(node, decorators, modifiers, name, members) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.members !== members
+ ? update(createEnumDeclaration(decorators, modifiers, name, members), node)
+ : node;
}
- function fillSignature(returnToken, flags, signature) {
- if (!(flags & 32)) {
- signature.typeParameters = parseTypeParameters();
+ function createModuleDeclaration(decorators, modifiers, name, body, flags) {
+ if (flags === void 0) { flags = 0; }
+ var node = createBaseDeclaration(256, decorators, modifiers);
+ node.flags |= flags & (16 | 4 | 1024);
+ node.name = name;
+ node.body = body;
+ if (ts.modifiersToFlags(node.modifiers) & 2) {
+ node.transformFlags = 1;
}
- var parametersParsedSuccessfully = parseParameterList(signature, flags);
- if (shouldParseReturnType(returnToken, !!(flags & 4))) {
- signature.type = parseTypeOrTypePredicate();
- if (typeHasArrowFunctionBlockingParseError(signature.type))
- return false;
+ else {
+ node.transformFlags |=
+ propagateChildFlags(node.name) |
+ propagateChildFlags(node.body) |
+ 1;
}
- return parametersParsedSuccessfully;
+ node.transformFlags &= ~8388608;
+ return node;
}
- function shouldParseReturnType(returnToken, isType) {
- if (returnToken === 38) {
- parseExpected(returnToken);
- return true;
- }
- else if (parseOptional(58)) {
- return true;
- }
- else if (isType && token() === 38) {
- parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(58));
- nextToken();
- return true;
- }
- return false;
+ function updateModuleDeclaration(node, decorators, modifiers, name, body) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.body !== body
+ ? update(createModuleDeclaration(decorators, modifiers, name, body, node.flags), node)
+ : node;
+ }
+ function createModuleBlock(statements) {
+ var node = createBaseNode(257);
+ node.statements = createNodeArray(statements);
+ node.transformFlags |= propagateChildrenFlags(node.statements);
+ return node;
}
- function parseParameterList(signature, flags) {
- if (!parseExpected(20)) {
- signature.parameters = createMissingList();
- return false;
- }
- var savedYieldContext = inYieldContext();
- var savedAwaitContext = inAwaitContext();
- setYieldContext(!!(flags & 1));
- setAwaitContext(!!(flags & 2));
- signature.parameters = flags & 32 ?
- parseDelimitedList(17, parseJSDocParameter) :
- parseDelimitedList(16, parseParameter);
- setYieldContext(savedYieldContext);
- setAwaitContext(savedAwaitContext);
- return parseExpected(21);
+ function updateModuleBlock(node, statements) {
+ return node.statements !== statements
+ ? update(createModuleBlock(statements), node)
+ : node;
}
- function parseTypeMemberSemicolon() {
- if (parseOptional(27)) {
- return;
- }
- parseSemicolon();
+ function createCaseBlock(clauses) {
+ var node = createBaseNode(258);
+ node.clauses = createNodeArray(clauses);
+ node.transformFlags |= propagateChildrenFlags(node.clauses);
+ return node;
}
- function parseSignatureMember(kind) {
- var node = createNodeWithJSDoc(kind);
- if (kind === 166) {
- parseExpected(99);
- }
- fillSignature(58, 4, node);
- parseTypeMemberSemicolon();
- return finishNode(node);
+ function updateCaseBlock(node, clauses) {
+ return node.clauses !== clauses
+ ? update(createCaseBlock(clauses), node)
+ : node;
}
- function isIndexSignature() {
- return token() === 22 && lookAhead(isUnambiguouslyIndexSignature);
+ function createNamespaceExportDeclaration(name) {
+ var node = createBaseNamedDeclaration(259, undefined, undefined, name);
+ node.transformFlags = 1;
+ return node;
}
- function isUnambiguouslyIndexSignature() {
- nextToken();
- if (token() === 25 || token() === 23) {
- return true;
- }
- if (ts.isModifierKind(token())) {
- nextToken();
- if (isIdentifier()) {
- return true;
- }
- }
- else if (!isIdentifier()) {
- return false;
- }
- else {
- nextToken();
- }
- if (token() === 58 || token() === 27) {
- return true;
- }
- if (token() !== 57) {
- return false;
- }
- nextToken();
- return token() === 58 || token() === 27 || token() === 23;
+ function updateNamespaceExportDeclaration(node, name) {
+ return node.name !== name
+ ? update(createNamespaceExportDeclaration(name), node)
+ : node;
+ }
+ function createImportEqualsDeclaration(decorators, modifiers, name, moduleReference) {
+ var node = createBaseNamedDeclaration(260, decorators, modifiers, name);
+ node.moduleReference = moduleReference;
+ node.transformFlags |= propagateChildFlags(node.moduleReference);
+ if (!ts.isExternalModuleReference(node.moduleReference))
+ node.transformFlags |= 1;
+ node.transformFlags &= ~8388608;
+ return node;
}
- function parseIndexSignatureDeclaration(node) {
- node.kind = 167;
- node.parameters = parseBracketedList(16, parseParameter, 22, 23);
- node.type = parseTypeAnnotation();
- parseTypeMemberSemicolon();
- return finishNode(node);
+ function updateImportEqualsDeclaration(node, decorators, modifiers, name, moduleReference) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.name !== name
+ || node.moduleReference !== moduleReference
+ ? update(createImportEqualsDeclaration(decorators, modifiers, name, moduleReference), node)
+ : node;
+ }
+ function createImportDeclaration(decorators, modifiers, importClause, moduleSpecifier) {
+ var node = createBaseDeclaration(261, decorators, modifiers);
+ node.importClause = importClause;
+ node.moduleSpecifier = moduleSpecifier;
+ node.transformFlags |=
+ propagateChildFlags(node.importClause) |
+ propagateChildFlags(node.moduleSpecifier);
+ node.transformFlags &= ~8388608;
+ return node;
}
- function parsePropertyOrMethodSignature(node) {
- node.name = parsePropertyName();
- node.questionToken = parseOptionalToken(57);
- if (token() === 20 || token() === 29) {
- node.kind = 160;
- fillSignature(58, 4, node);
- }
- else {
- node.kind = 158;
- node.type = parseTypeAnnotation();
- if (token() === 62) {
- node.initializer = parseInitializer();
- }
+ function updateImportDeclaration(node, decorators, modifiers, importClause, moduleSpecifier) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.importClause !== importClause
+ || node.moduleSpecifier !== moduleSpecifier
+ ? update(createImportDeclaration(decorators, modifiers, importClause, moduleSpecifier), node)
+ : node;
+ }
+ function createImportClause(isTypeOnly, name, namedBindings) {
+ var node = createBaseNode(262);
+ node.isTypeOnly = isTypeOnly;
+ node.name = name;
+ node.namedBindings = namedBindings;
+ node.transformFlags |=
+ propagateChildFlags(node.name) |
+ propagateChildFlags(node.namedBindings);
+ if (isTypeOnly) {
+ node.transformFlags |= 1;
}
- parseTypeMemberSemicolon();
- return finishNode(node);
+ node.transformFlags &= ~8388608;
+ return node;
}
- function isTypeMemberStart() {
- if (token() === 20 || token() === 29) {
- return true;
- }
- var idToken = false;
- while (ts.isModifierKind(token())) {
- idToken = true;
- nextToken();
- }
- if (token() === 22) {
- return true;
- }
- if (isLiteralPropertyName()) {
- idToken = true;
- nextToken();
- }
- if (idToken) {
- return token() === 20 ||
- token() === 29 ||
- token() === 57 ||
- token() === 58 ||
- token() === 27 ||
- canParseSemicolon();
- }
- return false;
+ function updateImportClause(node, isTypeOnly, name, namedBindings) {
+ return node.isTypeOnly !== isTypeOnly
+ || node.name !== name
+ || node.namedBindings !== namedBindings
+ ? update(createImportClause(isTypeOnly, name, namedBindings), node)
+ : node;
+ }
+ function createNamespaceImport(name) {
+ var node = createBaseNode(263);
+ node.name = name;
+ node.transformFlags |= propagateChildFlags(node.name);
+ node.transformFlags &= ~8388608;
+ return node;
}
- function parseTypeMember() {
- if (token() === 20 || token() === 29) {
- return parseSignatureMember(165);
- }
- if (token() === 99 && lookAhead(nextTokenIsOpenParenOrLessThan)) {
- return parseSignatureMember(166);
- }
- var node = createNodeWithJSDoc(0);
- node.modifiers = parseModifiers();
- if (isIndexSignature()) {
- return parseIndexSignatureDeclaration(node);
- }
- return parsePropertyOrMethodSignature(node);
+ function updateNamespaceImport(node, name) {
+ return node.name !== name
+ ? update(createNamespaceImport(name), node)
+ : node;
+ }
+ function createNamespaceExport(name) {
+ var node = createBaseNode(269);
+ node.name = name;
+ node.transformFlags |=
+ propagateChildFlags(node.name) |
+ 4;
+ node.transformFlags &= ~8388608;
+ return node;
}
- function nextTokenIsOpenParenOrLessThan() {
- nextToken();
- return token() === 20 || token() === 29;
+ function updateNamespaceExport(node, name) {
+ return node.name !== name
+ ? update(createNamespaceExport(name), node)
+ : node;
}
- function nextTokenIsDot() {
- return nextToken() === 24;
+ function createNamedImports(elements) {
+ var node = createBaseNode(264);
+ node.elements = createNodeArray(elements);
+ node.transformFlags |= propagateChildrenFlags(node.elements);
+ node.transformFlags &= ~8388608;
+ return node;
}
- function nextTokenIsOpenParenOrLessThanOrDot() {
- switch (nextToken()) {
- case 20:
- case 29:
- case 24:
- return true;
- }
- return false;
+ function updateNamedImports(node, elements) {
+ return node.elements !== elements
+ ? update(createNamedImports(elements), node)
+ : node;
+ }
+ function createImportSpecifier(propertyName, name) {
+ var node = createBaseNode(265);
+ node.propertyName = propertyName;
+ node.name = name;
+ node.transformFlags |=
+ propagateChildFlags(node.propertyName) |
+ propagateChildFlags(node.name);
+ node.transformFlags &= ~8388608;
+ return node;
}
- function parseTypeLiteral() {
- var node = createNode(173);
- node.members = parseObjectTypeMembers();
- return finishNode(node);
+ function updateImportSpecifier(node, propertyName, name) {
+ return node.propertyName !== propertyName
+ || node.name !== name
+ ? update(createImportSpecifier(propertyName, name), node)
+ : node;
+ }
+ function createExportAssignment(decorators, modifiers, isExportEquals, expression) {
+ var node = createBaseDeclaration(266, decorators, modifiers);
+ node.isExportEquals = isExportEquals;
+ node.expression = isExportEquals
+ ? parenthesizerRules().parenthesizeRightSideOfBinary(62, undefined, expression)
+ : parenthesizerRules().parenthesizeExpressionOfExportDefault(expression);
+ node.transformFlags |= propagateChildFlags(node.expression);
+ node.transformFlags &= ~8388608;
+ return node;
}
- function parseObjectTypeMembers() {
- var members;
- if (parseExpected(18)) {
- members = parseList(4, parseTypeMember);
- parseExpected(19);
- }
- else {
- members = createMissingList();
+ function updateExportAssignment(node, decorators, modifiers, expression) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.expression !== expression
+ ? update(createExportAssignment(decorators, modifiers, node.isExportEquals, expression), node)
+ : node;
+ }
+ function createExportDeclaration(decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier) {
+ var node = createBaseDeclaration(267, decorators, modifiers);
+ node.isTypeOnly = isTypeOnly;
+ node.exportClause = exportClause;
+ node.moduleSpecifier = moduleSpecifier;
+ node.transformFlags |=
+ propagateChildFlags(node.exportClause) |
+ propagateChildFlags(node.moduleSpecifier);
+ node.transformFlags &= ~8388608;
+ return node;
+ }
+ function updateExportDeclaration(node, decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier) {
+ return node.decorators !== decorators
+ || node.modifiers !== modifiers
+ || node.isTypeOnly !== isTypeOnly
+ || node.exportClause !== exportClause
+ || node.moduleSpecifier !== moduleSpecifier
+ ? update(createExportDeclaration(decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier), node)
+ : node;
+ }
+ function createNamedExports(elements) {
+ var node = createBaseNode(268);
+ node.elements = createNodeArray(elements);
+ node.transformFlags |= propagateChildrenFlags(node.elements);
+ node.transformFlags &= ~8388608;
+ return node;
+ }
+ function updateNamedExports(node, elements) {
+ return node.elements !== elements
+ ? update(createNamedExports(elements), node)
+ : node;
+ }
+ function createExportSpecifier(propertyName, name) {
+ var node = createBaseNode(270);
+ node.propertyName = asName(propertyName);
+ node.name = asName(name);
+ node.transformFlags |=
+ propagateChildFlags(node.propertyName) |
+ propagateChildFlags(node.name);
+ node.transformFlags &= ~8388608;
+ return node;
+ }
+ function updateExportSpecifier(node, propertyName, name) {
+ return node.propertyName !== propertyName
+ || node.name !== name
+ ? update(createExportSpecifier(propertyName, name), node)
+ : node;
+ }
+ function createMissingDeclaration() {
+ var node = createBaseDeclaration(271, undefined, undefined);
+ return node;
+ }
+ function createExternalModuleReference(expression) {
+ var node = createBaseNode(272);
+ node.expression = expression;
+ node.transformFlags |= propagateChildFlags(node.expression);
+ node.transformFlags &= ~8388608;
+ return node;
+ }
+ function updateExternalModuleReference(node, expression) {
+ return node.expression !== expression
+ ? update(createExternalModuleReference(expression), node)
+ : node;
+ }
+ function createJSDocPrimaryTypeWorker(kind) {
+ return createBaseNode(kind);
+ }
+ function createJSDocUnaryTypeWorker(kind, type) {
+ var node = createBaseNode(kind);
+ node.type = type;
+ return node;
+ }
+ function updateJSDocUnaryTypeWorker(kind, node, type) {
+ return node.type !== type
+ ? update(createJSDocUnaryTypeWorker(kind, type), node)
+ : node;
+ }
+ function createJSDocFunctionType(parameters, type) {
+ var node = createBaseSignatureDeclaration(308, undefined, undefined, undefined, undefined, 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) {
+ if (isArrayType === void 0) { isArrayType = false; }
+ var node = createBaseNode(312);
+ 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) {
+ var node = createBaseNode(301);
+ node.type = type;
+ return node;
+ }
+ function updateJSDocTypeExpression(node, type) {
+ return node.type !== type
+ ? update(createJSDocTypeExpression(type), node)
+ : node;
+ }
+ function createJSDocSignature(typeParameters, parameters, type) {
+ var node = createBaseNode(313);
+ 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) {
+ var defaultTagName = getDefaultTagNameForKind(node.kind);
+ return node.tagName.escapedText === ts.escapeLeadingUnderscores(defaultTagName)
+ ? node.tagName
+ : createIdentifier(defaultTagName);
+ }
+ function createBaseJSDocTag(kind, tagName, comment) {
+ var node = createBaseNode(kind);
+ node.tagName = tagName;
+ node.comment = comment;
+ return node;
+ }
+ function createJSDocTemplateTag(tagName, constraint, typeParameters, comment) {
+ var node = createBaseJSDocTag(330, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("template"), comment);
+ node.constraint = constraint;
+ node.typeParameters = createNodeArray(typeParameters);
+ return node;
+ }
+ function updateJSDocTemplateTag(node, tagName, constraint, typeParameters, comment) {
+ if (tagName === void 0) { tagName = getDefaultTagName(node); }
+ return node.tagName !== tagName
+ || node.constraint !== constraint
+ || node.typeParameters !== typeParameters
+ || node.comment !== comment
+ ? update(createJSDocTemplateTag(tagName, constraint, typeParameters, comment), node)
+ : node;
+ }
+ function createJSDocTypedefTag(tagName, typeExpression, fullName, comment) {
+ var node = createBaseJSDocTag(331, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("typedef"), comment);
+ node.typeExpression = typeExpression;
+ node.fullName = fullName;
+ node.name = ts.getJSDocTypeAliasName(fullName);
+ return node;
+ }
+ function updateJSDocTypedefTag(node, tagName, typeExpression, fullName, comment) {
+ if (tagName === void 0) { tagName = getDefaultTagName(node); }
+ return node.tagName !== tagName
+ || node.typeExpression !== typeExpression
+ || node.fullName !== fullName
+ || node.comment !== comment
+ ? update(createJSDocTypedefTag(tagName, typeExpression, fullName, comment), node)
+ : node;
+ }
+ function createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) {
+ var node = createBaseJSDocTag(326, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("param"), comment);
+ node.typeExpression = typeExpression;
+ node.name = name;
+ node.isNameFirst = !!isNameFirst;
+ node.isBracketed = isBracketed;
+ return node;
+ }
+ function updateJSDocParameterTag(node, tagName, name, isBracketed, typeExpression, isNameFirst, comment) {
+ if (tagName === void 0) { tagName = getDefaultTagName(node); }
+ return node.tagName !== tagName
+ || node.name !== name
+ || node.isBracketed !== isBracketed
+ || node.typeExpression !== typeExpression
+ || node.isNameFirst !== isNameFirst
+ || node.comment !== comment
+ ? update(createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment), node)
+ : node;
+ }
+ function createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) {
+ var node = createBaseJSDocTag(333, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("prop"), comment);
+ node.typeExpression = typeExpression;
+ node.name = name;
+ node.isNameFirst = !!isNameFirst;
+ node.isBracketed = isBracketed;
+ return node;
+ }
+ function updateJSDocPropertyTag(node, tagName, name, isBracketed, typeExpression, isNameFirst, comment) {
+ if (tagName === void 0) { tagName = getDefaultTagName(node); }
+ return node.tagName !== tagName
+ || node.name !== name
+ || node.isBracketed !== isBracketed
+ || node.typeExpression !== typeExpression
+ || node.isNameFirst !== isNameFirst
+ || node.comment !== comment
+ ? update(createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment), node)
+ : node;
+ }
+ function createJSDocCallbackTag(tagName, typeExpression, fullName, comment) {
+ var node = createBaseJSDocTag(324, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("callback"), comment);
+ node.typeExpression = typeExpression;
+ node.fullName = fullName;
+ node.name = ts.getJSDocTypeAliasName(fullName);
+ return node;
+ }
+ function updateJSDocCallbackTag(node, tagName, typeExpression, fullName, comment) {
+ if (tagName === void 0) { tagName = getDefaultTagName(node); }
+ return node.tagName !== tagName
+ || node.typeExpression !== typeExpression
+ || node.fullName !== fullName
+ || node.comment !== comment
+ ? update(createJSDocCallbackTag(tagName, typeExpression, fullName, comment), node)
+ : node;
+ }
+ function createJSDocAugmentsTag(tagName, className, comment) {
+ var node = createBaseJSDocTag(315, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("augments"), comment);
+ node.class = className;
+ return node;
+ }
+ function updateJSDocAugmentsTag(node, tagName, className, comment) {
+ if (tagName === void 0) { tagName = getDefaultTagName(node); }
+ return node.tagName !== tagName
+ || node.class !== className
+ || node.comment !== comment
+ ? update(createJSDocAugmentsTag(tagName, className, comment), node)
+ : node;
+ }
+ function createJSDocImplementsTag(tagName, className, comment) {
+ var node = createBaseJSDocTag(316, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("implements"), comment);
+ node.class = className;
+ return node;
+ }
+ function createJSDocSeeTag(tagName, name, comment) {
+ var node = createBaseJSDocTag(332, tagName !== null && tagName !== void 0 ? 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) {
+ var node = createBaseNode(302);
+ node.name = name;
+ return node;
+ }
+ function updateJSDocNameReference(node, name) {
+ return node.name !== name
+ ? update(createJSDocNameReference(name), node)
+ : node;
+ }
+ function updateJSDocImplementsTag(node, tagName, className, comment) {
+ if (tagName === void 0) { tagName = getDefaultTagName(node); }
+ return node.tagName !== tagName
+ || node.class !== className
+ || node.comment !== comment
+ ? update(createJSDocImplementsTag(tagName, className, comment), node)
+ : node;
+ }
+ function createJSDocSimpleTagWorker(kind, tagName, comment) {
+ var node = createBaseJSDocTag(kind, tagName !== null && tagName !== void 0 ? tagName : createIdentifier(getDefaultTagNameForKind(kind)), comment);
+ return node;
+ }
+ function updateJSDocSimpleTagWorker(kind, node, tagName, comment) {
+ if (tagName === void 0) { tagName = getDefaultTagName(node); }
+ return node.tagName !== tagName
+ || node.comment !== comment
+ ? update(createJSDocSimpleTagWorker(kind, tagName, comment), node) :
+ node;
+ }
+ function createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment) {
+ var node = createBaseJSDocTag(kind, tagName !== null && tagName !== void 0 ? tagName : createIdentifier(getDefaultTagNameForKind(kind)), comment);
+ node.typeExpression = typeExpression;
+ return node;
+ }
+ function updateJSDocTypeLikeTagWorker(kind, node, tagName, typeExpression, comment) {
+ if (tagName === void 0) { tagName = getDefaultTagName(node); }
+ return node.tagName !== tagName
+ || node.typeExpression !== typeExpression
+ || node.comment !== comment
+ ? update(createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment), node)
+ : node;
+ }
+ function createJSDocUnknownTag(tagName, comment) {
+ var node = createBaseJSDocTag(314, tagName, comment);
+ return node;
+ }
+ function updateJSDocUnknownTag(node, tagName, comment) {
+ return node.tagName !== tagName
+ || node.comment !== comment
+ ? update(createJSDocUnknownTag(tagName, comment), node)
+ : node;
+ }
+ function createJSDocComment(comment, tags) {
+ var node = createBaseNode(311);
+ 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) {
+ var node = createBaseNode(273);
+ node.openingElement = openingElement;
+ node.children = createNodeArray(children);
+ node.closingElement = closingElement;
+ node.transformFlags |=
+ propagateChildFlags(node.openingElement) |
+ propagateChildrenFlags(node.children) |
+ propagateChildFlags(node.closingElement) |
+ 2;
+ 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) {
+ var node = createBaseNode(274);
+ node.tagName = tagName;
+ node.typeArguments = asNodeArray(typeArguments);
+ node.attributes = attributes;
+ node.transformFlags |=
+ propagateChildFlags(node.tagName) |
+ propagateChildrenFlags(node.typeArguments) |
+ propagateChildFlags(node.attributes) |
+ 2;
+ if (node.typeArguments) {
+ node.transformFlags |= 1;
}
- return members;
+ return node;
}
- function isStartOfMappedType() {
- nextToken();
- if (token() === 39 || token() === 40) {
- return nextToken() === 138;
+ 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) {
+ var node = createBaseNode(275);
+ node.tagName = tagName;
+ node.typeArguments = asNodeArray(typeArguments);
+ node.attributes = attributes;
+ node.transformFlags |=
+ propagateChildFlags(node.tagName) |
+ propagateChildrenFlags(node.typeArguments) |
+ propagateChildFlags(node.attributes) |
+ 2;
+ if (typeArguments) {
+ node.transformFlags |= 1;
}
- if (token() === 138) {
- nextToken();
+ 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) {
+ var node = createBaseNode(276);
+ node.tagName = tagName;
+ node.transformFlags |=
+ propagateChildFlags(node.tagName) |
+ 2;
+ return node;
+ }
+ function updateJsxClosingElement(node, tagName) {
+ return node.tagName !== tagName
+ ? update(createJsxClosingElement(tagName), node)
+ : node;
+ }
+ function createJsxFragment(openingFragment, children, closingFragment) {
+ var node = createBaseNode(277);
+ node.openingFragment = openingFragment;
+ node.children = createNodeArray(children);
+ node.closingFragment = closingFragment;
+ node.transformFlags |=
+ propagateChildFlags(node.openingFragment) |
+ propagateChildrenFlags(node.children) |
+ propagateChildFlags(node.closingFragment) |
+ 2;
+ 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) {
+ var node = createBaseNode(11);
+ node.text = text;
+ node.containsOnlyTriviaWhiteSpaces = !!containsOnlyTriviaWhiteSpaces;
+ node.transformFlags |= 2;
+ return node;
+ }
+ function updateJsxText(node, text, containsOnlyTriviaWhiteSpaces) {
+ return node.text !== text
+ || node.containsOnlyTriviaWhiteSpaces !== containsOnlyTriviaWhiteSpaces
+ ? update(createJsxText(text, containsOnlyTriviaWhiteSpaces), node)
+ : node;
+ }
+ function createJsxOpeningFragment() {
+ var node = createBaseNode(278);
+ node.transformFlags |= 2;
+ return node;
+ }
+ function createJsxJsxClosingFragment() {
+ var node = createBaseNode(279);
+ node.transformFlags |= 2;
+ return node;
+ }
+ function createJsxAttribute(name, initializer) {
+ var node = createBaseNode(280);
+ node.name = name;
+ node.initializer = initializer;
+ node.transformFlags |=
+ propagateChildFlags(node.name) |
+ propagateChildFlags(node.initializer) |
+ 2;
+ return node;
+ }
+ function updateJsxAttribute(node, name, initializer) {
+ return node.name !== name
+ || node.initializer !== initializer
+ ? update(createJsxAttribute(name, initializer), node)
+ : node;
+ }
+ function createJsxAttributes(properties) {
+ var node = createBaseNode(281);
+ node.properties = createNodeArray(properties);
+ node.transformFlags |=
+ propagateChildrenFlags(node.properties) |
+ 2;
+ return node;
+ }
+ function updateJsxAttributes(node, properties) {
+ return node.properties !== properties
+ ? update(createJsxAttributes(properties), node)
+ : node;
+ }
+ function createJsxSpreadAttribute(expression) {
+ var node = createBaseNode(282);
+ node.expression = expression;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 2;
+ return node;
+ }
+ function updateJsxSpreadAttribute(node, expression) {
+ return node.expression !== expression
+ ? update(createJsxSpreadAttribute(expression), node)
+ : node;
+ }
+ function createJsxExpression(dotDotDotToken, expression) {
+ var node = createBaseNode(283);
+ node.dotDotDotToken = dotDotDotToken;
+ node.expression = expression;
+ node.transformFlags |=
+ propagateChildFlags(node.dotDotDotToken) |
+ propagateChildFlags(node.expression) |
+ 2;
+ return node;
+ }
+ function updateJsxExpression(node, expression) {
+ return node.expression !== expression
+ ? update(createJsxExpression(node.dotDotDotToken, expression), node)
+ : node;
+ }
+ function createCaseClause(expression, statements) {
+ var node = createBaseNode(284);
+ 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) {
+ var node = createBaseNode(285);
+ 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) {
+ var node = createBaseNode(286);
+ node.token = token;
+ node.types = createNodeArray(types);
+ node.transformFlags |= propagateChildrenFlags(node.types);
+ switch (token) {
+ case 93:
+ node.transformFlags |= 256;
+ break;
+ case 116:
+ node.transformFlags |= 1;
+ break;
+ default:
+ return ts.Debug.assertNever(token);
}
- return token() === 22 && nextTokenIsIdentifier() && nextToken() === 97;
+ return node;
}
- function parseMappedTypeParameter() {
- var node = createNode(155);
- node.name = parseIdentifier();
- parseExpected(97);
- node.constraint = parseType();
- return finishNode(node);
+ function updateHeritageClause(node, types) {
+ return node.types !== types
+ ? update(createHeritageClause(node.token, types), node)
+ : node;
+ }
+ function createCatchClause(variableDeclaration, block) {
+ var node = createBaseNode(287);
+ variableDeclaration = !ts.isString(variableDeclaration) ? variableDeclaration : createVariableDeclaration(variableDeclaration, undefined, undefined, undefined);
+ node.variableDeclaration = variableDeclaration;
+ node.block = block;
+ node.transformFlags |=
+ propagateChildFlags(node.variableDeclaration) |
+ propagateChildFlags(node.block);
+ if (!variableDeclaration)
+ node.transformFlags |= 16;
+ return node;
}
- function parseMappedType() {
- var node = createNode(186);
- parseExpected(18);
- if (token() === 138 || token() === 39 || token() === 40) {
- node.readonlyToken = parseTokenNode();
- if (node.readonlyToken.kind !== 138) {
- parseExpectedToken(138);
+ function updateCatchClause(node, variableDeclaration, block) {
+ return node.variableDeclaration !== variableDeclaration
+ || node.block !== block
+ ? update(createCatchClause(variableDeclaration, block), node)
+ : node;
+ }
+ function createPropertyAssignment(name, initializer) {
+ var node = createBaseNamedDeclaration(288, undefined, undefined, name);
+ node.initializer = parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer);
+ node.transformFlags |=
+ propagateChildFlags(node.name) |
+ propagateChildFlags(node.initializer);
+ return node;
+ }
+ function finishUpdatePropertyAssignment(updated, original) {
+ if (original.decorators)
+ updated.decorators = original.decorators;
+ if (original.modifiers)
+ updated.modifiers = original.modifiers;
+ if (original.questionToken)
+ updated.questionToken = original.questionToken;
+ if (original.exclamationToken)
+ updated.exclamationToken = original.exclamationToken;
+ return update(updated, original);
+ }
+ function updatePropertyAssignment(node, name, initializer) {
+ return node.name !== name
+ || node.initializer !== initializer
+ ? finishUpdatePropertyAssignment(createPropertyAssignment(name, initializer), node)
+ : node;
+ }
+ function createShorthandPropertyAssignment(name, objectAssignmentInitializer) {
+ var node = createBaseNamedDeclaration(289, undefined, undefined, name);
+ node.objectAssignmentInitializer = objectAssignmentInitializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(objectAssignmentInitializer);
+ node.transformFlags |=
+ propagateChildFlags(node.objectAssignmentInitializer) |
+ 256;
+ return node;
+ }
+ function finishUpdateShorthandPropertyAssignment(updated, original) {
+ if (original.decorators)
+ updated.decorators = original.decorators;
+ if (original.modifiers)
+ updated.modifiers = original.modifiers;
+ if (original.equalsToken)
+ updated.equalsToken = original.equalsToken;
+ if (original.questionToken)
+ updated.questionToken = original.questionToken;
+ if (original.exclamationToken)
+ updated.exclamationToken = original.exclamationToken;
+ return update(updated, original);
+ }
+ function updateShorthandPropertyAssignment(node, name, objectAssignmentInitializer) {
+ return node.name !== name
+ || node.objectAssignmentInitializer !== objectAssignmentInitializer
+ ? finishUpdateShorthandPropertyAssignment(createShorthandPropertyAssignment(name, objectAssignmentInitializer), node)
+ : node;
+ }
+ function createSpreadAssignment(expression) {
+ var node = createBaseNode(290);
+ node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 32 |
+ 16384;
+ return node;
+ }
+ function updateSpreadAssignment(node, expression) {
+ return node.expression !== expression
+ ? update(createSpreadAssignment(expression), node)
+ : node;
+ }
+ function createEnumMember(name, initializer) {
+ var node = createBaseNode(291);
+ node.name = asName(name);
+ node.initializer = initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer);
+ node.transformFlags |=
+ propagateChildFlags(node.name) |
+ propagateChildFlags(node.initializer) |
+ 1;
+ return node;
+ }
+ function updateEnumMember(node, name, initializer) {
+ return node.name !== name
+ || node.initializer !== initializer
+ ? update(createEnumMember(name, initializer), node)
+ : node;
+ }
+ function createSourceFile(statements, endOfFileToken, flags) {
+ var node = baseFactory.createBaseSourceFileNode(297);
+ node.statements = createNodeArray(statements);
+ node.endOfFileToken = endOfFileToken;
+ node.flags |= flags;
+ node.fileName = "";
+ node.text = "";
+ node.languageVersion = 0;
+ node.languageVariant = 0;
+ node.scriptKind = 0;
+ node.isDeclarationFile = false;
+ node.hasNoDefaultLib = false;
+ node.transformFlags |=
+ propagateChildrenFlags(node.statements) |
+ propagateChildFlags(node.endOfFileToken);
+ return node;
+ }
+ function cloneSourceFileWithChanges(source, statements, isDeclarationFile, referencedFiles, typeReferences, hasNoDefaultLib, libReferences) {
+ var node = baseFactory.createBaseSourceFileNode(297);
+ for (var p in source) {
+ if (p === "emitNode" || ts.hasProperty(node, p) || !ts.hasProperty(source, p))
+ continue;
+ node[p] = source[p];
+ }
+ node.flags |= source.flags;
+ node.statements = createNodeArray(statements);
+ node.endOfFileToken = source.endOfFileToken;
+ node.isDeclarationFile = isDeclarationFile;
+ node.referencedFiles = referencedFiles;
+ node.typeReferenceDirectives = typeReferences;
+ node.hasNoDefaultLib = hasNoDefaultLib;
+ node.libReferenceDirectives = libReferences;
+ node.transformFlags =
+ propagateChildrenFlags(node.statements) |
+ propagateChildFlags(node.endOfFileToken);
+ return node;
+ }
+ function updateSourceFile(node, statements, isDeclarationFile, referencedFiles, typeReferenceDirectives, hasNoDefaultLib, libReferenceDirectives) {
+ if (isDeclarationFile === void 0) { isDeclarationFile = node.isDeclarationFile; }
+ if (referencedFiles === void 0) { referencedFiles = node.referencedFiles; }
+ if (typeReferenceDirectives === void 0) { typeReferenceDirectives = node.typeReferenceDirectives; }
+ if (hasNoDefaultLib === void 0) { hasNoDefaultLib = node.hasNoDefaultLib; }
+ if (libReferenceDirectives === void 0) { libReferenceDirectives = node.libReferenceDirectives; }
+ return node.statements !== statements
+ || node.isDeclarationFile !== isDeclarationFile
+ || node.referencedFiles !== referencedFiles
+ || node.typeReferenceDirectives !== typeReferenceDirectives
+ || node.hasNoDefaultLib !== hasNoDefaultLib
+ || node.libReferenceDirectives !== libReferenceDirectives
+ ? update(cloneSourceFileWithChanges(node, statements, isDeclarationFile, referencedFiles, typeReferenceDirectives, hasNoDefaultLib, libReferenceDirectives), node)
+ : node;
+ }
+ function createBundle(sourceFiles, prepends) {
+ if (prepends === void 0) { prepends = ts.emptyArray; }
+ var node = createBaseNode(298);
+ node.prepends = prepends;
+ node.sourceFiles = sourceFiles;
+ return node;
+ }
+ function updateBundle(node, sourceFiles, prepends) {
+ if (prepends === void 0) { prepends = ts.emptyArray; }
+ return node.sourceFiles !== sourceFiles
+ || node.prepends !== prepends
+ ? update(createBundle(sourceFiles, prepends), node)
+ : node;
+ }
+ function createUnparsedSource(prologues, syntheticReferences, texts) {
+ var node = createBaseNode(299);
+ node.prologues = prologues;
+ node.syntheticReferences = syntheticReferences;
+ node.texts = texts;
+ node.fileName = "";
+ node.text = "";
+ node.referencedFiles = ts.emptyArray;
+ node.libReferenceDirectives = ts.emptyArray;
+ node.getLineAndCharacterOfPosition = function (pos) { return ts.getLineAndCharacterOfPosition(node, pos); };
+ return node;
+ }
+ function createBaseUnparsedNode(kind, data) {
+ var node = createBaseNode(kind);
+ node.data = data;
+ return node;
+ }
+ function createUnparsedPrologue(data) {
+ return createBaseUnparsedNode(292, data);
+ }
+ function createUnparsedPrepend(data, texts) {
+ var node = createBaseUnparsedNode(293, data);
+ node.texts = texts;
+ return node;
+ }
+ function createUnparsedTextLike(data, internal) {
+ return createBaseUnparsedNode(internal ? 295 : 294, data);
+ }
+ function createUnparsedSyntheticReference(section) {
+ var node = createBaseNode(296);
+ node.data = section.data;
+ node.section = section;
+ return node;
+ }
+ function createInputFiles() {
+ var node = createBaseNode(300);
+ node.javascriptText = "";
+ node.declarationText = "";
+ return node;
+ }
+ function createSyntheticExpression(type, isSpread, tupleNameSource) {
+ if (isSpread === void 0) { isSpread = false; }
+ var node = createBaseNode(227);
+ node.type = type;
+ node.isSpread = isSpread;
+ node.tupleNameSource = tupleNameSource;
+ return node;
+ }
+ function createSyntaxList(children) {
+ var node = createBaseNode(334);
+ node._children = children;
+ return node;
+ }
+ function createNotEmittedStatement(original) {
+ var node = createBaseNode(335);
+ node.original = original;
+ ts.setTextRange(node, original);
+ return node;
+ }
+ function createPartiallyEmittedExpression(expression, original) {
+ var node = createBaseNode(336);
+ node.expression = expression;
+ node.original = original;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ 1;
+ ts.setTextRange(node, original);
+ return node;
+ }
+ function updatePartiallyEmittedExpression(node, expression) {
+ return node.expression !== expression
+ ? update(createPartiallyEmittedExpression(expression, node.original), node)
+ : node;
+ }
+ function flattenCommaElements(node) {
+ if (ts.nodeIsSynthesized(node) && !ts.isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) {
+ if (ts.isCommaListExpression(node)) {
+ return node.elements;
}
- }
- parseExpected(22);
- node.typeParameter = parseMappedTypeParameter();
- parseExpected(23);
- if (token() === 57 || token() === 39 || token() === 40) {
- node.questionToken = parseTokenNode();
- if (node.questionToken.kind !== 57) {
- parseExpectedToken(57);
+ if (ts.isBinaryExpression(node) && ts.isCommaToken(node.operatorToken)) {
+ return [node.left, node.right];
}
}
- node.type = parseTypeAnnotation();
- parseSemicolon();
- parseExpected(19);
- return finishNode(node);
+ return node;
}
- function parseTupleElementType() {
- var pos = getNodePos();
- if (parseOptional(25)) {
- var node = createNode(177, pos);
- node.type = parseType();
- return finishNode(node);
- }
- var type = parseType();
- if (!(contextFlags & 4194304) && type.kind === 297 && type.pos === type.type.pos) {
- type.kind = 176;
- }
- return type;
+ function createCommaListExpression(elements) {
+ var node = createBaseNode(337);
+ node.elements = createNodeArray(ts.sameFlatMap(elements, flattenCommaElements));
+ node.transformFlags |= propagateChildrenFlags(node.elements);
+ return node;
}
- function parseTupleType() {
- var node = createNode(175);
- node.elementTypes = parseBracketedList(21, parseTupleElementType, 22, 23);
- return finishNode(node);
+ function updateCommaListExpression(node, elements) {
+ return node.elements !== elements
+ ? update(createCommaListExpression(elements), node)
+ : node;
}
- function parseParenthesizedType() {
- var node = createNode(182);
- parseExpected(20);
- node.type = parseType();
- parseExpected(21);
- return finishNode(node);
+ function createEndOfDeclarationMarker(original) {
+ var node = createBaseNode(339);
+ node.emitNode = {};
+ node.original = original;
+ return node;
}
- function parseFunctionOrConstructorType() {
- var pos = getNodePos();
- var kind = parseOptional(99) ? 171 : 170;
- var node = createNodeWithJSDoc(kind, pos);
- fillSignature(38, 4, node);
- return finishNode(node);
+ function createMergeDeclarationMarker(original) {
+ var node = createBaseNode(338);
+ node.emitNode = {};
+ node.original = original;
+ return node;
}
- function parseKeywordAndNoDot() {
- var node = parseTokenNode();
- return token() === 24 ? undefined : node;
+ function createSyntheticReferenceExpression(expression, thisArg) {
+ var node = createBaseNode(340);
+ node.expression = expression;
+ node.thisArg = thisArg;
+ node.transformFlags |=
+ propagateChildFlags(node.expression) |
+ propagateChildFlags(node.thisArg);
+ return node;
}
- function parseLiteralTypeNode(negative) {
- var node = createNode(187);
- var unaryMinusExpression;
- if (negative) {
- unaryMinusExpression = createNode(207);
- unaryMinusExpression.operator = 40;
- nextToken();
+ function updateSyntheticReferenceExpression(node, expression, thisArg) {
+ return node.expression !== expression
+ || node.thisArg !== thisArg
+ ? update(createSyntheticReferenceExpression(expression, thisArg), node)
+ : node;
+ }
+ function cloneNode(node) {
+ if (node === undefined) {
+ return node;
}
- var expression = token() === 106 || token() === 91
- ? parseTokenNode()
- : parseLiteralLikeNode(token());
- if (negative) {
- unaryMinusExpression.operand = expression;
- finishNode(unaryMinusExpression);
- expression = unaryMinusExpression;
+ var clone = ts.isSourceFile(node) ? baseFactory.createBaseSourceFileNode(297) :
+ ts.isIdentifier(node) ? baseFactory.createBaseIdentifierNode(78) :
+ ts.isPrivateIdentifier(node) ? baseFactory.createBasePrivateIdentifierNode(79) :
+ !ts.isNodeKind(node.kind) ? baseFactory.createBaseTokenNode(node.kind) :
+ baseFactory.createBaseNode(node.kind);
+ clone.flags |= (node.flags & ~8);
+ clone.transformFlags = node.transformFlags;
+ setOriginalNode(clone, node);
+ for (var key in node) {
+ if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {
+ continue;
+ }
+ clone[key] = node[key];
}
- node.literal = expression;
- return finishNode(node);
+ return clone;
}
- function isStartOfTypeOfImportType() {
- nextToken();
- return token() === 96;
+ function createImmediatelyInvokedFunctionExpression(statements, param, paramValue) {
+ return createCallExpression(createFunctionExpression(undefined, undefined, undefined, undefined, param ? [param] : [], undefined, createBlock(statements, true)), undefined, paramValue ? [paramValue] : []);
}
- function parseImportType() {
- sourceFile.flags |= 1048576;
- var node = createNode(188);
- if (parseOptional(108)) {
- node.isTypeOf = true;
+ function createImmediatelyInvokedArrowFunction(statements, param, paramValue) {
+ return createCallExpression(createArrowFunction(undefined, undefined, param ? [param] : [], undefined, undefined, createBlock(statements, true)), undefined, paramValue ? [paramValue] : []);
+ }
+ function createVoidZero() {
+ return createVoidExpression(createNumericLiteral("0"));
+ }
+ function createExportDefault(expression) {
+ return createExportAssignment(undefined, undefined, false, expression);
+ }
+ function createExternalModuleExport(exportName) {
+ return createExportDeclaration(undefined, undefined, false, createNamedExports([
+ createExportSpecifier(undefined, exportName)
+ ]));
+ }
+ function createTypeCheck(value, tag) {
+ return tag === "undefined"
+ ? factory.createStrictEquality(value, createVoidZero())
+ : factory.createStrictEquality(createTypeOfExpression(value), createStringLiteral(tag));
+ }
+ function createMethodCall(object, methodName, argumentsList) {
+ return createCallExpression(createPropertyAccessExpression(object, methodName), undefined, argumentsList);
+ }
+ function createFunctionBindCall(target, thisArg, argumentsList) {
+ return createMethodCall(target, "bind", __spreadArrays([thisArg], argumentsList));
+ }
+ function createFunctionCallCall(target, thisArg, argumentsList) {
+ return createMethodCall(target, "call", __spreadArrays([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 === undefined ? [] : [asExpression(start)]);
+ }
+ function createArrayConcatCall(array, argumentsList) {
+ return createMethodCall(array, "concat", argumentsList);
+ }
+ function createObjectDefinePropertyCall(target, propertyName, attributes) {
+ return createGlobalMethodCall("Object", "defineProperty", [target, asExpression(propertyName), attributes]);
+ }
+ function tryAddPropertyAssignment(properties, propertyName, expression) {
+ if (expression) {
+ properties.push(createPropertyAssignment(propertyName, expression));
+ return true;
}
- parseExpected(96);
- parseExpected(20);
- node.argument = parseType();
- parseExpected(21);
- if (parseOptional(24)) {
- node.qualifier = parseEntityName(true, ts.Diagnostics.Type_expected);
+ return false;
+ }
+ function createPropertyDescriptor(attributes, singleLine) {
+ var properties = [];
+ tryAddPropertyAssignment(properties, "enumerable", asExpression(attributes.enumerable));
+ tryAddPropertyAssignment(properties, "configurable", asExpression(attributes.configurable));
+ var isData = tryAddPropertyAssignment(properties, "writable", asExpression(attributes.writable));
+ isData = tryAddPropertyAssignment(properties, "value", attributes.value) || isData;
+ var isAccessor = tryAddPropertyAssignment(properties, "get", attributes.get);
+ isAccessor = tryAddPropertyAssignment(properties, "set", attributes.set) || isAccessor;
+ ts.Debug.assert(!(isData && isAccessor), "A PropertyDescriptor may not be both an accessor descriptor and a data descriptor.");
+ return createObjectLiteralExpression(properties, !singleLine);
+ }
+ function updateOuterExpression(outerExpression, expression) {
+ switch (outerExpression.kind) {
+ case 207: return updateParenthesizedExpression(outerExpression, expression);
+ case 206: return updateTypeAssertion(outerExpression, outerExpression.type, expression);
+ case 224: return updateAsExpression(outerExpression, expression, outerExpression.type);
+ case 225: return updateNonNullExpression(outerExpression, expression);
+ case 336: return updatePartiallyEmittedExpression(outerExpression, expression);
+ }
+ }
+ function isIgnorableParen(node) {
+ return ts.isParenthesizedExpression(node)
+ && ts.nodeIsSynthesized(node)
+ && ts.nodeIsSynthesized(ts.getSourceMapRange(node))
+ && ts.nodeIsSynthesized(ts.getCommentRange(node))
+ && !ts.some(ts.getSyntheticLeadingComments(node))
+ && !ts.some(ts.getSyntheticTrailingComments(node));
+ }
+ function restoreOuterExpressions(outerExpression, innerExpression, kinds) {
+ if (kinds === void 0) { kinds = 15; }
+ if (outerExpression && ts.isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) {
+ return updateOuterExpression(outerExpression, restoreOuterExpressions(outerExpression.expression, innerExpression));
+ }
+ return innerExpression;
+ }
+ function restoreEnclosingLabel(node, outermostLabeledStatement, afterRestoreLabelCallback) {
+ if (!outermostLabeledStatement) {
+ return node;
}
- if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29) {
- node.typeArguments = parseBracketedList(20, parseType, 29, 31);
+ var updated = updateLabeledStatement(outermostLabeledStatement, outermostLabeledStatement.label, ts.isLabeledStatement(outermostLabeledStatement.statement)
+ ? restoreEnclosingLabel(node, outermostLabeledStatement.statement)
+ : node);
+ if (afterRestoreLabelCallback) {
+ afterRestoreLabelCallback(outermostLabeledStatement);
}
- return finishNode(node);
- }
- function nextTokenIsNumericOrBigIntLiteral() {
- nextToken();
- return token() === 8 || token() === 9;
+ return updated;
}
- function parseNonArrayType() {
- switch (token()) {
- case 125:
- case 148:
- case 143:
- case 140:
- case 151:
- case 144:
- case 128:
- case 146:
- case 137:
- case 141:
- return tryParse(parseKeywordAndNoDot) || parseTypeReference();
- case 41:
- return parseJSDocAllType(false);
- case 65:
- return parseJSDocAllType(true);
- case 60:
- scanner.reScanQuestionToken();
- case 57:
- return parseJSDocUnknownOrNullableType();
- case 94:
- return parseJSDocFunctionType();
- case 53:
- return parseJSDocNonNullableType();
- case 14:
- case 10:
+ function shouldBeCapturedInTempVariable(node, cacheIdentifiers) {
+ var target = ts.skipParentheses(node);
+ switch (target.kind) {
+ case 78:
+ return cacheIdentifiers;
+ case 107:
case 8:
case 9:
- case 106:
- case 91:
- return parseLiteralTypeNode();
- case 40:
- return lookAhead(nextTokenIsNumericOrBigIntLiteral) ? parseLiteralTypeNode(true) : parseTypeReference();
- case 110:
- case 100:
- return parseTokenNode();
- case 104: {
- var thisKeyword = parseThisTypeNode();
- if (token() === 133 && !scanner.hasPrecedingLineBreak()) {
- return parseThisTypePredicate(thisKeyword);
- }
- else {
- return thisKeyword;
+ case 10:
+ return false;
+ case 199:
+ var elements = target.elements;
+ if (elements.length === 0) {
+ return false;
}
- }
- case 108:
- return lookAhead(isStartOfTypeOfImportType) ? parseImportType() : parseTypeQuery();
- case 18:
- return lookAhead(isStartOfMappedType) ? parseMappedType() : parseTypeLiteral();
- case 22:
- return parseTupleType();
- case 20:
- return parseParenthesizedType();
- case 96:
- return parseImportType();
- case 124:
- return lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? parseAssertsTypePredicate() : parseTypeReference();
+ return true;
+ case 200:
+ return target.properties.length > 0;
default:
- return parseTypeReference();
+ return true;
}
}
- function isStartOfType(inStartOfParameter) {
- switch (token()) {
- case 125:
- case 148:
- case 143:
- case 140:
- case 151:
- case 128:
- case 138:
- case 144:
- case 147:
- case 110:
- case 146:
- case 100:
- case 104:
- case 108:
- case 137:
- case 18:
- case 22:
- case 29:
- case 51:
- case 50:
- case 99:
- case 10:
- case 8:
- case 9:
- case 106:
- case 91:
- case 141:
- case 41:
- case 57:
- case 53:
- case 25:
- case 132:
- case 96:
- case 124:
- return true;
- case 94:
- return !inStartOfParameter;
- case 40:
- return !inStartOfParameter && lookAhead(nextTokenIsNumericOrBigIntLiteral);
- case 20:
- return !inStartOfParameter && lookAhead(isStartOfParenthesizedOrFunctionType);
- default:
- return isIdentifier();
+ function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers) {
+ if (cacheIdentifiers === void 0) { cacheIdentifiers = false; }
+ var callee = ts.skipOuterExpressions(expression, 15);
+ var thisArg;
+ var target;
+ if (ts.isSuperProperty(callee)) {
+ thisArg = createThis();
+ target = callee;
+ }
+ else if (ts.isSuperKeyword(callee)) {
+ thisArg = createThis();
+ target = languageVersion !== undefined && languageVersion < 2
+ ? ts.setTextRange(createIdentifier("_super"), callee)
+ : callee;
+ }
+ else if (ts.getEmitFlags(callee) & 4096) {
+ thisArg = createVoidZero();
+ target = parenthesizerRules().parenthesizeLeftSideOfAccess(callee);
+ }
+ else if (ts.isPropertyAccessExpression(callee)) {
+ if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) {
+ thisArg = createTempVariable(recordTempVariable);
+ target = createPropertyAccessExpression(ts.setTextRange(factory.createAssignment(thisArg, callee.expression), callee.expression), callee.name);
+ ts.setTextRange(target, callee);
+ }
+ else {
+ thisArg = callee.expression;
+ target = callee;
+ }
+ }
+ else if (ts.isElementAccessExpression(callee)) {
+ if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) {
+ thisArg = createTempVariable(recordTempVariable);
+ target = createElementAccessExpression(ts.setTextRange(factory.createAssignment(thisArg, callee.expression), callee.expression), callee.argumentExpression);
+ ts.setTextRange(target, callee);
+ }
+ else {
+ thisArg = callee.expression;
+ target = callee;
+ }
+ }
+ else {
+ thisArg = createVoidZero();
+ target = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+ }
+ return { target: target, thisArg: thisArg };
+ }
+ function inlineExpressions(expressions) {
+ return expressions.length > 10
+ ? createCommaListExpression(expressions)
+ : ts.reduceLeft(expressions, factory.createComma);
+ }
+ function getName(node, allowComments, allowSourceMaps, emitFlags) {
+ if (emitFlags === void 0) { emitFlags = 0; }
+ var nodeName = ts.getNameOfDeclaration(node);
+ if (nodeName && ts.isIdentifier(nodeName) && !ts.isGeneratedIdentifier(nodeName)) {
+ var name = ts.setParent(ts.setTextRange(cloneNode(nodeName), nodeName), nodeName.parent);
+ emitFlags |= ts.getEmitFlags(nodeName);
+ if (!allowSourceMaps)
+ emitFlags |= 48;
+ if (!allowComments)
+ emitFlags |= 1536;
+ if (emitFlags)
+ ts.setEmitFlags(name, emitFlags);
+ return name;
}
+ return getGeneratedNameForNode(node);
}
- function isStartOfParenthesizedOrFunctionType() {
- nextToken();
- return token() === 21 || isStartOfParameter(false) || isStartOfType();
+ function getInternalName(node, allowComments, allowSourceMaps) {
+ return getName(node, allowComments, allowSourceMaps, 16384 | 32768);
}
- function parsePostfixTypeOrHigher() {
- var type = parseNonArrayType();
- while (!scanner.hasPrecedingLineBreak()) {
- switch (token()) {
- case 53:
- type = createPostfixType(298, type);
- break;
- case 57:
- if (!(contextFlags & 4194304) && lookAhead(nextTokenIsStartOfType)) {
- return type;
- }
- type = createPostfixType(297, type);
- break;
- case 22:
- parseExpected(22);
- if (isStartOfType()) {
- var node = createNode(185, type.pos);
- node.objectType = type;
- node.indexType = parseType();
- parseExpected(23);
- type = finishNode(node);
- }
- else {
- var node = createNode(174, type.pos);
- node.elementType = type;
- parseExpected(23);
- type = finishNode(node);
- }
- break;
- default:
- return type;
- }
+ function getLocalName(node, allowComments, allowSourceMaps) {
+ return getName(node, allowComments, allowSourceMaps, 16384);
+ }
+ function getExportName(node, allowComments, allowSourceMaps) {
+ return getName(node, allowComments, allowSourceMaps, 8192);
+ }
+ function getDeclarationName(node, allowComments, allowSourceMaps) {
+ return getName(node, allowComments, allowSourceMaps);
+ }
+ function getNamespaceMemberName(ns, name, allowComments, allowSourceMaps) {
+ var qualifiedName = createPropertyAccessExpression(ns, ts.nodeIsSynthesized(name) ? name : cloneNode(name));
+ ts.setTextRange(qualifiedName, name);
+ var emitFlags = 0;
+ if (!allowSourceMaps)
+ emitFlags |= 48;
+ if (!allowComments)
+ emitFlags |= 1536;
+ if (emitFlags)
+ ts.setEmitFlags(qualifiedName, emitFlags);
+ return qualifiedName;
+ }
+ function getExternalModuleOrNamespaceExportName(ns, node, allowComments, allowSourceMaps) {
+ if (ns && ts.hasSyntacticModifier(node, 1)) {
+ return getNamespaceMemberName(ns, getName(node), allowComments, allowSourceMaps);
}
- return type;
+ return getExportName(node, allowComments, allowSourceMaps);
}
- function createPostfixType(kind, type) {
- nextToken();
- var postfix = createNode(kind, type.pos);
- postfix.type = type;
- return finishNode(postfix);
+ function copyPrologue(source, target, ensureUseStrict, visitor) {
+ var offset = copyStandardPrologue(source, target, ensureUseStrict);
+ return copyCustomPrologue(source, target, offset, visitor);
}
- function parseTypeOperator(operator) {
- var node = createNode(184);
- parseExpected(operator);
- node.operator = operator;
- node.type = parseTypeOperatorOrHigher();
- return finishNode(node);
+ function isUseStrictPrologue(node) {
+ return ts.isStringLiteral(node.expression) && node.expression.text === "use strict";
}
- function parseInferType() {
- var node = createNode(181);
- parseExpected(132);
- var typeParameter = createNode(155);
- typeParameter.name = parseIdentifier();
- node.typeParameter = finishNode(typeParameter);
- return finishNode(node);
+ function createUseStrictPrologue() {
+ return ts.startOnNewLine(createExpressionStatement(createStringLiteral("use strict")));
}
- function parseTypeOperatorOrHigher() {
- var operator = token();
- switch (operator) {
- case 134:
- case 147:
- case 138:
- return parseTypeOperator(operator);
- case 132:
- return parseInferType();
+ function copyStandardPrologue(source, target, ensureUseStrict) {
+ ts.Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array");
+ var foundUseStrict = false;
+ var statementOffset = 0;
+ var numStatements = source.length;
+ while (statementOffset < numStatements) {
+ var statement = source[statementOffset];
+ if (ts.isPrologueDirective(statement)) {
+ if (isUseStrictPrologue(statement)) {
+ foundUseStrict = true;
+ }
+ target.push(statement);
+ }
+ else {
+ break;
+ }
+ statementOffset++;
}
- return parsePostfixTypeOrHigher();
+ if (ensureUseStrict && !foundUseStrict) {
+ target.push(createUseStrictPrologue());
+ }
+ return statementOffset;
}
- function parseUnionOrIntersectionType(kind, parseConstituentType, operator) {
- var start = scanner.getStartPos();
- var hasLeadingOperator = parseOptional(operator);
- var type = parseConstituentType();
- if (token() === operator || hasLeadingOperator) {
- var types = [type];
- while (parseOptional(operator)) {
- types.push(parseConstituentType());
+ function copyCustomPrologue(source, target, statementOffset, visitor, filter) {
+ if (filter === void 0) { filter = ts.returnTrue; }
+ var numStatements = source.length;
+ while (statementOffset !== undefined && statementOffset < numStatements) {
+ var statement = source[statementOffset];
+ if (ts.getEmitFlags(statement) & 1048576 && filter(statement)) {
+ ts.append(target, visitor ? ts.visitNode(statement, visitor, ts.isStatement) : statement);
+ }
+ else {
+ break;
}
- var node = createNode(kind, start);
- node.types = createNodeArray(types, start);
- type = finishNode(node);
+ statementOffset++;
}
- return type;
+ return statementOffset;
}
- function parseIntersectionTypeOrHigher() {
- return parseUnionOrIntersectionType(179, parseTypeOperatorOrHigher, 50);
+ function ensureUseStrict(statements) {
+ var foundUseStrict = ts.findUseStrictPrologue(statements);
+ if (!foundUseStrict) {
+ return ts.setTextRange(createNodeArray(__spreadArrays([createUseStrictPrologue()], statements)), statements);
+ }
+ return statements;
}
- function parseUnionTypeOrHigher() {
- return parseUnionOrIntersectionType(178, parseIntersectionTypeOrHigher, 51);
+ function liftToBlock(nodes) {
+ ts.Debug.assert(ts.every(nodes, ts.isStatementOrBlock), "Cannot lift nodes to a Block.");
+ return ts.singleOrUndefined(nodes) || createBlock(nodes);
}
- function isStartOfFunctionType() {
- if (token() === 29) {
- return true;
+ function findSpanEnd(array, test, start) {
+ var i = start;
+ while (i < array.length && test(array[i])) {
+ i++;
}
- return token() === 20 && lookAhead(isUnambiguouslyStartOfFunctionType);
+ return i;
}
- function skipParameterStart() {
- if (ts.isModifierKind(token())) {
- parseModifiers();
+ function mergeLexicalEnvironment(statements, declarations) {
+ if (!ts.some(declarations)) {
+ return statements;
}
- if (isIdentifier() || token() === 104) {
- nextToken();
- return true;
+ var leftStandardPrologueEnd = findSpanEnd(statements, ts.isPrologueDirective, 0);
+ var leftHoistedFunctionsEnd = findSpanEnd(statements, ts.isHoistedFunction, leftStandardPrologueEnd);
+ var leftHoistedVariablesEnd = findSpanEnd(statements, ts.isHoistedVariableStatement, leftHoistedFunctionsEnd);
+ var rightStandardPrologueEnd = findSpanEnd(declarations, ts.isPrologueDirective, 0);
+ var rightHoistedFunctionsEnd = findSpanEnd(declarations, ts.isHoistedFunction, rightStandardPrologueEnd);
+ var rightHoistedVariablesEnd = findSpanEnd(declarations, ts.isHoistedVariableStatement, rightHoistedFunctionsEnd);
+ var rightCustomPrologueEnd = findSpanEnd(declarations, ts.isCustomPrologue, rightHoistedVariablesEnd);
+ ts.Debug.assert(rightCustomPrologueEnd === declarations.length, "Expected declarations to be valid standard or custom prologues");
+ var left = ts.isNodeArray(statements) ? statements.slice() : statements;
+ if (rightCustomPrologueEnd > rightHoistedVariablesEnd) {
+ left.splice.apply(left, __spreadArrays([leftHoistedVariablesEnd, 0], declarations.slice(rightHoistedVariablesEnd, rightCustomPrologueEnd)));
}
- if (token() === 22 || token() === 18) {
- var previousErrorCount = parseDiagnostics.length;
- parseIdentifierOrPattern();
- return previousErrorCount === parseDiagnostics.length;
+ if (rightHoistedVariablesEnd > rightHoistedFunctionsEnd) {
+ left.splice.apply(left, __spreadArrays([leftHoistedFunctionsEnd, 0], declarations.slice(rightHoistedFunctionsEnd, rightHoistedVariablesEnd)));
}
- return false;
- }
- function isUnambiguouslyStartOfFunctionType() {
- nextToken();
- if (token() === 21 || token() === 25) {
- return true;
+ if (rightHoistedFunctionsEnd > rightStandardPrologueEnd) {
+ left.splice.apply(left, __spreadArrays([leftStandardPrologueEnd, 0], declarations.slice(rightStandardPrologueEnd, rightHoistedFunctionsEnd)));
}
- if (skipParameterStart()) {
- if (token() === 58 || token() === 27 ||
- token() === 57 || token() === 62) {
- return true;
+ if (rightStandardPrologueEnd > 0) {
+ if (leftStandardPrologueEnd === 0) {
+ left.splice.apply(left, __spreadArrays([0, 0], declarations.slice(0, rightStandardPrologueEnd)));
}
- if (token() === 21) {
- nextToken();
- if (token() === 38) {
- return true;
+ else {
+ var leftPrologues = new ts.Map();
+ for (var i = 0; i < leftStandardPrologueEnd; i++) {
+ var leftPrologue = statements[i];
+ leftPrologues.set(leftPrologue.expression.text, true);
+ }
+ for (var i = rightStandardPrologueEnd - 1; i >= 0; i--) {
+ var rightPrologue = declarations[i];
+ if (!leftPrologues.has(rightPrologue.expression.text)) {
+ left.unshift(rightPrologue);
+ }
}
}
}
- return false;
- }
- function parseTypeOrTypePredicate() {
- var typePredicateVariable = isIdentifier() && tryParse(parseTypePredicatePrefix);
- var type = parseType();
- if (typePredicateVariable) {
- var node = createNode(168, typePredicateVariable.pos);
- node.assertsModifier = undefined;
- node.parameterName = typePredicateVariable;
- node.type = type;
- return finishNode(node);
- }
- else {
- return type;
+ if (ts.isNodeArray(statements)) {
+ return ts.setTextRange(createNodeArray(left, statements.hasTrailingComma), statements);
}
+ return statements;
}
- function parseTypePredicatePrefix() {
- var id = parseIdentifier();
- if (token() === 133 && !scanner.hasPrecedingLineBreak()) {
- nextToken();
- return id;
- }
+ function updateModifiers(node, modifiers) {
+ var _a;
+ if (typeof modifiers === "number") {
+ modifiers = createModifiersFromModifierFlags(modifiers);
+ }
+ return ts.isParameter(node) ? updateParameterDeclaration(node, node.decorators, modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) :
+ ts.isPropertySignature(node) ? updatePropertySignature(node, modifiers, node.name, node.questionToken, node.type) :
+ ts.isPropertyDeclaration(node) ? updatePropertyDeclaration(node, node.decorators, modifiers, node.name, (_a = node.questionToken) !== null && _a !== void 0 ? _a : node.exclamationToken, node.type, node.initializer) :
+ ts.isMethodSignature(node) ? updateMethodSignature(node, modifiers, node.name, node.questionToken, node.typeParameters, node.parameters, node.type) :
+ ts.isMethodDeclaration(node) ? updateMethodDeclaration(node, node.decorators, modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) :
+ ts.isConstructorDeclaration(node) ? updateConstructorDeclaration(node, node.decorators, modifiers, node.parameters, node.body) :
+ ts.isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, node.decorators, modifiers, node.name, node.parameters, node.type, node.body) :
+ ts.isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, node.decorators, modifiers, node.name, node.parameters, node.body) :
+ ts.isIndexSignatureDeclaration(node) ? updateIndexSignature(node, node.decorators, modifiers, node.parameters, node.type) :
+ ts.isFunctionExpression(node) ? updateFunctionExpression(node, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
+ ts.isArrowFunction(node) ? updateArrowFunction(node, modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body) :
+ ts.isClassExpression(node) ? updateClassExpression(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) :
+ ts.isVariableStatement(node) ? updateVariableStatement(node, modifiers, node.declarationList) :
+ ts.isFunctionDeclaration(node) ? updateFunctionDeclaration(node, node.decorators, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
+ ts.isClassDeclaration(node) ? updateClassDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) :
+ ts.isInterfaceDeclaration(node) ? updateInterfaceDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) :
+ ts.isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.type) :
+ ts.isEnumDeclaration(node) ? updateEnumDeclaration(node, node.decorators, modifiers, node.name, node.members) :
+ ts.isModuleDeclaration(node) ? updateModuleDeclaration(node, node.decorators, modifiers, node.name, node.body) :
+ ts.isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, node.decorators, modifiers, node.name, node.moduleReference) :
+ ts.isImportDeclaration(node) ? updateImportDeclaration(node, node.decorators, modifiers, node.importClause, node.moduleSpecifier) :
+ ts.isExportAssignment(node) ? updateExportAssignment(node, node.decorators, modifiers, node.expression) :
+ ts.isExportDeclaration(node) ? updateExportDeclaration(node, node.decorators, modifiers, node.isTypeOnly, node.exportClause, node.moduleSpecifier) :
+ ts.Debug.assertNever(node);
+ }
+ function asNodeArray(array) {
+ return array ? createNodeArray(array) : undefined;
+ }
+ function asName(name) {
+ return typeof name === "string" ? createIdentifier(name) :
+ name;
+ }
+ function asExpression(value) {
+ return typeof value === "string" ? createStringLiteral(value) :
+ typeof value === "number" ? createNumericLiteral(value) :
+ typeof value === "boolean" ? value ? createTrue() : createFalse() :
+ value;
+ }
+ function asToken(value) {
+ return typeof value === "number" ? createToken(value) : value;
+ }
+ function asEmbeddedStatement(statement) {
+ return statement && ts.isNotEmittedStatement(statement) ? ts.setTextRange(setOriginalNode(createEmptyStatement(), statement), statement) : statement;
+ }
+ }
+ ts.createNodeFactory = createNodeFactory;
+ function updateWithoutOriginal(updated, original) {
+ if (updated !== original) {
+ ts.setTextRange(updated, original);
}
- function parseAssertsTypePredicate() {
- var node = createNode(168);
- node.assertsModifier = parseExpectedToken(124);
- node.parameterName = token() === 104 ? parseThisTypeNode() : parseIdentifier();
- node.type = parseOptional(133) ? parseType() : undefined;
- return finishNode(node);
+ return updated;
+ }
+ function updateWithOriginal(updated, original) {
+ if (updated !== original) {
+ setOriginalNode(updated, original);
+ ts.setTextRange(updated, original);
}
- function parseType() {
- return doOutsideOfContext(40960, parseTypeWorker);
+ return updated;
+ }
+ function getDefaultTagNameForKind(kind) {
+ switch (kind) {
+ case 329: return "type";
+ case 327: return "returns";
+ case 328: return "this";
+ case 325: return "enum";
+ case 317: return "author";
+ case 319: return "class";
+ case 320: return "public";
+ case 321: return "private";
+ case 322: return "protected";
+ case 323: return "readonly";
+ case 330: return "template";
+ case 331: return "typedef";
+ case 326: return "param";
+ case 333: return "prop";
+ case 324: return "callback";
+ case 315: return "augments";
+ case 316: return "implements";
+ default:
+ return ts.Debug.fail("Unsupported kind: " + ts.Debug.formatSyntaxKind(kind));
}
- function parseTypeWorker(noConditionalTypes) {
- if (isStartOfFunctionType() || token() === 99) {
- return parseFunctionOrConstructorType();
- }
- var type = parseUnionTypeOrHigher();
- if (!noConditionalTypes && !scanner.hasPrecedingLineBreak() && parseOptional(90)) {
- var node = createNode(180, type.pos);
- node.checkType = type;
- node.extendsType = parseTypeWorker(true);
- parseExpected(57);
- node.trueType = parseTypeWorker();
- parseExpected(58);
- node.falseType = parseTypeWorker();
- return finishNode(node);
- }
- return type;
+ }
+ var rawTextScanner;
+ var invalidValueSentinel = {};
+ function getCookedText(kind, rawText) {
+ if (!rawTextScanner) {
+ rawTextScanner = ts.createScanner(99, false, 0);
}
- function parseTypeAnnotation() {
- return parseOptional(58) ? parseType() : undefined;
- }
- function isStartOfLeftHandSideExpression() {
- switch (token()) {
- case 104:
- case 102:
- case 100:
- case 106:
- case 91:
- case 8:
- case 9:
- case 10:
- case 14:
- case 15:
- case 20:
- case 22:
- case 18:
- case 94:
- case 80:
- case 99:
- case 43:
- case 67:
- case 75:
- return true;
- case 96:
- return lookAhead(nextTokenIsOpenParenOrLessThanOrDot);
- default:
- return isIdentifier();
- }
- }
- function isStartOfExpression() {
- if (isStartOfLeftHandSideExpression()) {
- return true;
- }
- switch (token()) {
- case 39:
- case 40:
- case 54:
- case 53:
- case 85:
- case 108:
- case 110:
- case 45:
- case 46:
- case 29:
- case 127:
- case 121:
- case 76:
- return true;
- default:
- if (isBinaryOperator()) {
- return true;
- }
- return isIdentifier();
- }
+ switch (kind) {
+ case 14:
+ rawTextScanner.setText("`" + rawText + "`");
+ break;
+ case 15:
+ rawTextScanner.setText("`" + rawText + "${");
+ break;
+ case 16:
+ rawTextScanner.setText("}" + rawText + "${");
+ break;
+ case 17:
+ rawTextScanner.setText("}" + rawText + "`");
+ break;
}
- function isStartOfExpressionStatement() {
- return token() !== 18 &&
- token() !== 94 &&
- token() !== 80 &&
- token() !== 59 &&
- isStartOfExpression();
+ var token = rawTextScanner.scan();
+ if (token === 23) {
+ token = rawTextScanner.reScanTemplateToken(false);
}
- function parseExpression() {
- var saveDecoratorContext = inDecoratorContext();
- if (saveDecoratorContext) {
- setDecoratorContext(false);
- }
- var expr = parseAssignmentExpressionOrHigher();
- var operatorToken;
- while ((operatorToken = parseOptionalToken(27))) {
- expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher());
- }
- if (saveDecoratorContext) {
- setDecoratorContext(true);
- }
- return expr;
+ if (rawTextScanner.isUnterminated()) {
+ rawTextScanner.setText(undefined);
+ return invalidValueSentinel;
}
- function parseInitializer() {
- return parseOptional(62) ? parseAssignmentExpressionOrHigher() : undefined;
+ var tokenValue;
+ switch (token) {
+ case 14:
+ case 15:
+ case 16:
+ case 17:
+ tokenValue = rawTextScanner.getTokenValue();
+ break;
}
- function parseAssignmentExpressionOrHigher() {
- if (isYieldExpression()) {
- return parseYieldExpression();
- }
- var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
- if (arrowExpression) {
- return arrowExpression;
- }
- var expr = parseBinaryExpressionOrHigher(0);
- if (expr.kind === 75 && token() === 38) {
- return parseSimpleArrowFunctionExpression(expr);
- }
- if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
- return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher());
- }
- return parseConditionalExpressionRest(expr);
+ if (tokenValue === undefined || rawTextScanner.scan() !== 1) {
+ rawTextScanner.setText(undefined);
+ return invalidValueSentinel;
}
- function isYieldExpression() {
- if (token() === 121) {
- if (inYieldContext()) {
- return true;
- }
- return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine);
- }
- return false;
+ rawTextScanner.setText(undefined);
+ return tokenValue;
+ }
+ function propagateIdentifierNameFlags(node) {
+ return propagateChildFlags(node) & ~8388608;
+ }
+ function propagatePropertyNameFlagsOfChild(node, transformFlags) {
+ return transformFlags | (node.transformFlags & 4096);
+ }
+ function propagateChildFlags(child) {
+ if (!child)
+ return 0;
+ var childFlags = child.transformFlags & ~getTransformFlagsSubtreeExclusions(child.kind);
+ return ts.isNamedDeclaration(child) && ts.isPropertyName(child.name) ? propagatePropertyNameFlagsOfChild(child.name, childFlags) : childFlags;
+ }
+ function propagateChildrenFlags(children) {
+ return children ? children.transformFlags : 0;
+ }
+ function aggregateChildrenFlags(children) {
+ var subtreeFlags = 0;
+ for (var _i = 0, children_2 = children; _i < children_2.length; _i++) {
+ var child = children_2[_i];
+ subtreeFlags |= propagateChildFlags(child);
}
- function nextTokenIsIdentifierOnSameLine() {
- nextToken();
- return !scanner.hasPrecedingLineBreak() && isIdentifier();
+ children.transformFlags = subtreeFlags;
+ }
+ function getTransformFlagsSubtreeExclusions(kind) {
+ if (kind >= 172 && kind <= 195) {
+ return -2;
}
- function parseYieldExpression() {
- var node = createNode(212);
- nextToken();
- if (!scanner.hasPrecedingLineBreak() &&
- (token() === 41 || isStartOfExpression())) {
- node.asteriskToken = parseOptionalToken(41);
- node.expression = parseAssignmentExpressionOrHigher();
- return finishNode(node);
- }
- else {
- return finishNode(node);
- }
+ switch (kind) {
+ case 203:
+ case 204:
+ case 199:
+ return 536879104;
+ case 256:
+ return 546379776;
+ case 160:
+ return 536870912;
+ case 209:
+ return 547309568;
+ case 208:
+ case 251:
+ return 547313664;
+ case 250:
+ return 537018368;
+ case 252:
+ case 221:
+ return 536905728;
+ case 166:
+ return 547311616;
+ case 163:
+ return 536875008;
+ case 165:
+ case 167:
+ case 168:
+ return 538923008;
+ case 128:
+ case 144:
+ case 155:
+ case 141:
+ case 147:
+ case 145:
+ case 131:
+ case 148:
+ case 113:
+ case 159:
+ case 162:
+ case 164:
+ case 169:
+ case 170:
+ case 171:
+ case 253:
+ case 254:
+ return -2;
+ case 200:
+ return 536922112;
+ case 287:
+ return 536887296;
+ case 196:
+ case 197:
+ return 536879104;
+ case 206:
+ case 224:
+ case 336:
+ case 207:
+ case 105:
+ return 536870912;
+ case 201:
+ case 202:
+ return 536870912;
+ default:
+ return 536870912;
}
- function parseSimpleArrowFunctionExpression(identifier, asyncModifier) {
- ts.Debug.assert(token() === 38, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
- var node;
- if (asyncModifier) {
- node = createNode(202, asyncModifier.pos);
- node.modifiers = asyncModifier;
- }
- else {
- node = createNode(202, identifier.pos);
+ }
+ ts.getTransformFlagsSubtreeExclusions = getTransformFlagsSubtreeExclusions;
+ var baseFactory = ts.createBaseNodeFactory();
+ function makeSynthetic(node) {
+ node.flags |= 8;
+ return node;
+ }
+ var syntheticFactory = {
+ createBaseSourceFileNode: function (kind) { return makeSynthetic(baseFactory.createBaseSourceFileNode(kind)); },
+ createBaseIdentifierNode: function (kind) { return makeSynthetic(baseFactory.createBaseIdentifierNode(kind)); },
+ createBasePrivateIdentifierNode: function (kind) { return makeSynthetic(baseFactory.createBasePrivateIdentifierNode(kind)); },
+ createBaseTokenNode: function (kind) { return makeSynthetic(baseFactory.createBaseTokenNode(kind)); },
+ createBaseNode: function (kind) { return makeSynthetic(baseFactory.createBaseNode(kind)); },
+ };
+ ts.factory = createNodeFactory(4, syntheticFactory);
+ function createUnparsedSourceFile(textOrInputFiles, mapPathOrType, mapTextOrStripInternal) {
+ var stripInternal;
+ var bundleFileInfo;
+ var fileName;
+ var text;
+ var length;
+ var sourceMapPath;
+ var sourceMapText;
+ var getText;
+ var getSourceMapText;
+ var oldFileOfCurrentEmit;
+ if (!ts.isString(textOrInputFiles)) {
+ ts.Debug.assert(mapPathOrType === "js" || mapPathOrType === "dts");
+ fileName = (mapPathOrType === "js" ? textOrInputFiles.javascriptPath : textOrInputFiles.declarationPath) || "";
+ sourceMapPath = mapPathOrType === "js" ? textOrInputFiles.javascriptMapPath : textOrInputFiles.declarationMapPath;
+ getText = function () { return mapPathOrType === "js" ? textOrInputFiles.javascriptText : textOrInputFiles.declarationText; };
+ getSourceMapText = function () { return mapPathOrType === "js" ? textOrInputFiles.javascriptMapText : textOrInputFiles.declarationMapText; };
+ length = function () { return getText().length; };
+ if (textOrInputFiles.buildInfo && textOrInputFiles.buildInfo.bundle) {
+ ts.Debug.assert(mapTextOrStripInternal === undefined || typeof mapTextOrStripInternal === "boolean");
+ stripInternal = mapTextOrStripInternal;
+ bundleFileInfo = mapPathOrType === "js" ? textOrInputFiles.buildInfo.bundle.js : textOrInputFiles.buildInfo.bundle.dts;
+ oldFileOfCurrentEmit = textOrInputFiles.oldFileOfCurrentEmit;
}
- var parameter = createNode(156, identifier.pos);
- parameter.name = identifier;
- finishNode(parameter);
- node.parameters = createNodeArray([parameter], parameter.pos, parameter.end);
- node.equalsGreaterThanToken = parseExpectedToken(38);
- node.body = parseArrowFunctionExpressionBody(!!asyncModifier);
- return addJSDocComment(finishNode(node));
}
- function tryParseParenthesizedArrowFunctionExpression() {
- var triState = isParenthesizedArrowFunctionExpression();
- if (triState === 0) {
- return undefined;
- }
- var arrowFunction = triState === 1
- ? parseParenthesizedArrowFunctionExpressionHead(true)
- : tryParse(parsePossibleParenthesizedArrowFunctionExpressionHead);
- if (!arrowFunction) {
- return undefined;
- }
- var isAsync = hasModifierOfKind(arrowFunction, 126);
- var lastToken = token();
- arrowFunction.equalsGreaterThanToken = parseExpectedToken(38);
- arrowFunction.body = (lastToken === 38 || lastToken === 18)
- ? parseArrowFunctionExpressionBody(isAsync)
- : parseIdentifier();
- return finishNode(arrowFunction);
+ else {
+ fileName = "";
+ text = textOrInputFiles;
+ length = textOrInputFiles.length;
+ sourceMapPath = mapPathOrType;
+ sourceMapText = mapTextOrStripInternal;
+ }
+ var node = oldFileOfCurrentEmit ?
+ parseOldFileOfCurrentEmit(ts.Debug.assertDefined(bundleFileInfo)) :
+ parseUnparsedSourceFile(bundleFileInfo, stripInternal, length);
+ node.fileName = fileName;
+ node.sourceMapPath = sourceMapPath;
+ node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
+ if (getText && getSourceMapText) {
+ Object.defineProperty(node, "text", { get: getText });
+ Object.defineProperty(node, "sourceMapText", { get: getSourceMapText });
}
- function isParenthesizedArrowFunctionExpression() {
- if (token() === 20 || token() === 29 || token() === 126) {
- return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
- }
- if (token() === 38) {
- return 1;
- }
- return 0;
+ else {
+ ts.Debug.assert(!oldFileOfCurrentEmit);
+ node.text = text !== null && text !== void 0 ? text : "";
+ node.sourceMapText = sourceMapText;
}
- function isParenthesizedArrowFunctionExpressionWorker() {
- if (token() === 126) {
- nextToken();
- if (scanner.hasPrecedingLineBreak()) {
- return 0;
- }
- if (token() !== 20 && token() !== 29) {
- return 0;
- }
- }
- var first = token();
- var second = nextToken();
- if (first === 20) {
- if (second === 21) {
- var third = nextToken();
- switch (third) {
- case 38:
- case 58:
- case 18:
- return 1;
- default:
- return 0;
- }
- }
- if (second === 22 || second === 18) {
- return 2;
- }
- if (second === 25) {
- return 1;
- }
- if (ts.isModifierKind(second) && second !== 126 && lookAhead(nextTokenIsIdentifier)) {
- return 1;
- }
- if (!isIdentifier() && second !== 104) {
- return 0;
- }
- switch (nextToken()) {
- case 58:
- return 1;
- case 57:
- nextToken();
- if (token() === 58 || token() === 27 || token() === 62 || token() === 21) {
- return 1;
- }
- return 0;
- case 27:
- case 62:
- case 21:
- return 2;
- }
- return 0;
- }
- else {
- ts.Debug.assert(first === 29);
- if (!isIdentifier()) {
- return 0;
- }
- if (sourceFile.languageVariant === 1) {
- var isArrowFunctionInJsx = lookAhead(function () {
- var third = nextToken();
- if (third === 90) {
- var fourth = nextToken();
- switch (fourth) {
- case 62:
- case 31:
- return false;
- default:
- return true;
- }
- }
- else if (third === 27) {
- return true;
+ return node;
+ }
+ ts.createUnparsedSourceFile = createUnparsedSourceFile;
+ function parseUnparsedSourceFile(bundleFileInfo, stripInternal, length) {
+ var prologues;
+ var helpers;
+ var referencedFiles;
+ var typeReferenceDirectives;
+ var libReferenceDirectives;
+ var prependChildren;
+ var texts;
+ var hasNoDefaultLib;
+ for (var _i = 0, _a = bundleFileInfo ? bundleFileInfo.sections : ts.emptyArray; _i < _a.length; _i++) {
+ var section = _a[_i];
+ switch (section.kind) {
+ case "prologue":
+ prologues = ts.append(prologues, ts.setTextRange(ts.factory.createUnparsedPrologue(section.data), section));
+ break;
+ case "emitHelpers":
+ helpers = ts.append(helpers, ts.getAllUnscopedEmitHelpers().get(section.data));
+ break;
+ case "no-default-lib":
+ hasNoDefaultLib = true;
+ break;
+ case "reference":
+ referencedFiles = ts.append(referencedFiles, { pos: -1, end: -1, fileName: section.data });
+ break;
+ case "type":
+ typeReferenceDirectives = ts.append(typeReferenceDirectives, section.data);
+ break;
+ case "lib":
+ libReferenceDirectives = ts.append(libReferenceDirectives, { pos: -1, end: -1, fileName: section.data });
+ break;
+ case "prepend":
+ var prependTexts = void 0;
+ for (var _b = 0, _c = section.texts; _b < _c.length; _b++) {
+ var text = _c[_b];
+ if (!stripInternal || text.kind !== "internal") {
+ prependTexts = ts.append(prependTexts, ts.setTextRange(ts.factory.createUnparsedTextLike(text.data, text.kind === "internal"), text));
}
- return false;
- });
- if (isArrowFunctionInJsx) {
- return 1;
}
- return 0;
- }
- return 2;
+ prependChildren = ts.addRange(prependChildren, prependTexts);
+ texts = ts.append(texts, ts.factory.createUnparsedPrepend(section.data, prependTexts !== null && prependTexts !== void 0 ? prependTexts : ts.emptyArray));
+ break;
+ case "internal":
+ if (stripInternal) {
+ if (!texts)
+ texts = [];
+ break;
+ }
+ case "text":
+ texts = ts.append(texts, ts.setTextRange(ts.factory.createUnparsedTextLike(section.data, section.kind === "internal"), section));
+ break;
+ default:
+ ts.Debug.assertNever(section);
}
}
- function parsePossibleParenthesizedArrowFunctionExpressionHead() {
- var tokenPos = scanner.getTokenPos();
- if (notParenthesizedArrow && notParenthesizedArrow.has(tokenPos.toString())) {
- return undefined;
- }
- var result = parseParenthesizedArrowFunctionExpressionHead(false);
- if (!result) {
- (notParenthesizedArrow || (notParenthesizedArrow = ts.createMap())).set(tokenPos.toString(), true);
- }
- return result;
+ if (!texts) {
+ var textNode = ts.factory.createUnparsedTextLike(undefined, false);
+ ts.setTextRangePosWidth(textNode, 0, typeof length === "function" ? length() : length);
+ texts = [textNode];
}
- function tryParseAsyncSimpleArrowFunctionExpression() {
- if (token() === 126) {
- if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1) {
- var asyncModifier = parseModifiersForArrowFunction();
- var expr = parseBinaryExpressionOrHigher(0);
- return parseSimpleArrowFunctionExpression(expr, asyncModifier);
- }
+ var node = ts.parseNodeFactory.createUnparsedSource(prologues !== null && prologues !== void 0 ? prologues : ts.emptyArray, undefined, texts);
+ ts.setEachParent(prologues, node);
+ ts.setEachParent(texts, node);
+ ts.setEachParent(prependChildren, node);
+ node.hasNoDefaultLib = hasNoDefaultLib;
+ node.helpers = helpers;
+ node.referencedFiles = referencedFiles || ts.emptyArray;
+ node.typeReferenceDirectives = typeReferenceDirectives;
+ node.libReferenceDirectives = libReferenceDirectives || ts.emptyArray;
+ return node;
+ }
+ function parseOldFileOfCurrentEmit(bundleFileInfo) {
+ var texts;
+ var syntheticReferences;
+ for (var _i = 0, _a = bundleFileInfo.sections; _i < _a.length; _i++) {
+ var section = _a[_i];
+ switch (section.kind) {
+ case "internal":
+ case "text":
+ texts = ts.append(texts, ts.setTextRange(ts.factory.createUnparsedTextLike(section.data, section.kind === "internal"), section));
+ break;
+ case "no-default-lib":
+ case "reference":
+ case "type":
+ case "lib":
+ syntheticReferences = ts.append(syntheticReferences, ts.setTextRange(ts.factory.createUnparsedSyntheticReference(section), section));
+ break;
+ case "prologue":
+ case "emitHelpers":
+ case "prepend":
+ break;
+ default:
+ ts.Debug.assertNever(section);
}
- return undefined;
}
- function isUnParenthesizedAsyncArrowFunctionWorker() {
- if (token() === 126) {
- nextToken();
- if (scanner.hasPrecedingLineBreak() || token() === 38) {
- return 0;
+ var node = ts.factory.createUnparsedSource(ts.emptyArray, syntheticReferences, texts !== null && texts !== void 0 ? texts : ts.emptyArray);
+ ts.setEachParent(syntheticReferences, node);
+ ts.setEachParent(texts, node);
+ node.helpers = ts.map(bundleFileInfo.sources && bundleFileInfo.sources.helpers, function (name) { return ts.getAllUnscopedEmitHelpers().get(name); });
+ return node;
+ }
+ function createInputFiles(javascriptTextOrReadFileText, declarationTextOrJavascriptPath, javascriptMapPath, javascriptMapTextOrDeclarationPath, declarationMapPath, declarationMapTextOrBuildInfoPath, javascriptPath, declarationPath, buildInfoPath, buildInfo, oldFileOfCurrentEmit) {
+ var node = ts.parseNodeFactory.createInputFiles();
+ if (!ts.isString(javascriptTextOrReadFileText)) {
+ var cache_1 = new ts.Map();
+ var textGetter_1 = function (path) {
+ if (path === undefined)
+ return undefined;
+ var value = cache_1.get(path);
+ if (value === undefined) {
+ value = javascriptTextOrReadFileText(path);
+ cache_1.set(path, value !== undefined ? value : false);
}
- var expr = parseBinaryExpressionOrHigher(0);
- if (!scanner.hasPrecedingLineBreak() && expr.kind === 75 && token() === 38) {
- return 1;
+ return value !== false ? value : undefined;
+ };
+ var definedTextGetter_1 = function (path) {
+ var result = textGetter_1(path);
+ return result !== undefined ? result : "/* Input file " + path + " was missing */\r\n";
+ };
+ var buildInfo_1;
+ var getAndCacheBuildInfo_1 = function (getText) {
+ if (buildInfo_1 === undefined) {
+ var result = getText();
+ buildInfo_1 = result !== undefined ? ts.getBuildInfo(result) : false;
}
- }
- return 0;
+ return buildInfo_1 || undefined;
+ };
+ node.javascriptPath = declarationTextOrJavascriptPath;
+ node.javascriptMapPath = javascriptMapPath;
+ node.declarationPath = ts.Debug.assertDefined(javascriptMapTextOrDeclarationPath);
+ node.declarationMapPath = declarationMapPath;
+ node.buildInfoPath = declarationMapTextOrBuildInfoPath;
+ Object.defineProperties(node, {
+ javascriptText: { get: function () { return definedTextGetter_1(declarationTextOrJavascriptPath); } },
+ javascriptMapText: { get: function () { return textGetter_1(javascriptMapPath); } },
+ declarationText: { get: function () { return definedTextGetter_1(ts.Debug.assertDefined(javascriptMapTextOrDeclarationPath)); } },
+ declarationMapText: { get: function () { return textGetter_1(declarationMapPath); } },
+ buildInfo: { get: function () { return getAndCacheBuildInfo_1(function () { return textGetter_1(declarationMapTextOrBuildInfoPath); }); } }
+ });
}
- function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) {
- var node = createNodeWithJSDoc(202);
- node.modifiers = parseModifiersForArrowFunction();
- var isAsync = hasModifierOfKind(node, 126) ? 2 : 0;
- if (!fillSignature(58, isAsync, node) && !allowAmbiguity) {
- return undefined;
- }
- var hasJSDocFunctionType = node.type && ts.isJSDocFunctionType(node.type);
- if (!allowAmbiguity && token() !== 38 && (hasJSDocFunctionType || token() !== 18)) {
- return undefined;
- }
- return node;
+ else {
+ node.javascriptText = javascriptTextOrReadFileText;
+ node.javascriptMapPath = javascriptMapPath;
+ node.javascriptMapText = javascriptMapTextOrDeclarationPath;
+ node.declarationText = declarationTextOrJavascriptPath;
+ node.declarationMapPath = declarationMapPath;
+ node.declarationMapText = declarationMapTextOrBuildInfoPath;
+ node.javascriptPath = javascriptPath;
+ node.declarationPath = declarationPath;
+ node.buildInfoPath = buildInfoPath;
+ node.buildInfo = buildInfo;
+ node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
}
- function parseArrowFunctionExpressionBody(isAsync) {
- if (token() === 18) {
- return parseFunctionBlock(isAsync ? 2 : 0);
- }
- if (token() !== 26 &&
- token() !== 94 &&
- token() !== 80 &&
- isStartOfStatement() &&
- !isStartOfExpressionStatement()) {
- return parseFunctionBlock(16 | (isAsync ? 2 : 0));
- }
- return isAsync
- ? doInAwaitContext(parseAssignmentExpressionOrHigher)
- : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
+ return node;
+ }
+ ts.createInputFiles = createInputFiles;
+ var SourceMapSource;
+ function createSourceMapSource(fileName, text, skipTrivia) {
+ return new (SourceMapSource || (SourceMapSource = ts.objectAllocator.getSourceMapSourceConstructor()))(fileName, text, skipTrivia);
+ }
+ ts.createSourceMapSource = createSourceMapSource;
+ function setOriginalNode(node, original) {
+ node.original = original;
+ if (original) {
+ var emitNode = original.emitNode;
+ if (emitNode)
+ node.emitNode = mergeEmitNode(emitNode, node.emitNode);
}
- function parseConditionalExpressionRest(leftOperand) {
- var questionToken = parseOptionalToken(57);
- if (!questionToken) {
- return leftOperand;
+ return node;
+ }
+ ts.setOriginalNode = setOriginalNode;
+ function mergeEmitNode(sourceEmitNode, destEmitNode) {
+ var flags = sourceEmitNode.flags, leadingComments = sourceEmitNode.leadingComments, trailingComments = sourceEmitNode.trailingComments, commentRange = sourceEmitNode.commentRange, sourceMapRange = sourceEmitNode.sourceMapRange, tokenSourceMapRanges = sourceEmitNode.tokenSourceMapRanges, constantValue = sourceEmitNode.constantValue, helpers = sourceEmitNode.helpers, startsOnNewLine = sourceEmitNode.startsOnNewLine;
+ if (!destEmitNode)
+ destEmitNode = {};
+ if (leadingComments)
+ destEmitNode.leadingComments = ts.addRange(leadingComments.slice(), destEmitNode.leadingComments);
+ if (trailingComments)
+ destEmitNode.trailingComments = ts.addRange(trailingComments.slice(), destEmitNode.trailingComments);
+ if (flags)
+ destEmitNode.flags = flags;
+ if (commentRange)
+ destEmitNode.commentRange = commentRange;
+ if (sourceMapRange)
+ destEmitNode.sourceMapRange = sourceMapRange;
+ if (tokenSourceMapRanges)
+ destEmitNode.tokenSourceMapRanges = mergeTokenSourceMapRanges(tokenSourceMapRanges, destEmitNode.tokenSourceMapRanges);
+ if (constantValue !== undefined)
+ destEmitNode.constantValue = constantValue;
+ if (helpers) {
+ for (var _i = 0, helpers_1 = helpers; _i < helpers_1.length; _i++) {
+ var helper = helpers_1[_i];
+ destEmitNode.helpers = ts.appendIfUnique(destEmitNode.helpers, helper);
}
- var node = createNode(210, leftOperand.pos);
- node.condition = leftOperand;
- node.questionToken = questionToken;
- node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher);
- node.colonToken = parseExpectedToken(58);
- node.whenFalse = ts.nodeIsPresent(node.colonToken)
- ? parseAssignmentExpressionOrHigher()
- : createMissingNode(75, false, ts.Diagnostics._0_expected, ts.tokenToString(58));
- return finishNode(node);
}
- function parseBinaryExpressionOrHigher(precedence) {
- var leftOperand = parseUnaryExpressionOrHigher();
- return parseBinaryExpressionRest(precedence, leftOperand);
- }
- function isInOrOfKeyword(t) {
- return t === 97 || t === 152;
- }
- function parseBinaryExpressionRest(precedence, leftOperand) {
- while (true) {
- reScanGreaterToken();
- var newPrecedence = ts.getBinaryOperatorPrecedence(token());
- var consumeCurrentOperator = token() === 42 ?
- newPrecedence >= precedence :
- newPrecedence > precedence;
- if (!consumeCurrentOperator) {
- break;
- }
- if (token() === 97 && inDisallowInContext()) {
- break;
- }
- if (token() === 123) {
- if (scanner.hasPrecedingLineBreak()) {
- break;
- }
- else {
- nextToken();
- leftOperand = makeAsExpression(leftOperand, parseType());
- }
- }
- else {
- leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence));
- }
- }
- return leftOperand;
- }
- function isBinaryOperator() {
- if (inDisallowInContext() && token() === 97) {
- return false;
- }
- return ts.getBinaryOperatorPrecedence(token()) > 0;
- }
- function makeBinaryExpression(left, operatorToken, right) {
- var node = createNode(209, left.pos);
- node.left = left;
- node.operatorToken = operatorToken;
- node.right = right;
- return finishNode(node);
- }
- function makeAsExpression(left, right) {
- var node = createNode(217, left.pos);
- node.expression = left;
- node.type = right;
- return finishNode(node);
- }
- function parsePrefixUnaryExpression() {
- var node = createNode(207);
- node.operator = token();
- nextToken();
- node.operand = parseSimpleUnaryExpression();
- return finishNode(node);
- }
- function parseDeleteExpression() {
- var node = createNode(203);
- nextToken();
- node.expression = parseSimpleUnaryExpression();
- return finishNode(node);
- }
- function parseTypeOfExpression() {
- var node = createNode(204);
- nextToken();
- node.expression = parseSimpleUnaryExpression();
- return finishNode(node);
- }
- function parseVoidExpression() {
- var node = createNode(205);
- nextToken();
- node.expression = parseSimpleUnaryExpression();
- return finishNode(node);
- }
- function isAwaitExpression() {
- if (token() === 127) {
- if (inAwaitContext()) {
- return true;
- }
- return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine);
- }
- return false;
- }
- function parseAwaitExpression() {
- var node = createNode(206);
- nextToken();
- node.expression = parseSimpleUnaryExpression();
- return finishNode(node);
+ if (startsOnNewLine !== undefined)
+ destEmitNode.startsOnNewLine = startsOnNewLine;
+ return destEmitNode;
+ }
+ function mergeTokenSourceMapRanges(sourceRanges, destRanges) {
+ if (!destRanges)
+ destRanges = [];
+ for (var key in sourceRanges) {
+ destRanges[key] = sourceRanges[key];
}
- function parseUnaryExpressionOrHigher() {
- if (isUpdateExpression()) {
- var updateExpression = parseUpdateExpression();
- return token() === 42 ?
- parseBinaryExpressionRest(ts.getBinaryOperatorPrecedence(token()), updateExpression) :
- updateExpression;
- }
- var unaryOperator = token();
- var simpleUnaryExpression = parseSimpleUnaryExpression();
- if (token() === 42) {
- var pos = ts.skipTrivia(sourceText, simpleUnaryExpression.pos);
- var end = simpleUnaryExpression.end;
- if (simpleUnaryExpression.kind === 199) {
- parseErrorAt(pos, end, ts.Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
- }
- else {
- parseErrorAt(pos, end, ts.Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, ts.tokenToString(unaryOperator));
+ return destRanges;
+ }
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function getOrCreateEmitNode(node) {
+ var _a;
+ if (!node.emitNode) {
+ if (ts.isParseTreeNode(node)) {
+ if (node.kind === 297) {
+ return node.emitNode = { annotatedNodes: [node] };
}
+ var sourceFile = (_a = ts.getSourceFileOfNode(ts.getParseTreeNode(ts.getSourceFileOfNode(node)))) !== null && _a !== void 0 ? _a : ts.Debug.fail("Could not determine parsed source file.");
+ getOrCreateEmitNode(sourceFile).annotatedNodes.push(node);
}
- return simpleUnaryExpression;
+ node.emitNode = {};
}
- function parseSimpleUnaryExpression() {
- switch (token()) {
- case 39:
- case 40:
- case 54:
- case 53:
- return parsePrefixUnaryExpression();
- case 85:
- return parseDeleteExpression();
- case 108:
- return parseTypeOfExpression();
- case 110:
- return parseVoidExpression();
- case 29:
- return parseTypeAssertion();
- case 127:
- if (isAwaitExpression()) {
- return parseAwaitExpression();
- }
- default:
- return parseUpdateExpression();
+ return node.emitNode;
+ }
+ ts.getOrCreateEmitNode = getOrCreateEmitNode;
+ function disposeEmitNodes(sourceFile) {
+ var _a, _b;
+ var annotatedNodes = (_b = (_a = ts.getSourceFileOfNode(ts.getParseTreeNode(sourceFile))) === null || _a === void 0 ? void 0 : _a.emitNode) === null || _b === void 0 ? void 0 : _b.annotatedNodes;
+ if (annotatedNodes) {
+ for (var _i = 0, annotatedNodes_1 = annotatedNodes; _i < annotatedNodes_1.length; _i++) {
+ var node = annotatedNodes_1[_i];
+ node.emitNode = undefined;
}
}
- function isUpdateExpression() {
- switch (token()) {
- case 39:
- case 40:
- case 54:
- case 53:
- case 85:
- case 108:
- case 110:
- case 127:
- return false;
- case 29:
- if (sourceFile.languageVariant !== 1) {
- return false;
- }
- default:
- return true;
+ }
+ ts.disposeEmitNodes = disposeEmitNodes;
+ function removeAllComments(node) {
+ var emitNode = getOrCreateEmitNode(node);
+ emitNode.flags |= 1536;
+ emitNode.leadingComments = undefined;
+ emitNode.trailingComments = undefined;
+ return node;
+ }
+ ts.removeAllComments = removeAllComments;
+ function setEmitFlags(node, emitFlags) {
+ getOrCreateEmitNode(node).flags = emitFlags;
+ return node;
+ }
+ ts.setEmitFlags = setEmitFlags;
+ function addEmitFlags(node, emitFlags) {
+ var emitNode = getOrCreateEmitNode(node);
+ emitNode.flags = emitNode.flags | emitFlags;
+ return node;
+ }
+ ts.addEmitFlags = addEmitFlags;
+ function getSourceMapRange(node) {
+ var _a, _b;
+ return (_b = (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.sourceMapRange) !== null && _b !== void 0 ? _b : node;
+ }
+ ts.getSourceMapRange = getSourceMapRange;
+ function setSourceMapRange(node, range) {
+ getOrCreateEmitNode(node).sourceMapRange = range;
+ return node;
+ }
+ ts.setSourceMapRange = setSourceMapRange;
+ function getTokenSourceMapRange(node, token) {
+ var _a, _b;
+ return (_b = (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.tokenSourceMapRanges) === null || _b === void 0 ? void 0 : _b[token];
+ }
+ ts.getTokenSourceMapRange = getTokenSourceMapRange;
+ function setTokenSourceMapRange(node, token, range) {
+ var _a;
+ var emitNode = getOrCreateEmitNode(node);
+ var tokenSourceMapRanges = (_a = emitNode.tokenSourceMapRanges) !== null && _a !== void 0 ? _a : (emitNode.tokenSourceMapRanges = []);
+ tokenSourceMapRanges[token] = range;
+ return node;
+ }
+ ts.setTokenSourceMapRange = setTokenSourceMapRange;
+ function getStartsOnNewLine(node) {
+ var _a;
+ return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.startsOnNewLine;
+ }
+ ts.getStartsOnNewLine = getStartsOnNewLine;
+ function setStartsOnNewLine(node, newLine) {
+ getOrCreateEmitNode(node).startsOnNewLine = newLine;
+ return node;
+ }
+ ts.setStartsOnNewLine = setStartsOnNewLine;
+ function getCommentRange(node) {
+ var _a, _b;
+ return (_b = (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.commentRange) !== null && _b !== void 0 ? _b : node;
+ }
+ ts.getCommentRange = getCommentRange;
+ function setCommentRange(node, range) {
+ getOrCreateEmitNode(node).commentRange = range;
+ return node;
+ }
+ ts.setCommentRange = setCommentRange;
+ function getSyntheticLeadingComments(node) {
+ var _a;
+ return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.leadingComments;
+ }
+ ts.getSyntheticLeadingComments = getSyntheticLeadingComments;
+ function setSyntheticLeadingComments(node, comments) {
+ getOrCreateEmitNode(node).leadingComments = comments;
+ return node;
+ }
+ ts.setSyntheticLeadingComments = setSyntheticLeadingComments;
+ function addSyntheticLeadingComment(node, kind, text, hasTrailingNewLine) {
+ return setSyntheticLeadingComments(node, ts.append(getSyntheticLeadingComments(node), { kind: kind, pos: -1, end: -1, hasTrailingNewLine: hasTrailingNewLine, text: text }));
+ }
+ ts.addSyntheticLeadingComment = addSyntheticLeadingComment;
+ function getSyntheticTrailingComments(node) {
+ var _a;
+ return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.trailingComments;
+ }
+ ts.getSyntheticTrailingComments = getSyntheticTrailingComments;
+ function setSyntheticTrailingComments(node, comments) {
+ getOrCreateEmitNode(node).trailingComments = comments;
+ return node;
+ }
+ ts.setSyntheticTrailingComments = setSyntheticTrailingComments;
+ function addSyntheticTrailingComment(node, kind, text, hasTrailingNewLine) {
+ return setSyntheticTrailingComments(node, ts.append(getSyntheticTrailingComments(node), { kind: kind, pos: -1, end: -1, hasTrailingNewLine: hasTrailingNewLine, text: text }));
+ }
+ ts.addSyntheticTrailingComment = addSyntheticTrailingComment;
+ function moveSyntheticComments(node, original) {
+ setSyntheticLeadingComments(node, getSyntheticLeadingComments(original));
+ setSyntheticTrailingComments(node, getSyntheticTrailingComments(original));
+ var emit = getOrCreateEmitNode(original);
+ emit.leadingComments = undefined;
+ emit.trailingComments = undefined;
+ return node;
+ }
+ ts.moveSyntheticComments = moveSyntheticComments;
+ function getConstantValue(node) {
+ var _a;
+ return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.constantValue;
+ }
+ ts.getConstantValue = getConstantValue;
+ function setConstantValue(node, value) {
+ var emitNode = getOrCreateEmitNode(node);
+ emitNode.constantValue = value;
+ return node;
+ }
+ ts.setConstantValue = setConstantValue;
+ function addEmitHelper(node, helper) {
+ var emitNode = getOrCreateEmitNode(node);
+ emitNode.helpers = ts.append(emitNode.helpers, helper);
+ return node;
+ }
+ ts.addEmitHelper = addEmitHelper;
+ function addEmitHelpers(node, helpers) {
+ if (ts.some(helpers)) {
+ var emitNode = getOrCreateEmitNode(node);
+ for (var _i = 0, helpers_2 = helpers; _i < helpers_2.length; _i++) {
+ var helper = helpers_2[_i];
+ emitNode.helpers = ts.appendIfUnique(emitNode.helpers, helper);
}
}
- function parseUpdateExpression() {
- if (token() === 45 || token() === 46) {
- var node = createNode(207);
- node.operator = token();
- nextToken();
- node.operand = parseLeftHandSideExpressionOrHigher();
- return finishNode(node);
- }
- else if (sourceFile.languageVariant === 1 && token() === 29 && lookAhead(nextTokenIsIdentifierOrKeywordOrGreaterThan)) {
- return parseJsxElementOrSelfClosingElementOrFragment(true);
- }
- var expression = parseLeftHandSideExpressionOrHigher();
- ts.Debug.assert(ts.isLeftHandSideExpression(expression));
- if ((token() === 45 || token() === 46) && !scanner.hasPrecedingLineBreak()) {
- var node = createNode(208, expression.pos);
- node.operand = expression;
- node.operator = token();
- nextToken();
- return finishNode(node);
- }
- return expression;
+ return node;
+ }
+ ts.addEmitHelpers = addEmitHelpers;
+ function removeEmitHelper(node, helper) {
+ var _a;
+ var helpers = (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.helpers;
+ if (helpers) {
+ return ts.orderedRemoveItem(helpers, helper);
}
- function parseLeftHandSideExpressionOrHigher() {
- var expression;
- if (token() === 96) {
- if (lookAhead(nextTokenIsOpenParenOrLessThan)) {
- sourceFile.flags |= 1048576;
- expression = parseTokenNode();
- }
- else if (lookAhead(nextTokenIsDot)) {
- var fullStart = scanner.getStartPos();
- nextToken();
- nextToken();
- var node = createNode(219, fullStart);
- node.keywordToken = 96;
- node.name = parseIdentifierName();
- expression = finishNode(node);
- sourceFile.flags |= 2097152;
- }
- else {
- expression = parseMemberExpressionOrHigher();
- }
+ return false;
+ }
+ ts.removeEmitHelper = removeEmitHelper;
+ function getEmitHelpers(node) {
+ var _a;
+ return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.helpers;
+ }
+ ts.getEmitHelpers = getEmitHelpers;
+ function moveEmitHelpers(source, target, predicate) {
+ var sourceEmitNode = source.emitNode;
+ var sourceEmitHelpers = sourceEmitNode && sourceEmitNode.helpers;
+ if (!ts.some(sourceEmitHelpers))
+ return;
+ var targetEmitNode = getOrCreateEmitNode(target);
+ var helpersRemoved = 0;
+ for (var i = 0; i < sourceEmitHelpers.length; i++) {
+ var helper = sourceEmitHelpers[i];
+ if (predicate(helper)) {
+ helpersRemoved++;
+ targetEmitNode.helpers = ts.appendIfUnique(targetEmitNode.helpers, helper);
}
- else {
- expression = token() === 102 ? parseSuperExpression() : parseMemberExpressionOrHigher();
+ else if (helpersRemoved > 0) {
+ sourceEmitHelpers[i - helpersRemoved] = helper;
}
- return parseCallExpressionRest(expression);
- }
- function parseMemberExpressionOrHigher() {
- var expression = parsePrimaryExpression();
- return parseMemberExpressionRest(expression, true);
}
- function parseSuperExpression() {
- var expression = parseTokenNode();
- if (token() === 29) {
- var startPos = getNodePos();
- var typeArguments = tryParse(parseTypeArgumentsInExpression);
- if (typeArguments !== undefined) {
- parseErrorAt(startPos, getNodePos(), ts.Diagnostics.super_may_not_use_type_arguments);
- }
- }
- if (token() === 20 || token() === 24 || token() === 22) {
- return expression;
- }
- var node = createNode(194, expression.pos);
- node.expression = expression;
- parseExpectedToken(24, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
- node.name = parseRightSideOfDot(true, true);
- return finishNode(node);
+ if (helpersRemoved > 0) {
+ sourceEmitHelpers.length -= helpersRemoved;
}
- function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext) {
- var opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext);
- var result;
- if (opening.kind === 268) {
- var node = createNode(266, opening.pos);
- node.openingElement = opening;
- node.children = parseJsxChildren(node.openingElement);
- node.closingElement = parseJsxClosingElement(inExpressionContext);
- if (!tagNamesAreEquivalent(node.openingElement.tagName, node.closingElement.tagName)) {
- parseErrorAtRange(node.closingElement, ts.Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, ts.getTextOfNodeFromSourceText(sourceText, node.openingElement.tagName));
- }
- result = finishNode(node);
- }
- else if (opening.kind === 271) {
- var node = createNode(270, opening.pos);
- node.openingFragment = opening;
- node.children = parseJsxChildren(node.openingFragment);
- node.closingFragment = parseJsxClosingFragment(inExpressionContext);
- result = finishNode(node);
- }
- else {
- ts.Debug.assert(opening.kind === 267);
- result = opening;
- }
- if (inExpressionContext && token() === 29) {
- var invalidElement = tryParse(function () { return parseJsxElementOrSelfClosingElementOrFragment(true); });
- if (invalidElement) {
- parseErrorAtCurrentToken(ts.Diagnostics.JSX_expressions_must_have_one_parent_element);
- var badNode = createNode(209, result.pos);
- badNode.end = invalidElement.end;
- badNode.left = result;
- badNode.right = invalidElement;
- badNode.operatorToken = createMissingNode(27, false);
- badNode.operatorToken.pos = badNode.operatorToken.end = badNode.right.pos;
- return badNode;
- }
- }
- return result;
+ }
+ ts.moveEmitHelpers = moveEmitHelpers;
+ function ignoreSourceNewlines(node) {
+ getOrCreateEmitNode(node).flags |= 134217728;
+ return node;
+ }
+ ts.ignoreSourceNewlines = ignoreSourceNewlines;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function createEmitHelperFactory(context) {
+ var factory = context.factory;
+ return {
+ getUnscopedHelperName: getUnscopedHelperName,
+ createDecorateHelper: createDecorateHelper,
+ createMetadataHelper: createMetadataHelper,
+ createParamHelper: createParamHelper,
+ createAssignHelper: createAssignHelper,
+ createAwaitHelper: createAwaitHelper,
+ createAsyncGeneratorHelper: createAsyncGeneratorHelper,
+ createAsyncDelegatorHelper: createAsyncDelegatorHelper,
+ createAsyncValuesHelper: createAsyncValuesHelper,
+ createRestHelper: createRestHelper,
+ createAwaiterHelper: createAwaiterHelper,
+ createExtendsHelper: createExtendsHelper,
+ createTemplateObjectHelper: createTemplateObjectHelper,
+ createSpreadHelper: createSpreadHelper,
+ createSpreadArraysHelper: createSpreadArraysHelper,
+ createValuesHelper: createValuesHelper,
+ createReadHelper: createReadHelper,
+ createGeneratorHelper: createGeneratorHelper,
+ createCreateBindingHelper: createCreateBindingHelper,
+ createImportStarHelper: createImportStarHelper,
+ createImportStarCallbackHelper: createImportStarCallbackHelper,
+ createImportDefaultHelper: createImportDefaultHelper,
+ createExportStarHelper: createExportStarHelper,
+ createClassPrivateFieldGetHelper: createClassPrivateFieldGetHelper,
+ createClassPrivateFieldSetHelper: createClassPrivateFieldSetHelper,
+ };
+ function getUnscopedHelperName(name) {
+ return ts.setEmitFlags(factory.createIdentifier(name), 4096 | 2);
+ }
+ function createDecorateHelper(decoratorExpressions, target, memberName, descriptor) {
+ context.requestEmitHelper(ts.decorateHelper);
+ var argumentsArray = [];
+ argumentsArray.push(factory.createArrayLiteralExpression(decoratorExpressions, true));
+ argumentsArray.push(target);
+ if (memberName) {
+ argumentsArray.push(memberName);
+ if (descriptor) {
+ argumentsArray.push(descriptor);
+ }
+ }
+ return factory.createCallExpression(getUnscopedHelperName("__decorate"), undefined, argumentsArray);
+ }
+ function createMetadataHelper(metadataKey, metadataValue) {
+ context.requestEmitHelper(ts.metadataHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__metadata"), undefined, [
+ factory.createStringLiteral(metadataKey),
+ metadataValue
+ ]);
}
- function parseJsxText() {
- var node = createNode(11);
- node.text = scanner.getTokenValue();
- node.containsOnlyTriviaWhiteSpaces = currentToken === 12;
- currentToken = scanner.scanJsxToken();
- return finishNode(node);
+ function createParamHelper(expression, parameterOffset, location) {
+ context.requestEmitHelper(ts.paramHelper);
+ return ts.setTextRange(factory.createCallExpression(getUnscopedHelperName("__param"), undefined, [
+ factory.createNumericLiteral(parameterOffset + ""),
+ expression
+ ]), location);
+ }
+ function createAssignHelper(attributesSegments) {
+ if (context.getCompilerOptions().target >= 2) {
+ return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "assign"), undefined, attributesSegments);
+ }
+ context.requestEmitHelper(ts.assignHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__assign"), undefined, attributesSegments);
+ }
+ function createAwaitHelper(expression) {
+ context.requestEmitHelper(ts.awaitHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__await"), undefined, [expression]);
+ }
+ function createAsyncGeneratorHelper(generatorFunc, hasLexicalThis) {
+ context.requestEmitHelper(ts.awaitHelper);
+ context.requestEmitHelper(ts.asyncGeneratorHelper);
+ (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 262144 | 524288;
+ return factory.createCallExpression(getUnscopedHelperName("__asyncGenerator"), undefined, [
+ hasLexicalThis ? factory.createThis() : factory.createVoidZero(),
+ factory.createIdentifier("arguments"),
+ generatorFunc
+ ]);
}
- function parseJsxChild(openingTag, token) {
- switch (token) {
- case 1:
- if (ts.isJsxOpeningFragment(openingTag)) {
- parseErrorAtRange(openingTag, ts.Diagnostics.JSX_fragment_has_no_corresponding_closing_tag);
+ function createAsyncDelegatorHelper(expression) {
+ context.requestEmitHelper(ts.awaitHelper);
+ context.requestEmitHelper(ts.asyncDelegator);
+ return factory.createCallExpression(getUnscopedHelperName("__asyncDelegator"), undefined, [expression]);
+ }
+ function createAsyncValuesHelper(expression) {
+ context.requestEmitHelper(ts.asyncValues);
+ return factory.createCallExpression(getUnscopedHelperName("__asyncValues"), undefined, [expression]);
+ }
+ function createRestHelper(value, elements, computedTempVariables, location) {
+ context.requestEmitHelper(ts.restHelper);
+ var propertyNames = [];
+ var computedTempVariableOffset = 0;
+ for (var i = 0; i < elements.length - 1; i++) {
+ var propertyName = ts.getPropertyNameOfBindingOrAssignmentElement(elements[i]);
+ if (propertyName) {
+ if (ts.isComputedPropertyName(propertyName)) {
+ ts.Debug.assertIsDefined(computedTempVariables, "Encountered computed property name but 'computedTempVariables' argument was not provided.");
+ var temp = computedTempVariables[computedTempVariableOffset];
+ computedTempVariableOffset++;
+ propertyNames.push(factory.createConditionalExpression(factory.createTypeCheck(temp, "symbol"), undefined, temp, undefined, factory.createAdd(temp, factory.createStringLiteral(""))));
}
else {
- var tag = openingTag.tagName;
- var start = ts.skipTrivia(sourceText, tag.pos);
- parseErrorAt(start, tag.end, ts.Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, ts.getTextOfNodeFromSourceText(sourceText, openingTag.tagName));
+ propertyNames.push(factory.createStringLiteralFromNode(propertyName));
}
- return undefined;
- case 30:
- case 7:
- return undefined;
- case 11:
- case 12:
- return parseJsxText();
- case 18:
- return parseJsxExpression(false);
- case 29:
- return parseJsxElementOrSelfClosingElementOrFragment(false);
- default:
- return ts.Debug.assertNever(token);
+ }
}
+ return factory.createCallExpression(getUnscopedHelperName("__rest"), undefined, [
+ value,
+ ts.setTextRange(factory.createArrayLiteralExpression(propertyNames), location)
+ ]);
}
- function parseJsxChildren(openingTag) {
- var list = [];
- var listPos = getNodePos();
- var saveParsingContext = parsingContext;
- parsingContext |= 1 << 14;
- while (true) {
- var child = parseJsxChild(openingTag, currentToken = scanner.reScanJsxToken());
- if (!child)
- break;
- list.push(child);
- }
- parsingContext = saveParsingContext;
- return createNodeArray(list, listPos);
+ function createAwaiterHelper(hasLexicalThis, hasLexicalArguments, promiseConstructor, body) {
+ context.requestEmitHelper(ts.awaiterHelper);
+ var generatorFunc = factory.createFunctionExpression(undefined, factory.createToken(41), undefined, undefined, [], undefined, body);
+ (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 262144 | 524288;
+ return factory.createCallExpression(getUnscopedHelperName("__awaiter"), undefined, [
+ hasLexicalThis ? factory.createThis() : factory.createVoidZero(),
+ hasLexicalArguments ? factory.createIdentifier("arguments") : factory.createVoidZero(),
+ promiseConstructor ? ts.createExpressionFromEntityName(factory, promiseConstructor) : factory.createVoidZero(),
+ generatorFunc
+ ]);
}
- function parseJsxAttributes() {
- var jsxAttributes = createNode(274);
- jsxAttributes.properties = parseList(13, parseJsxAttribute);
- return finishNode(jsxAttributes);
+ function createExtendsHelper(name) {
+ context.requestEmitHelper(ts.extendsHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__extends"), undefined, [name, factory.createUniqueName("_super", 16 | 32)]);
}
- function parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext) {
- var fullStart = scanner.getStartPos();
- parseExpected(29);
- if (token() === 31) {
- var node_1 = createNode(271, fullStart);
- scanJsxText();
- return finishNode(node_1);
- }
- var tagName = parseJsxElementName();
- var typeArguments = tryParseTypeArguments();
- var attributes = parseJsxAttributes();
- var node;
- if (token() === 31) {
- node = createNode(268, fullStart);
- scanJsxText();
- }
- else {
- parseExpected(43);
- if (inExpressionContext) {
- parseExpected(31);
- }
- else {
- parseExpected(31, undefined, false);
- scanJsxText();
- }
- node = createNode(267, fullStart);
- }
- node.tagName = tagName;
- node.typeArguments = typeArguments;
- node.attributes = attributes;
- return finishNode(node);
+ function createTemplateObjectHelper(cooked, raw) {
+ context.requestEmitHelper(ts.templateObjectHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__makeTemplateObject"), undefined, [cooked, raw]);
}
- function parseJsxElementName() {
- scanJsxIdentifier();
- var expression = token() === 104 ?
- parseTokenNode() : parseIdentifierName();
- while (parseOptional(24)) {
- var propertyAccess = createNode(194, expression.pos);
- propertyAccess.expression = expression;
- propertyAccess.name = parseRightSideOfDot(true, false);
- expression = finishNode(propertyAccess);
- }
- return expression;
+ function createSpreadHelper(argumentList) {
+ context.requestEmitHelper(ts.readHelper);
+ context.requestEmitHelper(ts.spreadHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__spread"), undefined, argumentList);
}
- function parseJsxExpression(inExpressionContext) {
- var node = createNode(276);
- if (!parseExpected(18)) {
- return undefined;
- }
- if (token() !== 19) {
- node.dotDotDotToken = parseOptionalToken(25);
- node.expression = parseExpression();
- }
- if (inExpressionContext) {
- parseExpected(19);
- }
- else {
- if (parseExpected(19, undefined, false)) {
- scanJsxText();
- }
- }
- return finishNode(node);
+ function createSpreadArraysHelper(argumentList) {
+ context.requestEmitHelper(ts.spreadArraysHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__spreadArrays"), undefined, argumentList);
}
- function parseJsxAttribute() {
- if (token() === 18) {
- return parseJsxSpreadAttribute();
- }
- scanJsxIdentifier();
- var node = createNode(273);
- node.name = parseIdentifierName();
- if (token() === 62) {
- switch (scanJsxAttributeValue()) {
- case 10:
- node.initializer = parseLiteralNode();
- break;
- default:
- node.initializer = parseJsxExpression(true);
- break;
- }
- }
- return finishNode(node);
+ function createValuesHelper(expression) {
+ context.requestEmitHelper(ts.valuesHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__values"), undefined, [expression]);
}
- function parseJsxSpreadAttribute() {
- var node = createNode(275);
- parseExpected(18);
- parseExpected(25);
- node.expression = parseExpression();
- parseExpected(19);
- return finishNode(node);
+ function createReadHelper(iteratorRecord, count) {
+ context.requestEmitHelper(ts.readHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__read"), undefined, count !== undefined
+ ? [iteratorRecord, factory.createNumericLiteral(count + "")]
+ : [iteratorRecord]);
}
- function parseJsxClosingElement(inExpressionContext) {
- var node = createNode(269);
- parseExpected(30);
- node.tagName = parseJsxElementName();
- if (inExpressionContext) {
- parseExpected(31);
- }
- else {
- parseExpected(31, undefined, false);
- scanJsxText();
- }
- return finishNode(node);
+ function createGeneratorHelper(body) {
+ context.requestEmitHelper(ts.generatorHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__generator"), undefined, [factory.createThis(), body]);
}
- function parseJsxClosingFragment(inExpressionContext) {
- var node = createNode(272);
- parseExpected(30);
- if (ts.tokenIsIdentifierOrKeyword(token())) {
- parseErrorAtRange(parseJsxElementName(), ts.Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment);
- }
- if (inExpressionContext) {
- parseExpected(31);
- }
- else {
- parseExpected(31, undefined, false);
- scanJsxText();
- }
- return finishNode(node);
+ function createCreateBindingHelper(module, inputName, outputName) {
+ context.requestEmitHelper(ts.createBindingHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__createBinding"), undefined, __spreadArrays([factory.createIdentifier("exports"), module, inputName], (outputName ? [outputName] : [])));
}
- function parseTypeAssertion() {
- var node = createNode(199);
- parseExpected(29);
- node.type = parseType();
- parseExpected(31);
- node.expression = parseSimpleUnaryExpression();
- return finishNode(node);
+ function createImportStarHelper(expression) {
+ context.requestEmitHelper(ts.importStarHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__importStar"), undefined, [expression]);
}
- function nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate() {
- nextToken();
- return ts.tokenIsIdentifierOrKeyword(token())
- || token() === 22
- || isTemplateStartOfTaggedTemplate();
+ function createImportStarCallbackHelper() {
+ context.requestEmitHelper(ts.importStarHelper);
+ return getUnscopedHelperName("__importStar");
}
- function isStartOfOptionalPropertyOrElementAccessChain() {
- return token() === 28
- && lookAhead(nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate);
+ function createImportDefaultHelper(expression) {
+ context.requestEmitHelper(ts.importDefaultHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__importDefault"), undefined, [expression]);
}
- function tryReparseOptionalChain(node) {
- if (node.flags & 32) {
- return true;
- }
- if (ts.isNonNullExpression(node)) {
- var expr = node.expression;
- while (ts.isNonNullExpression(expr) && !(expr.flags & 32)) {
- expr = expr.expression;
- }
- if (expr.flags & 32) {
- while (ts.isNonNullExpression(node)) {
- node.flags |= 32;
- node = node.expression;
- }
- return true;
- }
- }
- return false;
+ function createExportStarHelper(moduleExpression, exportsExpression) {
+ if (exportsExpression === void 0) { exportsExpression = factory.createIdentifier("exports"); }
+ context.requestEmitHelper(ts.exportStarHelper);
+ context.requestEmitHelper(ts.createBindingHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__exportStar"), undefined, [moduleExpression, exportsExpression]);
}
- function parsePropertyAccessExpressionRest(expression, questionDotToken) {
- var propertyAccess = createNode(194, expression.pos);
- propertyAccess.expression = expression;
- propertyAccess.questionDotToken = questionDotToken;
- propertyAccess.name = parseRightSideOfDot(true, true);
- if (questionDotToken || tryReparseOptionalChain(expression)) {
- propertyAccess.flags |= 32;
- if (ts.isPrivateIdentifier(propertyAccess.name)) {
- parseErrorAtRange(propertyAccess.name, ts.Diagnostics.An_optional_chain_cannot_contain_private_identifiers);
- }
- }
- return finishNode(propertyAccess);
+ function createClassPrivateFieldGetHelper(receiver, privateField) {
+ context.requestEmitHelper(ts.classPrivateFieldGetHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldGet"), undefined, [receiver, privateField]);
}
- function parseElementAccessExpressionRest(expression, questionDotToken) {
- var indexedAccess = createNode(195, expression.pos);
- indexedAccess.expression = expression;
- indexedAccess.questionDotToken = questionDotToken;
- if (token() === 23) {
- indexedAccess.argumentExpression = createMissingNode(75, true, ts.Diagnostics.An_element_access_expression_should_take_an_argument);
- }
- else {
- var argument = allowInAnd(parseExpression);
- if (ts.isStringOrNumericLiteralLike(argument)) {
- argument.text = internIdentifier(argument.text);
- }
- indexedAccess.argumentExpression = argument;
- }
- parseExpected(23);
- if (questionDotToken || tryReparseOptionalChain(expression)) {
- indexedAccess.flags |= 32;
- }
- return finishNode(indexedAccess);
+ function createClassPrivateFieldSetHelper(receiver, privateField, value) {
+ context.requestEmitHelper(ts.classPrivateFieldSetHelper);
+ return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), undefined, [receiver, privateField, value]);
}
- function parseMemberExpressionRest(expression, allowOptionalChain) {
- while (true) {
- var questionDotToken = void 0;
- var isPropertyAccess = false;
- if (allowOptionalChain && isStartOfOptionalPropertyOrElementAccessChain()) {
- questionDotToken = parseExpectedToken(28);
- isPropertyAccess = ts.tokenIsIdentifierOrKeyword(token());
- }
- else {
- isPropertyAccess = parseOptional(24);
- }
- if (isPropertyAccess) {
- expression = parsePropertyAccessExpressionRest(expression, questionDotToken);
- continue;
- }
- if (!questionDotToken && token() === 53 && !scanner.hasPrecedingLineBreak()) {
- nextToken();
- var nonNullExpression = createNode(218, expression.pos);
- nonNullExpression.expression = expression;
- expression = finishNode(nonNullExpression);
- continue;
- }
- if ((questionDotToken || !inDecoratorContext()) && parseOptional(22)) {
- expression = parseElementAccessExpressionRest(expression, questionDotToken);
- continue;
- }
- if (isTemplateStartOfTaggedTemplate()) {
- expression = parseTaggedTemplateRest(expression, questionDotToken, undefined);
- continue;
- }
- return expression;
- }
- }
- function isTemplateStartOfTaggedTemplate() {
- return token() === 14 || token() === 15;
- }
- function parseTaggedTemplateRest(tag, questionDotToken, typeArguments) {
- var tagExpression = createNode(198, tag.pos);
- tagExpression.tag = tag;
- tagExpression.questionDotToken = questionDotToken;
- tagExpression.typeArguments = typeArguments;
- tagExpression.template = token() === 14
- ? (reScanTemplateHeadOrNoSubstitutionTemplate(), parseLiteralNode())
- : parseTemplateExpression(true);
- if (questionDotToken || tag.flags & 32) {
- tagExpression.flags |= 32;
- }
- return finishNode(tagExpression);
+ }
+ ts.createEmitHelperFactory = createEmitHelperFactory;
+ function compareEmitHelpers(x, y) {
+ if (x === y)
+ return 0;
+ if (x.priority === y.priority)
+ return 0;
+ if (x.priority === undefined)
+ return 1;
+ if (y.priority === undefined)
+ return -1;
+ return ts.compareValues(x.priority, y.priority);
+ }
+ ts.compareEmitHelpers = compareEmitHelpers;
+ function helperString(input) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
}
- function parseCallExpressionRest(expression) {
- while (true) {
- expression = parseMemberExpressionRest(expression, true);
- var questionDotToken = parseOptionalToken(28);
- if (token() === 29 || token() === 47) {
- var typeArguments = tryParse(parseTypeArgumentsInExpression);
- if (typeArguments) {
- if (isTemplateStartOfTaggedTemplate()) {
- expression = parseTaggedTemplateRest(expression, questionDotToken, typeArguments);
- continue;
- }
- var callExpr = createNode(196, expression.pos);
- callExpr.expression = expression;
- callExpr.questionDotToken = questionDotToken;
- callExpr.typeArguments = typeArguments;
- callExpr.arguments = parseArgumentList();
- if (questionDotToken || tryReparseOptionalChain(expression)) {
- callExpr.flags |= 32;
- }
- expression = finishNode(callExpr);
- continue;
- }
- }
- else if (token() === 20) {
- var callExpr = createNode(196, expression.pos);
- callExpr.expression = expression;
- callExpr.questionDotToken = questionDotToken;
- callExpr.arguments = parseArgumentList();
- if (questionDotToken || tryReparseOptionalChain(expression)) {
- callExpr.flags |= 32;
- }
- expression = finishNode(callExpr);
- continue;
- }
- if (questionDotToken) {
- var propertyAccess = createNode(194, expression.pos);
- propertyAccess.expression = expression;
- propertyAccess.questionDotToken = questionDotToken;
- propertyAccess.name = createMissingNode(75, false, ts.Diagnostics.Identifier_expected);
- propertyAccess.flags |= 32;
- expression = finishNode(propertyAccess);
- }
- break;
+ return function (uniqueName) {
+ var result = "";
+ for (var i = 0; i < args.length; i++) {
+ result += input[i];
+ result += uniqueName(args[i]);
}
- return expression;
- }
- function parseArgumentList() {
- parseExpected(20);
- var result = parseDelimitedList(11, parseArgumentExpression);
- parseExpected(21);
+ result += input[input.length - 1];
return result;
+ };
+ }
+ ts.helperString = helperString;
+ ts.decorateHelper = {
+ name: "typescript:decorate",
+ importName: "__decorate",
+ scoped: false,
+ priority: 2,
+ text: "\n var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n };"
+ };
+ ts.metadataHelper = {
+ name: "typescript:metadata",
+ importName: "__metadata",
+ scoped: false,
+ priority: 3,
+ text: "\n var __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n };"
+ };
+ ts.paramHelper = {
+ name: "typescript:param",
+ importName: "__param",
+ scoped: false,
+ priority: 4,
+ text: "\n var __param = (this && this.__param) || function (paramIndex, decorator) {\n return function (target, key) { decorator(target, key, paramIndex); }\n };"
+ };
+ ts.assignHelper = {
+ name: "typescript:assign",
+ importName: "__assign",
+ scoped: false,
+ priority: 1,
+ text: "\n var __assign = (this && this.__assign) || function () {\n __assign = Object.assign || function(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n t[p] = s[p];\n }\n return t;\n };\n return __assign.apply(this, arguments);\n };"
+ };
+ ts.awaitHelper = {
+ name: "typescript:await",
+ importName: "__await",
+ scoped: false,
+ text: "\n var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }"
+ };
+ ts.asyncGeneratorHelper = {
+ name: "typescript:asyncGenerator",
+ importName: "__asyncGenerator",
+ scoped: false,
+ dependencies: [ts.awaitHelper],
+ text: "\n var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n function fulfill(value) { resume(\"next\", value); }\n function reject(value) { resume(\"throw\", value); }\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n };"
+ };
+ ts.asyncDelegator = {
+ name: "typescript:asyncDelegator",
+ importName: "__asyncDelegator",
+ scoped: false,
+ dependencies: [ts.awaitHelper],
+ text: "\n var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {\n var i, p;\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\n };"
+ };
+ ts.asyncValues = {
+ name: "typescript:asyncValues",
+ importName: "__asyncValues",
+ scoped: false,
+ text: "\n var __asyncValues = (this && this.__asyncValues) || function (o) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var m = o[Symbol.asyncIterator], i;\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n };"
+ };
+ ts.restHelper = {
+ name: "typescript:rest",
+ importName: "__rest",
+ scoped: false,
+ text: "\n var __rest = (this && this.__rest) || function (s, e) {\n var t = {};\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n };"
+ };
+ ts.awaiterHelper = {
+ name: "typescript:awaiter",
+ importName: "__awaiter",
+ scoped: false,
+ priority: 5,
+ text: "\n var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n };"
+ };
+ ts.extendsHelper = {
+ name: "typescript:extends",
+ importName: "__extends",
+ scoped: false,
+ priority: 0,
+ text: "\n var __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n })();"
+ };
+ ts.templateObjectHelper = {
+ name: "typescript:makeTemplateObject",
+ importName: "__makeTemplateObject",
+ scoped: false,
+ priority: 0,
+ text: "\n var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n return cooked;\n };"
+ };
+ ts.readHelper = {
+ name: "typescript:read",
+ importName: "__read",
+ scoped: false,
+ text: "\n var __read = (this && this.__read) || function (o, n) {\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n if (!m) return o;\n var i = m.call(o), r, ar = [], e;\n try {\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n }\n catch (error) { e = { error: error }; }\n finally {\n try {\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\n }\n finally { if (e) throw e.error; }\n }\n return ar;\n };"
+ };
+ ts.spreadHelper = {
+ name: "typescript:spread",
+ importName: "__spread",
+ scoped: false,
+ dependencies: [ts.readHelper],
+ text: "\n var __spread = (this && this.__spread) || function () {\n for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));\n return ar;\n };"
+ };
+ ts.spreadArraysHelper = {
+ name: "typescript:spreadArrays",
+ importName: "__spreadArrays",
+ scoped: false,
+ text: "\n var __spreadArrays = (this && this.__spreadArrays) || function () {\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n r[k] = a[j];\n return r;\n };"
+ };
+ ts.valuesHelper = {
+ name: "typescript:values",
+ importName: "__values",
+ scoped: false,
+ text: "\n var __values = (this && this.__values) || function(o) {\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n if (m) return m.call(o);\n if (o && typeof o.length === \"number\") return {\n next: function () {\n if (o && i >= o.length) o = void 0;\n return { value: o && o[i++], done: !o };\n }\n };\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n };"
+ };
+ ts.generatorHelper = {
+ name: "typescript:generator",
+ importName: "__generator",
+ scoped: false,
+ priority: 6,
+ text: "\n var __generator = (this && this.__generator) || function (thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (_) try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n };"
+ };
+ ts.createBindingHelper = {
+ name: "typescript:commonjscreatebinding",
+ importName: "__createBinding",
+ scoped: false,
+ priority: 1,
+ text: "\n var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n }) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n }));"
+ };
+ ts.setModuleDefaultHelper = {
+ name: "typescript:commonjscreatevalue",
+ importName: "__setModuleDefault",
+ scoped: false,
+ priority: 1,
+ text: "\n var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n }) : function(o, v) {\n o[\"default\"] = v;\n });"
+ };
+ ts.importStarHelper = {
+ name: "typescript:commonjsimportstar",
+ importName: "__importStar",
+ scoped: false,
+ dependencies: [ts.createBindingHelper, ts.setModuleDefaultHelper],
+ priority: 2,
+ text: "\n var __importStar = (this && this.__importStar) || function (mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n __setModuleDefault(result, mod);\n return result;\n };"
+ };
+ ts.importDefaultHelper = {
+ name: "typescript:commonjsimportdefault",
+ importName: "__importDefault",
+ scoped: false,
+ text: "\n var __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n };"
+ };
+ ts.exportStarHelper = {
+ name: "typescript:export-star",
+ importName: "__exportStar",
+ scoped: false,
+ dependencies: [ts.createBindingHelper],
+ priority: 2,
+ text: "\n var __exportStar = (this && this.__exportStar) || function(m, exports) {\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n };"
+ };
+ ts.classPrivateFieldGetHelper = {
+ name: "typescript:classPrivateFieldGet",
+ importName: "__classPrivateFieldGet",
+ scoped: false,
+ text: "\n var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {\n if (!privateMap.has(receiver)) {\n throw new TypeError(\"attempted to get private field on non-instance\");\n }\n return privateMap.get(receiver);\n };"
+ };
+ ts.classPrivateFieldSetHelper = {
+ name: "typescript:classPrivateFieldSet",
+ importName: "__classPrivateFieldSet",
+ scoped: false,
+ text: "\n var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {\n if (!privateMap.has(receiver)) {\n throw new TypeError(\"attempted to set private field on non-instance\");\n }\n privateMap.set(receiver, value);\n return value;\n };"
+ };
+ var allUnscopedEmitHelpers;
+ function getAllUnscopedEmitHelpers() {
+ return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = ts.arrayToMap([
+ ts.decorateHelper,
+ ts.metadataHelper,
+ ts.paramHelper,
+ ts.assignHelper,
+ ts.awaitHelper,
+ ts.asyncGeneratorHelper,
+ ts.asyncDelegator,
+ ts.asyncValues,
+ ts.restHelper,
+ ts.awaiterHelper,
+ ts.extendsHelper,
+ ts.templateObjectHelper,
+ ts.spreadHelper,
+ ts.spreadArraysHelper,
+ ts.valuesHelper,
+ ts.readHelper,
+ ts.generatorHelper,
+ ts.importStarHelper,
+ ts.importDefaultHelper,
+ ts.exportStarHelper,
+ ts.classPrivateFieldGetHelper,
+ ts.classPrivateFieldSetHelper,
+ ts.createBindingHelper,
+ ts.setModuleDefaultHelper
+ ], function (helper) { return helper.name; }));
+ }
+ ts.getAllUnscopedEmitHelpers = getAllUnscopedEmitHelpers;
+ ts.asyncSuperHelper = {
+ name: "typescript:async-super",
+ scoped: true,
+ text: helperString(__makeTemplateObject(["\n const ", " = name => super[name];"], ["\n const ", " = name => super[name];"]), "_superIndex")
+ };
+ ts.advancedAsyncSuperHelper = {
+ name: "typescript:advanced-async-super",
+ scoped: true,
+ text: helperString(__makeTemplateObject(["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"], ["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"]), "_superIndex")
+ };
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function isNumericLiteral(node) {
+ return node.kind === 8;
+ }
+ ts.isNumericLiteral = isNumericLiteral;
+ function isBigIntLiteral(node) {
+ return node.kind === 9;
+ }
+ ts.isBigIntLiteral = isBigIntLiteral;
+ function isStringLiteral(node) {
+ return node.kind === 10;
+ }
+ ts.isStringLiteral = isStringLiteral;
+ function isJsxText(node) {
+ return node.kind === 11;
+ }
+ ts.isJsxText = isJsxText;
+ function isRegularExpressionLiteral(node) {
+ return node.kind === 13;
+ }
+ ts.isRegularExpressionLiteral = isRegularExpressionLiteral;
+ function isNoSubstitutionTemplateLiteral(node) {
+ return node.kind === 14;
+ }
+ ts.isNoSubstitutionTemplateLiteral = isNoSubstitutionTemplateLiteral;
+ function isTemplateHead(node) {
+ return node.kind === 15;
+ }
+ ts.isTemplateHead = isTemplateHead;
+ function isTemplateMiddle(node) {
+ return node.kind === 16;
+ }
+ ts.isTemplateMiddle = isTemplateMiddle;
+ function isTemplateTail(node) {
+ return node.kind === 17;
+ }
+ ts.isTemplateTail = isTemplateTail;
+ function isIdentifier(node) {
+ return node.kind === 78;
+ }
+ ts.isIdentifier = isIdentifier;
+ function isQualifiedName(node) {
+ return node.kind === 157;
+ }
+ ts.isQualifiedName = isQualifiedName;
+ function isComputedPropertyName(node) {
+ return node.kind === 158;
+ }
+ ts.isComputedPropertyName = isComputedPropertyName;
+ function isPrivateIdentifier(node) {
+ return node.kind === 79;
+ }
+ ts.isPrivateIdentifier = isPrivateIdentifier;
+ function isSuperKeyword(node) {
+ return node.kind === 105;
+ }
+ ts.isSuperKeyword = isSuperKeyword;
+ function isImportKeyword(node) {
+ return node.kind === 99;
+ }
+ ts.isImportKeyword = isImportKeyword;
+ function isCommaToken(node) {
+ return node.kind === 27;
+ }
+ ts.isCommaToken = isCommaToken;
+ function isQuestionToken(node) {
+ return node.kind === 57;
+ }
+ ts.isQuestionToken = isQuestionToken;
+ function isExclamationToken(node) {
+ return node.kind === 53;
+ }
+ ts.isExclamationToken = isExclamationToken;
+ function isTypeParameterDeclaration(node) {
+ return node.kind === 159;
+ }
+ ts.isTypeParameterDeclaration = isTypeParameterDeclaration;
+ function isParameter(node) {
+ return node.kind === 160;
+ }
+ ts.isParameter = isParameter;
+ function isDecorator(node) {
+ return node.kind === 161;
+ }
+ ts.isDecorator = isDecorator;
+ function isPropertySignature(node) {
+ return node.kind === 162;
+ }
+ ts.isPropertySignature = isPropertySignature;
+ function isPropertyDeclaration(node) {
+ return node.kind === 163;
+ }
+ ts.isPropertyDeclaration = isPropertyDeclaration;
+ function isMethodSignature(node) {
+ return node.kind === 164;
+ }
+ ts.isMethodSignature = isMethodSignature;
+ function isMethodDeclaration(node) {
+ return node.kind === 165;
+ }
+ ts.isMethodDeclaration = isMethodDeclaration;
+ function isConstructorDeclaration(node) {
+ return node.kind === 166;
+ }
+ ts.isConstructorDeclaration = isConstructorDeclaration;
+ function isGetAccessorDeclaration(node) {
+ return node.kind === 167;
+ }
+ ts.isGetAccessorDeclaration = isGetAccessorDeclaration;
+ function isSetAccessorDeclaration(node) {
+ return node.kind === 168;
+ }
+ ts.isSetAccessorDeclaration = isSetAccessorDeclaration;
+ function isCallSignatureDeclaration(node) {
+ return node.kind === 169;
+ }
+ ts.isCallSignatureDeclaration = isCallSignatureDeclaration;
+ function isConstructSignatureDeclaration(node) {
+ return node.kind === 170;
+ }
+ ts.isConstructSignatureDeclaration = isConstructSignatureDeclaration;
+ function isIndexSignatureDeclaration(node) {
+ return node.kind === 171;
+ }
+ ts.isIndexSignatureDeclaration = isIndexSignatureDeclaration;
+ function isTypePredicateNode(node) {
+ return node.kind === 172;
+ }
+ ts.isTypePredicateNode = isTypePredicateNode;
+ function isTypeReferenceNode(node) {
+ return node.kind === 173;
+ }
+ ts.isTypeReferenceNode = isTypeReferenceNode;
+ function isFunctionTypeNode(node) {
+ return node.kind === 174;
+ }
+ ts.isFunctionTypeNode = isFunctionTypeNode;
+ function isConstructorTypeNode(node) {
+ return node.kind === 175;
+ }
+ ts.isConstructorTypeNode = isConstructorTypeNode;
+ function isTypeQueryNode(node) {
+ return node.kind === 176;
+ }
+ ts.isTypeQueryNode = isTypeQueryNode;
+ function isTypeLiteralNode(node) {
+ return node.kind === 177;
+ }
+ ts.isTypeLiteralNode = isTypeLiteralNode;
+ function isArrayTypeNode(node) {
+ return node.kind === 178;
+ }
+ ts.isArrayTypeNode = isArrayTypeNode;
+ function isTupleTypeNode(node) {
+ return node.kind === 179;
+ }
+ ts.isTupleTypeNode = isTupleTypeNode;
+ function isNamedTupleMember(node) {
+ return node.kind === 192;
+ }
+ ts.isNamedTupleMember = isNamedTupleMember;
+ function isOptionalTypeNode(node) {
+ return node.kind === 180;
+ }
+ ts.isOptionalTypeNode = isOptionalTypeNode;
+ function isRestTypeNode(node) {
+ return node.kind === 181;
+ }
+ ts.isRestTypeNode = isRestTypeNode;
+ function isUnionTypeNode(node) {
+ return node.kind === 182;
+ }
+ ts.isUnionTypeNode = isUnionTypeNode;
+ function isIntersectionTypeNode(node) {
+ return node.kind === 183;
+ }
+ ts.isIntersectionTypeNode = isIntersectionTypeNode;
+ function isConditionalTypeNode(node) {
+ return node.kind === 184;
+ }
+ ts.isConditionalTypeNode = isConditionalTypeNode;
+ function isInferTypeNode(node) {
+ return node.kind === 185;
+ }
+ ts.isInferTypeNode = isInferTypeNode;
+ function isParenthesizedTypeNode(node) {
+ return node.kind === 186;
+ }
+ ts.isParenthesizedTypeNode = isParenthesizedTypeNode;
+ function isThisTypeNode(node) {
+ return node.kind === 187;
+ }
+ ts.isThisTypeNode = isThisTypeNode;
+ function isTypeOperatorNode(node) {
+ return node.kind === 188;
+ }
+ ts.isTypeOperatorNode = isTypeOperatorNode;
+ function isIndexedAccessTypeNode(node) {
+ return node.kind === 189;
+ }
+ ts.isIndexedAccessTypeNode = isIndexedAccessTypeNode;
+ function isMappedTypeNode(node) {
+ return node.kind === 190;
+ }
+ ts.isMappedTypeNode = isMappedTypeNode;
+ function isLiteralTypeNode(node) {
+ return node.kind === 191;
+ }
+ ts.isLiteralTypeNode = isLiteralTypeNode;
+ function isImportTypeNode(node) {
+ return node.kind === 195;
+ }
+ ts.isImportTypeNode = isImportTypeNode;
+ function isTemplateLiteralTypeSpan(node) {
+ return node.kind === 194;
+ }
+ ts.isTemplateLiteralTypeSpan = isTemplateLiteralTypeSpan;
+ function isTemplateLiteralTypeNode(node) {
+ return node.kind === 193;
+ }
+ ts.isTemplateLiteralTypeNode = isTemplateLiteralTypeNode;
+ function isObjectBindingPattern(node) {
+ return node.kind === 196;
+ }
+ ts.isObjectBindingPattern = isObjectBindingPattern;
+ function isArrayBindingPattern(node) {
+ return node.kind === 197;
+ }
+ ts.isArrayBindingPattern = isArrayBindingPattern;
+ function isBindingElement(node) {
+ return node.kind === 198;
+ }
+ ts.isBindingElement = isBindingElement;
+ function isArrayLiteralExpression(node) {
+ return node.kind === 199;
+ }
+ ts.isArrayLiteralExpression = isArrayLiteralExpression;
+ function isObjectLiteralExpression(node) {
+ return node.kind === 200;
+ }
+ ts.isObjectLiteralExpression = isObjectLiteralExpression;
+ function isPropertyAccessExpression(node) {
+ return node.kind === 201;
+ }
+ ts.isPropertyAccessExpression = isPropertyAccessExpression;
+ function isElementAccessExpression(node) {
+ return node.kind === 202;
+ }
+ ts.isElementAccessExpression = isElementAccessExpression;
+ function isCallExpression(node) {
+ return node.kind === 203;
+ }
+ ts.isCallExpression = isCallExpression;
+ function isNewExpression(node) {
+ return node.kind === 204;
+ }
+ ts.isNewExpression = isNewExpression;
+ function isTaggedTemplateExpression(node) {
+ return node.kind === 205;
+ }
+ ts.isTaggedTemplateExpression = isTaggedTemplateExpression;
+ function isTypeAssertionExpression(node) {
+ return node.kind === 206;
+ }
+ ts.isTypeAssertionExpression = isTypeAssertionExpression;
+ function isParenthesizedExpression(node) {
+ return node.kind === 207;
+ }
+ ts.isParenthesizedExpression = isParenthesizedExpression;
+ function isFunctionExpression(node) {
+ return node.kind === 208;
+ }
+ ts.isFunctionExpression = isFunctionExpression;
+ function isArrowFunction(node) {
+ return node.kind === 209;
+ }
+ ts.isArrowFunction = isArrowFunction;
+ function isDeleteExpression(node) {
+ return node.kind === 210;
+ }
+ ts.isDeleteExpression = isDeleteExpression;
+ function isTypeOfExpression(node) {
+ return node.kind === 211;
+ }
+ ts.isTypeOfExpression = isTypeOfExpression;
+ function isVoidExpression(node) {
+ return node.kind === 212;
+ }
+ ts.isVoidExpression = isVoidExpression;
+ function isAwaitExpression(node) {
+ return node.kind === 213;
+ }
+ ts.isAwaitExpression = isAwaitExpression;
+ function isPrefixUnaryExpression(node) {
+ return node.kind === 214;
+ }
+ ts.isPrefixUnaryExpression = isPrefixUnaryExpression;
+ function isPostfixUnaryExpression(node) {
+ return node.kind === 215;
+ }
+ ts.isPostfixUnaryExpression = isPostfixUnaryExpression;
+ function isBinaryExpression(node) {
+ return node.kind === 216;
+ }
+ ts.isBinaryExpression = isBinaryExpression;
+ function isConditionalExpression(node) {
+ return node.kind === 217;
+ }
+ ts.isConditionalExpression = isConditionalExpression;
+ function isTemplateExpression(node) {
+ return node.kind === 218;
+ }
+ ts.isTemplateExpression = isTemplateExpression;
+ function isYieldExpression(node) {
+ return node.kind === 219;
+ }
+ ts.isYieldExpression = isYieldExpression;
+ function isSpreadElement(node) {
+ return node.kind === 220;
+ }
+ ts.isSpreadElement = isSpreadElement;
+ function isClassExpression(node) {
+ return node.kind === 221;
+ }
+ ts.isClassExpression = isClassExpression;
+ function isOmittedExpression(node) {
+ return node.kind === 222;
+ }
+ ts.isOmittedExpression = isOmittedExpression;
+ function isExpressionWithTypeArguments(node) {
+ return node.kind === 223;
+ }
+ ts.isExpressionWithTypeArguments = isExpressionWithTypeArguments;
+ function isAsExpression(node) {
+ return node.kind === 224;
+ }
+ ts.isAsExpression = isAsExpression;
+ function isNonNullExpression(node) {
+ return node.kind === 225;
+ }
+ ts.isNonNullExpression = isNonNullExpression;
+ function isMetaProperty(node) {
+ return node.kind === 226;
+ }
+ ts.isMetaProperty = isMetaProperty;
+ function isSyntheticExpression(node) {
+ return node.kind === 227;
+ }
+ ts.isSyntheticExpression = isSyntheticExpression;
+ function isPartiallyEmittedExpression(node) {
+ return node.kind === 336;
+ }
+ ts.isPartiallyEmittedExpression = isPartiallyEmittedExpression;
+ function isCommaListExpression(node) {
+ return node.kind === 337;
+ }
+ ts.isCommaListExpression = isCommaListExpression;
+ function isTemplateSpan(node) {
+ return node.kind === 228;
+ }
+ ts.isTemplateSpan = isTemplateSpan;
+ function isSemicolonClassElement(node) {
+ return node.kind === 229;
+ }
+ ts.isSemicolonClassElement = isSemicolonClassElement;
+ function isBlock(node) {
+ return node.kind === 230;
+ }
+ ts.isBlock = isBlock;
+ function isVariableStatement(node) {
+ return node.kind === 232;
+ }
+ ts.isVariableStatement = isVariableStatement;
+ function isEmptyStatement(node) {
+ return node.kind === 231;
+ }
+ ts.isEmptyStatement = isEmptyStatement;
+ function isExpressionStatement(node) {
+ return node.kind === 233;
+ }
+ ts.isExpressionStatement = isExpressionStatement;
+ function isIfStatement(node) {
+ return node.kind === 234;
+ }
+ ts.isIfStatement = isIfStatement;
+ function isDoStatement(node) {
+ return node.kind === 235;
+ }
+ ts.isDoStatement = isDoStatement;
+ function isWhileStatement(node) {
+ return node.kind === 236;
+ }
+ ts.isWhileStatement = isWhileStatement;
+ function isForStatement(node) {
+ return node.kind === 237;
+ }
+ ts.isForStatement = isForStatement;
+ function isForInStatement(node) {
+ return node.kind === 238;
+ }
+ ts.isForInStatement = isForInStatement;
+ function isForOfStatement(node) {
+ return node.kind === 239;
+ }
+ ts.isForOfStatement = isForOfStatement;
+ function isContinueStatement(node) {
+ return node.kind === 240;
+ }
+ ts.isContinueStatement = isContinueStatement;
+ function isBreakStatement(node) {
+ return node.kind === 241;
+ }
+ ts.isBreakStatement = isBreakStatement;
+ function isReturnStatement(node) {
+ return node.kind === 242;
+ }
+ ts.isReturnStatement = isReturnStatement;
+ function isWithStatement(node) {
+ return node.kind === 243;
+ }
+ ts.isWithStatement = isWithStatement;
+ function isSwitchStatement(node) {
+ return node.kind === 244;
+ }
+ ts.isSwitchStatement = isSwitchStatement;
+ function isLabeledStatement(node) {
+ return node.kind === 245;
+ }
+ ts.isLabeledStatement = isLabeledStatement;
+ function isThrowStatement(node) {
+ return node.kind === 246;
+ }
+ ts.isThrowStatement = isThrowStatement;
+ function isTryStatement(node) {
+ return node.kind === 247;
+ }
+ ts.isTryStatement = isTryStatement;
+ function isDebuggerStatement(node) {
+ return node.kind === 248;
+ }
+ ts.isDebuggerStatement = isDebuggerStatement;
+ function isVariableDeclaration(node) {
+ return node.kind === 249;
+ }
+ ts.isVariableDeclaration = isVariableDeclaration;
+ function isVariableDeclarationList(node) {
+ return node.kind === 250;
+ }
+ ts.isVariableDeclarationList = isVariableDeclarationList;
+ function isFunctionDeclaration(node) {
+ return node.kind === 251;
+ }
+ ts.isFunctionDeclaration = isFunctionDeclaration;
+ function isClassDeclaration(node) {
+ return node.kind === 252;
+ }
+ ts.isClassDeclaration = isClassDeclaration;
+ function isInterfaceDeclaration(node) {
+ return node.kind === 253;
+ }
+ ts.isInterfaceDeclaration = isInterfaceDeclaration;
+ function isTypeAliasDeclaration(node) {
+ return node.kind === 254;
+ }
+ ts.isTypeAliasDeclaration = isTypeAliasDeclaration;
+ function isEnumDeclaration(node) {
+ return node.kind === 255;
+ }
+ ts.isEnumDeclaration = isEnumDeclaration;
+ function isModuleDeclaration(node) {
+ return node.kind === 256;
+ }
+ ts.isModuleDeclaration = isModuleDeclaration;
+ function isModuleBlock(node) {
+ return node.kind === 257;
+ }
+ ts.isModuleBlock = isModuleBlock;
+ function isCaseBlock(node) {
+ return node.kind === 258;
+ }
+ ts.isCaseBlock = isCaseBlock;
+ function isNamespaceExportDeclaration(node) {
+ return node.kind === 259;
+ }
+ ts.isNamespaceExportDeclaration = isNamespaceExportDeclaration;
+ function isImportEqualsDeclaration(node) {
+ return node.kind === 260;
+ }
+ ts.isImportEqualsDeclaration = isImportEqualsDeclaration;
+ function isImportDeclaration(node) {
+ return node.kind === 261;
+ }
+ ts.isImportDeclaration = isImportDeclaration;
+ function isImportClause(node) {
+ return node.kind === 262;
+ }
+ ts.isImportClause = isImportClause;
+ function isNamespaceImport(node) {
+ return node.kind === 263;
+ }
+ ts.isNamespaceImport = isNamespaceImport;
+ function isNamespaceExport(node) {
+ return node.kind === 269;
+ }
+ ts.isNamespaceExport = isNamespaceExport;
+ function isNamedImports(node) {
+ return node.kind === 264;
+ }
+ ts.isNamedImports = isNamedImports;
+ function isImportSpecifier(node) {
+ return node.kind === 265;
+ }
+ ts.isImportSpecifier = isImportSpecifier;
+ function isExportAssignment(node) {
+ return node.kind === 266;
+ }
+ ts.isExportAssignment = isExportAssignment;
+ function isExportDeclaration(node) {
+ return node.kind === 267;
+ }
+ ts.isExportDeclaration = isExportDeclaration;
+ function isNamedExports(node) {
+ return node.kind === 268;
+ }
+ ts.isNamedExports = isNamedExports;
+ function isExportSpecifier(node) {
+ return node.kind === 270;
+ }
+ ts.isExportSpecifier = isExportSpecifier;
+ function isMissingDeclaration(node) {
+ return node.kind === 271;
+ }
+ ts.isMissingDeclaration = isMissingDeclaration;
+ function isNotEmittedStatement(node) {
+ return node.kind === 335;
+ }
+ ts.isNotEmittedStatement = isNotEmittedStatement;
+ function isSyntheticReference(node) {
+ return node.kind === 340;
+ }
+ ts.isSyntheticReference = isSyntheticReference;
+ function isMergeDeclarationMarker(node) {
+ return node.kind === 338;
+ }
+ ts.isMergeDeclarationMarker = isMergeDeclarationMarker;
+ function isEndOfDeclarationMarker(node) {
+ return node.kind === 339;
+ }
+ ts.isEndOfDeclarationMarker = isEndOfDeclarationMarker;
+ function isExternalModuleReference(node) {
+ return node.kind === 272;
+ }
+ ts.isExternalModuleReference = isExternalModuleReference;
+ function isJsxElement(node) {
+ return node.kind === 273;
+ }
+ ts.isJsxElement = isJsxElement;
+ function isJsxSelfClosingElement(node) {
+ return node.kind === 274;
+ }
+ ts.isJsxSelfClosingElement = isJsxSelfClosingElement;
+ function isJsxOpeningElement(node) {
+ return node.kind === 275;
+ }
+ ts.isJsxOpeningElement = isJsxOpeningElement;
+ function isJsxClosingElement(node) {
+ return node.kind === 276;
+ }
+ ts.isJsxClosingElement = isJsxClosingElement;
+ function isJsxFragment(node) {
+ return node.kind === 277;
+ }
+ ts.isJsxFragment = isJsxFragment;
+ function isJsxOpeningFragment(node) {
+ return node.kind === 278;
+ }
+ ts.isJsxOpeningFragment = isJsxOpeningFragment;
+ function isJsxClosingFragment(node) {
+ return node.kind === 279;
+ }
+ ts.isJsxClosingFragment = isJsxClosingFragment;
+ function isJsxAttribute(node) {
+ return node.kind === 280;
+ }
+ ts.isJsxAttribute = isJsxAttribute;
+ function isJsxAttributes(node) {
+ return node.kind === 281;
+ }
+ ts.isJsxAttributes = isJsxAttributes;
+ function isJsxSpreadAttribute(node) {
+ return node.kind === 282;
+ }
+ ts.isJsxSpreadAttribute = isJsxSpreadAttribute;
+ function isJsxExpression(node) {
+ return node.kind === 283;
+ }
+ ts.isJsxExpression = isJsxExpression;
+ function isCaseClause(node) {
+ return node.kind === 284;
+ }
+ ts.isCaseClause = isCaseClause;
+ function isDefaultClause(node) {
+ return node.kind === 285;
+ }
+ ts.isDefaultClause = isDefaultClause;
+ function isHeritageClause(node) {
+ return node.kind === 286;
+ }
+ ts.isHeritageClause = isHeritageClause;
+ function isCatchClause(node) {
+ return node.kind === 287;
+ }
+ ts.isCatchClause = isCatchClause;
+ function isPropertyAssignment(node) {
+ return node.kind === 288;
+ }
+ ts.isPropertyAssignment = isPropertyAssignment;
+ function isShorthandPropertyAssignment(node) {
+ return node.kind === 289;
+ }
+ ts.isShorthandPropertyAssignment = isShorthandPropertyAssignment;
+ function isSpreadAssignment(node) {
+ return node.kind === 290;
+ }
+ ts.isSpreadAssignment = isSpreadAssignment;
+ function isEnumMember(node) {
+ return node.kind === 291;
+ }
+ ts.isEnumMember = isEnumMember;
+ function isUnparsedPrepend(node) {
+ return node.kind === 293;
+ }
+ ts.isUnparsedPrepend = isUnparsedPrepend;
+ function isSourceFile(node) {
+ return node.kind === 297;
+ }
+ ts.isSourceFile = isSourceFile;
+ function isBundle(node) {
+ return node.kind === 298;
+ }
+ ts.isBundle = isBundle;
+ function isUnparsedSource(node) {
+ return node.kind === 299;
+ }
+ ts.isUnparsedSource = isUnparsedSource;
+ function isJSDocTypeExpression(node) {
+ return node.kind === 301;
+ }
+ ts.isJSDocTypeExpression = isJSDocTypeExpression;
+ function isJSDocNameReference(node) {
+ return node.kind === 302;
+ }
+ ts.isJSDocNameReference = isJSDocNameReference;
+ function isJSDocAllType(node) {
+ return node.kind === 303;
+ }
+ ts.isJSDocAllType = isJSDocAllType;
+ function isJSDocUnknownType(node) {
+ return node.kind === 304;
+ }
+ ts.isJSDocUnknownType = isJSDocUnknownType;
+ function isJSDocNullableType(node) {
+ return node.kind === 305;
+ }
+ ts.isJSDocNullableType = isJSDocNullableType;
+ function isJSDocNonNullableType(node) {
+ return node.kind === 306;
+ }
+ ts.isJSDocNonNullableType = isJSDocNonNullableType;
+ function isJSDocOptionalType(node) {
+ return node.kind === 307;
+ }
+ ts.isJSDocOptionalType = isJSDocOptionalType;
+ function isJSDocFunctionType(node) {
+ return node.kind === 308;
+ }
+ ts.isJSDocFunctionType = isJSDocFunctionType;
+ function isJSDocVariadicType(node) {
+ return node.kind === 309;
+ }
+ ts.isJSDocVariadicType = isJSDocVariadicType;
+ function isJSDocNamepathType(node) {
+ return node.kind === 310;
+ }
+ ts.isJSDocNamepathType = isJSDocNamepathType;
+ function isJSDoc(node) {
+ return node.kind === 311;
+ }
+ ts.isJSDoc = isJSDoc;
+ function isJSDocTypeLiteral(node) {
+ return node.kind === 312;
+ }
+ ts.isJSDocTypeLiteral = isJSDocTypeLiteral;
+ function isJSDocSignature(node) {
+ return node.kind === 313;
+ }
+ ts.isJSDocSignature = isJSDocSignature;
+ function isJSDocAugmentsTag(node) {
+ return node.kind === 315;
+ }
+ ts.isJSDocAugmentsTag = isJSDocAugmentsTag;
+ function isJSDocAuthorTag(node) {
+ return node.kind === 317;
+ }
+ ts.isJSDocAuthorTag = isJSDocAuthorTag;
+ function isJSDocClassTag(node) {
+ return node.kind === 319;
+ }
+ ts.isJSDocClassTag = isJSDocClassTag;
+ function isJSDocCallbackTag(node) {
+ return node.kind === 324;
+ }
+ ts.isJSDocCallbackTag = isJSDocCallbackTag;
+ function isJSDocPublicTag(node) {
+ return node.kind === 320;
+ }
+ ts.isJSDocPublicTag = isJSDocPublicTag;
+ function isJSDocPrivateTag(node) {
+ return node.kind === 321;
+ }
+ ts.isJSDocPrivateTag = isJSDocPrivateTag;
+ function isJSDocProtectedTag(node) {
+ return node.kind === 322;
+ }
+ ts.isJSDocProtectedTag = isJSDocProtectedTag;
+ function isJSDocReadonlyTag(node) {
+ return node.kind === 323;
+ }
+ ts.isJSDocReadonlyTag = isJSDocReadonlyTag;
+ function isJSDocDeprecatedTag(node) {
+ return node.kind === 318;
+ }
+ ts.isJSDocDeprecatedTag = isJSDocDeprecatedTag;
+ function isJSDocEnumTag(node) {
+ return node.kind === 325;
+ }
+ ts.isJSDocEnumTag = isJSDocEnumTag;
+ function isJSDocParameterTag(node) {
+ return node.kind === 326;
+ }
+ ts.isJSDocParameterTag = isJSDocParameterTag;
+ function isJSDocReturnTag(node) {
+ return node.kind === 327;
+ }
+ ts.isJSDocReturnTag = isJSDocReturnTag;
+ function isJSDocThisTag(node) {
+ return node.kind === 328;
+ }
+ ts.isJSDocThisTag = isJSDocThisTag;
+ function isJSDocTypeTag(node) {
+ return node.kind === 329;
+ }
+ ts.isJSDocTypeTag = isJSDocTypeTag;
+ function isJSDocTemplateTag(node) {
+ return node.kind === 330;
+ }
+ ts.isJSDocTemplateTag = isJSDocTemplateTag;
+ function isJSDocTypedefTag(node) {
+ return node.kind === 331;
+ }
+ ts.isJSDocTypedefTag = isJSDocTypedefTag;
+ function isJSDocUnknownTag(node) {
+ return node.kind === 314;
+ }
+ ts.isJSDocUnknownTag = isJSDocUnknownTag;
+ function isJSDocPropertyTag(node) {
+ return node.kind === 333;
+ }
+ ts.isJSDocPropertyTag = isJSDocPropertyTag;
+ function isJSDocImplementsTag(node) {
+ return node.kind === 316;
+ }
+ ts.isJSDocImplementsTag = isJSDocImplementsTag;
+ function isSyntaxList(n) {
+ return n.kind === 334;
+ }
+ ts.isSyntaxList = isSyntaxList;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function createEmptyExports(factory) {
+ return factory.createExportDeclaration(undefined, undefined, false, factory.createNamedExports([]), undefined);
+ }
+ ts.createEmptyExports = createEmptyExports;
+ function createMemberAccessForPropertyName(factory, target, memberName, location) {
+ if (ts.isComputedPropertyName(memberName)) {
+ return ts.setTextRange(factory.createElementAccessExpression(target, memberName.expression), location);
+ }
+ else {
+ var expression = ts.setTextRange(ts.isIdentifierOrPrivateIdentifier(memberName)
+ ? factory.createPropertyAccessExpression(target, memberName)
+ : factory.createElementAccessExpression(target, memberName), memberName);
+ ts.getOrCreateEmitNode(expression).flags |= 64;
+ return expression;
+ }
+ }
+ ts.createMemberAccessForPropertyName = createMemberAccessForPropertyName;
+ function createReactNamespace(reactNamespace, parent) {
+ var react = ts.parseNodeFactory.createIdentifier(reactNamespace || "React");
+ ts.setParent(react, ts.getParseTreeNode(parent));
+ return react;
+ }
+ function createJsxFactoryExpressionFromEntityName(factory, jsxFactory, parent) {
+ if (ts.isQualifiedName(jsxFactory)) {
+ var left = createJsxFactoryExpressionFromEntityName(factory, jsxFactory.left, parent);
+ var right = factory.createIdentifier(ts.idText(jsxFactory.right));
+ right.escapedText = jsxFactory.right.escapedText;
+ return factory.createPropertyAccessExpression(left, right);
+ }
+ else {
+ return createReactNamespace(ts.idText(jsxFactory), parent);
+ }
+ }
+ function createJsxFactoryExpression(factory, jsxFactoryEntity, reactNamespace, parent) {
+ return jsxFactoryEntity ?
+ createJsxFactoryExpressionFromEntityName(factory, jsxFactoryEntity, parent) :
+ factory.createPropertyAccessExpression(createReactNamespace(reactNamespace, parent), "createElement");
+ }
+ ts.createJsxFactoryExpression = createJsxFactoryExpression;
+ function createJsxFragmentFactoryExpression(factory, jsxFragmentFactoryEntity, reactNamespace, parent) {
+ return jsxFragmentFactoryEntity ?
+ createJsxFactoryExpressionFromEntityName(factory, jsxFragmentFactoryEntity, parent) :
+ factory.createPropertyAccessExpression(createReactNamespace(reactNamespace, parent), "Fragment");
+ }
+ function createExpressionForJsxElement(factory, callee, tagName, props, children, location) {
+ var argumentsList = [tagName];
+ if (props) {
+ argumentsList.push(props);
+ }
+ if (children && children.length > 0) {
+ if (!props) {
+ argumentsList.push(factory.createNull());
+ }
+ if (children.length > 1) {
+ for (var _i = 0, children_3 = children; _i < children_3.length; _i++) {
+ var child = children_3[_i];
+ startOnNewLine(child);
+ argumentsList.push(child);
+ }
+ }
+ else {
+ argumentsList.push(children[0]);
+ }
+ }
+ return ts.setTextRange(factory.createCallExpression(callee, undefined, argumentsList), location);
+ }
+ ts.createExpressionForJsxElement = createExpressionForJsxElement;
+ function createExpressionForJsxFragment(factory, jsxFactoryEntity, jsxFragmentFactoryEntity, reactNamespace, children, parentElement, location) {
+ var tagName = createJsxFragmentFactoryExpression(factory, jsxFragmentFactoryEntity, reactNamespace, parentElement);
+ var argumentsList = [tagName, factory.createNull()];
+ if (children && children.length > 0) {
+ if (children.length > 1) {
+ for (var _i = 0, children_4 = children; _i < children_4.length; _i++) {
+ var child = children_4[_i];
+ startOnNewLine(child);
+ argumentsList.push(child);
+ }
+ }
+ else {
+ argumentsList.push(children[0]);
+ }
+ }
+ return ts.setTextRange(factory.createCallExpression(createJsxFactoryExpression(factory, jsxFactoryEntity, reactNamespace, parentElement), undefined, argumentsList), location);
+ }
+ ts.createExpressionForJsxFragment = createExpressionForJsxFragment;
+ function createForOfBindingStatement(factory, node, boundValue) {
+ if (ts.isVariableDeclarationList(node)) {
+ var firstDeclaration = ts.first(node.declarations);
+ var updatedDeclaration = factory.updateVariableDeclaration(firstDeclaration, firstDeclaration.name, undefined, undefined, boundValue);
+ return ts.setTextRange(factory.createVariableStatement(undefined, factory.updateVariableDeclarationList(node, [updatedDeclaration])), node);
+ }
+ else {
+ var updatedExpression = ts.setTextRange(factory.createAssignment(node, boundValue), node);
+ return ts.setTextRange(factory.createExpressionStatement(updatedExpression), node);
+ }
+ }
+ ts.createForOfBindingStatement = createForOfBindingStatement;
+ function insertLeadingStatement(factory, dest, source) {
+ if (ts.isBlock(dest)) {
+ return factory.updateBlock(dest, ts.setTextRange(factory.createNodeArray(__spreadArrays([source], dest.statements)), dest.statements));
+ }
+ else {
+ return factory.createBlock(factory.createNodeArray([dest, source]), true);
+ }
+ }
+ ts.insertLeadingStatement = insertLeadingStatement;
+ function createExpressionFromEntityName(factory, node) {
+ if (ts.isQualifiedName(node)) {
+ var left = createExpressionFromEntityName(factory, node.left);
+ var right = ts.setParent(ts.setTextRange(factory.cloneNode(node.right), node.right), node.right.parent);
+ return ts.setTextRange(factory.createPropertyAccessExpression(left, right), node);
+ }
+ else {
+ return ts.setParent(ts.setTextRange(factory.cloneNode(node), node), node.parent);
+ }
+ }
+ ts.createExpressionFromEntityName = createExpressionFromEntityName;
+ function createExpressionForPropertyName(factory, memberName) {
+ if (ts.isIdentifier(memberName)) {
+ return factory.createStringLiteralFromNode(memberName);
+ }
+ else if (ts.isComputedPropertyName(memberName)) {
+ return ts.setParent(ts.setTextRange(factory.cloneNode(memberName.expression), memberName.expression), memberName.expression.parent);
+ }
+ else {
+ return ts.setParent(ts.setTextRange(factory.cloneNode(memberName), memberName), memberName.parent);
+ }
+ }
+ ts.createExpressionForPropertyName = createExpressionForPropertyName;
+ function createExpressionForAccessorDeclaration(factory, properties, property, receiver, multiLine) {
+ var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;
+ if (property === firstAccessor) {
+ return ts.setTextRange(factory.createObjectDefinePropertyCall(receiver, createExpressionForPropertyName(factory, property.name), factory.createPropertyDescriptor({
+ enumerable: factory.createFalse(),
+ configurable: true,
+ get: getAccessor && ts.setTextRange(ts.setOriginalNode(factory.createFunctionExpression(getAccessor.modifiers, undefined, undefined, undefined, getAccessor.parameters, undefined, getAccessor.body), getAccessor), getAccessor),
+ set: setAccessor && ts.setTextRange(ts.setOriginalNode(factory.createFunctionExpression(setAccessor.modifiers, undefined, undefined, undefined, setAccessor.parameters, undefined, setAccessor.body), setAccessor), setAccessor)
+ }, !multiLine)), firstAccessor);
+ }
+ return undefined;
+ }
+ function createExpressionForPropertyAssignment(factory, property, receiver) {
+ return ts.setOriginalNode(ts.setTextRange(factory.createAssignment(createMemberAccessForPropertyName(factory, receiver, property.name, property.name), property.initializer), property), property);
+ }
+ function createExpressionForShorthandPropertyAssignment(factory, property, receiver) {
+ return ts.setOriginalNode(ts.setTextRange(factory.createAssignment(createMemberAccessForPropertyName(factory, receiver, property.name, property.name), factory.cloneNode(property.name)), property), property);
+ }
+ function createExpressionForMethodDeclaration(factory, method, receiver) {
+ return ts.setOriginalNode(ts.setTextRange(factory.createAssignment(createMemberAccessForPropertyName(factory, receiver, method.name, method.name), ts.setOriginalNode(ts.setTextRange(factory.createFunctionExpression(method.modifiers, method.asteriskToken, undefined, undefined, method.parameters, undefined, method.body), method), method)), method), method);
+ }
+ function createExpressionForObjectLiteralElementLike(factory, node, property, receiver) {
+ if (property.name && ts.isPrivateIdentifier(property.name)) {
+ ts.Debug.failBadSyntaxKind(property.name, "Private identifiers are not allowed in object literals.");
+ }
+ switch (property.kind) {
+ case 167:
+ case 168:
+ return createExpressionForAccessorDeclaration(factory, node.properties, property, receiver, !!node.multiLine);
+ case 288:
+ return createExpressionForPropertyAssignment(factory, property, receiver);
+ case 289:
+ return createExpressionForShorthandPropertyAssignment(factory, property, receiver);
+ case 165:
+ return createExpressionForMethodDeclaration(factory, property, receiver);
+ }
+ }
+ ts.createExpressionForObjectLiteralElementLike = createExpressionForObjectLiteralElementLike;
+ function isInternalName(node) {
+ return (ts.getEmitFlags(node) & 32768) !== 0;
+ }
+ ts.isInternalName = isInternalName;
+ function isLocalName(node) {
+ return (ts.getEmitFlags(node) & 16384) !== 0;
+ }
+ ts.isLocalName = isLocalName;
+ function isExportName(node) {
+ return (ts.getEmitFlags(node) & 8192) !== 0;
+ }
+ ts.isExportName = isExportName;
+ function isUseStrictPrologue(node) {
+ return ts.isStringLiteral(node.expression) && node.expression.text === "use strict";
+ }
+ function findUseStrictPrologue(statements) {
+ for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) {
+ var statement = statements_1[_i];
+ if (ts.isPrologueDirective(statement)) {
+ if (isUseStrictPrologue(statement)) {
+ return statement;
+ }
+ }
+ else {
+ break;
+ }
+ }
+ return undefined;
+ }
+ ts.findUseStrictPrologue = findUseStrictPrologue;
+ function startsWithUseStrict(statements) {
+ var firstStatement = ts.firstOrUndefined(statements);
+ return firstStatement !== undefined
+ && ts.isPrologueDirective(firstStatement)
+ && isUseStrictPrologue(firstStatement);
+ }
+ ts.startsWithUseStrict = startsWithUseStrict;
+ function isCommaSequence(node) {
+ return node.kind === 216 && node.operatorToken.kind === 27 ||
+ node.kind === 337;
+ }
+ ts.isCommaSequence = isCommaSequence;
+ function isOuterExpression(node, kinds) {
+ if (kinds === void 0) { kinds = 15; }
+ switch (node.kind) {
+ case 207:
+ return (kinds & 1) !== 0;
+ case 206:
+ case 224:
+ return (kinds & 2) !== 0;
+ case 225:
+ return (kinds & 4) !== 0;
+ case 336:
+ return (kinds & 8) !== 0;
+ }
+ return false;
+ }
+ ts.isOuterExpression = isOuterExpression;
+ function skipOuterExpressions(node, kinds) {
+ if (kinds === void 0) { kinds = 15; }
+ while (isOuterExpression(node, kinds)) {
+ node = node.expression;
+ }
+ return node;
+ }
+ ts.skipOuterExpressions = skipOuterExpressions;
+ function skipAssertions(node) {
+ return skipOuterExpressions(node, 6);
+ }
+ ts.skipAssertions = skipAssertions;
+ function startOnNewLine(node) {
+ return ts.setStartsOnNewLine(node, true);
+ }
+ ts.startOnNewLine = startOnNewLine;
+ function getExternalHelpersModuleName(node) {
+ var parseNode = ts.getOriginalNode(node, ts.isSourceFile);
+ var emitNode = parseNode && parseNode.emitNode;
+ return emitNode && emitNode.externalHelpersModuleName;
+ }
+ ts.getExternalHelpersModuleName = getExternalHelpersModuleName;
+ function hasRecordedExternalHelpers(sourceFile) {
+ var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile);
+ var emitNode = parseNode && parseNode.emitNode;
+ return !!emitNode && (!!emitNode.externalHelpersModuleName || !!emitNode.externalHelpers);
+ }
+ ts.hasRecordedExternalHelpers = hasRecordedExternalHelpers;
+ function createExternalHelpersImportDeclarationIfNeeded(nodeFactory, helperFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault) {
+ if (compilerOptions.importHelpers && ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
+ var namedBindings = void 0;
+ var moduleKind = ts.getEmitModuleKind(compilerOptions);
+ if (moduleKind >= ts.ModuleKind.ES2015 && moduleKind <= ts.ModuleKind.ESNext) {
+ var helpers = ts.getEmitHelpers(sourceFile);
+ if (helpers) {
+ var helperNames = [];
+ for (var _i = 0, helpers_3 = helpers; _i < helpers_3.length; _i++) {
+ var helper = helpers_3[_i];
+ if (!helper.scoped) {
+ var importName = helper.importName;
+ if (importName) {
+ ts.pushIfUnique(helperNames, importName);
+ }
+ }
+ }
+ if (ts.some(helperNames)) {
+ helperNames.sort(ts.compareStringsCaseSensitive);
+ namedBindings = nodeFactory.createNamedImports(ts.map(helperNames, function (name) { return ts.isFileLevelUniqueName(sourceFile, name)
+ ? nodeFactory.createImportSpecifier(undefined, nodeFactory.createIdentifier(name))
+ : nodeFactory.createImportSpecifier(nodeFactory.createIdentifier(name), helperFactory.getUnscopedHelperName(name)); }));
+ var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile);
+ var emitNode = ts.getOrCreateEmitNode(parseNode);
+ emitNode.externalHelpers = true;
+ }
+ }
+ }
+ else {
+ var externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(nodeFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar || hasImportDefault);
+ if (externalHelpersModuleName) {
+ namedBindings = nodeFactory.createNamespaceImport(externalHelpersModuleName);
+ }
+ }
+ if (namedBindings) {
+ var externalHelpersImportDeclaration = nodeFactory.createImportDeclaration(undefined, undefined, nodeFactory.createImportClause(false, undefined, namedBindings), nodeFactory.createStringLiteral(ts.externalHelpersModuleNameText));
+ ts.addEmitFlags(externalHelpersImportDeclaration, 67108864);
+ return externalHelpersImportDeclaration;
+ }
+ }
+ }
+ ts.createExternalHelpersImportDeclarationIfNeeded = createExternalHelpersImportDeclarationIfNeeded;
+ function getOrCreateExternalHelpersModuleNameIfNeeded(factory, node, compilerOptions, hasExportStarsToExportValues, hasImportStarOrImportDefault) {
+ if (compilerOptions.importHelpers && ts.isEffectiveExternalModule(node, compilerOptions)) {
+ var externalHelpersModuleName = getExternalHelpersModuleName(node);
+ if (externalHelpersModuleName) {
+ return externalHelpersModuleName;
+ }
+ var moduleKind = ts.getEmitModuleKind(compilerOptions);
+ var create = (hasExportStarsToExportValues || (compilerOptions.esModuleInterop && hasImportStarOrImportDefault))
+ && moduleKind !== ts.ModuleKind.System
+ && moduleKind < ts.ModuleKind.ES2015;
+ if (!create) {
+ var helpers = ts.getEmitHelpers(node);
+ if (helpers) {
+ for (var _i = 0, helpers_4 = helpers; _i < helpers_4.length; _i++) {
+ var helper = helpers_4[_i];
+ if (!helper.scoped) {
+ create = true;
+ break;
+ }
+ }
+ }
+ }
+ if (create) {
+ var parseNode = ts.getOriginalNode(node, ts.isSourceFile);
+ var emitNode = ts.getOrCreateEmitNode(parseNode);
+ return emitNode.externalHelpersModuleName || (emitNode.externalHelpersModuleName = factory.createUniqueName(ts.externalHelpersModuleNameText));
+ }
+ }
+ }
+ ts.getOrCreateExternalHelpersModuleNameIfNeeded = getOrCreateExternalHelpersModuleNameIfNeeded;
+ function getLocalNameForExternalImport(factory, node, sourceFile) {
+ var namespaceDeclaration = ts.getNamespaceDeclarationNode(node);
+ if (namespaceDeclaration && !ts.isDefaultImport(node) && !ts.isExportNamespaceAsDefaultDeclaration(node)) {
+ var name = namespaceDeclaration.name;
+ return ts.isGeneratedIdentifier(name) ? name : factory.createIdentifier(ts.getSourceTextOfNodeFromSourceFile(sourceFile, name) || ts.idText(name));
+ }
+ if (node.kind === 261 && node.importClause) {
+ return factory.getGeneratedNameForNode(node);
+ }
+ if (node.kind === 267 && node.moduleSpecifier) {
+ return factory.getGeneratedNameForNode(node);
+ }
+ return undefined;
+ }
+ ts.getLocalNameForExternalImport = getLocalNameForExternalImport;
+ function getExternalModuleNameLiteral(factory, importNode, sourceFile, host, resolver, compilerOptions) {
+ var moduleName = ts.getExternalModuleName(importNode);
+ if (moduleName.kind === 10) {
+ return tryGetModuleNameFromDeclaration(importNode, host, factory, resolver, compilerOptions)
+ || tryRenameExternalModule(factory, moduleName, sourceFile)
+ || factory.cloneNode(moduleName);
+ }
+ return undefined;
+ }
+ ts.getExternalModuleNameLiteral = getExternalModuleNameLiteral;
+ function tryRenameExternalModule(factory, moduleName, sourceFile) {
+ var rename = sourceFile.renamedDependencies && sourceFile.renamedDependencies.get(moduleName.text);
+ return rename && factory.createStringLiteral(rename);
+ }
+ function tryGetModuleNameFromFile(factory, file, host, options) {
+ if (!file) {
+ return undefined;
+ }
+ if (file.moduleName) {
+ return factory.createStringLiteral(file.moduleName);
+ }
+ if (!file.isDeclarationFile && ts.outFile(options)) {
+ return factory.createStringLiteral(ts.getExternalModuleNameFromPath(host, file.fileName));
+ }
+ return undefined;
+ }
+ ts.tryGetModuleNameFromFile = tryGetModuleNameFromFile;
+ function tryGetModuleNameFromDeclaration(declaration, host, factory, resolver, compilerOptions) {
+ return tryGetModuleNameFromFile(factory, resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions);
+ }
+ function getInitializerOfBindingOrAssignmentElement(bindingElement) {
+ if (ts.isDeclarationBindingElement(bindingElement)) {
+ return bindingElement.initializer;
+ }
+ if (ts.isPropertyAssignment(bindingElement)) {
+ var initializer = bindingElement.initializer;
+ return ts.isAssignmentExpression(initializer, true)
+ ? initializer.right
+ : undefined;
+ }
+ if (ts.isShorthandPropertyAssignment(bindingElement)) {
+ return bindingElement.objectAssignmentInitializer;
+ }
+ if (ts.isAssignmentExpression(bindingElement, true)) {
+ return bindingElement.right;
+ }
+ if (ts.isSpreadElement(bindingElement)) {
+ return getInitializerOfBindingOrAssignmentElement(bindingElement.expression);
+ }
+ }
+ ts.getInitializerOfBindingOrAssignmentElement = getInitializerOfBindingOrAssignmentElement;
+ function getTargetOfBindingOrAssignmentElement(bindingElement) {
+ if (ts.isDeclarationBindingElement(bindingElement)) {
+ return bindingElement.name;
+ }
+ if (ts.isObjectLiteralElementLike(bindingElement)) {
+ switch (bindingElement.kind) {
+ case 288:
+ return getTargetOfBindingOrAssignmentElement(bindingElement.initializer);
+ case 289:
+ return bindingElement.name;
+ case 290:
+ return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
+ }
+ return undefined;
+ }
+ if (ts.isAssignmentExpression(bindingElement, true)) {
+ return getTargetOfBindingOrAssignmentElement(bindingElement.left);
+ }
+ if (ts.isSpreadElement(bindingElement)) {
+ return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
+ }
+ return bindingElement;
+ }
+ ts.getTargetOfBindingOrAssignmentElement = getTargetOfBindingOrAssignmentElement;
+ function getRestIndicatorOfBindingOrAssignmentElement(bindingElement) {
+ switch (bindingElement.kind) {
+ case 160:
+ case 198:
+ return bindingElement.dotDotDotToken;
+ case 220:
+ case 290:
+ return bindingElement;
+ }
+ return undefined;
+ }
+ ts.getRestIndicatorOfBindingOrAssignmentElement = getRestIndicatorOfBindingOrAssignmentElement;
+ function getPropertyNameOfBindingOrAssignmentElement(bindingElement) {
+ var propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement);
+ ts.Debug.assert(!!propertyName || ts.isSpreadAssignment(bindingElement), "Invalid property name for binding element.");
+ return propertyName;
+ }
+ ts.getPropertyNameOfBindingOrAssignmentElement = getPropertyNameOfBindingOrAssignmentElement;
+ function tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement) {
+ switch (bindingElement.kind) {
+ case 198:
+ if (bindingElement.propertyName) {
+ var propertyName = bindingElement.propertyName;
+ if (ts.isPrivateIdentifier(propertyName)) {
+ return ts.Debug.failBadSyntaxKind(propertyName);
+ }
+ return ts.isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression)
+ ? propertyName.expression
+ : propertyName;
+ }
+ break;
+ case 288:
+ if (bindingElement.name) {
+ var propertyName = bindingElement.name;
+ if (ts.isPrivateIdentifier(propertyName)) {
+ return ts.Debug.failBadSyntaxKind(propertyName);
+ }
+ return ts.isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression)
+ ? propertyName.expression
+ : propertyName;
+ }
+ break;
+ case 290:
+ if (bindingElement.name && ts.isPrivateIdentifier(bindingElement.name)) {
+ return ts.Debug.failBadSyntaxKind(bindingElement.name);
+ }
+ return bindingElement.name;
+ }
+ var target = getTargetOfBindingOrAssignmentElement(bindingElement);
+ if (target && ts.isPropertyName(target)) {
+ return target;
+ }
+ }
+ ts.tryGetPropertyNameOfBindingOrAssignmentElement = tryGetPropertyNameOfBindingOrAssignmentElement;
+ function isStringOrNumericLiteral(node) {
+ var kind = node.kind;
+ return kind === 10
+ || kind === 8;
+ }
+ function getElementsOfBindingOrAssignmentPattern(name) {
+ switch (name.kind) {
+ case 196:
+ case 197:
+ case 199:
+ return name.elements;
+ case 200:
+ return name.properties;
+ }
+ }
+ ts.getElementsOfBindingOrAssignmentPattern = getElementsOfBindingOrAssignmentPattern;
+ function getJSDocTypeAliasName(fullName) {
+ if (fullName) {
+ var rightNode = fullName;
+ while (true) {
+ if (ts.isIdentifier(rightNode) || !rightNode.body) {
+ return ts.isIdentifier(rightNode) ? rightNode : rightNode.name;
+ }
+ rightNode = rightNode.body;
+ }
+ }
+ }
+ ts.getJSDocTypeAliasName = getJSDocTypeAliasName;
+ function canHaveModifiers(node) {
+ var kind = node.kind;
+ return kind === 160
+ || kind === 162
+ || kind === 163
+ || kind === 164
+ || kind === 165
+ || kind === 166
+ || kind === 167
+ || kind === 168
+ || kind === 171
+ || kind === 208
+ || kind === 209
+ || kind === 221
+ || kind === 232
+ || kind === 251
+ || kind === 252
+ || kind === 253
+ || kind === 254
+ || kind === 255
+ || kind === 256
+ || kind === 260
+ || kind === 261
+ || kind === 266
+ || kind === 267;
+ }
+ ts.canHaveModifiers = canHaveModifiers;
+ function isExportModifier(node) {
+ return node.kind === 92;
+ }
+ ts.isExportModifier = isExportModifier;
+ function isAsyncModifier(node) {
+ return node.kind === 129;
+ }
+ ts.isAsyncModifier = isAsyncModifier;
+ function isStaticModifier(node) {
+ return node.kind === 123;
+ }
+ ts.isStaticModifier = isStaticModifier;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function setTextRange(range, location) {
+ return location ? ts.setTextRangePosEnd(range, location.pos, location.end) : range;
+ }
+ ts.setTextRange = setTextRange;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ var NodeConstructor;
+ var TokenConstructor;
+ var IdentifierConstructor;
+ var PrivateIdentifierConstructor;
+ var SourceFileConstructor;
+ ts.parseBaseNodeFactory = {
+ createBaseSourceFileNode: function (kind) { return new (SourceFileConstructor || (SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor()))(kind, -1, -1); },
+ createBaseIdentifierNode: function (kind) { return new (IdentifierConstructor || (IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor()))(kind, -1, -1); },
+ createBasePrivateIdentifierNode: function (kind) { return new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor()))(kind, -1, -1); },
+ createBaseTokenNode: function (kind) { return new (TokenConstructor || (TokenConstructor = ts.objectAllocator.getTokenConstructor()))(kind, -1, -1); },
+ createBaseNode: function (kind) { return new (NodeConstructor || (NodeConstructor = ts.objectAllocator.getNodeConstructor()))(kind, -1, -1); },
+ };
+ ts.parseNodeFactory = ts.createNodeFactory(1, ts.parseBaseNodeFactory);
+ function visitNode(cbNode, node) {
+ return node && cbNode(node);
+ }
+ function visitNodes(cbNode, cbNodes, nodes) {
+ if (nodes) {
+ if (cbNodes) {
+ return cbNodes(nodes);
+ }
+ for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+ var node = nodes_1[_i];
+ var result = cbNode(node);
+ if (result) {
+ return result;
+ }
+ }
+ }
+ }
+ function isJSDocLikeText(text, start) {
+ return text.charCodeAt(start + 1) === 42 &&
+ text.charCodeAt(start + 2) === 42 &&
+ text.charCodeAt(start + 3) !== 47;
+ }
+ ts.isJSDocLikeText = isJSDocLikeText;
+ function forEachChild(node, cbNode, cbNodes) {
+ if (!node || node.kind <= 156) {
+ return;
+ }
+ switch (node.kind) {
+ case 157:
+ return visitNode(cbNode, node.left) ||
+ visitNode(cbNode, node.right);
+ case 159:
+ return visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.constraint) ||
+ visitNode(cbNode, node.default) ||
+ visitNode(cbNode, node.expression);
+ case 289:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.exclamationToken) ||
+ visitNode(cbNode, node.equalsToken) ||
+ visitNode(cbNode, node.objectAssignmentInitializer);
+ case 290:
+ return visitNode(cbNode, node.expression);
+ case 160:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.dotDotDotToken) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.type) ||
+ visitNode(cbNode, node.initializer);
+ case 163:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.exclamationToken) ||
+ visitNode(cbNode, node.type) ||
+ visitNode(cbNode, node.initializer);
+ case 162:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.type) ||
+ visitNode(cbNode, node.initializer);
+ case 288:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.initializer);
+ case 249:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.exclamationToken) ||
+ visitNode(cbNode, node.type) ||
+ visitNode(cbNode, node.initializer);
+ case 198:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.dotDotDotToken) ||
+ visitNode(cbNode, node.propertyName) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.initializer);
+ case 174:
+ case 175:
+ case 169:
+ case 170:
+ case 171:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNodes(cbNode, cbNodes, node.typeParameters) ||
+ visitNodes(cbNode, cbNodes, node.parameters) ||
+ visitNode(cbNode, node.type);
+ case 165:
+ case 164:
+ case 166:
+ case 167:
+ case 168:
+ case 208:
+ case 251:
+ case 209:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.asteriskToken) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.exclamationToken) ||
+ visitNodes(cbNode, cbNodes, node.typeParameters) ||
+ visitNodes(cbNode, cbNodes, node.parameters) ||
+ visitNode(cbNode, node.type) ||
+ visitNode(cbNode, node.equalsGreaterThanToken) ||
+ visitNode(cbNode, node.body);
+ case 173:
+ return visitNode(cbNode, node.typeName) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments);
+ case 172:
+ return visitNode(cbNode, node.assertsModifier) ||
+ visitNode(cbNode, node.parameterName) ||
+ visitNode(cbNode, node.type);
+ case 176:
+ return visitNode(cbNode, node.exprName);
+ case 177:
+ return visitNodes(cbNode, cbNodes, node.members);
+ case 178:
+ return visitNode(cbNode, node.elementType);
+ case 179:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 182:
+ case 183:
+ return visitNodes(cbNode, cbNodes, node.types);
+ case 184:
+ return visitNode(cbNode, node.checkType) ||
+ visitNode(cbNode, node.extendsType) ||
+ visitNode(cbNode, node.trueType) ||
+ visitNode(cbNode, node.falseType);
+ case 185:
+ return visitNode(cbNode, node.typeParameter);
+ case 195:
+ return visitNode(cbNode, node.argument) ||
+ visitNode(cbNode, node.qualifier) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments);
+ case 186:
+ case 188:
+ return visitNode(cbNode, node.type);
+ case 189:
+ return visitNode(cbNode, node.objectType) ||
+ visitNode(cbNode, node.indexType);
+ case 190:
+ return visitNode(cbNode, node.readonlyToken) ||
+ visitNode(cbNode, node.typeParameter) ||
+ visitNode(cbNode, node.nameType) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.type);
+ case 191:
+ return visitNode(cbNode, node.literal);
+ case 192:
+ return visitNode(cbNode, node.dotDotDotToken) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.type);
+ case 196:
+ case 197:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 199:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 200:
+ return visitNodes(cbNode, cbNodes, node.properties);
+ case 201:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.questionDotToken) ||
+ visitNode(cbNode, node.name);
+ case 202:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.questionDotToken) ||
+ visitNode(cbNode, node.argumentExpression);
+ case 203:
+ case 204:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.questionDotToken) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments) ||
+ visitNodes(cbNode, cbNodes, node.arguments);
+ case 205:
+ return visitNode(cbNode, node.tag) ||
+ visitNode(cbNode, node.questionDotToken) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments) ||
+ visitNode(cbNode, node.template);
+ case 206:
+ return visitNode(cbNode, node.type) ||
+ visitNode(cbNode, node.expression);
+ case 207:
+ return visitNode(cbNode, node.expression);
+ case 210:
+ return visitNode(cbNode, node.expression);
+ case 211:
+ return visitNode(cbNode, node.expression);
+ case 212:
+ return visitNode(cbNode, node.expression);
+ case 214:
+ return visitNode(cbNode, node.operand);
+ case 219:
+ return visitNode(cbNode, node.asteriskToken) ||
+ visitNode(cbNode, node.expression);
+ case 213:
+ return visitNode(cbNode, node.expression);
+ case 215:
+ return visitNode(cbNode, node.operand);
+ case 216:
+ return visitNode(cbNode, node.left) ||
+ visitNode(cbNode, node.operatorToken) ||
+ visitNode(cbNode, node.right);
+ case 224:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.type);
+ case 225:
+ return visitNode(cbNode, node.expression);
+ case 226:
+ return visitNode(cbNode, node.name);
+ case 217:
+ return visitNode(cbNode, node.condition) ||
+ visitNode(cbNode, node.questionToken) ||
+ visitNode(cbNode, node.whenTrue) ||
+ visitNode(cbNode, node.colonToken) ||
+ visitNode(cbNode, node.whenFalse);
+ case 220:
+ return visitNode(cbNode, node.expression);
+ case 230:
+ case 257:
+ return visitNodes(cbNode, cbNodes, node.statements);
+ case 297:
+ return visitNodes(cbNode, cbNodes, node.statements) ||
+ visitNode(cbNode, node.endOfFileToken);
+ case 232:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.declarationList);
+ case 250:
+ return visitNodes(cbNode, cbNodes, node.declarations);
+ case 233:
+ return visitNode(cbNode, node.expression);
+ case 234:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.thenStatement) ||
+ visitNode(cbNode, node.elseStatement);
+ case 235:
+ return visitNode(cbNode, node.statement) ||
+ visitNode(cbNode, node.expression);
+ case 236:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.statement);
+ case 237:
+ return visitNode(cbNode, node.initializer) ||
+ visitNode(cbNode, node.condition) ||
+ visitNode(cbNode, node.incrementor) ||
+ visitNode(cbNode, node.statement);
+ case 238:
+ return visitNode(cbNode, node.initializer) ||
+ visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.statement);
+ case 239:
+ return visitNode(cbNode, node.awaitModifier) ||
+ visitNode(cbNode, node.initializer) ||
+ visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.statement);
+ case 240:
+ case 241:
+ return visitNode(cbNode, node.label);
+ case 242:
+ return visitNode(cbNode, node.expression);
+ case 243:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.statement);
+ case 244:
+ return visitNode(cbNode, node.expression) ||
+ visitNode(cbNode, node.caseBlock);
+ case 258:
+ return visitNodes(cbNode, cbNodes, node.clauses);
+ case 284:
+ return visitNode(cbNode, node.expression) ||
+ visitNodes(cbNode, cbNodes, node.statements);
+ case 285:
+ return visitNodes(cbNode, cbNodes, node.statements);
+ case 245:
+ return visitNode(cbNode, node.label) ||
+ visitNode(cbNode, node.statement);
+ case 246:
+ return visitNode(cbNode, node.expression);
+ case 247:
+ return visitNode(cbNode, node.tryBlock) ||
+ visitNode(cbNode, node.catchClause) ||
+ visitNode(cbNode, node.finallyBlock);
+ case 287:
+ return visitNode(cbNode, node.variableDeclaration) ||
+ visitNode(cbNode, node.block);
+ case 161:
+ return visitNode(cbNode, node.expression);
+ case 252:
+ case 221:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNodes(cbNode, cbNodes, node.typeParameters) ||
+ visitNodes(cbNode, cbNodes, node.heritageClauses) ||
+ visitNodes(cbNode, cbNodes, node.members);
+ case 253:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNodes(cbNode, cbNodes, node.typeParameters) ||
+ visitNodes(cbNode, cbNodes, node.heritageClauses) ||
+ visitNodes(cbNode, cbNodes, node.members);
+ case 254:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNodes(cbNode, cbNodes, node.typeParameters) ||
+ visitNode(cbNode, node.type);
+ case 255:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNodes(cbNode, cbNodes, node.members);
+ case 291:
+ return visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.initializer);
+ case 256:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.body);
+ case 260:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.moduleReference);
+ case 261:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.importClause) ||
+ visitNode(cbNode, node.moduleSpecifier);
+ case 262:
+ return visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.namedBindings);
+ case 259:
+ return visitNode(cbNode, node.name);
+ case 263:
+ return visitNode(cbNode, node.name);
+ case 269:
+ return visitNode(cbNode, node.name);
+ case 264:
+ case 268:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 267:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.exportClause) ||
+ visitNode(cbNode, node.moduleSpecifier);
+ case 265:
+ case 270:
+ return visitNode(cbNode, node.propertyName) ||
+ visitNode(cbNode, node.name);
+ case 266:
+ return visitNodes(cbNode, cbNodes, node.decorators) ||
+ visitNodes(cbNode, cbNodes, node.modifiers) ||
+ visitNode(cbNode, node.expression);
+ case 218:
+ return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans);
+ case 228:
+ return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal);
+ case 193:
+ return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans);
+ case 194:
+ return visitNode(cbNode, node.type) || visitNode(cbNode, node.literal);
+ case 158:
+ return visitNode(cbNode, node.expression);
+ case 286:
+ return visitNodes(cbNode, cbNodes, node.types);
+ case 223:
+ return visitNode(cbNode, node.expression) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments);
+ case 272:
+ return visitNode(cbNode, node.expression);
+ case 271:
+ return visitNodes(cbNode, cbNodes, node.decorators);
+ case 337:
+ return visitNodes(cbNode, cbNodes, node.elements);
+ case 273:
+ return visitNode(cbNode, node.openingElement) ||
+ visitNodes(cbNode, cbNodes, node.children) ||
+ visitNode(cbNode, node.closingElement);
+ case 277:
+ return visitNode(cbNode, node.openingFragment) ||
+ visitNodes(cbNode, cbNodes, node.children) ||
+ visitNode(cbNode, node.closingFragment);
+ case 274:
+ case 275:
+ return visitNode(cbNode, node.tagName) ||
+ visitNodes(cbNode, cbNodes, node.typeArguments) ||
+ visitNode(cbNode, node.attributes);
+ case 281:
+ return visitNodes(cbNode, cbNodes, node.properties);
+ case 280:
+ return visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.initializer);
+ case 282:
+ return visitNode(cbNode, node.expression);
+ case 283:
+ return visitNode(cbNode, node.dotDotDotToken) ||
+ visitNode(cbNode, node.expression);
+ case 276:
+ return visitNode(cbNode, node.tagName);
+ case 180:
+ case 181:
+ case 301:
+ case 306:
+ case 305:
+ case 307:
+ case 309:
+ return visitNode(cbNode, node.type);
+ case 308:
+ return visitNodes(cbNode, cbNodes, node.parameters) ||
+ visitNode(cbNode, node.type);
+ case 311:
+ return visitNodes(cbNode, cbNodes, node.tags);
+ case 332:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.name);
+ case 302:
+ return visitNode(cbNode, node.name);
+ case 326:
+ case 333:
+ return visitNode(cbNode, node.tagName) ||
+ (node.isNameFirst
+ ? visitNode(cbNode, node.name) ||
+ visitNode(cbNode, node.typeExpression)
+ : visitNode(cbNode, node.typeExpression) ||
+ visitNode(cbNode, node.name));
+ case 317:
+ return visitNode(cbNode, node.tagName);
+ case 316:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.class);
+ case 315:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.class);
+ case 330:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.constraint) ||
+ visitNodes(cbNode, cbNodes, node.typeParameters);
+ case 331:
+ return visitNode(cbNode, node.tagName) ||
+ (node.typeExpression &&
+ node.typeExpression.kind === 301
+ ? visitNode(cbNode, node.typeExpression) ||
+ visitNode(cbNode, node.fullName)
+ : visitNode(cbNode, node.fullName) ||
+ visitNode(cbNode, node.typeExpression));
+ case 324:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.fullName) ||
+ visitNode(cbNode, node.typeExpression);
+ case 327:
+ case 329:
+ case 328:
+ case 325:
+ return visitNode(cbNode, node.tagName) ||
+ visitNode(cbNode, node.typeExpression);
+ case 313:
+ return ts.forEach(node.typeParameters, cbNode) ||
+ ts.forEach(node.parameters, cbNode) ||
+ visitNode(cbNode, node.type);
+ case 312:
+ return ts.forEach(node.jsDocPropertyTags, cbNode);
+ case 314:
+ case 319:
+ case 320:
+ case 321:
+ case 322:
+ case 323:
+ return visitNode(cbNode, node.tagName);
+ case 336:
+ return visitNode(cbNode, node.expression);
+ }
+ }
+ ts.forEachChild = forEachChild;
+ function forEachChildRecursively(rootNode, cbNode, cbNodes) {
+ var stack = [rootNode];
+ while (stack.length) {
+ var parent = stack.pop();
+ var res = visitAllPossibleChildren(parent, gatherPossibleChildren(parent));
+ if (res) {
+ return res;
+ }
+ }
+ return;
+ function gatherPossibleChildren(node) {
+ var children = [];
+ forEachChild(node, addWorkItem, addWorkItem);
+ return children;
+ function addWorkItem(n) {
+ children.unshift(n);
+ }
+ }
+ function visitAllPossibleChildren(parent, children) {
+ for (var _i = 0, children_5 = children; _i < children_5.length; _i++) {
+ var child = children_5[_i];
+ if (ts.isArray(child)) {
+ if (cbNodes) {
+ var res = cbNodes(child, parent);
+ if (res) {
+ if (res === "skip")
+ continue;
+ return res;
+ }
+ }
+ for (var i = child.length - 1; i >= 0; i--) {
+ var realChild = child[i];
+ var res = cbNode(realChild, parent);
+ if (res) {
+ if (res === "skip")
+ continue;
+ return res;
+ }
+ stack.push(realChild);
+ }
+ }
+ else {
+ stack.push(child);
+ var res = cbNode(child, parent);
+ if (res) {
+ if (res === "skip")
+ continue;
+ return res;
+ }
+ }
+ }
+ }
+ }
+ ts.forEachChildRecursively = forEachChildRecursively;
+ function createSourceFile(fileName, sourceText, languageVersion, setParentNodes, scriptKind) {
+ if (setParentNodes === void 0) { setParentNodes = false; }
+ var tracingData = ["parse", "createSourceFile", { path: fileName }];
+ ts.tracing.begin.apply(ts.tracing, tracingData);
+ ts.performance.mark("beforeParse");
+ var result;
+ ts.perfLogger.logStartParseSourceFile(fileName);
+ if (languageVersion === 100) {
+ result = Parser.parseSourceFile(fileName, sourceText, languageVersion, undefined, setParentNodes, 6);
+ }
+ else {
+ result = Parser.parseSourceFile(fileName, sourceText, languageVersion, undefined, setParentNodes, scriptKind);
+ }
+ ts.perfLogger.logStopParseSourceFile();
+ ts.performance.mark("afterParse");
+ ts.performance.measure("Parse", "beforeParse", "afterParse");
+ ts.tracing.end.apply(ts.tracing, tracingData);
+ return result;
+ }
+ ts.createSourceFile = createSourceFile;
+ function parseIsolatedEntityName(text, languageVersion) {
+ return Parser.parseIsolatedEntityName(text, languageVersion);
+ }
+ ts.parseIsolatedEntityName = parseIsolatedEntityName;
+ function parseJsonText(fileName, sourceText) {
+ return Parser.parseJsonText(fileName, sourceText);
+ }
+ ts.parseJsonText = parseJsonText;
+ function isExternalModule(file) {
+ return file.externalModuleIndicator !== undefined;
+ }
+ ts.isExternalModule = isExternalModule;
+ function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) {
+ if (aggressiveChecks === void 0) { aggressiveChecks = false; }
+ var newSourceFile = IncrementalParser.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
+ newSourceFile.flags |= (sourceFile.flags & 3145728);
+ return newSourceFile;
+ }
+ ts.updateSourceFile = updateSourceFile;
+ function parseIsolatedJSDocComment(content, start, length) {
+ var result = Parser.JSDocParser.parseIsolatedJSDocComment(content, start, length);
+ if (result && result.jsDoc) {
+ Parser.fixupParentReferences(result.jsDoc);
+ }
+ return result;
+ }
+ ts.parseIsolatedJSDocComment = parseIsolatedJSDocComment;
+ function parseJSDocTypeExpressionForTests(content, start, length) {
+ return Parser.JSDocParser.parseJSDocTypeExpressionForTests(content, start, length);
+ }
+ ts.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests;
+ var Parser;
+ (function (Parser) {
+ var scanner = ts.createScanner(99, true);
+ var disallowInAndDecoratorContext = 4096 | 16384;
+ var NodeConstructor;
+ var TokenConstructor;
+ var IdentifierConstructor;
+ var PrivateIdentifierConstructor;
+ var SourceFileConstructor;
+ function countNode(node) {
+ nodeCount++;
+ return node;
+ }
+ var baseNodeFactory = {
+ createBaseSourceFileNode: function (kind) { return countNode(new SourceFileConstructor(kind, 0, 0)); },
+ createBaseIdentifierNode: function (kind) { return countNode(new IdentifierConstructor(kind, 0, 0)); },
+ createBasePrivateIdentifierNode: function (kind) { return countNode(new PrivateIdentifierConstructor(kind, 0, 0)); },
+ createBaseTokenNode: function (kind) { return countNode(new TokenConstructor(kind, 0, 0)); },
+ createBaseNode: function (kind) { return countNode(new NodeConstructor(kind, 0, 0)); }
+ };
+ var factory = ts.createNodeFactory(1 | 2 | 8, baseNodeFactory);
+ var fileName;
+ var sourceFlags;
+ var sourceText;
+ var languageVersion;
+ var scriptKind;
+ var languageVariant;
+ var parseDiagnostics;
+ var jsDocDiagnostics;
+ var syntaxCursor;
+ var currentToken;
+ var nodeCount;
+ var identifiers;
+ var privateIdentifiers;
+ var identifierCount;
+ var parsingContext;
+ var notParenthesizedArrow;
+ var contextFlags;
+ var topLevel = true;
+ var parseErrorBeforeNextFinishedNode = false;
+ function parseSourceFile(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes, scriptKind) {
+ if (setParentNodes === void 0) { setParentNodes = false; }
+ scriptKind = ts.ensureScriptKind(fileName, scriptKind);
+ if (scriptKind === 6) {
+ var result_3 = parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes);
+ ts.convertToObjectWorker(result_3, result_3.parseDiagnostics, false, undefined, undefined);
+ result_3.referencedFiles = ts.emptyArray;
+ result_3.typeReferenceDirectives = ts.emptyArray;
+ result_3.libReferenceDirectives = ts.emptyArray;
+ result_3.amdDependencies = ts.emptyArray;
+ result_3.hasNoDefaultLib = false;
+ result_3.pragmas = ts.emptyMap;
+ return result_3;
+ }
+ initializeState(fileName, sourceText, languageVersion, syntaxCursor, scriptKind);
+ var result = parseSourceFileWorker(languageVersion, setParentNodes, scriptKind);
+ clearState();
+ return result;
+ }
+ Parser.parseSourceFile = parseSourceFile;
+ function parseIsolatedEntityName(content, languageVersion) {
+ initializeState("", content, languageVersion, undefined, 1);
+ nextToken();
+ var entityName = parseEntityName(true);
+ var isInvalid = token() === 1 && !parseDiagnostics.length;
+ clearState();
+ return isInvalid ? entityName : undefined;
+ }
+ Parser.parseIsolatedEntityName = parseIsolatedEntityName;
+ function parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes) {
+ if (languageVersion === void 0) { languageVersion = 2; }
+ if (setParentNodes === void 0) { setParentNodes = false; }
+ initializeState(fileName, sourceText, languageVersion, syntaxCursor, 6);
+ sourceFlags = contextFlags;
+ nextToken();
+ var pos = getNodePos();
+ var statements, endOfFileToken;
+ if (token() === 1) {
+ statements = createNodeArray([], pos, pos);
+ endOfFileToken = parseTokenNode();
+ }
+ else {
+ var expression = void 0;
+ switch (token()) {
+ case 22:
+ expression = parseArrayLiteralExpression();
+ break;
+ case 109:
+ case 94:
+ case 103:
+ expression = parseTokenNode();
+ break;
+ case 40:
+ if (lookAhead(function () { return nextToken() === 8 && nextToken() !== 58; })) {
+ expression = parsePrefixUnaryExpression();
+ }
+ else {
+ expression = parseObjectLiteralExpression();
+ }
+ break;
+ case 8:
+ case 10:
+ if (lookAhead(function () { return nextToken() !== 58; })) {
+ expression = parseLiteralNode();
+ break;
+ }
+ default:
+ expression = parseObjectLiteralExpression();
+ break;
+ }
+ var statement = factory.createExpressionStatement(expression);
+ finishNode(statement, pos);
+ statements = createNodeArray([statement], pos);
+ endOfFileToken = parseExpectedToken(1, ts.Diagnostics.Unexpected_token);
+ }
+ var sourceFile = createSourceFile(fileName, 2, 6, false, statements, endOfFileToken, sourceFlags);
+ if (setParentNodes) {
+ fixupParentReferences(sourceFile);
+ }
+ sourceFile.nodeCount = nodeCount;
+ sourceFile.identifierCount = identifierCount;
+ sourceFile.identifiers = identifiers;
+ sourceFile.parseDiagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile);
+ if (jsDocDiagnostics) {
+ sourceFile.jsDocDiagnostics = ts.attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
+ }
+ var result = sourceFile;
+ clearState();
+ return result;
+ }
+ Parser.parseJsonText = parseJsonText;
+ function initializeState(_fileName, _sourceText, _languageVersion, _syntaxCursor, _scriptKind) {
+ NodeConstructor = ts.objectAllocator.getNodeConstructor();
+ TokenConstructor = ts.objectAllocator.getTokenConstructor();
+ IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor();
+ PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor();
+ SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor();
+ fileName = ts.normalizePath(_fileName);
+ sourceText = _sourceText;
+ languageVersion = _languageVersion;
+ syntaxCursor = _syntaxCursor;
+ scriptKind = _scriptKind;
+ languageVariant = ts.getLanguageVariant(_scriptKind);
+ parseDiagnostics = [];
+ parsingContext = 0;
+ identifiers = new ts.Map();
+ privateIdentifiers = new ts.Map();
+ identifierCount = 0;
+ nodeCount = 0;
+ sourceFlags = 0;
+ topLevel = true;
+ switch (scriptKind) {
+ case 1:
+ case 2:
+ contextFlags = 131072;
+ break;
+ case 6:
+ contextFlags = 131072 | 33554432;
+ break;
+ default:
+ contextFlags = 0;
+ break;
+ }
+ parseErrorBeforeNextFinishedNode = false;
+ scanner.setText(sourceText);
+ scanner.setOnError(scanError);
+ scanner.setScriptTarget(languageVersion);
+ scanner.setLanguageVariant(languageVariant);
+ }
+ function clearState() {
+ scanner.clearCommentDirectives();
+ scanner.setText("");
+ scanner.setOnError(undefined);
+ sourceText = undefined;
+ languageVersion = undefined;
+ syntaxCursor = undefined;
+ scriptKind = undefined;
+ languageVariant = undefined;
+ sourceFlags = 0;
+ parseDiagnostics = undefined;
+ jsDocDiagnostics = undefined;
+ parsingContext = 0;
+ identifiers = undefined;
+ notParenthesizedArrow = undefined;
+ topLevel = true;
+ }
+ function parseSourceFileWorker(languageVersion, setParentNodes, scriptKind) {
+ var isDeclarationFile = isDeclarationFileName(fileName);
+ if (isDeclarationFile) {
+ contextFlags |= 8388608;
+ }
+ sourceFlags = contextFlags;
+ nextToken();
+ var statements = parseList(0, parseStatement);
+ ts.Debug.assert(token() === 1);
+ var endOfFileToken = addJSDocComment(parseTokenNode());
+ var sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, sourceFlags);
+ processCommentPragmas(sourceFile, sourceText);
+ processPragmasIntoFields(sourceFile, reportPragmaDiagnostic);
+ sourceFile.commentDirectives = scanner.getCommentDirectives();
+ sourceFile.nodeCount = nodeCount;
+ sourceFile.identifierCount = identifierCount;
+ sourceFile.identifiers = identifiers;
+ sourceFile.parseDiagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile);
+ if (jsDocDiagnostics) {
+ sourceFile.jsDocDiagnostics = ts.attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
+ }
+ if (setParentNodes) {
+ fixupParentReferences(sourceFile);
+ }
+ return sourceFile;
+ function reportPragmaDiagnostic(pos, end, diagnostic) {
+ parseDiagnostics.push(ts.createDetachedDiagnostic(fileName, pos, end, diagnostic));
+ }
+ }
+ function withJSDoc(node, hasJSDoc) {
+ return hasJSDoc ? addJSDocComment(node) : node;
+ }
+ var hasDeprecatedTag = false;
+ function addJSDocComment(node) {
+ ts.Debug.assert(!node.jsDoc);
+ var jsDoc = ts.mapDefined(ts.getJSDocCommentRanges(node, sourceText), function (comment) { return JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos); });
+ if (jsDoc.length)
+ node.jsDoc = jsDoc;
+ if (hasDeprecatedTag) {
+ hasDeprecatedTag = false;
+ node.flags |= 134217728;
+ }
+ return node;
+ }
+ function reparseTopLevelAwait(sourceFile) {
+ var savedSyntaxCursor = syntaxCursor;
+ var baseSyntaxCursor = IncrementalParser.createSyntaxCursor(sourceFile);
+ syntaxCursor = { currentNode: currentNode };
+ var statements = [];
+ var savedParseDiagnostics = parseDiagnostics;
+ parseDiagnostics = [];
+ var pos = 0;
+ var start = findNextStatementWithAwait(sourceFile.statements, 0);
+ var _loop_3 = function () {
+ var prevStatement = sourceFile.statements[pos];
+ var nextStatement = sourceFile.statements[start];
+ ts.addRange(statements, sourceFile.statements, pos, start);
+ pos = findNextStatementWithoutAwait(sourceFile.statements, start);
+ var diagnosticStart = ts.findIndex(savedParseDiagnostics, function (diagnostic) { return diagnostic.start >= prevStatement.pos; });
+ var diagnosticEnd = diagnosticStart >= 0 ? ts.findIndex(savedParseDiagnostics, function (diagnostic) { return diagnostic.start >= nextStatement.pos; }, diagnosticStart) : -1;
+ if (diagnosticStart >= 0) {
+ ts.addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart, diagnosticEnd >= 0 ? diagnosticEnd : undefined);
+ }
+ speculationHelper(function () {
+ var savedContextFlags = contextFlags;
+ contextFlags |= 32768;
+ scanner.setTextPos(nextStatement.pos);
+ nextToken();
+ while (token() !== 1) {
+ var startPos = scanner.getStartPos();
+ var statement = parseListElement(0, parseStatement);
+ statements.push(statement);
+ if (startPos === scanner.getStartPos()) {
+ nextToken();
+ }
+ if (pos >= 0) {
+ var nonAwaitStatement = sourceFile.statements[pos];
+ if (statement.end === nonAwaitStatement.pos) {
+ break;
+ }
+ if (statement.end > nonAwaitStatement.pos) {
+ pos = findNextStatementWithoutAwait(sourceFile.statements, pos + 1);
+ }
+ }
+ }
+ contextFlags = savedContextFlags;
+ }, 2);
+ start = pos >= 0 ? findNextStatementWithAwait(sourceFile.statements, pos) : -1;
+ };
+ while (start !== -1) {
+ _loop_3();
+ }
+ if (pos >= 0) {
+ var prevStatement_1 = sourceFile.statements[pos];
+ ts.addRange(statements, sourceFile.statements, pos);
+ var diagnosticStart = ts.findIndex(savedParseDiagnostics, function (diagnostic) { return diagnostic.start >= prevStatement_1.pos; });
+ if (diagnosticStart >= 0) {
+ ts.addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart);
+ }
+ }
+ syntaxCursor = savedSyntaxCursor;
+ return factory.updateSourceFile(sourceFile, ts.setTextRange(factory.createNodeArray(statements), sourceFile.statements));
+ function containsPossibleTopLevelAwait(node) {
+ return !(node.flags & 32768)
+ && !!(node.transformFlags & 8388608);
+ }
+ function findNextStatementWithAwait(statements, start) {
+ for (var i = start; i < statements.length; i++) {
+ if (containsPossibleTopLevelAwait(statements[i])) {
+ return i;
+ }
+ }
+ return -1;
+ }
+ function findNextStatementWithoutAwait(statements, start) {
+ for (var i = start; i < statements.length; i++) {
+ if (!containsPossibleTopLevelAwait(statements[i])) {
+ return i;
+ }
+ }
+ return -1;
+ }
+ function currentNode(position) {
+ var node = baseSyntaxCursor.currentNode(position);
+ if (topLevel && node && containsPossibleTopLevelAwait(node)) {
+ node.intersectsChange = true;
+ }
+ return node;
+ }
+ }
+ function fixupParentReferences(rootNode) {
+ ts.setParentRecursive(rootNode, true);
+ }
+ Parser.fixupParentReferences = fixupParentReferences;
+ function createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, flags) {
+ var sourceFile = factory.createSourceFile(statements, endOfFileToken, flags);
+ ts.setTextRangePosWidth(sourceFile, 0, sourceText.length);
+ setExternalModuleIndicator(sourceFile);
+ if (!isDeclarationFile && isExternalModule(sourceFile) && sourceFile.transformFlags & 8388608) {
+ sourceFile = reparseTopLevelAwait(sourceFile);
+ }
+ sourceFile.text = sourceText;
+ sourceFile.bindDiagnostics = [];
+ sourceFile.bindSuggestionDiagnostics = undefined;
+ sourceFile.languageVersion = languageVersion;
+ sourceFile.fileName = fileName;
+ sourceFile.languageVariant = ts.getLanguageVariant(scriptKind);
+ sourceFile.isDeclarationFile = isDeclarationFile;
+ sourceFile.scriptKind = scriptKind;
+ return sourceFile;
+ }
+ function setContextFlag(val, flag) {
+ if (val) {
+ contextFlags |= flag;
+ }
+ else {
+ contextFlags &= ~flag;
+ }
+ }
+ function setDisallowInContext(val) {
+ setContextFlag(val, 4096);
+ }
+ function setYieldContext(val) {
+ setContextFlag(val, 8192);
+ }
+ function setDecoratorContext(val) {
+ setContextFlag(val, 16384);
+ }
+ function setAwaitContext(val) {
+ setContextFlag(val, 32768);
+ }
+ function doOutsideOfContext(context, func) {
+ var contextFlagsToClear = context & contextFlags;
+ if (contextFlagsToClear) {
+ setContextFlag(false, contextFlagsToClear);
+ var result = func();
+ setContextFlag(true, contextFlagsToClear);
+ return result;
+ }
+ return func();
+ }
+ function doInsideOfContext(context, func) {
+ var contextFlagsToSet = context & ~contextFlags;
+ if (contextFlagsToSet) {
+ setContextFlag(true, contextFlagsToSet);
+ var result = func();
+ setContextFlag(false, contextFlagsToSet);
+ return result;
+ }
+ return func();
+ }
+ function allowInAnd(func) {
+ return doOutsideOfContext(4096, func);
+ }
+ function disallowInAnd(func) {
+ return doInsideOfContext(4096, func);
+ }
+ function doInYieldContext(func) {
+ return doInsideOfContext(8192, func);
+ }
+ function doInDecoratorContext(func) {
+ return doInsideOfContext(16384, func);
+ }
+ function doInAwaitContext(func) {
+ return doInsideOfContext(32768, func);
+ }
+ function doOutsideOfAwaitContext(func) {
+ return doOutsideOfContext(32768, func);
+ }
+ function doInYieldAndAwaitContext(func) {
+ return doInsideOfContext(8192 | 32768, func);
+ }
+ function doOutsideOfYieldAndAwaitContext(func) {
+ return doOutsideOfContext(8192 | 32768, func);
+ }
+ function inContext(flags) {
+ return (contextFlags & flags) !== 0;
+ }
+ function inYieldContext() {
+ return inContext(8192);
+ }
+ function inDisallowInContext() {
+ return inContext(4096);
+ }
+ function inDecoratorContext() {
+ return inContext(16384);
+ }
+ function inAwaitContext() {
+ return inContext(32768);
+ }
+ function parseErrorAtCurrentToken(message, arg0) {
+ parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0);
+ }
+ function parseErrorAtPosition(start, length, message, arg0) {
+ var lastError = ts.lastOrUndefined(parseDiagnostics);
+ if (!lastError || start !== lastError.start) {
+ parseDiagnostics.push(ts.createDetachedDiagnostic(fileName, start, length, message, arg0));
+ }
+ parseErrorBeforeNextFinishedNode = true;
+ }
+ function parseErrorAt(start, end, message, arg0) {
+ parseErrorAtPosition(start, end - start, message, arg0);
+ }
+ function parseErrorAtRange(range, message, arg0) {
+ parseErrorAt(range.pos, range.end, message, arg0);
+ }
+ function scanError(message, length) {
+ parseErrorAtPosition(scanner.getTextPos(), length, message);
+ }
+ function getNodePos() {
+ return scanner.getStartPos();
+ }
+ function hasPrecedingJSDocComment() {
+ return scanner.hasPrecedingJSDocComment();
+ }
+ function token() {
+ return currentToken;
+ }
+ function nextTokenWithoutCheck() {
+ return currentToken = scanner.scan();
+ }
+ function nextTokenAnd(func) {
+ nextToken();
+ return func();
+ }
+ function nextToken() {
+ if (ts.isKeyword(currentToken) && (scanner.hasUnicodeEscape() || scanner.hasExtendedUnicodeEscape())) {
+ parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), ts.Diagnostics.Keywords_cannot_contain_escape_characters);
+ }
+ return nextTokenWithoutCheck();
+ }
+ function nextTokenJSDoc() {
+ return currentToken = scanner.scanJsDocToken();
+ }
+ function reScanGreaterToken() {
+ return currentToken = scanner.reScanGreaterToken();
+ }
+ function reScanSlashToken() {
+ return currentToken = scanner.reScanSlashToken();
+ }
+ function reScanTemplateToken(isTaggedTemplate) {
+ return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
+ }
+ function reScanTemplateHeadOrNoSubstitutionTemplate() {
+ return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
+ }
+ function reScanLessThanToken() {
+ return currentToken = scanner.reScanLessThanToken();
+ }
+ function scanJsxIdentifier() {
+ return currentToken = scanner.scanJsxIdentifier();
+ }
+ function scanJsxText() {
+ return currentToken = scanner.scanJsxToken();
+ }
+ function scanJsxAttributeValue() {
+ return currentToken = scanner.scanJsxAttributeValue();
+ }
+ function speculationHelper(callback, speculationKind) {
+ var saveToken = currentToken;
+ var saveParseDiagnosticsLength = parseDiagnostics.length;
+ var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
+ var saveContextFlags = contextFlags;
+ var result = speculationKind !== 0
+ ? scanner.lookAhead(callback)
+ : scanner.tryScan(callback);
+ ts.Debug.assert(saveContextFlags === contextFlags);
+ if (!result || speculationKind !== 0) {
+ currentToken = saveToken;
+ if (speculationKind !== 2) {
+ parseDiagnostics.length = saveParseDiagnosticsLength;
+ }
+ parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
+ }
+ return result;
+ }
+ function lookAhead(callback) {
+ return speculationHelper(callback, 1);
+ }
+ function tryParse(callback) {
+ return speculationHelper(callback, 0);
+ }
+ function isBindingIdentifier() {
+ if (token() === 78) {
+ return true;
+ }
+ return token() > 115;
+ }
+ function isIdentifier() {
+ if (token() === 78) {
+ return true;
+ }
+ if (token() === 124 && inYieldContext()) {
+ return false;
+ }
+ if (token() === 130 && inAwaitContext()) {
+ return false;
+ }
+ return token() > 115;
+ }
+ function parseExpected(kind, diagnosticMessage, shouldAdvance) {
+ if (shouldAdvance === void 0) { shouldAdvance = true; }
+ if (token() === kind) {
+ if (shouldAdvance) {
+ nextToken();
+ }
+ return true;
+ }
+ if (diagnosticMessage) {
+ parseErrorAtCurrentToken(diagnosticMessage);
+ }
+ else {
+ parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind));
+ }
+ return false;
+ }
+ function parseExpectedJSDoc(kind) {
+ if (token() === kind) {
+ nextTokenJSDoc();
+ return true;
+ }
+ parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind));
+ return false;
+ }
+ function parseOptional(t) {
+ if (token() === t) {
+ nextToken();
+ return true;
+ }
+ return false;
+ }
+ function parseOptionalToken(t) {
+ if (token() === t) {
+ return parseTokenNode();
+ }
+ return undefined;
+ }
+ function parseOptionalTokenJSDoc(t) {
+ if (token() === t) {
+ return parseTokenNodeJSDoc();
+ }
+ return undefined;
+ }
+ function parseExpectedToken(t, diagnosticMessage, arg0) {
+ return parseOptionalToken(t) ||
+ createMissingNode(t, false, diagnosticMessage || ts.Diagnostics._0_expected, arg0 || ts.tokenToString(t));
+ }
+ function parseExpectedTokenJSDoc(t) {
+ return parseOptionalTokenJSDoc(t) ||
+ createMissingNode(t, false, ts.Diagnostics._0_expected, ts.tokenToString(t));
+ }
+ function parseTokenNode() {
+ var pos = getNodePos();
+ var kind = token();
+ nextToken();
+ return finishNode(factory.createToken(kind), pos);
+ }
+ function parseTokenNodeJSDoc() {
+ var pos = getNodePos();
+ var kind = token();
+ nextTokenJSDoc();
+ return finishNode(factory.createToken(kind), pos);
+ }
+ function canParseSemicolon() {
+ if (token() === 26) {
+ return true;
+ }
+ return token() === 19 || token() === 1 || scanner.hasPrecedingLineBreak();
+ }
+ function parseSemicolon() {
+ if (canParseSemicolon()) {
+ if (token() === 26) {
+ nextToken();
+ }
+ return true;
+ }
+ else {
+ return parseExpected(26);
+ }
+ }
+ function createNodeArray(elements, pos, end, hasTrailingComma) {
+ var array = factory.createNodeArray(elements, hasTrailingComma);
+ ts.setTextRangePosEnd(array, pos, end !== null && end !== void 0 ? end : scanner.getStartPos());
+ return array;
+ }
+ function finishNode(node, pos, end) {
+ ts.setTextRangePosEnd(node, pos, end !== null && end !== void 0 ? end : scanner.getStartPos());
+ if (contextFlags) {
+ node.flags |= contextFlags;
+ }
+ if (parseErrorBeforeNextFinishedNode) {
+ parseErrorBeforeNextFinishedNode = false;
+ node.flags |= 65536;
+ }
+ return node;
+ }
+ function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
+ if (reportAtCurrentPosition) {
+ parseErrorAtPosition(scanner.getStartPos(), 0, diagnosticMessage, arg0);
+ }
+ else if (diagnosticMessage) {
+ parseErrorAtCurrentToken(diagnosticMessage, arg0);
+ }
+ var pos = getNodePos();
+ var result = kind === 78 ? factory.createIdentifier("", undefined, undefined) :
+ ts.isTemplateLiteralKind(kind) ? factory.createTemplateLiteralLikeNode(kind, "", "", undefined) :
+ kind === 8 ? factory.createNumericLiteral("", undefined) :
+ kind === 10 ? factory.createStringLiteral("", undefined) :
+ kind === 271 ? factory.createMissingDeclaration() :
+ factory.createToken(kind);
+ return finishNode(result, pos);
+ }
+ function internIdentifier(text) {
+ var identifier = identifiers.get(text);
+ if (identifier === undefined) {
+ identifiers.set(text, identifier = text);
+ }
+ return identifier;
+ }
+ function createIdentifier(isIdentifier, diagnosticMessage, privateIdentifierDiagnosticMessage) {
+ identifierCount++;
+ if (isIdentifier) {
+ var pos = getNodePos();
+ var originalKeywordKind = token();
+ var text = internIdentifier(scanner.getTokenValue());
+ nextTokenWithoutCheck();
+ return finishNode(factory.createIdentifier(text, undefined, originalKeywordKind), pos);
+ }
+ if (token() === 79) {
+ parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage || ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+ return createIdentifier(true);
+ }
+ var reportAtCurrentPosition = token() === 1;
+ var isReservedWord = scanner.isReservedWord();
+ var msgArg = scanner.getTokenText();
+ var defaultMessage = isReservedWord ?
+ ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here :
+ ts.Diagnostics.Identifier_expected;
+ return createMissingNode(78, reportAtCurrentPosition, diagnosticMessage || defaultMessage, msgArg);
+ }
+ function parseBindingIdentifier(privateIdentifierDiagnosticMessage) {
+ return createIdentifier(isBindingIdentifier(), undefined, privateIdentifierDiagnosticMessage);
+ }
+ function parseIdentifier(diagnosticMessage, privateIdentifierDiagnosticMessage) {
+ return createIdentifier(isIdentifier(), diagnosticMessage, privateIdentifierDiagnosticMessage);
+ }
+ function parseIdentifierName(diagnosticMessage) {
+ return createIdentifier(ts.tokenIsIdentifierOrKeyword(token()), diagnosticMessage);
+ }
+ function isLiteralPropertyName() {
+ return ts.tokenIsIdentifierOrKeyword(token()) ||
+ token() === 10 ||
+ token() === 8;
+ }
+ function parsePropertyNameWorker(allowComputedPropertyNames) {
+ if (token() === 10 || token() === 8) {
+ var node = parseLiteralNode();
+ node.text = internIdentifier(node.text);
+ return node;
+ }
+ if (allowComputedPropertyNames && token() === 22) {
+ return parseComputedPropertyName();
+ }
+ if (token() === 79) {
+ return parsePrivateIdentifier();
+ }
+ return parseIdentifierName();
+ }
+ function parsePropertyName() {
+ return parsePropertyNameWorker(true);
+ }
+ function parseComputedPropertyName() {
+ var pos = getNodePos();
+ parseExpected(22);
+ var expression = allowInAnd(parseExpression);
+ parseExpected(23);
+ return finishNode(factory.createComputedPropertyName(expression), pos);
+ }
+ function internPrivateIdentifier(text) {
+ var privateIdentifier = privateIdentifiers.get(text);
+ if (privateIdentifier === undefined) {
+ privateIdentifiers.set(text, privateIdentifier = text);
+ }
+ return privateIdentifier;
+ }
+ function parsePrivateIdentifier() {
+ var pos = getNodePos();
+ var node = factory.createPrivateIdentifier(internPrivateIdentifier(scanner.getTokenText()));
+ 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 84:
+ return nextToken() === 91;
+ case 92:
+ nextToken();
+ if (token() === 87) {
+ return lookAhead(nextTokenCanFollowDefaultKeyword);
+ }
+ if (token() === 149) {
+ return lookAhead(nextTokenCanFollowExportModifier);
+ }
+ return canFollowExportModifier();
+ case 87:
+ return nextTokenCanFollowDefaultKeyword();
+ case 123:
+ case 134:
+ case 146:
+ nextToken();
+ return canFollowModifier();
+ default:
+ return nextTokenIsOnSameLineAndCanFollowModifier();
+ }
+ }
+ function canFollowExportModifier() {
+ return token() !== 41
+ && token() !== 126
+ && token() !== 18
+ && canFollowModifier();
+ }
+ function nextTokenCanFollowExportModifier() {
+ nextToken();
+ return canFollowExportModifier();
+ }
+ function parseAnyContextualModifier() {
+ return ts.isModifierKind(token()) && tryParse(nextTokenCanFollowModifier);
+ }
+ function canFollowModifier() {
+ return token() === 22
+ || token() === 18
+ || token() === 41
+ || token() === 25
+ || isLiteralPropertyName();
+ }
+ function nextTokenCanFollowDefaultKeyword() {
+ nextToken();
+ return token() === 83 || token() === 97 ||
+ token() === 117 ||
+ (token() === 125 && lookAhead(nextTokenIsClassKeywordOnSameLine)) ||
+ (token() === 129 && lookAhead(nextTokenIsFunctionKeywordOnSameLine));
+ }
+ function isListElement(parsingContext, inErrorRecovery) {
+ var node = currentNode(parsingContext);
+ if (node) {
+ return true;
+ }
+ switch (parsingContext) {
+ case 0:
+ case 1:
+ case 3:
+ return !(token() === 26 && inErrorRecovery) && isStartOfStatement();
+ case 2:
+ return token() === 81 || token() === 87;
+ case 4:
+ return lookAhead(isTypeMemberStart);
+ case 5:
+ return lookAhead(isClassMemberStart) || (token() === 26 && !inErrorRecovery);
+ case 6:
+ return token() === 22 || isLiteralPropertyName();
+ case 12:
+ switch (token()) {
+ case 22:
+ case 41:
+ case 25:
+ case 24:
+ return true;
+ default:
+ return isLiteralPropertyName();
+ }
+ case 18:
+ return isLiteralPropertyName();
+ case 9:
+ return token() === 22 || token() === 25 || isLiteralPropertyName();
+ case 7:
+ if (token() === 18) {
+ return lookAhead(isValidHeritageClauseObjectLiteral);
+ }
+ if (!inErrorRecovery) {
+ return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
+ }
+ else {
+ return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword();
+ }
+ case 8:
+ return isBindingIdentifierOrPrivateIdentifierOrPattern();
+ case 10:
+ return token() === 27 || token() === 25 || isBindingIdentifierOrPrivateIdentifierOrPattern();
+ case 19:
+ return isIdentifier();
+ case 15:
+ switch (token()) {
+ case 27:
+ case 24:
+ return true;
+ }
+ case 11:
+ return token() === 25 || isStartOfExpression();
+ case 16:
+ return isStartOfParameter(false);
+ case 17:
+ return isStartOfParameter(true);
+ case 20:
+ case 21:
+ return token() === 27 || isStartOfType();
+ case 22:
+ return isHeritageClause();
+ case 23:
+ return ts.tokenIsIdentifierOrKeyword(token());
+ case 13:
+ return ts.tokenIsIdentifierOrKeyword(token()) || token() === 18;
+ case 14:
+ return true;
+ }
+ return ts.Debug.fail("Non-exhaustive case in 'isListElement'.");
+ }
+ function isValidHeritageClauseObjectLiteral() {
+ ts.Debug.assert(token() === 18);
+ if (nextToken() === 19) {
+ var next = nextToken();
+ return next === 27 || next === 18 || next === 93 || next === 116;
+ }
+ return true;
+ }
+ function nextTokenIsIdentifier() {
+ nextToken();
+ return isIdentifier();
+ }
+ function nextTokenIsIdentifierOrKeyword() {
+ nextToken();
+ return ts.tokenIsIdentifierOrKeyword(token());
+ }
+ function nextTokenIsIdentifierOrKeywordOrGreaterThan() {
+ nextToken();
+ return ts.tokenIsIdentifierOrKeywordOrGreaterThan(token());
+ }
+ function isHeritageClauseExtendsOrImplementsKeyword() {
+ if (token() === 116 ||
+ token() === 93) {
+ return lookAhead(nextTokenIsStartOfExpression);
+ }
+ return false;
+ }
+ function nextTokenIsStartOfExpression() {
+ nextToken();
+ return isStartOfExpression();
+ }
+ function nextTokenIsStartOfType() {
+ nextToken();
+ return isStartOfType();
+ }
+ function isListTerminator(kind) {
+ if (token() === 1) {
+ return true;
+ }
+ switch (kind) {
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ case 6:
+ case 12:
+ case 9:
+ case 23:
+ return token() === 19;
+ case 3:
+ return token() === 19 || token() === 81 || token() === 87;
+ case 7:
+ return token() === 18 || token() === 93 || token() === 116;
+ case 8:
+ return isVariableDeclaratorListTerminator();
+ case 19:
+ return token() === 31 || token() === 20 || token() === 18 || token() === 93 || token() === 116;
+ case 11:
+ return token() === 21 || token() === 26;
+ case 15:
+ case 21:
+ case 10:
+ return token() === 23;
+ case 17:
+ case 16:
+ case 18:
+ return token() === 21 || token() === 23;
+ case 20:
+ return token() !== 27;
+ case 22:
+ return token() === 18 || token() === 19;
+ case 13:
+ return token() === 31 || token() === 43;
+ case 14:
+ return token() === 29 && lookAhead(nextTokenIsSlash);
+ default:
+ return false;
+ }
+ }
+ function isVariableDeclaratorListTerminator() {
+ if (canParseSemicolon()) {
+ return true;
+ }
+ if (isInOrOfKeyword(token())) {
+ return true;
+ }
+ if (token() === 38) {
+ return true;
+ }
+ return false;
+ }
+ function isInSomeParsingContext() {
+ for (var kind = 0; kind < 24; kind++) {
+ if (parsingContext & (1 << kind)) {
+ if (isListElement(kind, true) || isListTerminator(kind)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ function parseList(kind, parseElement) {
+ var saveParsingContext = parsingContext;
+ parsingContext |= 1 << kind;
+ var list = [];
+ var listPos = getNodePos();
+ while (!isListTerminator(kind)) {
+ if (isListElement(kind, false)) {
+ var element = parseListElement(kind, parseElement);
+ list.push(element);
+ continue;
+ }
+ if (abortParsingListOrMoveToNextToken(kind)) {
+ break;
+ }
+ }
+ parsingContext = saveParsingContext;
+ return createNodeArray(list, listPos);
+ }
+ function parseListElement(parsingContext, parseElement) {
+ var node = currentNode(parsingContext);
+ if (node) {
+ return consumeNode(node);
+ }
+ return parseElement();
+ }
+ function currentNode(parsingContext) {
+ if (!syntaxCursor || !isReusableParsingContext(parsingContext) || parseErrorBeforeNextFinishedNode) {
+ return undefined;
+ }
+ var node = syntaxCursor.currentNode(scanner.getStartPos());
+ if (ts.nodeIsMissing(node) || node.intersectsChange || ts.containsParseError(node)) {
+ return undefined;
+ }
+ var nodeContextFlags = node.flags & 25358336;
+ if (nodeContextFlags !== contextFlags) {
+ return undefined;
+ }
+ if (!canReuseNode(node, parsingContext)) {
+ return undefined;
+ }
+ if (node.jsDocCache) {
+ node.jsDocCache = undefined;
+ }
+ return node;
+ }
+ function consumeNode(node) {
+ scanner.setTextPos(node.end);
+ nextToken();
+ return node;
+ }
+ function isReusableParsingContext(parsingContext) {
+ switch (parsingContext) {
+ case 5:
+ case 2:
+ case 0:
+ case 1:
+ case 3:
+ case 6:
+ case 4:
+ case 8:
+ case 17:
+ case 16:
+ return true;
+ }
+ return false;
+ }
+ function canReuseNode(node, parsingContext) {
+ switch (parsingContext) {
+ case 5:
+ return isReusableClassMember(node);
+ case 2:
+ return isReusableSwitchClause(node);
+ case 0:
+ case 1:
+ case 3:
+ return isReusableStatement(node);
+ case 6:
+ return isReusableEnumMember(node);
+ case 4:
+ return isReusableTypeMember(node);
+ case 8:
+ return isReusableVariableDeclaration(node);
+ case 17:
+ case 16:
+ return isReusableParameter(node);
+ }
+ return false;
+ }
+ function isReusableClassMember(node) {
+ if (node) {
+ switch (node.kind) {
+ case 166:
+ case 171:
+ case 167:
+ case 168:
+ case 163:
+ case 229:
+ return true;
+ case 165:
+ var methodDeclaration = node;
+ var nameIsConstructor = methodDeclaration.name.kind === 78 &&
+ methodDeclaration.name.originalKeywordKind === 132;
+ return !nameIsConstructor;
+ }
+ }
+ return false;
+ }
+ function isReusableSwitchClause(node) {
+ if (node) {
+ switch (node.kind) {
+ case 284:
+ case 285:
+ return true;
+ }
+ }
+ return false;
+ }
+ function isReusableStatement(node) {
+ if (node) {
+ switch (node.kind) {
+ case 251:
+ case 232:
+ case 230:
+ case 234:
+ case 233:
+ case 246:
+ case 242:
+ case 244:
+ case 241:
+ case 240:
+ case 238:
+ case 239:
+ case 237:
+ case 236:
+ case 243:
+ case 231:
+ case 247:
+ case 245:
+ case 235:
+ case 248:
+ case 261:
+ case 260:
+ case 267:
+ case 266:
+ case 256:
+ case 252:
+ case 253:
+ case 255:
+ case 254:
+ return true;
+ }
+ }
+ return false;
}
- function parseTypeArgumentsInExpression() {
- if (reScanLessThanToken() !== 29) {
- return undefined;
- }
- nextToken();
- var typeArguments = parseDelimitedList(20, parseType);
- if (!parseExpected(31)) {
- return undefined;
- }
- return typeArguments && canFollowTypeArgumentsInExpression()
- ? typeArguments
- : undefined;
- }
- function canFollowTypeArgumentsInExpression() {
- switch (token()) {
- case 20:
- case 14:
- case 15:
- case 24:
- case 21:
- case 23:
- case 58:
- case 26:
- case 57:
- case 34:
- case 36:
- case 35:
- case 37:
- case 55:
- case 56:
- case 60:
- case 52:
- case 50:
- case 51:
- case 19:
- case 1:
- return true;
- case 27:
- case 18:
- default:
- return false;
- }
- }
- function parsePrimaryExpression() {
- switch (token()) {
- case 8:
- case 9:
- case 10:
- case 14:
- return parseLiteralNode();
- case 104:
- case 102:
- case 100:
- case 106:
- case 91:
- return parseTokenNode();
- case 20:
- return parseParenthesizedExpression();
- case 22:
- return parseArrayLiteralExpression();
- case 18:
- return parseObjectLiteralExpression();
- case 126:
- if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) {
- break;
- }
- return parseFunctionExpression();
- case 80:
- return parseClassExpression();
- case 94:
- return parseFunctionExpression();
- case 99:
- return parseNewExpressionOrNewDotTarget();
- case 43:
- case 67:
- if (reScanSlashToken() === 13) {
- return parseLiteralNode();
- }
- break;
- case 15:
- return parseTemplateExpression(false);
- }
- return parseIdentifier(ts.Diagnostics.Expression_expected);
- }
- function parseParenthesizedExpression() {
- var node = createNodeWithJSDoc(200);
- parseExpected(20);
- node.expression = allowInAnd(parseExpression);
- parseExpected(21);
- return finishNode(node);
- }
- function parseSpreadElement() {
- var node = createNode(213);
- parseExpected(25);
- node.expression = parseAssignmentExpressionOrHigher();
- return finishNode(node);
- }
- function parseArgumentOrArrayLiteralElement() {
- return token() === 25 ? parseSpreadElement() :
- token() === 27 ? createNode(215) :
- parseAssignmentExpressionOrHigher();
- }
- function parseArgumentExpression() {
- return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
- }
- function parseArrayLiteralExpression() {
- var node = createNode(192);
- parseExpected(22);
- if (scanner.hasPrecedingLineBreak()) {
- node.multiLine = true;
- }
- node.elements = parseDelimitedList(15, parseArgumentOrArrayLiteralElement);
- parseExpected(23);
- return finishNode(node);
- }
- function parseObjectLiteralElement() {
- var node = createNodeWithJSDoc(0);
- if (parseOptionalToken(25)) {
- node.kind = 283;
- node.expression = parseAssignmentExpressionOrHigher();
- return finishNode(node);
- }
- node.decorators = parseDecorators();
- node.modifiers = parseModifiers();
- if (parseContextualModifier(131)) {
- return parseAccessorDeclaration(node, 163);
- }
- if (parseContextualModifier(142)) {
- return parseAccessorDeclaration(node, 164);
- }
- var asteriskToken = parseOptionalToken(41);
- var tokenIsIdentifier = isIdentifier();
- node.name = parsePropertyName();
- node.questionToken = parseOptionalToken(57);
- node.exclamationToken = parseOptionalToken(53);
- if (asteriskToken || token() === 20 || token() === 29) {
- return parseMethodDeclaration(node, asteriskToken);
- }
- var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58);
- if (isShorthandPropertyAssignment) {
- node.kind = 282;
- var equalsToken = parseOptionalToken(62);
- if (equalsToken) {
- node.equalsToken = equalsToken;
- node.objectAssignmentInitializer = allowInAnd(parseAssignmentExpressionOrHigher);
- }
- }
- else {
- node.kind = 281;
- parseExpected(58);
- node.initializer = allowInAnd(parseAssignmentExpressionOrHigher);
- }
- return finishNode(node);
- }
- function parseObjectLiteralExpression() {
- var node = createNode(193);
- var openBracePosition = scanner.getTokenPos();
- parseExpected(18);
- if (scanner.hasPrecedingLineBreak()) {
- node.multiLine = true;
- }
- node.properties = parseDelimitedList(12, parseObjectLiteralElement, true);
- if (!parseExpected(19)) {
- var lastError = ts.lastOrUndefined(parseDiagnostics);
- if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
- ts.addRelatedInfo(lastError, ts.createFileDiagnostic(sourceFile, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
- }
- }
- return finishNode(node);
- }
- function parseFunctionExpression() {
- var saveDecoratorContext = inDecoratorContext();
- if (saveDecoratorContext) {
- setDecoratorContext(false);
- }
- var node = createNodeWithJSDoc(201);
- node.modifiers = parseModifiers();
- parseExpected(94);
- node.asteriskToken = parseOptionalToken(41);
- var isGenerator = node.asteriskToken ? 1 : 0;
- var isAsync = hasModifierOfKind(node, 126) ? 2 : 0;
- node.name =
- isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) :
- isGenerator ? doInYieldContext(parseOptionalIdentifier) :
- isAsync ? doInAwaitContext(parseOptionalIdentifier) :
- parseOptionalIdentifier();
- fillSignature(58, isGenerator | isAsync, node);
- node.body = parseFunctionBlock(isGenerator | isAsync);
- if (saveDecoratorContext) {
- setDecoratorContext(true);
- }
- return finishNode(node);
- }
- function parseOptionalIdentifier() {
- return isIdentifier() ? parseIdentifier() : undefined;
- }
- function parseNewExpressionOrNewDotTarget() {
- var fullStart = scanner.getStartPos();
- parseExpected(99);
- if (parseOptional(24)) {
- var node_2 = createNode(219, fullStart);
- node_2.keywordToken = 99;
- node_2.name = parseIdentifierName();
- return finishNode(node_2);
- }
- var expression = parsePrimaryExpression();
- var typeArguments;
- while (true) {
- expression = parseMemberExpressionRest(expression, false);
- typeArguments = tryParse(parseTypeArgumentsInExpression);
- if (isTemplateStartOfTaggedTemplate()) {
- ts.Debug.assert(!!typeArguments, "Expected a type argument list; all plain tagged template starts should be consumed in 'parseMemberExpressionRest'");
- expression = parseTaggedTemplateRest(expression, undefined, typeArguments);
- typeArguments = undefined;
- }
- break;
- }
- var node = createNode(197, fullStart);
- node.expression = expression;
- node.typeArguments = typeArguments;
- if (token() === 20) {
- node.arguments = parseArgumentList();
- }
- else if (node.typeArguments) {
- parseErrorAt(fullStart, scanner.getStartPos(), ts.Diagnostics.A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list);
- }
- return finishNode(node);
- }
- function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) {
- var node = createNode(223);
- var openBracePosition = scanner.getTokenPos();
- if (parseExpected(18, diagnosticMessage) || ignoreMissingOpenBrace) {
- if (scanner.hasPrecedingLineBreak()) {
- node.multiLine = true;
- }
- node.statements = parseList(1, parseStatement);
- if (!parseExpected(19)) {
- var lastError = ts.lastOrUndefined(parseDiagnostics);
- if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
- ts.addRelatedInfo(lastError, ts.createFileDiagnostic(sourceFile, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
- }
- }
- }
- else {
- node.statements = createMissingList();
- }
- return finishNode(node);
- }
- function parseFunctionBlock(flags, diagnosticMessage) {
- var savedYieldContext = inYieldContext();
- setYieldContext(!!(flags & 1));
- var savedAwaitContext = inAwaitContext();
- setAwaitContext(!!(flags & 2));
- var saveDecoratorContext = inDecoratorContext();
- if (saveDecoratorContext) {
- setDecoratorContext(false);
- }
- var block = parseBlock(!!(flags & 16), diagnosticMessage);
- if (saveDecoratorContext) {
- setDecoratorContext(true);
- }
- setYieldContext(savedYieldContext);
- setAwaitContext(savedAwaitContext);
- return block;
- }
- function parseEmptyStatement() {
- var node = createNode(224);
- parseExpected(26);
- return finishNode(node);
- }
- function parseIfStatement() {
- var node = createNode(227);
- parseExpected(95);
- parseExpected(20);
- node.expression = allowInAnd(parseExpression);
- parseExpected(21);
- node.thenStatement = parseStatement();
- node.elseStatement = parseOptional(87) ? parseStatement() : undefined;
- return finishNode(node);
- }
- function parseDoStatement() {
- var node = createNode(228);
- parseExpected(86);
- node.statement = parseStatement();
- parseExpected(111);
- parseExpected(20);
- node.expression = allowInAnd(parseExpression);
- parseExpected(21);
- parseOptional(26);
- return finishNode(node);
- }
- function parseWhileStatement() {
- var node = createNode(229);
- parseExpected(111);
- parseExpected(20);
- node.expression = allowInAnd(parseExpression);
- parseExpected(21);
- node.statement = parseStatement();
- return finishNode(node);
- }
- function parseForOrForInOrForOfStatement() {
- var pos = getNodePos();
- parseExpected(93);
- var awaitToken = parseOptionalToken(127);
- parseExpected(20);
- var initializer;
- if (token() !== 26) {
- if (token() === 109 || token() === 115 || token() === 81) {
- initializer = parseVariableDeclarationList(true);
- }
- else {
- initializer = disallowInAnd(parseExpression);
- }
- }
- var forOrForInOrForOfStatement;
- if (awaitToken ? parseExpected(152) : parseOptional(152)) {
- var forOfStatement = createNode(232, pos);
- forOfStatement.awaitModifier = awaitToken;
- forOfStatement.initializer = initializer;
- forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher);
- parseExpected(21);
- forOrForInOrForOfStatement = forOfStatement;
- }
- else if (parseOptional(97)) {
- var forInStatement = createNode(231, pos);
- forInStatement.initializer = initializer;
- forInStatement.expression = allowInAnd(parseExpression);
- parseExpected(21);
- forOrForInOrForOfStatement = forInStatement;
- }
- else {
- var forStatement = createNode(230, pos);
- forStatement.initializer = initializer;
- parseExpected(26);
- if (token() !== 26 && token() !== 21) {
- forStatement.condition = allowInAnd(parseExpression);
- }
- parseExpected(26);
- if (token() !== 21) {
- forStatement.incrementor = allowInAnd(parseExpression);
- }
- parseExpected(21);
- forOrForInOrForOfStatement = forStatement;
- }
- forOrForInOrForOfStatement.statement = parseStatement();
- return finishNode(forOrForInOrForOfStatement);
- }
- function parseBreakOrContinueStatement(kind) {
- var node = createNode(kind);
- parseExpected(kind === 234 ? 77 : 82);
- if (!canParseSemicolon()) {
- node.label = parseIdentifier();
- }
- parseSemicolon();
- return finishNode(node);
- }
- function parseReturnStatement() {
- var node = createNode(235);
- parseExpected(101);
- if (!canParseSemicolon()) {
- node.expression = allowInAnd(parseExpression);
- }
- parseSemicolon();
- return finishNode(node);
- }
- function parseWithStatement() {
- var node = createNode(236);
- parseExpected(112);
- parseExpected(20);
- node.expression = allowInAnd(parseExpression);
- parseExpected(21);
- node.statement = doInsideOfContext(16777216, parseStatement);
- return finishNode(node);
- }
- function parseCaseClause() {
- var node = createNode(277);
- parseExpected(78);
- node.expression = allowInAnd(parseExpression);
- parseExpected(58);
- node.statements = parseList(3, parseStatement);
- return finishNode(node);
- }
- function parseDefaultClause() {
- var node = createNode(278);
- parseExpected(84);
- parseExpected(58);
- node.statements = parseList(3, parseStatement);
- return finishNode(node);
- }
- function parseCaseOrDefaultClause() {
- return token() === 78 ? parseCaseClause() : parseDefaultClause();
- }
- function parseSwitchStatement() {
- var node = createNode(237);
- parseExpected(103);
- parseExpected(20);
- node.expression = allowInAnd(parseExpression);
- parseExpected(21);
- var caseBlock = createNode(251);
- parseExpected(18);
- caseBlock.clauses = parseList(2, parseCaseOrDefaultClause);
- parseExpected(19);
- node.caseBlock = finishNode(caseBlock);
- return finishNode(node);
- }
- function parseThrowStatement() {
- var node = createNode(239);
- parseExpected(105);
- node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression);
- parseSemicolon();
- return finishNode(node);
- }
- function parseTryStatement() {
- var node = createNode(240);
- parseExpected(107);
- node.tryBlock = parseBlock(false);
- node.catchClause = token() === 79 ? parseCatchClause() : undefined;
- if (!node.catchClause || token() === 92) {
- parseExpected(92);
- node.finallyBlock = parseBlock(false);
- }
- return finishNode(node);
- }
- function parseCatchClause() {
- var result = createNode(280);
- parseExpected(79);
- if (parseOptional(20)) {
- result.variableDeclaration = parseVariableDeclaration();
- parseExpected(21);
- }
- else {
- result.variableDeclaration = undefined;
- }
- result.block = parseBlock(false);
- return finishNode(result);
- }
- function parseDebuggerStatement() {
- var node = createNode(241);
- parseExpected(83);
- parseSemicolon();
- return finishNode(node);
- }
- function parseExpressionOrLabeledStatement() {
- var node = createNodeWithJSDoc(token() === 75 ? 0 : 226);
- var expression = allowInAnd(parseExpression);
- if (expression.kind === 75 && parseOptional(58)) {
- node.kind = 238;
- node.label = expression;
- node.statement = parseStatement();
- }
- else {
- node.kind = 226;
- node.expression = expression;
- parseSemicolon();
- }
- return finishNode(node);
- }
- function nextTokenIsIdentifierOrKeywordOnSameLine() {
- nextToken();
- return ts.tokenIsIdentifierOrKeyword(token()) && !scanner.hasPrecedingLineBreak();
- }
- function nextTokenIsClassKeywordOnSameLine() {
- nextToken();
- return token() === 80 && !scanner.hasPrecedingLineBreak();
- }
- function nextTokenIsFunctionKeywordOnSameLine() {
- nextToken();
- return token() === 94 && !scanner.hasPrecedingLineBreak();
- }
- function nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine() {
- nextToken();
- return (ts.tokenIsIdentifierOrKeyword(token()) || token() === 8 || token() === 9 || token() === 10) && !scanner.hasPrecedingLineBreak();
- }
- function isDeclaration() {
- while (true) {
- switch (token()) {
- case 109:
- case 115:
- case 81:
- case 94:
- case 80:
- case 88:
- return true;
- case 114:
- case 145:
- return nextTokenIsIdentifierOnSameLine();
- case 135:
- case 136:
- return nextTokenIsIdentifierOrStringLiteralOnSameLine();
- case 122:
- case 126:
- case 130:
- case 117:
- case 118:
- case 119:
- case 138:
- nextToken();
- if (scanner.hasPrecedingLineBreak()) {
- return false;
- }
- continue;
- case 150:
- nextToken();
- return token() === 18 || token() === 75 || token() === 89;
- case 96:
- nextToken();
- return token() === 10 || token() === 41 ||
- token() === 18 || ts.tokenIsIdentifierOrKeyword(token());
- case 89:
- var currentToken_1 = nextToken();
- if (currentToken_1 === 145) {
- currentToken_1 = lookAhead(nextToken);
- }
- if (currentToken_1 === 62 || currentToken_1 === 41 ||
- currentToken_1 === 18 || currentToken_1 === 84 ||
- currentToken_1 === 123) {
- return true;
- }
- continue;
- case 120:
- nextToken();
- continue;
- default:
- return false;
- }
- }
- }
- function isStartOfDeclaration() {
- return lookAhead(isDeclaration);
- }
- function isStartOfStatement() {
- switch (token()) {
- case 59:
- case 26:
- case 18:
- case 109:
- case 115:
- case 94:
- case 80:
- case 88:
- case 95:
- case 86:
- case 111:
- case 93:
- case 82:
- case 77:
- case 101:
- case 112:
- case 103:
- case 105:
- case 107:
- case 83:
- case 79:
- case 92:
- return true;
- case 96:
- return isStartOfDeclaration() || lookAhead(nextTokenIsOpenParenOrLessThanOrDot);
- case 81:
- case 89:
- return isStartOfDeclaration();
- case 126:
- case 130:
- case 114:
- case 135:
- case 136:
- case 145:
- case 150:
- return true;
- case 119:
- case 117:
- case 118:
- case 120:
- case 138:
- return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
- default:
- return isStartOfExpression();
- }
- }
- function nextTokenIsIdentifierOrStartOfDestructuring() {
- nextToken();
- return isIdentifier() || token() === 18 || token() === 22;
- }
- function isLetDeclaration() {
- return lookAhead(nextTokenIsIdentifierOrStartOfDestructuring);
- }
- function parseStatement() {
- switch (token()) {
- case 26:
- return parseEmptyStatement();
- case 18:
- return parseBlock(false);
- case 109:
- return parseVariableStatement(createNodeWithJSDoc(242));
- case 115:
- if (isLetDeclaration()) {
- return parseVariableStatement(createNodeWithJSDoc(242));
- }
- break;
- case 94:
- return parseFunctionDeclaration(createNodeWithJSDoc(244));
- case 80:
- return parseClassDeclaration(createNodeWithJSDoc(245));
- case 95:
- return parseIfStatement();
- case 86:
- return parseDoStatement();
- case 111:
- return parseWhileStatement();
- case 93:
- return parseForOrForInOrForOfStatement();
- case 82:
- return parseBreakOrContinueStatement(233);
- case 77:
- return parseBreakOrContinueStatement(234);
- case 101:
- return parseReturnStatement();
- case 112:
- return parseWithStatement();
- case 103:
- return parseSwitchStatement();
- case 105:
- return parseThrowStatement();
- case 107:
- case 79:
- case 92:
- return parseTryStatement();
- case 83:
- return parseDebuggerStatement();
- case 59:
- return parseDeclaration();
- case 126:
- case 114:
- case 145:
- case 135:
- case 136:
- case 130:
- case 81:
- case 88:
- case 89:
- case 96:
- case 117:
- case 118:
- case 119:
- case 122:
- case 120:
- case 138:
- case 150:
- if (isStartOfDeclaration()) {
- return parseDeclaration();
- }
- break;
- }
- return parseExpressionOrLabeledStatement();
- }
- function isDeclareModifier(modifier) {
- return modifier.kind === 130;
- }
- function parseDeclaration() {
- var modifiers = lookAhead(function () { return (parseDecorators(), parseModifiers()); });
- var isAmbient = ts.some(modifiers, isDeclareModifier);
- if (isAmbient) {
- var node_3 = tryReuseAmbientDeclaration();
- if (node_3) {
- return node_3;
- }
- }
- var node = createNodeWithJSDoc(0);
- node.decorators = parseDecorators();
- node.modifiers = parseModifiers();
- if (isAmbient) {
- for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
- var m = _a[_i];
- m.flags |= 8388608;
- }
- return doInsideOfContext(8388608, function () { return parseDeclarationWorker(node); });
- }
- else {
- return parseDeclarationWorker(node);
- }
- }
- function tryReuseAmbientDeclaration() {
- return doInsideOfContext(8388608, function () {
- var node = currentNode(parsingContext);
- if (node) {
- return consumeNode(node);
- }
- });
- }
- function parseDeclarationWorker(node) {
- switch (token()) {
- case 109:
- case 115:
- case 81:
- return parseVariableStatement(node);
- case 94:
- return parseFunctionDeclaration(node);
- case 80:
- return parseClassDeclaration(node);
- case 114:
- return parseInterfaceDeclaration(node);
- case 145:
- return parseTypeAliasDeclaration(node);
- case 88:
- return parseEnumDeclaration(node);
- case 150:
- case 135:
- case 136:
- return parseModuleDeclaration(node);
- case 96:
- return parseImportDeclarationOrImportEqualsDeclaration(node);
- case 89:
- nextToken();
- switch (token()) {
- case 84:
- case 62:
- return parseExportAssignment(node);
- case 123:
- return parseNamespaceExportDeclaration(node);
- default:
- return parseExportDeclaration(node);
- }
- default:
- if (node.decorators || node.modifiers) {
- var missing = createMissingNode(264, true, ts.Diagnostics.Declaration_expected);
- missing.pos = node.pos;
- missing.decorators = node.decorators;
- missing.modifiers = node.modifiers;
- return finishNode(missing);
- }
- return undefined;
- }
- }
- function nextTokenIsIdentifierOrStringLiteralOnSameLine() {
- nextToken();
- return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token() === 10);
- }
- function parseFunctionBlockOrSemicolon(flags, diagnosticMessage) {
- if (token() !== 18 && canParseSemicolon()) {
- parseSemicolon();
- return;
- }
- return parseFunctionBlock(flags, diagnosticMessage);
- }
- function parseArrayBindingElement() {
- if (token() === 27) {
- return createNode(215);
- }
- var node = createNode(191);
- node.dotDotDotToken = parseOptionalToken(25);
- node.name = parseIdentifierOrPattern();
- node.initializer = parseInitializer();
- return finishNode(node);
- }
- function parseObjectBindingElement() {
- var node = createNode(191);
- node.dotDotDotToken = parseOptionalToken(25);
- var tokenIsIdentifier = isIdentifier();
- var propertyName = parsePropertyName();
- if (tokenIsIdentifier && token() !== 58) {
- node.name = propertyName;
- }
- else {
- parseExpected(58);
- node.propertyName = propertyName;
- node.name = parseIdentifierOrPattern();
- }
- node.initializer = parseInitializer();
- return finishNode(node);
- }
- function parseObjectBindingPattern() {
- var node = createNode(189);
- parseExpected(18);
- node.elements = parseDelimitedList(9, parseObjectBindingElement);
- parseExpected(19);
- return finishNode(node);
- }
- function parseArrayBindingPattern() {
- var node = createNode(190);
- parseExpected(22);
- node.elements = parseDelimitedList(10, parseArrayBindingElement);
- parseExpected(23);
- return finishNode(node);
- }
- function isIdentifierOrPrivateIdentifierOrPattern() {
- return token() === 18
- || token() === 22
- || token() === 76
- || isIdentifier();
- }
- function parseIdentifierOrPattern(privateIdentifierDiagnosticMessage) {
- if (token() === 22) {
- return parseArrayBindingPattern();
- }
- if (token() === 18) {
- return parseObjectBindingPattern();
- }
- return parseIdentifier(undefined, privateIdentifierDiagnosticMessage);
- }
- function parseVariableDeclarationAllowExclamation() {
- return parseVariableDeclaration(true);
- }
- function parseVariableDeclaration(allowExclamation) {
- var node = createNode(242);
- node.name = parseIdentifierOrPattern(ts.Diagnostics.Private_identifiers_are_not_allowed_in_variable_declarations);
- if (allowExclamation && node.name.kind === 75 &&
- token() === 53 && !scanner.hasPrecedingLineBreak()) {
- node.exclamationToken = parseTokenNode();
- }
- node.type = parseTypeAnnotation();
- if (!isInOrOfKeyword(token())) {
- node.initializer = parseInitializer();
- }
- return finishNode(node);
- }
- function parseVariableDeclarationList(inForStatementInitializer) {
- var node = createNode(243);
- switch (token()) {
- case 109:
- break;
- case 115:
- node.flags |= 1;
- break;
- case 81:
- node.flags |= 2;
- break;
- default:
- ts.Debug.fail();
- }
- nextToken();
- if (token() === 152 && lookAhead(canFollowContextualOfKeyword)) {
- node.declarations = createMissingList();
- }
- else {
- var savedDisallowIn = inDisallowInContext();
- setDisallowInContext(inForStatementInitializer);
- node.declarations = parseDelimitedList(8, inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation);
- setDisallowInContext(savedDisallowIn);
- }
- return finishNode(node);
- }
- function canFollowContextualOfKeyword() {
- return nextTokenIsIdentifier() && nextToken() === 21;
- }
- function parseVariableStatement(node) {
- node.kind = 225;
- node.declarationList = parseVariableDeclarationList(false);
- parseSemicolon();
- return finishNode(node);
- }
- function parseFunctionDeclaration(node) {
- node.kind = 244;
- parseExpected(94);
- node.asteriskToken = parseOptionalToken(41);
- node.name = hasModifierOfKind(node, 84) ? parseOptionalIdentifier() : parseIdentifier();
- var isGenerator = node.asteriskToken ? 1 : 0;
- var isAsync = hasModifierOfKind(node, 126) ? 2 : 0;
- fillSignature(58, isGenerator | isAsync, node);
- node.body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, ts.Diagnostics.or_expected);
- return finishNode(node);
- }
- function parseConstructorName() {
- if (token() === 129) {
- return parseExpected(129);
- }
- if (token() === 10 && lookAhead(nextToken) === 20) {
- return tryParse(function () {
- var literalNode = parseLiteralNode();
- return literalNode.text === "constructor" ? literalNode : undefined;
- });
- }
- }
- function tryParseConstructorDeclaration(node) {
- return tryParse(function () {
- if (parseConstructorName()) {
- node.kind = 162;
- fillSignature(58, 0, node);
- node.body = parseFunctionBlockOrSemicolon(0, ts.Diagnostics.or_expected);
- return finishNode(node);
- }
- });
- }
- function parseMethodDeclaration(node, asteriskToken, diagnosticMessage) {
- node.kind = 161;
- node.asteriskToken = asteriskToken;
- var isGenerator = asteriskToken ? 1 : 0;
- var isAsync = hasModifierOfKind(node, 126) ? 2 : 0;
- fillSignature(58, isGenerator | isAsync, node);
- node.body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, diagnosticMessage);
- return finishNode(node);
- }
- function parsePropertyDeclaration(node) {
- node.kind = 159;
- if (!node.questionToken && token() === 53 && !scanner.hasPrecedingLineBreak()) {
- node.exclamationToken = parseTokenNode();
- }
- node.type = parseTypeAnnotation();
- node.initializer = doOutsideOfContext(8192 | 32768 | 4096, parseInitializer);
- parseSemicolon();
- return finishNode(node);
- }
- function parsePropertyOrMethodDeclaration(node) {
- var asteriskToken = parseOptionalToken(41);
- node.name = parsePropertyName();
- node.questionToken = parseOptionalToken(57);
- if (asteriskToken || token() === 20 || token() === 29) {
- return parseMethodDeclaration(node, asteriskToken, ts.Diagnostics.or_expected);
- }
- return parsePropertyDeclaration(node);
- }
- function parseAccessorDeclaration(node, kind) {
- node.kind = kind;
- node.name = parsePropertyName();
- fillSignature(58, 0, node);
- node.body = parseFunctionBlockOrSemicolon(0);
- return finishNode(node);
- }
- function isClassMemberStart() {
- var idToken;
- if (token() === 59) {
- return true;
- }
- while (ts.isModifierKind(token())) {
- idToken = token();
- if (ts.isClassMemberModifier(idToken)) {
- return true;
- }
- nextToken();
- }
- if (token() === 41) {
- return true;
- }
- if (isLiteralPropertyName()) {
- idToken = token();
- nextToken();
- }
- if (token() === 22) {
- return true;
- }
- if (idToken !== undefined) {
- if (!ts.isKeyword(idToken) || idToken === 142 || idToken === 131) {
- return true;
- }
- switch (token()) {
- case 20:
- case 29:
- case 53:
- case 58:
- case 62:
- case 57:
- return true;
- default:
- return canParseSemicolon();
- }
- }
- return false;
- }
- function parseDecorators() {
- var list;
- var listPos = getNodePos();
- while (true) {
- var decoratorStart = getNodePos();
- if (!parseOptional(59)) {
- break;
- }
- var decorator = createNode(157, decoratorStart);
- decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher);
- finishNode(decorator);
- (list || (list = [])).push(decorator);
- }
- return list && createNodeArray(list, listPos);
- }
- function parseModifiers(permitInvalidConstAsModifier) {
- var list;
- var listPos = getNodePos();
- while (true) {
- var modifierStart = scanner.getStartPos();
- var modifierKind = token();
- if (token() === 81 && permitInvalidConstAsModifier) {
- if (!tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) {
- break;
- }
- }
- else {
- if (!parseAnyContextualModifier()) {
- break;
- }
- }
- var modifier = finishNode(createNode(modifierKind, modifierStart));
- (list || (list = [])).push(modifier);
- }
- return list && createNodeArray(list, listPos);
- }
- function parseModifiersForArrowFunction() {
- var modifiers;
- if (token() === 126) {
- var modifierStart = scanner.getStartPos();
- var modifierKind = token();
- nextToken();
- var modifier = finishNode(createNode(modifierKind, modifierStart));
- modifiers = createNodeArray([modifier], modifierStart);
- }
- return modifiers;
- }
- function parseClassElement() {
- if (token() === 26) {
- var result = createNode(222);
- nextToken();
- return finishNode(result);
- }
- var node = createNodeWithJSDoc(0);
- node.decorators = parseDecorators();
- node.modifiers = parseModifiers(true);
- if (parseContextualModifier(131)) {
- return parseAccessorDeclaration(node, 163);
- }
- if (parseContextualModifier(142)) {
- return parseAccessorDeclaration(node, 164);
- }
- if (token() === 129 || token() === 10) {
- var constructorDeclaration = tryParseConstructorDeclaration(node);
- if (constructorDeclaration) {
- return constructorDeclaration;
- }
- }
- if (isIndexSignature()) {
- return parseIndexSignatureDeclaration(node);
- }
- if (ts.tokenIsIdentifierOrKeyword(token()) ||
- token() === 10 ||
- token() === 8 ||
- token() === 41 ||
- token() === 22) {
- var isAmbient = node.modifiers && ts.some(node.modifiers, isDeclareModifier);
- if (isAmbient) {
- for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
- var m = _a[_i];
- m.flags |= 8388608;
- }
- return doInsideOfContext(8388608, function () { return parsePropertyOrMethodDeclaration(node); });
- }
- else {
- return parsePropertyOrMethodDeclaration(node);
- }
- }
- if (node.decorators || node.modifiers) {
- node.name = createMissingNode(75, true, ts.Diagnostics.Declaration_expected);
- return parsePropertyDeclaration(node);
- }
- return ts.Debug.fail("Should not have attempted to parse class member declaration.");
- }
- function parseClassExpression() {
- return parseClassDeclarationOrExpression(createNodeWithJSDoc(0), 214);
- }
- function parseClassDeclaration(node) {
- return parseClassDeclarationOrExpression(node, 245);
- }
- function parseClassDeclarationOrExpression(node, kind) {
- node.kind = kind;
- parseExpected(80);
- node.name = parseNameOfClassDeclarationOrExpression();
- node.typeParameters = parseTypeParameters();
- node.heritageClauses = parseHeritageClauses();
- if (parseExpected(18)) {
- node.members = parseClassMembers();
- parseExpected(19);
- }
- else {
- node.members = createMissingList();
- }
- return finishNode(node);
- }
- function parseNameOfClassDeclarationOrExpression() {
- return isIdentifier() && !isImplementsClause()
- ? parseIdentifier()
- : undefined;
- }
- function isImplementsClause() {
- return token() === 113 && lookAhead(nextTokenIsIdentifierOrKeyword);
- }
- function parseHeritageClauses() {
- if (isHeritageClause()) {
- return parseList(22, parseHeritageClause);
- }
- return undefined;
- }
- function parseHeritageClause() {
- var tok = token();
- ts.Debug.assert(tok === 90 || tok === 113);
- var node = createNode(279);
- node.token = tok;
- nextToken();
- node.types = parseDelimitedList(7, parseExpressionWithTypeArguments);
- return finishNode(node);
- }
- function parseExpressionWithTypeArguments() {
- var node = createNode(216);
- node.expression = parseLeftHandSideExpressionOrHigher();
- node.typeArguments = tryParseTypeArguments();
- return finishNode(node);
- }
- function tryParseTypeArguments() {
- return token() === 29 ?
- parseBracketedList(20, parseType, 29, 31) : undefined;
- }
- function isHeritageClause() {
- return token() === 90 || token() === 113;
- }
- function parseClassMembers() {
- return parseList(5, parseClassElement);
- }
- function parseInterfaceDeclaration(node) {
- node.kind = 246;
- parseExpected(114);
- node.name = parseIdentifier();
- node.typeParameters = parseTypeParameters();
- node.heritageClauses = parseHeritageClauses();
- node.members = parseObjectTypeMembers();
- return finishNode(node);
- }
- function parseTypeAliasDeclaration(node) {
- node.kind = 247;
- parseExpected(145);
- node.name = parseIdentifier();
- node.typeParameters = parseTypeParameters();
- parseExpected(62);
- node.type = parseType();
- parseSemicolon();
- return finishNode(node);
- }
- function parseEnumMember() {
- var node = createNodeWithJSDoc(284);
- node.name = parsePropertyName();
- node.initializer = allowInAnd(parseInitializer);
- return finishNode(node);
- }
- function parseEnumDeclaration(node) {
- node.kind = 248;
- parseExpected(88);
- node.name = parseIdentifier();
- if (parseExpected(18)) {
- node.members = doOutsideOfYieldAndAwaitContext(function () { return parseDelimitedList(6, parseEnumMember); });
- parseExpected(19);
- }
- else {
- node.members = createMissingList();
- }
- return finishNode(node);
- }
- function parseModuleBlock() {
- var node = createNode(250);
- if (parseExpected(18)) {
- node.statements = parseList(1, parseStatement);
- parseExpected(19);
- }
- else {
- node.statements = createMissingList();
- }
- return finishNode(node);
- }
- function parseModuleOrNamespaceDeclaration(node, flags) {
- node.kind = 249;
- var namespaceFlag = flags & 16;
- node.flags |= flags;
- node.name = parseIdentifier();
- node.body = parseOptional(24)
- ? parseModuleOrNamespaceDeclaration(createNode(0), 4 | namespaceFlag)
- : parseModuleBlock();
- return finishNode(node);
- }
- function parseAmbientExternalModuleDeclaration(node) {
- node.kind = 249;
- if (token() === 150) {
- node.name = parseIdentifier();
- node.flags |= 1024;
- }
- else {
- node.name = parseLiteralNode();
- node.name.text = internIdentifier(node.name.text);
- }
- if (token() === 18) {
- node.body = parseModuleBlock();
- }
- else {
- parseSemicolon();
- }
- return finishNode(node);
- }
- function parseModuleDeclaration(node) {
- var flags = 0;
- if (token() === 150) {
- return parseAmbientExternalModuleDeclaration(node);
- }
- else if (parseOptional(136)) {
- flags |= 16;
- }
- else {
- parseExpected(135);
- if (token() === 10) {
- return parseAmbientExternalModuleDeclaration(node);
- }
- }
- return parseModuleOrNamespaceDeclaration(node, flags);
- }
- function isExternalModuleReference() {
- return token() === 139 &&
- lookAhead(nextTokenIsOpenParen);
- }
- function nextTokenIsOpenParen() {
- return nextToken() === 20;
- }
- function nextTokenIsSlash() {
- return nextToken() === 43;
- }
- function parseNamespaceExportDeclaration(node) {
- node.kind = 252;
- parseExpected(123);
- parseExpected(136);
- node.name = parseIdentifier();
- parseSemicolon();
- return finishNode(node);
- }
- function parseImportDeclarationOrImportEqualsDeclaration(node) {
- parseExpected(96);
- var afterImportPos = scanner.getStartPos();
- var identifier;
- if (isIdentifier()) {
- identifier = parseIdentifier();
- }
- var isTypeOnly = false;
- if (token() !== 149 &&
- (identifier === null || identifier === void 0 ? void 0 : identifier.escapedText) === "type" &&
- (isIdentifier() || tokenAfterImportDefinitelyProducesImportDeclaration())) {
- isTypeOnly = true;
- identifier = isIdentifier() ? parseIdentifier() : undefined;
- }
- if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration()) {
- return parseImportEqualsDeclaration(node, identifier, isTypeOnly);
- }
- node.kind = 254;
- if (identifier ||
- token() === 41 ||
- token() === 18) {
- node.importClause = parseImportClause(identifier, afterImportPos, isTypeOnly);
- parseExpected(149);
- }
- node.moduleSpecifier = parseModuleSpecifier();
- parseSemicolon();
- return finishNode(node);
- }
- function tokenAfterImportDefinitelyProducesImportDeclaration() {
- return token() === 41 || token() === 18;
- }
- function tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() {
- return token() === 27 || token() === 149;
- }
- function parseImportEqualsDeclaration(node, identifier, isTypeOnly) {
- node.kind = 253;
- node.name = identifier;
- parseExpected(62);
- node.moduleReference = parseModuleReference();
- parseSemicolon();
- var finished = finishNode(node);
- if (isTypeOnly) {
- parseErrorAtRange(finished, ts.Diagnostics.Only_ECMAScript_imports_may_use_import_type);
- }
- return finished;
- }
- function parseImportClause(identifier, fullStart, isTypeOnly) {
- var importClause = createNode(255, fullStart);
- importClause.isTypeOnly = isTypeOnly;
- if (identifier) {
- importClause.name = identifier;
- }
- if (!importClause.name ||
- parseOptional(27)) {
- importClause.namedBindings = token() === 41 ? parseNamespaceImport() : parseNamedImportsOrExports(257);
- }
- return finishNode(importClause);
- }
- function parseModuleReference() {
- return isExternalModuleReference()
- ? parseExternalModuleReference()
- : parseEntityName(false);
- }
- function parseExternalModuleReference() {
- var node = createNode(265);
- parseExpected(139);
- parseExpected(20);
- node.expression = parseModuleSpecifier();
- parseExpected(21);
- return finishNode(node);
- }
- function parseModuleSpecifier() {
- if (token() === 10) {
- var result = parseLiteralNode();
- result.text = internIdentifier(result.text);
- return result;
- }
- else {
- return parseExpression();
- }
- }
- function parseNamespaceImport() {
- var namespaceImport = createNode(256);
- parseExpected(41);
- parseExpected(123);
- namespaceImport.name = parseIdentifier();
- return finishNode(namespaceImport);
- }
- function parseNamedImportsOrExports(kind) {
- var node = createNode(kind);
- node.elements = parseBracketedList(23, kind === 257 ? parseImportSpecifier : parseExportSpecifier, 18, 19);
- return finishNode(node);
- }
- function parseExportSpecifier() {
- return parseImportOrExportSpecifier(263);
- }
- function parseImportSpecifier() {
- return parseImportOrExportSpecifier(258);
- }
- function parseImportOrExportSpecifier(kind) {
- var node = createNode(kind);
- var checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier();
- var checkIdentifierStart = scanner.getTokenPos();
- var checkIdentifierEnd = scanner.getTextPos();
- var identifierName = parseIdentifierName();
- if (token() === 123) {
- node.propertyName = identifierName;
- parseExpected(123);
- checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier();
- checkIdentifierStart = scanner.getTokenPos();
- checkIdentifierEnd = scanner.getTextPos();
- node.name = parseIdentifierName();
- }
- else {
- node.name = identifierName;
- }
- if (kind === 258 && checkIdentifierIsKeyword) {
- parseErrorAt(checkIdentifierStart, checkIdentifierEnd, ts.Diagnostics.Identifier_expected);
- }
- return finishNode(node);
- }
- function parseNamespaceExport(pos) {
- var node = createNode(262, pos);
- node.name = parseIdentifier();
- return finishNode(node);
- }
- function parseExportDeclaration(node) {
- node.kind = 260;
- node.isTypeOnly = parseOptional(145);
- var namespaceExportPos = scanner.getStartPos();
- if (parseOptional(41)) {
- if (parseOptional(123)) {
- node.exportClause = parseNamespaceExport(namespaceExportPos);
- }
- parseExpected(149);
- node.moduleSpecifier = parseModuleSpecifier();
- }
- else {
- node.exportClause = parseNamedImportsOrExports(261);
- if (token() === 149 || (token() === 10 && !scanner.hasPrecedingLineBreak())) {
- parseExpected(149);
- node.moduleSpecifier = parseModuleSpecifier();
- }
- }
- parseSemicolon();
- return finishNode(node);
- }
- function parseExportAssignment(node) {
- node.kind = 259;
- if (parseOptional(62)) {
- node.isExportEquals = true;
- }
- else {
- parseExpected(84);
- }
- node.expression = parseAssignmentExpressionOrHigher();
- parseSemicolon();
- return finishNode(node);
- }
- function setExternalModuleIndicator(sourceFile) {
- sourceFile.externalModuleIndicator =
- ts.forEach(sourceFile.statements, isAnExternalModuleIndicatorNode) ||
- getImportMetaIfNecessary(sourceFile);
- }
- function isAnExternalModuleIndicatorNode(node) {
- return hasModifierOfKind(node, 89)
- || node.kind === 253 && node.moduleReference.kind === 265
- || node.kind === 254
- || node.kind === 259
- || node.kind === 260 ? node : undefined;
- }
- function getImportMetaIfNecessary(sourceFile) {
- return sourceFile.flags & 2097152 ?
- walkTreeForExternalModuleIndicators(sourceFile) :
- undefined;
- }
- function walkTreeForExternalModuleIndicators(node) {
- return isImportMeta(node) ? node : forEachChild(node, walkTreeForExternalModuleIndicators);
- }
- function hasModifierOfKind(node, kind) {
- return ts.some(node.modifiers, function (m) { return m.kind === kind; });
- }
- function isImportMeta(node) {
- return ts.isMetaProperty(node) && node.keywordToken === 96 && node.name.escapedText === "meta";
- }
- var JSDocParser;
- (function (JSDocParser) {
- function parseJSDocTypeExpressionForTests(content, start, length) {
- initializeState(content, 99, undefined, 1);
- sourceFile = createSourceFile("file.js", 99, 1, false);
- scanner.setText(content, start, length);
- currentToken = scanner.scan();
- var jsDocTypeExpression = parseJSDocTypeExpression();
- var diagnostics = parseDiagnostics;
- clearState();
- return jsDocTypeExpression ? { jsDocTypeExpression: jsDocTypeExpression, diagnostics: diagnostics } : undefined;
- }
- JSDocParser.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests;
- function parseJSDocTypeExpression(mayOmitBraces) {
- var result = createNode(294);
- var hasBrace = (mayOmitBraces ? parseOptional : parseExpected)(18);
- result.type = doInsideOfContext(4194304, parseJSDocType);
- if (!mayOmitBraces || hasBrace) {
- parseExpectedJSDoc(19);
- }
- fixupParentReferences(result);
- return finishNode(result);
- }
- JSDocParser.parseJSDocTypeExpression = parseJSDocTypeExpression;
- function parseIsolatedJSDocComment(content, start, length) {
- initializeState(content, 99, undefined, 1);
- sourceFile = { languageVariant: 0, text: content };
- var jsDoc = doInsideOfContext(4194304, function () { return parseJSDocCommentWorker(start, length); });
- var diagnostics = parseDiagnostics;
- clearState();
- return jsDoc ? { jsDoc: jsDoc, diagnostics: diagnostics } : undefined;
- }
- JSDocParser.parseIsolatedJSDocComment = parseIsolatedJSDocComment;
- function parseJSDocComment(parent, start, length) {
- var _a;
- var saveToken = currentToken;
- var saveParseDiagnosticsLength = parseDiagnostics.length;
- var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
- var comment = doInsideOfContext(4194304, function () { return parseJSDocCommentWorker(start, length); });
- if (comment) {
- comment.parent = parent;
- }
- if (contextFlags & 131072) {
- if (!sourceFile.jsDocDiagnostics) {
- sourceFile.jsDocDiagnostics = [];
- }
- (_a = sourceFile.jsDocDiagnostics).push.apply(_a, parseDiagnostics);
- }
- currentToken = saveToken;
- parseDiagnostics.length = saveParseDiagnosticsLength;
- parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
- return comment;
- }
- JSDocParser.parseJSDocComment = parseJSDocComment;
- function parseJSDocCommentWorker(start, length) {
- if (start === void 0) { start = 0; }
- var content = sourceText;
- var end = length === undefined ? content.length : start + length;
- length = end - start;
- ts.Debug.assert(start >= 0);
- ts.Debug.assert(start <= end);
- ts.Debug.assert(end <= content.length);
- if (!isJSDocLikeText(content, start)) {
- return undefined;
- }
- var tags;
- var tagsPos;
- var tagsEnd;
- var comments = [];
- return scanner.scanRange(start + 3, length - 5, function () {
- var state = 1;
- var margin;
- var indent = start - Math.max(content.lastIndexOf("\n", start), 0) + 4;
- function pushComment(text) {
- if (!margin) {
- margin = indent;
- }
- comments.push(text);
- indent += text.length;
- }
- nextTokenJSDoc();
- while (parseOptionalJsdoc(5))
- ;
- if (parseOptionalJsdoc(4)) {
- state = 0;
- indent = 0;
- }
- loop: while (true) {
- switch (token()) {
- case 59:
- if (state === 0 || state === 1) {
- removeTrailingWhitespace(comments);
- addTag(parseTag(indent));
- state = 0;
- margin = undefined;
- }
- else {
- pushComment(scanner.getTokenText());
- }
- break;
- case 4:
- comments.push(scanner.getTokenText());
- state = 0;
- indent = 0;
- break;
- case 41:
- var asterisk = scanner.getTokenText();
- if (state === 1 || state === 2) {
- state = 2;
- pushComment(asterisk);
- }
- else {
- state = 1;
- indent += asterisk.length;
- }
- break;
- case 5:
- var whitespace = scanner.getTokenText();
- if (state === 2) {
- comments.push(whitespace);
- }
- else if (margin !== undefined && indent + whitespace.length > margin) {
- comments.push(whitespace.slice(margin - indent - 1));
- }
- indent += whitespace.length;
- break;
- case 1:
- break loop;
- default:
- state = 2;
- pushComment(scanner.getTokenText());
- break;
- }
- nextTokenJSDoc();
- }
- removeLeadingNewlines(comments);
- removeTrailingWhitespace(comments);
- return createJSDocComment();
- });
- function removeLeadingNewlines(comments) {
- while (comments.length && (comments[0] === "\n" || comments[0] === "\r")) {
- comments.shift();
- }
- }
- function removeTrailingWhitespace(comments) {
- while (comments.length && comments[comments.length - 1].trim() === "") {
- comments.pop();
- }
- }
- function createJSDocComment() {
- var result = createNode(303, start);
- result.tags = tags && createNodeArray(tags, tagsPos, tagsEnd);
- result.comment = comments.length ? comments.join("") : undefined;
- return finishNode(result, end);
- }
- function isNextNonwhitespaceTokenEndOfFile() {
- while (true) {
- nextTokenJSDoc();
- if (token() === 1) {
- return true;
- }
- if (!(token() === 5 || token() === 4)) {
- return false;
- }
- }
- }
- function skipWhitespace() {
- if (token() === 5 || token() === 4) {
- if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) {
- return;
- }
- }
- while (token() === 5 || token() === 4) {
- nextTokenJSDoc();
- }
- }
- function skipWhitespaceOrAsterisk() {
- if (token() === 5 || token() === 4) {
- if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) {
- return "";
- }
- }
- var precedingLineBreak = scanner.hasPrecedingLineBreak();
- var seenLineBreak = false;
- var indentText = "";
- while ((precedingLineBreak && token() === 41) || token() === 5 || token() === 4) {
- indentText += scanner.getTokenText();
- if (token() === 4) {
- precedingLineBreak = true;
- seenLineBreak = true;
- indentText = "";
- }
- else if (token() === 41) {
- precedingLineBreak = false;
- }
- nextTokenJSDoc();
- }
- return seenLineBreak ? indentText : "";
- }
- function parseTag(margin) {
- ts.Debug.assert(token() === 59);
- var start = scanner.getTokenPos();
- nextTokenJSDoc();
- var tagName = parseJSDocIdentifierName(undefined);
- var indentText = skipWhitespaceOrAsterisk();
- var tag;
- switch (tagName.escapedText) {
- case "author":
- tag = parseAuthorTag(start, tagName, margin);
- break;
- case "implements":
- tag = parseImplementsTag(start, tagName);
- break;
- case "augments":
- case "extends":
- tag = parseAugmentsTag(start, tagName);
- break;
- case "class":
- case "constructor":
- tag = parseSimpleTag(start, 310, tagName);
- break;
- case "public":
- tag = parseSimpleTag(start, 311, tagName);
- break;
- case "private":
- tag = parseSimpleTag(start, 312, tagName);
- break;
- case "protected":
- tag = parseSimpleTag(start, 313, tagName);
- break;
- case "readonly":
- tag = parseSimpleTag(start, 314, tagName);
- break;
- case "this":
- tag = parseThisTag(start, tagName);
- break;
- case "enum":
- tag = parseEnumTag(start, tagName);
- break;
- case "arg":
- case "argument":
- case "param":
- return parseParameterOrPropertyTag(start, tagName, 2, margin);
- case "return":
- case "returns":
- tag = parseReturnTag(start, tagName);
- break;
- case "template":
- tag = parseTemplateTag(start, tagName);
- break;
- case "type":
- tag = parseTypeTag(start, tagName);
- break;
- case "typedef":
- tag = parseTypedefTag(start, tagName, margin);
- break;
- case "callback":
- tag = parseCallbackTag(start, tagName, margin);
- break;
- default:
- tag = parseUnknownTag(start, tagName);
- break;
- }
- if (!tag.comment) {
- if (!indentText) {
- margin += tag.end - tag.pos;
- }
- tag.comment = parseTagComments(margin, indentText.slice(margin));
- }
- return tag;
- }
- function parseTagComments(indent, initialMargin) {
- var comments = [];
- var state = 0;
- var margin;
- function pushComment(text) {
- if (!margin) {
- margin = indent;
- }
- comments.push(text);
- indent += text.length;
- }
- if (initialMargin !== undefined) {
- if (initialMargin !== "") {
- pushComment(initialMargin);
- }
- state = 1;
- }
- var tok = token();
- loop: while (true) {
- switch (tok) {
- case 4:
- if (state >= 1) {
- state = 0;
- comments.push(scanner.getTokenText());
- }
- indent = 0;
- break;
- case 59:
- if (state === 3) {
- comments.push(scanner.getTokenText());
- break;
- }
- scanner.setTextPos(scanner.getTextPos() - 1);
- case 1:
- break loop;
- case 5:
- if (state === 2 || state === 3) {
- pushComment(scanner.getTokenText());
- }
- else {
- var whitespace = scanner.getTokenText();
- if (margin !== undefined && indent + whitespace.length > margin) {
- comments.push(whitespace.slice(margin - indent));
- }
- indent += whitespace.length;
- }
- break;
- case 18:
- state = 2;
- if (lookAhead(function () { return nextTokenJSDoc() === 59 && ts.tokenIsIdentifierOrKeyword(nextTokenJSDoc()) && scanner.getTokenText() === "link"; })) {
- pushComment(scanner.getTokenText());
- nextTokenJSDoc();
- pushComment(scanner.getTokenText());
- nextTokenJSDoc();
- }
- pushComment(scanner.getTokenText());
- break;
- case 61:
- if (state === 3) {
- state = 2;
- }
- else {
- state = 3;
- }
- pushComment(scanner.getTokenText());
- break;
- case 41:
- if (state === 0) {
- state = 1;
- indent += 1;
- break;
- }
- default:
- if (state !== 3) {
- state = 2;
- }
- pushComment(scanner.getTokenText());
- break;
- }
- tok = nextTokenJSDoc();
- }
- removeLeadingNewlines(comments);
- removeTrailingWhitespace(comments);
- return comments.length === 0 ? undefined : comments.join("");
- }
- function parseUnknownTag(start, tagName) {
- var result = createNode(306, start);
- result.tagName = tagName;
- return finishNode(result);
- }
- 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 ? parseJSDocTypeExpression() : undefined;
- }
- function parseBracketNameInPropertyAndParamTag() {
- var isBracketed = parseOptionalJsdoc(22);
- if (isBracketed) {
- skipWhitespace();
- }
- var isBackquoted = parseOptionalJsdoc(61);
- var name = parseJSDocEntityName();
- if (isBackquoted) {
- parseExpectedTokenJSDoc(61);
- }
- if (isBracketed) {
- skipWhitespace();
- if (parseOptionalToken(62)) {
- parseExpression();
- }
- parseExpected(23);
- }
- return { name: name, isBracketed: isBracketed };
- }
- function isObjectOrObjectArrayTypeReference(node) {
- switch (node.kind) {
- case 141:
- return true;
- case 174:
- return isObjectOrObjectArrayTypeReference(node.elementType);
- default:
- return ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.escapedText === "Object" && !node.typeArguments;
- }
- }
- function parseParameterOrPropertyTag(start, tagName, target, indent) {
- var typeExpression = tryParseTypeExpression();
- var isNameFirst = !typeExpression;
- skipWhitespaceOrAsterisk();
- var _a = parseBracketNameInPropertyAndParamTag(), name = _a.name, isBracketed = _a.isBracketed;
- skipWhitespace();
- if (isNameFirst) {
- typeExpression = tryParseTypeExpression();
- }
- var result = target === 1 ?
- createNode(323, start) :
- createNode(317, start);
- var comment = parseTagComments(indent + scanner.getStartPos() - start);
- var nestedTypeLiteral = target !== 4 && parseNestedTypeLiteral(typeExpression, name, target, indent);
- if (nestedTypeLiteral) {
- typeExpression = nestedTypeLiteral;
- isNameFirst = true;
- }
- result.tagName = tagName;
- result.typeExpression = typeExpression;
- result.name = name;
- result.isNameFirst = isNameFirst;
- result.isBracketed = isBracketed;
- result.comment = comment;
- return finishNode(result);
- }
- function parseNestedTypeLiteral(typeExpression, name, target, indent) {
- if (typeExpression && isObjectOrObjectArrayTypeReference(typeExpression.type)) {
- var typeLiteralExpression = createNode(294, scanner.getTokenPos());
- var child = void 0;
- var jsdocTypeLiteral = void 0;
- var start_3 = scanner.getStartPos();
- var children = void 0;
- while (child = tryParse(function () { return parseChildParameterOrPropertyTag(target, indent, name); })) {
- if (child.kind === 317 || child.kind === 323) {
- children = ts.append(children, child);
- }
- }
- if (children) {
- jsdocTypeLiteral = createNode(304, start_3);
- jsdocTypeLiteral.jsDocPropertyTags = children;
- if (typeExpression.type.kind === 174) {
- jsdocTypeLiteral.isArrayType = true;
- }
- typeLiteralExpression.type = finishNode(jsdocTypeLiteral);
- return finishNode(typeLiteralExpression);
- }
- }
- }
- function parseReturnTag(start, tagName) {
- if (ts.some(tags, ts.isJSDocReturnTag)) {
- parseErrorAt(tagName.pos, scanner.getTokenPos(), ts.Diagnostics._0_tag_already_specified, tagName.escapedText);
- }
- var result = createNode(318, start);
- result.tagName = tagName;
- result.typeExpression = tryParseTypeExpression();
- return finishNode(result);
- }
- function parseTypeTag(start, tagName) {
- if (ts.some(tags, ts.isJSDocTypeTag)) {
- parseErrorAt(tagName.pos, scanner.getTokenPos(), ts.Diagnostics._0_tag_already_specified, tagName.escapedText);
- }
- var result = createNode(320, start);
- result.tagName = tagName;
- result.typeExpression = parseJSDocTypeExpression(true);
- return finishNode(result);
- }
- function parseAuthorTag(start, tagName, indent) {
- var result = createNode(309, start);
- result.tagName = tagName;
- var authorInfoWithEmail = tryParse(function () { return tryParseAuthorNameAndEmail(); });
- if (!authorInfoWithEmail) {
- return finishNode(result);
- }
- result.comment = authorInfoWithEmail;
- if (lookAhead(function () { return nextToken() !== 4; })) {
- var comment = parseTagComments(indent);
- if (comment) {
- result.comment += comment;
- }
- }
- return finishNode(result);
- }
- function tryParseAuthorNameAndEmail() {
- var comments = [];
- var seenLessThan = false;
- var seenGreaterThan = false;
- var token = scanner.getToken();
- loop: while (true) {
- switch (token) {
- case 75:
- case 5:
- case 24:
- case 59:
- comments.push(scanner.getTokenText());
- break;
- case 29:
- if (seenLessThan || seenGreaterThan) {
- return;
- }
- seenLessThan = true;
- comments.push(scanner.getTokenText());
- break;
- case 31:
- if (!seenLessThan || seenGreaterThan) {
- return;
- }
- seenGreaterThan = true;
- comments.push(scanner.getTokenText());
- scanner.setTextPos(scanner.getTokenPos() + 1);
- break loop;
- case 4:
- case 1:
- break loop;
- }
- token = nextTokenJSDoc();
- }
- if (seenLessThan && seenGreaterThan) {
- return comments.length === 0 ? undefined : comments.join("");
- }
- }
- function parseImplementsTag(start, tagName) {
- var result = createNode(308, start);
- result.tagName = tagName;
- result.class = parseExpressionWithTypeArgumentsForAugments();
- return finishNode(result);
- }
- function parseAugmentsTag(start, tagName) {
- var result = createNode(307, start);
- result.tagName = tagName;
- result.class = parseExpressionWithTypeArgumentsForAugments();
- return finishNode(result);
- }
- function parseExpressionWithTypeArgumentsForAugments() {
- var usedBrace = parseOptional(18);
- var node = createNode(216);
- node.expression = parsePropertyAccessEntityNameExpression();
- node.typeArguments = tryParseTypeArguments();
- var res = finishNode(node);
- if (usedBrace) {
- parseExpected(19);
- }
- return res;
- }
- function parsePropertyAccessEntityNameExpression() {
- var node = parseJSDocIdentifierName();
- while (parseOptional(24)) {
- var prop = createNode(194, node.pos);
- prop.expression = node;
- prop.name = parseJSDocIdentifierName();
- node = finishNode(prop);
- }
- return node;
- }
- function parseSimpleTag(start, kind, tagName) {
- var tag = createNode(kind, start);
- tag.tagName = tagName;
- return finishNode(tag);
- }
- function parseThisTag(start, tagName) {
- var tag = createNode(319, start);
- tag.tagName = tagName;
- tag.typeExpression = parseJSDocTypeExpression(true);
- skipWhitespace();
- return finishNode(tag);
- }
- function parseEnumTag(start, tagName) {
- var tag = createNode(316, start);
- tag.tagName = tagName;
- tag.typeExpression = parseJSDocTypeExpression(true);
- skipWhitespace();
- return finishNode(tag);
- }
- function parseTypedefTag(start, tagName, indent) {
- var typeExpression = tryParseTypeExpression();
- skipWhitespaceOrAsterisk();
- var typedefTag = createNode(322, start);
- typedefTag.tagName = tagName;
- typedefTag.fullName = parseJSDocTypeNameWithNamespace();
- typedefTag.name = getJSDocTypeAliasName(typedefTag.fullName);
- skipWhitespace();
- typedefTag.comment = parseTagComments(indent);
- typedefTag.typeExpression = typeExpression;
- var end;
- if (!typeExpression || isObjectOrObjectArrayTypeReference(typeExpression.type)) {
- var child = void 0;
- var jsdocTypeLiteral = void 0;
- var childTypeTag = void 0;
- while (child = tryParse(function () { return parseChildPropertyTag(indent); })) {
- if (!jsdocTypeLiteral) {
- jsdocTypeLiteral = createNode(304, start);
- }
- if (child.kind === 320) {
- if (childTypeTag) {
- break;
- }
- else {
- childTypeTag = child;
- }
- }
- else {
- jsdocTypeLiteral.jsDocPropertyTags = ts.append(jsdocTypeLiteral.jsDocPropertyTags, child);
- }
- }
- if (jsdocTypeLiteral) {
- if (typeExpression && typeExpression.type.kind === 174) {
- jsdocTypeLiteral.isArrayType = true;
- }
- typedefTag.typeExpression = childTypeTag && childTypeTag.typeExpression && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ?
- childTypeTag.typeExpression :
- finishNode(jsdocTypeLiteral);
- end = typedefTag.typeExpression.end;
- }
- }
- return finishNode(typedefTag, end || typedefTag.comment !== undefined ? scanner.getStartPos() : (typedefTag.fullName || typedefTag.typeExpression || typedefTag.tagName).end);
- }
- function parseJSDocTypeNameWithNamespace(nested) {
- var pos = scanner.getTokenPos();
- if (!ts.tokenIsIdentifierOrKeyword(token())) {
- return undefined;
- }
- var typeNameOrNamespaceName = parseJSDocIdentifierName();
- if (parseOptional(24)) {
- var jsDocNamespaceNode = createNode(249, pos);
- if (nested) {
- jsDocNamespaceNode.flags |= 4;
- }
- jsDocNamespaceNode.name = typeNameOrNamespaceName;
- jsDocNamespaceNode.body = parseJSDocTypeNameWithNamespace(true);
- return finishNode(jsDocNamespaceNode);
- }
- if (nested) {
- typeNameOrNamespaceName.isInJSDocNamespace = true;
- }
- return typeNameOrNamespaceName;
- }
- function parseCallbackTag(start, tagName, indent) {
- var callbackTag = createNode(315, start);
- callbackTag.tagName = tagName;
- callbackTag.fullName = parseJSDocTypeNameWithNamespace();
- callbackTag.name = getJSDocTypeAliasName(callbackTag.fullName);
- skipWhitespace();
- callbackTag.comment = parseTagComments(indent);
- var child;
- var jsdocSignature = createNode(305, start);
- jsdocSignature.parameters = [];
- while (child = tryParse(function () { return parseChildParameterOrPropertyTag(4, indent); })) {
- jsdocSignature.parameters = ts.append(jsdocSignature.parameters, child);
- }
- var returnTag = tryParse(function () {
- if (parseOptionalJsdoc(59)) {
- var tag = parseTag(indent);
- if (tag && tag.kind === 318) {
- return tag;
- }
- }
- });
- if (returnTag) {
- jsdocSignature.type = returnTag;
- }
- callbackTag.typeExpression = finishNode(jsdocSignature);
- return finishNode(callbackTag);
- }
- function getJSDocTypeAliasName(fullName) {
- if (fullName) {
- var rightNode = fullName;
- while (true) {
- if (ts.isIdentifier(rightNode) || !rightNode.body) {
- return ts.isIdentifier(rightNode) ? rightNode : rightNode.name;
- }
- rightNode = rightNode.body;
- }
- }
- }
- function escapedTextsEqual(a, b) {
- while (!ts.isIdentifier(a) || !ts.isIdentifier(b)) {
- if (!ts.isIdentifier(a) && !ts.isIdentifier(b) && a.right.escapedText === b.right.escapedText) {
- a = a.left;
- b = b.left;
- }
- else {
- return false;
- }
- }
- return a.escapedText === b.escapedText;
- }
- function parseChildPropertyTag(indent) {
- return parseChildParameterOrPropertyTag(1, indent);
- }
- function parseChildParameterOrPropertyTag(target, indent, name) {
- var canParseTag = true;
- var seenAsterisk = false;
- while (true) {
- switch (nextTokenJSDoc()) {
- case 59:
- if (canParseTag) {
- var child = tryParseChildTag(target, indent);
- if (child && (child.kind === 317 || child.kind === 323) &&
- target !== 4 &&
- name && (ts.isIdentifier(child.name) || !escapedTextsEqual(name, child.name.left))) {
- return false;
- }
- return child;
- }
- seenAsterisk = false;
- break;
- case 4:
- canParseTag = true;
- seenAsterisk = false;
- break;
- case 41:
- if (seenAsterisk) {
- canParseTag = false;
- }
- seenAsterisk = true;
- break;
- case 75:
- canParseTag = false;
- break;
- case 1:
- return false;
- }
- }
- }
- function tryParseChildTag(target, indent) {
- ts.Debug.assert(token() === 59);
- var start = scanner.getStartPos();
- nextTokenJSDoc();
- var tagName = parseJSDocIdentifierName();
- skipWhitespace();
- var t;
- switch (tagName.escapedText) {
- case "type":
- return target === 1 && parseTypeTag(start, tagName);
- case "prop":
- case "property":
- t = 1;
- break;
- case "arg":
- case "argument":
- case "param":
- t = 2 | 4;
- break;
- default:
- return false;
- }
- if (!(target & t)) {
- return false;
- }
- return parseParameterOrPropertyTag(start, tagName, target, indent);
- }
- function parseTemplateTag(start, tagName) {
- var constraint;
- if (token() === 18) {
- constraint = parseJSDocTypeExpression();
- }
- var typeParameters = [];
- var typeParametersPos = getNodePos();
- do {
- skipWhitespace();
- var typeParameter = createNode(155);
- typeParameter.name = parseJSDocIdentifierName(ts.Diagnostics.Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces);
- finishNode(typeParameter);
- skipWhitespaceOrAsterisk();
- typeParameters.push(typeParameter);
- } while (parseOptionalJsdoc(27));
- var result = createNode(321, start);
- result.tagName = tagName;
- result.constraint = constraint;
- result.typeParameters = createNodeArray(typeParameters, typeParametersPos);
- finishNode(result);
- return result;
- }
- function parseOptionalJsdoc(t) {
- if (token() === t) {
- nextTokenJSDoc();
- return true;
- }
- return false;
- }
- function parseJSDocEntityName() {
- var entity = parseJSDocIdentifierName();
- if (parseOptional(22)) {
- parseExpected(23);
- }
- while (parseOptional(24)) {
- var name = parseJSDocIdentifierName();
- if (parseOptional(22)) {
- parseExpected(23);
- }
- entity = createQualifiedName(entity, name);
- }
- return entity;
- }
- function parseJSDocIdentifierName(message) {
- if (!ts.tokenIsIdentifierOrKeyword(token())) {
- return createMissingNode(75, !message, message || ts.Diagnostics.Identifier_expected);
- }
- identifierCount++;
- var pos = scanner.getTokenPos();
- var end = scanner.getTextPos();
- var result = createNode(75, pos);
- if (token() !== 75) {
- result.originalKeywordKind = token();
- }
- result.escapedText = ts.escapeLeadingUnderscores(internIdentifier(scanner.getTokenValue()));
- finishNode(result, end);
- nextTokenJSDoc();
- return result;
- }
- }
- })(JSDocParser = Parser.JSDocParser || (Parser.JSDocParser = {}));
- })(Parser || (Parser = {}));
- var IncrementalParser;
- (function (IncrementalParser) {
- function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) {
- aggressiveChecks = aggressiveChecks || ts.Debug.shouldAssert(2);
- checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks);
- if (ts.textChangeRangeIsUnchanged(textChangeRange)) {
- return sourceFile;
- }
- if (sourceFile.statements.length === 0) {
- return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, undefined, true, sourceFile.scriptKind);
- }
- var incrementalSourceFile = sourceFile;
- ts.Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed);
- incrementalSourceFile.hasBeenIncrementallyParsed = true;
- var oldText = sourceFile.text;
- var syntaxCursor = createSyntaxCursor(sourceFile);
- var changeRange = extendToAffectedRange(sourceFile, textChangeRange);
- checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks);
- ts.Debug.assert(changeRange.span.start <= textChangeRange.span.start);
- ts.Debug.assert(ts.textSpanEnd(changeRange.span) === ts.textSpanEnd(textChangeRange.span));
- ts.Debug.assert(ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)) === ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange)));
- var delta = ts.textChangeRangeNewSpan(changeRange).length - changeRange.span.length;
- updateTokenPositionsAndMarkElements(incrementalSourceFile, changeRange.span.start, ts.textSpanEnd(changeRange.span), ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)), delta, oldText, newText, aggressiveChecks);
- var result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, true, sourceFile.scriptKind);
- result.commentDirectives = getNewCommentDirectives(sourceFile.commentDirectives, result.commentDirectives, changeRange.span.start, ts.textSpanEnd(changeRange.span), delta, oldText, newText, aggressiveChecks);
- return result;
- }
- IncrementalParser.updateSourceFile = updateSourceFile;
- function getNewCommentDirectives(oldDirectives, newDirectives, changeStart, changeRangeOldEnd, delta, oldText, newText, aggressiveChecks) {
- if (!oldDirectives)
- return newDirectives;
- var commentDirectives;
- var addedNewlyScannedDirectives = false;
- for (var _i = 0, oldDirectives_1 = oldDirectives; _i < oldDirectives_1.length; _i++) {
- var directive = oldDirectives_1[_i];
- var range = directive.range, type = directive.type;
- if (range.end < changeStart) {
- commentDirectives = ts.append(commentDirectives, directive);
- }
- else if (range.pos > changeRangeOldEnd) {
- addNewlyScannedDirectives();
- var updatedDirective = {
- range: { pos: range.pos + delta, end: range.end + delta },
- type: type
- };
- commentDirectives = ts.append(commentDirectives, updatedDirective);
- if (aggressiveChecks) {
- ts.Debug.assert(oldText.substring(range.pos, range.end) === newText.substring(updatedDirective.range.pos, updatedDirective.range.end));
- }
- }
- }
- addNewlyScannedDirectives();
- return commentDirectives;
- function addNewlyScannedDirectives() {
- if (addedNewlyScannedDirectives)
- return;
- addedNewlyScannedDirectives = true;
- if (!commentDirectives) {
- commentDirectives = newDirectives;
- }
- else if (newDirectives) {
- commentDirectives.push.apply(commentDirectives, newDirectives);
- }
- }
- }
- function moveElementEntirelyPastChangeRange(element, isArray, delta, oldText, newText, aggressiveChecks) {
- if (isArray) {
- visitArray(element);
- }
- else {
- visitNode(element);
- }
- return;
- function visitNode(node) {
- var text = "";
- if (aggressiveChecks && shouldCheckNode(node)) {
- text = oldText.substring(node.pos, node.end);
- }
- if (node._children) {
- node._children = undefined;
- }
- node.pos += delta;
- node.end += delta;
- if (aggressiveChecks && shouldCheckNode(node)) {
- ts.Debug.assert(text === newText.substring(node.pos, node.end));
- }
- forEachChild(node, visitNode, visitArray);
- if (ts.hasJSDocNodes(node)) {
- for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) {
- var jsDocComment = _a[_i];
- visitNode(jsDocComment);
- }
- }
- checkNodePositions(node, aggressiveChecks);
- }
- function visitArray(array) {
- array._children = undefined;
- array.pos += delta;
- array.end += delta;
- for (var _i = 0, array_8 = array; _i < array_8.length; _i++) {
- var node = array_8[_i];
- visitNode(node);
- }
- }
- }
- function shouldCheckNode(node) {
- switch (node.kind) {
- case 10:
- case 8:
- case 75:
- return true;
- }
- return false;
- }
- function adjustIntersectingElement(element, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta) {
- ts.Debug.assert(element.end >= changeStart, "Adjusting an element that was entirely before the change range");
- ts.Debug.assert(element.pos <= changeRangeOldEnd, "Adjusting an element that was entirely after the change range");
- ts.Debug.assert(element.pos <= element.end);
- element.pos = Math.min(element.pos, changeRangeNewEnd);
- if (element.end >= changeRangeOldEnd) {
- element.end += delta;
- }
- else {
- element.end = Math.min(element.end, changeRangeNewEnd);
- }
- ts.Debug.assert(element.pos <= element.end);
- if (element.parent) {
- ts.Debug.assert(element.pos >= element.parent.pos);
- ts.Debug.assert(element.end <= element.parent.end);
- }
- }
- function checkNodePositions(node, aggressiveChecks) {
- if (aggressiveChecks) {
- var pos_2 = node.pos;
- var visitNode_1 = function (child) {
- ts.Debug.assert(child.pos >= pos_2);
- pos_2 = child.end;
- };
- if (ts.hasJSDocNodes(node)) {
- for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) {
- var jsDocComment = _a[_i];
- visitNode_1(jsDocComment);
- }
- }
- forEachChild(node, visitNode_1);
- ts.Debug.assert(pos_2 <= node.end);
- }
- }
- function updateTokenPositionsAndMarkElements(sourceFile, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta, oldText, newText, aggressiveChecks) {
- visitNode(sourceFile);
- return;
- function visitNode(child) {
- ts.Debug.assert(child.pos <= child.end);
- if (child.pos > changeRangeOldEnd) {
- moveElementEntirelyPastChangeRange(child, false, delta, oldText, newText, aggressiveChecks);
- return;
- }
- var fullEnd = child.end;
- if (fullEnd >= changeStart) {
- child.intersectsChange = true;
- child._children = undefined;
- adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
- forEachChild(child, visitNode, visitArray);
- if (ts.hasJSDocNodes(child)) {
- for (var _i = 0, _a = child.jsDoc; _i < _a.length; _i++) {
- var jsDocComment = _a[_i];
- visitNode(jsDocComment);
- }
- }
- checkNodePositions(child, aggressiveChecks);
- return;
- }
- ts.Debug.assert(fullEnd < changeStart);
- }
- function visitArray(array) {
- ts.Debug.assert(array.pos <= array.end);
- if (array.pos > changeRangeOldEnd) {
- moveElementEntirelyPastChangeRange(array, true, delta, oldText, newText, aggressiveChecks);
- return;
- }
- var fullEnd = array.end;
- if (fullEnd >= changeStart) {
- array.intersectsChange = true;
- array._children = undefined;
- adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
- for (var _i = 0, array_9 = array; _i < array_9.length; _i++) {
- var node = array_9[_i];
- visitNode(node);
- }
- return;
- }
- ts.Debug.assert(fullEnd < changeStart);
- }
- }
- function extendToAffectedRange(sourceFile, changeRange) {
- var maxLookahead = 1;
- var start = changeRange.span.start;
- for (var i = 0; start > 0 && i <= maxLookahead; i++) {
- var nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start);
- ts.Debug.assert(nearestNode.pos <= start);
- var position = nearestNode.pos;
- start = Math.max(0, position - 1);
- }
- var finalSpan = ts.createTextSpanFromBounds(start, ts.textSpanEnd(changeRange.span));
- var finalLength = changeRange.newLength + (changeRange.span.start - start);
- return ts.createTextChangeRange(finalSpan, finalLength);
- }
- function findNearestNodeStartingBeforeOrAtPosition(sourceFile, position) {
- var bestResult = sourceFile;
- var lastNodeEntirelyBeforePosition;
- forEachChild(sourceFile, visit);
- if (lastNodeEntirelyBeforePosition) {
- var lastChildOfLastEntireNodeBeforePosition = getLastDescendant(lastNodeEntirelyBeforePosition);
- if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) {
- bestResult = lastChildOfLastEntireNodeBeforePosition;
- }
- }
- return bestResult;
- function getLastDescendant(node) {
- while (true) {
- var lastChild = ts.getLastChild(node);
- if (lastChild) {
- node = lastChild;
- }
- else {
- return node;
- }
- }
- }
- function visit(child) {
- if (ts.nodeIsMissing(child)) {
- return;
- }
- if (child.pos <= position) {
- if (child.pos >= bestResult.pos) {
- bestResult = child;
- }
- if (position < child.end) {
- forEachChild(child, visit);
- return true;
- }
- else {
- ts.Debug.assert(child.end <= position);
- lastNodeEntirelyBeforePosition = child;
- }
- }
- else {
- ts.Debug.assert(child.pos > position);
- return true;
- }
- }
- }
- function checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks) {
- var oldText = sourceFile.text;
- if (textChangeRange) {
- ts.Debug.assert((oldText.length - textChangeRange.span.length + textChangeRange.newLength) === newText.length);
- if (aggressiveChecks || ts.Debug.shouldAssert(3)) {
- var oldTextPrefix = oldText.substr(0, textChangeRange.span.start);
- var newTextPrefix = newText.substr(0, textChangeRange.span.start);
- ts.Debug.assert(oldTextPrefix === newTextPrefix);
- var oldTextSuffix = oldText.substring(ts.textSpanEnd(textChangeRange.span), oldText.length);
- var newTextSuffix = newText.substring(ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange)), newText.length);
- ts.Debug.assert(oldTextSuffix === newTextSuffix);
- }
- }
- }
- function createSyntaxCursor(sourceFile) {
- var currentArray = sourceFile.statements;
- var currentArrayIndex = 0;
- ts.Debug.assert(currentArrayIndex < currentArray.length);
- var current = currentArray[currentArrayIndex];
- var lastQueriedPosition = -1;
- return {
- currentNode: function (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;
- ts.Debug.assert(!current || current.pos === position);
- return current;
- }
- };
- function findHighestListElementThatStartsAtPosition(position) {
- currentArray = undefined;
- currentArrayIndex = -1;
- current = undefined;
- forEachChild(sourceFile, visitNode, visitArray);
- return;
- function visitNode(node) {
- if (position >= node.pos && position < node.end) {
- forEachChild(node, visitNode, visitArray);
- return true;
- }
- return false;
- }
- function visitArray(array) {
- if (position >= array.pos && position < array.end) {
- for (var i = 0; i < array.length; i++) {
- var 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, visitNode, visitArray);
- return true;
- }
- }
- }
- }
- }
- return false;
- }
- }
- }
- })(IncrementalParser || (IncrementalParser = {}));
- function isDeclarationFileName(fileName) {
- return ts.fileExtensionIs(fileName, ".d.ts");
- }
- ts.isDeclarationFileName = isDeclarationFileName;
- function processCommentPragmas(context, sourceText) {
- var pragmas = [];
- for (var _i = 0, _a = ts.getLeadingCommentRanges(sourceText, 0) || ts.emptyArray; _i < _a.length; _i++) {
- var range = _a[_i];
- var comment = sourceText.substring(range.pos, range.end);
- extractPragmas(pragmas, range, comment);
- }
- context.pragmas = ts.createMap();
- for (var _b = 0, pragmas_1 = pragmas; _b < pragmas_1.length; _b++) {
- var pragma = pragmas_1[_b];
- if (context.pragmas.has(pragma.name)) {
- var currentValue = context.pragmas.get(pragma.name);
- if (currentValue instanceof Array) {
- currentValue.push(pragma.args);
- }
- else {
- context.pragmas.set(pragma.name, [currentValue, pragma.args]);
- }
- continue;
- }
- context.pragmas.set(pragma.name, pragma.args);
- }
- }
- ts.processCommentPragmas = processCommentPragmas;
- function processPragmasIntoFields(context, reportDiagnostic) {
- context.checkJsDirective = undefined;
- context.referencedFiles = [];
- context.typeReferenceDirectives = [];
- context.libReferenceDirectives = [];
- context.amdDependencies = [];
- context.hasNoDefaultLib = false;
- context.pragmas.forEach(function (entryOrList, key) {
- switch (key) {
- case "reference": {
- var referencedFiles_1 = context.referencedFiles;
- var typeReferenceDirectives_1 = context.typeReferenceDirectives;
- var libReferenceDirectives_1 = context.libReferenceDirectives;
- ts.forEach(ts.toArray(entryOrList), function (arg) {
- var _a = arg.arguments, types = _a.types, lib = _a.lib, path = _a.path;
- if (arg.arguments["no-default-lib"]) {
- context.hasNoDefaultLib = true;
- }
- else if (types) {
- typeReferenceDirectives_1.push({ pos: types.pos, end: types.end, fileName: types.value });
- }
- else if (lib) {
- libReferenceDirectives_1.push({ pos: lib.pos, end: lib.end, fileName: lib.value });
- }
- else if (path) {
- referencedFiles_1.push({ pos: path.pos, end: path.end, fileName: path.value });
- }
- else {
- reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, ts.Diagnostics.Invalid_reference_directive_syntax);
- }
- });
- break;
- }
- case "amd-dependency": {
- context.amdDependencies = ts.map(ts.toArray(entryOrList), function (x) { return ({ name: x.arguments.name, path: x.arguments.path }); });
- break;
- }
- case "amd-module": {
- if (entryOrList instanceof Array) {
- for (var _i = 0, entryOrList_1 = entryOrList; _i < entryOrList_1.length; _i++) {
- var entry = entryOrList_1[_i];
- if (context.moduleName) {
- reportDiagnostic(entry.range.pos, entry.range.end - entry.range.pos, ts.Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments);
- }
- context.moduleName = entry.arguments.name;
- }
- }
- else {
- context.moduleName = entryOrList.arguments.name;
- }
- break;
- }
- case "ts-nocheck":
- case "ts-check": {
- ts.forEach(ts.toArray(entryOrList), function (entry) {
- if (!context.checkJsDirective || entry.range.pos > context.checkJsDirective.pos) {
- context.checkJsDirective = {
- enabled: key === "ts-check",
- end: entry.range.end,
- pos: entry.range.pos
- };
- }
- });
- break;
- }
- case "jsx": return;
- default: ts.Debug.fail("Unhandled pragma kind");
- }
- });
- }
- ts.processPragmasIntoFields = processPragmasIntoFields;
- var namedArgRegExCache = ts.createMap();
- function getNamedArgRegEx(name) {
- if (namedArgRegExCache.has(name)) {
- return namedArgRegExCache.get(name);
- }
- var result = new RegExp("(\\s" + name + "\\s*=\\s*)('|\")(.+?)\\2", "im");
- namedArgRegExCache.set(name, result);
- return result;
- }
- var tripleSlashXMLCommentStartRegEx = /^\/\/\/\s*<(\S+)\s.*?\/>/im;
- var singleLinePragmaRegEx = /^\/\/\/?\s*@(\S+)\s*(.*)\s*$/im;
- function extractPragmas(pragmas, range, text) {
- var tripleSlash = range.kind === 2 && tripleSlashXMLCommentStartRegEx.exec(text);
- if (tripleSlash) {
- var name = tripleSlash[1].toLowerCase();
- var pragma = ts.commentPragmas[name];
- if (!pragma || !(pragma.kind & 1)) {
- return;
- }
- if (pragma.args) {
- var argument = {};
- for (var _i = 0, _a = pragma.args; _i < _a.length; _i++) {
- var arg = _a[_i];
- var matcher = getNamedArgRegEx(arg.name);
- var matchResult = matcher.exec(text);
- if (!matchResult && !arg.optional) {
- return;
- }
- else if (matchResult) {
- if (arg.captureSpan) {
- var startPos = range.pos + matchResult.index + matchResult[1].length + matchResult[2].length;
- argument[arg.name] = {
- value: matchResult[3],
- pos: startPos,
- end: startPos + matchResult[3].length
- };
- }
- else {
- argument[arg.name] = matchResult[3];
- }
- }
- }
- pragmas.push({ name: name, args: { arguments: argument, range: range } });
- }
- else {
- pragmas.push({ name: name, args: { arguments: {}, range: range } });
- }
- return;
- }
- var singleLine = range.kind === 2 && singleLinePragmaRegEx.exec(text);
- if (singleLine) {
- return addPragmaForMatch(pragmas, range, 2, singleLine);
- }
- if (range.kind === 3) {
- var multiLinePragmaRegEx = /\s*@(\S+)\s*(.*)\s*$/gim;
- var multiLineMatch = void 0;
- while (multiLineMatch = multiLinePragmaRegEx.exec(text)) {
- addPragmaForMatch(pragmas, range, 4, multiLineMatch);
- }
- }
- }
- function addPragmaForMatch(pragmas, range, kind, match) {
- if (!match)
- return;
- var name = match[1].toLowerCase();
- var pragma = ts.commentPragmas[name];
- if (!pragma || !(pragma.kind & kind)) {
- return;
- }
- var args = match[2];
- var argument = getNamedPragmaArguments(pragma, args);
- if (argument === "fail")
- return;
- pragmas.push({ name: name, args: { arguments: argument, range: range } });
- return;
- }
- function getNamedPragmaArguments(pragma, text) {
- if (!text)
- return {};
- if (!pragma.args)
- return {};
- var args = text.split(/\s+/);
- var argMap = {};
- for (var i = 0; i < pragma.args.length; i++) {
- var argument = pragma.args[i];
- if (!args[i] && !argument.optional) {
- return "fail";
- }
- if (argument.captureSpan) {
- return ts.Debug.fail("Capture spans not yet implemented for non-xml pragmas");
- }
- argMap[argument.name] = args[i];
- }
- return argMap;
- }
- function tagNamesAreEquivalent(lhs, rhs) {
- if (lhs.kind !== rhs.kind) {
- return false;
- }
- if (lhs.kind === 75) {
- return lhs.escapedText === rhs.escapedText;
- }
- if (lhs.kind === 104) {
- return true;
- }
- return lhs.name.escapedText === rhs.name.escapedText &&
- tagNamesAreEquivalent(lhs.expression, rhs.expression);
- }
- ts.tagNamesAreEquivalent = tagNamesAreEquivalent;
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- ts.compileOnSaveCommandLineOption = { name: "compileOnSave", type: "boolean" };
- 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"],
- ["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"],
- ["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"],
- ["es2020.bigint", "lib.es2020.bigint.d.ts"],
- ["es2020.promise", "lib.es2020.promise.d.ts"],
- ["es2020.string", "lib.es2020.string.d.ts"],
- ["es2020.symbol.wellknown", "lib.es2020.symbol.wellknown.d.ts"],
- ["esnext.array", "lib.es2019.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.esnext.string.d.ts"],
- ["esnext.promise", "lib.esnext.promise.d.ts"]
- ];
- ts.libs = libEntries.map(function (entry) { return entry[0]; });
- ts.libMap = ts.createMapFromEntries(libEntries);
- ts.optionsForWatch = [
- {
- name: "watchFile",
- type: ts.createMapFromTemplate({
- fixedpollinginterval: ts.WatchFileKind.FixedPollingInterval,
- prioritypollinginterval: ts.WatchFileKind.PriorityPollingInterval,
- dynamicprioritypolling: ts.WatchFileKind.DynamicPriorityPolling,
- usefsevents: ts.WatchFileKind.UseFsEvents,
- usefseventsonparentdirectory: ts.WatchFileKind.UseFsEventsOnParentDirectory,
- }),
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_DynamicPriorityPolling_UseFsEvents_UseFsEventsOnParentDirectory,
- },
- {
- name: "watchDirectory",
- type: ts.createMapFromTemplate({
- usefsevents: ts.WatchDirectoryKind.UseFsEvents,
- fixedpollinginterval: ts.WatchDirectoryKind.FixedPollingInterval,
- dynamicprioritypolling: ts.WatchDirectoryKind.DynamicPriorityPolling,
- }),
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively_Colon_UseFsEvents_default_FixedPollingInterval_DynamicPriorityPolling,
- },
- {
- name: "fallbackPolling",
- type: ts.createMapFromTemplate({
- fixedinterval: ts.PollingWatchKind.FixedInterval,
- priorityinterval: ts.PollingWatchKind.PriorityInterval,
- dynamicpriority: ts.PollingWatchKind.DynamicPriority,
- }),
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_FixedInterval_default_PriorityInterval_DynamicPriority,
- },
- {
- name: "synchronousWatchDirectory",
- type: "boolean",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively,
- },
- ];
- ts.commonOptionsWithBuild = [
- {
- name: "help",
- shortName: "h",
- type: "boolean",
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Print_this_message,
- },
- {
- name: "help",
- shortName: "?",
- type: "boolean"
- },
- {
- name: "watch",
- shortName: "w",
- type: "boolean",
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Watch_input_files,
- },
- {
- name: "preserveWatchOutput",
- type: "boolean",
- showInSimplifiedHelpView: false,
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen,
- },
- {
- name: "listFiles",
- type: "boolean",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Print_names_of_files_part_of_the_compilation
- },
- {
- name: "listEmittedFiles",
- type: "boolean",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Print_names_of_generated_files_part_of_the_compilation
- },
- {
- name: "pretty",
- type: "boolean",
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental
- },
- {
- name: "traceResolution",
- type: "boolean",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Enable_tracing_of_the_name_resolution_process
- },
- {
- name: "diagnostics",
- type: "boolean",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Show_diagnostic_information
- },
- {
- name: "extendedDiagnostics",
- type: "boolean",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Show_verbose_diagnostic_information
- },
- {
- name: "generateCpuProfile",
- type: "string",
- isFilePath: true,
- paramType: ts.Diagnostics.FILE_OR_DIRECTORY,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Generates_a_CPU_profile
- },
- {
- name: "incremental",
- shortName: "i",
- type: "boolean",
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Enable_incremental_compilation,
- transpileOptionValue: undefined
- },
- {
- name: "assumeChangesOnlyAffectDirectDependencies",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- affectsEmit: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it
- },
- {
- name: "locale",
- type: "string",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.The_locale_used_when_displaying_messages_to_the_user_e_g_en_us
- },
- ];
- ts.optionDeclarations = __spreadArrays(ts.commonOptionsWithBuild, [
- {
- name: "all",
- type: "boolean",
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Show_all_compiler_options,
- },
- {
- name: "version",
- shortName: "v",
- type: "boolean",
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Print_the_compiler_s_version,
- },
- {
- name: "init",
- type: "boolean",
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file,
- },
- {
- name: "project",
- shortName: "p",
- type: "string",
- isFilePath: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Command_line_Options,
- paramType: ts.Diagnostics.FILE_OR_DIRECTORY,
- description: ts.Diagnostics.Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json,
- },
- {
- name: "build",
- type: "boolean",
- shortName: "b",
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Build_one_or_more_projects_and_their_dependencies_if_out_of_date
- },
- {
- name: "showConfig",
- type: "boolean",
- category: ts.Diagnostics.Command_line_Options,
- isCommandLineOnly: true,
- description: ts.Diagnostics.Print_the_final_configuration_instead_of_building
- },
- {
- name: "listFilesOnly",
- type: "boolean",
- category: ts.Diagnostics.Command_line_Options,
- affectsSemanticDiagnostics: true,
- affectsEmit: true,
- isCommandLineOnly: true,
- description: ts.Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing
- },
- {
- name: "target",
- shortName: "t",
- type: ts.createMapFromTemplate({
- es3: 0,
- es5: 1,
- es6: 2,
- es2015: 2,
- es2016: 3,
- es2017: 4,
- es2018: 5,
- es2019: 6,
- es2020: 7,
- esnext: 99,
- }),
- affectsSourceFile: true,
- affectsModuleResolution: true,
- affectsEmit: true,
- paramType: ts.Diagnostics.VERSION,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_ES2020_or_ESNEXT,
- },
- {
- name: "module",
- shortName: "m",
- type: ts.createMapFromTemplate({
- none: ts.ModuleKind.None,
- commonjs: ts.ModuleKind.CommonJS,
- amd: ts.ModuleKind.AMD,
- system: ts.ModuleKind.System,
- umd: ts.ModuleKind.UMD,
- es6: ts.ModuleKind.ES2015,
- es2015: ts.ModuleKind.ES2015,
- es2020: ts.ModuleKind.ES2020,
- esnext: ts.ModuleKind.ESNext
- }),
- affectsModuleResolution: true,
- affectsEmit: true,
- paramType: ts.Diagnostics.KIND,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Specify_module_code_generation_Colon_none_commonjs_amd_system_umd_es2015_es2020_or_ESNext,
- },
- {
- name: "lib",
- type: "list",
- element: {
- name: "lib",
- type: ts.libMap
- },
- affectsModuleResolution: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Specify_library_files_to_be_included_in_the_compilation,
- transpileOptionValue: undefined
- },
- {
- name: "allowJs",
- type: "boolean",
- affectsModuleResolution: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Allow_javascript_files_to_be_compiled
- },
- {
- name: "checkJs",
- type: "boolean",
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Report_errors_in_js_files
- },
- {
- name: "jsx",
- type: ts.createMapFromTemplate({
- "preserve": 1,
- "react-native": 3,
- "react": 2
- }),
- affectsSourceFile: true,
- paramType: ts.Diagnostics.KIND,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Specify_JSX_code_generation_Colon_preserve_react_native_or_react,
- },
- {
- name: "declaration",
- shortName: "d",
- type: "boolean",
- affectsEmit: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Generates_corresponding_d_ts_file,
- transpileOptionValue: undefined
- },
- {
- name: "declarationMap",
- type: "boolean",
- affectsEmit: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Generates_a_sourcemap_for_each_corresponding_d_ts_file,
- transpileOptionValue: undefined
- },
- {
- name: "emitDeclarationOnly",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Only_emit_d_ts_declaration_files,
- transpileOptionValue: undefined
- },
- {
- name: "sourceMap",
- type: "boolean",
- affectsEmit: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Generates_corresponding_map_file,
- },
- {
- name: "outFile",
- type: "string",
- affectsEmit: true,
- isFilePath: true,
- paramType: ts.Diagnostics.FILE,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file,
- transpileOptionValue: undefined
- },
- {
- name: "outDir",
- type: "string",
- affectsEmit: true,
- isFilePath: true,
- paramType: ts.Diagnostics.DIRECTORY,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Redirect_output_structure_to_the_directory,
- },
- {
- name: "rootDir",
- type: "string",
- affectsEmit: true,
- isFilePath: true,
- paramType: ts.Diagnostics.LOCATION,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir,
- },
- {
- name: "composite",
- type: "boolean",
- affectsEmit: true,
- isTSConfigOnly: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Enable_project_compilation,
- transpileOptionValue: undefined
- },
- {
- name: "tsBuildInfoFile",
- type: "string",
- affectsEmit: true,
- isFilePath: true,
- paramType: ts.Diagnostics.FILE,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Specify_file_to_store_incremental_compilation_information,
- transpileOptionValue: undefined
- },
- {
- name: "removeComments",
- type: "boolean",
- affectsEmit: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Do_not_emit_comments_to_output,
- },
- {
- name: "noEmit",
- type: "boolean",
- affectsEmit: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Do_not_emit_outputs,
- transpileOptionValue: undefined
- },
- {
- name: "importHelpers",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Import_emit_helpers_from_tslib
- },
- {
- name: "importsNotUsedAsValues",
- type: ts.createMapFromTemplate({
- remove: 0,
- preserve: 1,
- error: 2
- }),
- affectsEmit: true,
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types
- },
- {
- name: "downlevelIteration",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3
- },
- {
- name: "isolatedModules",
- type: "boolean",
- category: ts.Diagnostics.Basic_Options,
- description: ts.Diagnostics.Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule,
- transpileOptionValue: true
- },
- {
- name: "strict",
- type: "boolean",
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Strict_Type_Checking_Options,
- description: ts.Diagnostics.Enable_all_strict_type_checking_options
- },
- {
- name: "noImplicitAny",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- strictFlag: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Strict_Type_Checking_Options,
- description: ts.Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type
- },
- {
- name: "strictNullChecks",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- strictFlag: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Strict_Type_Checking_Options,
- description: ts.Diagnostics.Enable_strict_null_checks
- },
- {
- name: "strictFunctionTypes",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- strictFlag: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Strict_Type_Checking_Options,
- description: ts.Diagnostics.Enable_strict_checking_of_function_types
- },
- {
- name: "strictBindCallApply",
- type: "boolean",
- strictFlag: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Strict_Type_Checking_Options,
- description: ts.Diagnostics.Enable_strict_bind_call_and_apply_methods_on_functions
- },
- {
- name: "strictPropertyInitialization",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- strictFlag: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Strict_Type_Checking_Options,
- description: ts.Diagnostics.Enable_strict_checking_of_property_initialization_in_classes
- },
- {
- name: "noImplicitThis",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- strictFlag: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Strict_Type_Checking_Options,
- description: ts.Diagnostics.Raise_error_on_this_expressions_with_an_implied_any_type,
- },
- {
- name: "alwaysStrict",
- type: "boolean",
- affectsSourceFile: true,
- strictFlag: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Strict_Type_Checking_Options,
- description: ts.Diagnostics.Parse_in_strict_mode_and_emit_use_strict_for_each_source_file
- },
- {
- name: "noUnusedLocals",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Additional_Checks,
- description: ts.Diagnostics.Report_errors_on_unused_locals,
- },
- {
- name: "noUnusedParameters",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Additional_Checks,
- description: ts.Diagnostics.Report_errors_on_unused_parameters,
- },
- {
- name: "noImplicitReturns",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Additional_Checks,
- description: ts.Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value
- },
- {
- name: "noFallthroughCasesInSwitch",
- type: "boolean",
- affectsBindDiagnostics: true,
- affectsSemanticDiagnostics: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Additional_Checks,
- description: ts.Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
- },
- {
- name: "moduleResolution",
- type: ts.createMapFromTemplate({
- node: ts.ModuleResolutionKind.NodeJs,
- classic: ts.ModuleResolutionKind.Classic,
- }),
- affectsModuleResolution: true,
- paramType: ts.Diagnostics.STRATEGY,
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
- },
- {
- name: "baseUrl",
- type: "string",
- affectsModuleResolution: true,
- isFilePath: true,
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.Base_directory_to_resolve_non_absolute_module_names
- },
- {
- name: "paths",
- type: "object",
- affectsModuleResolution: true,
- isTSConfigOnly: true,
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl,
- transpileOptionValue: undefined
- },
- {
- name: "rootDirs",
- type: "list",
- isTSConfigOnly: true,
- element: {
- name: "rootDirs",
- type: "string",
- isFilePath: true
- },
- affectsModuleResolution: true,
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime,
- transpileOptionValue: undefined
- },
- {
- name: "typeRoots",
- type: "list",
- element: {
- name: "typeRoots",
- type: "string",
- isFilePath: true
- },
- affectsModuleResolution: true,
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.List_of_folders_to_include_type_definitions_from
- },
- {
- name: "types",
- type: "list",
- element: {
- name: "types",
- type: "string"
- },
- affectsModuleResolution: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.Type_declaration_files_to_be_included_in_compilation,
- transpileOptionValue: undefined
- },
- {
- name: "allowSyntheticDefaultImports",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking
- },
- {
- name: "esModuleInterop",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- affectsEmit: true,
- showInSimplifiedHelpView: true,
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports
- },
- {
- name: "preserveSymlinks",
- type: "boolean",
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.Do_not_resolve_the_real_path_of_symlinks,
- },
- {
- name: "allowUmdGlobalAccess",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Module_Resolution_Options,
- description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules,
- },
- {
- name: "sourceRoot",
- type: "string",
- affectsEmit: true,
- paramType: ts.Diagnostics.LOCATION,
- category: ts.Diagnostics.Source_Map_Options,
- description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations,
- },
- {
- name: "mapRoot",
- type: "string",
- affectsEmit: true,
- paramType: ts.Diagnostics.LOCATION,
- category: ts.Diagnostics.Source_Map_Options,
- description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations,
- },
- {
- name: "inlineSourceMap",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Source_Map_Options,
- description: ts.Diagnostics.Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file
- },
- {
- name: "inlineSources",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Source_Map_Options,
- description: ts.Diagnostics.Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap_to_be_set
- },
- {
- name: "experimentalDecorators",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Experimental_Options,
- description: ts.Diagnostics.Enables_experimental_support_for_ES7_decorators
- },
- {
- name: "emitDecoratorMetadata",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- affectsEmit: true,
- category: ts.Diagnostics.Experimental_Options,
- description: ts.Diagnostics.Enables_experimental_support_for_emitting_type_metadata_for_decorators
- },
- {
- name: "jsxFactory",
- type: "string",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h
- },
- {
- name: "resolveJsonModule",
- type: "boolean",
- affectsModuleResolution: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Include_modules_imported_with_json_extension
- },
- {
- name: "out",
- type: "string",
- affectsEmit: true,
- isFilePath: false,
- category: ts.Diagnostics.Advanced_Options,
- paramType: ts.Diagnostics.FILE,
- description: ts.Diagnostics.Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file,
- transpileOptionValue: undefined
- },
- {
- name: "reactNamespace",
- type: "string",
- affectsEmit: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react_JSX_emit
- },
- {
- name: "skipDefaultLibCheck",
- type: "boolean",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files
- },
- {
- name: "charset",
- type: "string",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.The_character_set_of_the_input_files
- },
- {
- name: "emitBOM",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files
- },
- {
- name: "newLine",
- type: ts.createMapFromTemplate({
- crlf: 0,
- lf: 1
- }),
- affectsEmit: true,
- paramType: ts.Diagnostics.NEWLINE,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix,
- },
- {
- name: "noErrorTruncation",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_truncate_error_messages
- },
- {
- name: "noLib",
- type: "boolean",
- affectsModuleResolution: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_include_the_default_library_file_lib_d_ts,
- transpileOptionValue: true
- },
- {
- name: "noResolve",
- type: "boolean",
- affectsModuleResolution: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files,
- transpileOptionValue: true
- },
- {
- name: "stripInternal",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_emit_declarations_for_code_that_has_an_internal_annotation,
- },
- {
- name: "disableSizeLimit",
- type: "boolean",
- affectsSourceFile: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Disable_size_limitations_on_JavaScript_projects
- },
- {
- name: "disableSourceOfProjectReferenceRedirect",
- type: "boolean",
- isTSConfigOnly: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects
- },
- {
- name: "disableSolutionSearching",
- type: "boolean",
- isTSConfigOnly: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Disable_solution_searching_for_this_project
- },
- {
- name: "noImplicitUseStrict",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_emit_use_strict_directives_in_module_output
- },
- {
- name: "noEmitHelpers",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_generate_custom_helper_functions_like_extends_in_compiled_output
- },
- {
- name: "noEmitOnError",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_emit_outputs_if_any_errors_were_reported,
- transpileOptionValue: undefined
- },
- {
- name: "preserveConstEnums",
- type: "boolean",
- affectsEmit: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
- },
- {
- name: "declarationDir",
- type: "string",
- affectsEmit: true,
- isFilePath: true,
- paramType: ts.Diagnostics.DIRECTORY,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Output_directory_for_generated_declaration_files,
- transpileOptionValue: undefined
- },
- {
- name: "skipLibCheck",
- type: "boolean",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Skip_type_checking_of_declaration_files,
- },
- {
- name: "allowUnusedLabels",
- type: "boolean",
- affectsBindDiagnostics: true,
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_report_errors_on_unused_labels
- },
- {
- name: "allowUnreachableCode",
- type: "boolean",
- affectsBindDiagnostics: true,
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Do_not_report_errors_on_unreachable_code
- },
- {
- name: "suppressExcessPropertyErrors",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Suppress_excess_property_checks_for_object_literals,
- },
- {
- name: "suppressImplicitAnyIndexErrors",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures,
- },
- {
- name: "forceConsistentCasingInFileNames",
- type: "boolean",
- affectsModuleResolution: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
- },
- {
- name: "maxNodeModuleJsDepth",
- type: "number",
- affectsModuleResolution: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files
- },
- {
- name: "noStrictGenericChecks",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Disable_strict_checking_of_generic_signatures_in_function_types,
- },
- {
- name: "useDefineForClassFields",
- type: "boolean",
- affectsSemanticDiagnostics: true,
- affectsEmit: true,
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Emit_class_fields_with_Define_instead_of_Set,
- },
- {
- name: "keyofStringsOnly",
- type: "boolean",
- category: ts.Diagnostics.Advanced_Options,
- description: ts.Diagnostics.Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols,
- },
- {
- name: "plugins",
- type: "list",
- isTSConfigOnly: true,
- element: {
- name: "plugin",
- type: "object"
- },
- description: ts.Diagnostics.List_of_language_service_plugins
- },
- ]);
- ts.semanticDiagnosticsOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsSemanticDiagnostics; });
- ts.affectsEmitOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsEmit; });
- ts.moduleResolutionOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsModuleResolution; });
- ts.sourceFileAffectingCompilerOptions = ts.optionDeclarations.filter(function (option) {
- return !!option.affectsSourceFile || !!option.affectsModuleResolution || !!option.affectsBindDiagnostics;
- });
- ts.transpileOptionValueCompilerOptions = ts.optionDeclarations.filter(function (option) {
- return ts.hasProperty(option, "transpileOptionValue");
- });
- ts.buildOpts = __spreadArrays(ts.commonOptionsWithBuild, [
- {
- name: "verbose",
- shortName: "v",
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Enable_verbose_logging,
- type: "boolean"
- },
- {
- name: "dry",
- shortName: "d",
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Show_what_would_be_built_or_deleted_if_specified_with_clean,
- type: "boolean"
- },
- {
- name: "force",
- shortName: "f",
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Build_all_projects_including_those_that_appear_to_be_up_to_date,
- type: "boolean"
- },
- {
- name: "clean",
- category: ts.Diagnostics.Command_line_Options,
- description: ts.Diagnostics.Delete_the_outputs_of_all_projects,
- type: "boolean"
- }
- ]);
- ts.typeAcquisitionDeclarations = [
- {
- name: "enableAutoDiscovery",
- type: "boolean",
- },
- {
- name: "enable",
- type: "boolean",
- },
- {
- name: "include",
- type: "list",
- element: {
- name: "include",
- type: "string"
+ function isReusableEnumMember(node) {
+ return node.kind === 291;
+ }
+ function isReusableTypeMember(node) {
+ if (node) {
+ switch (node.kind) {
+ case 170:
+ case 164:
+ case 171:
+ case 162:
+ case 169:
+ return true;
+ }
}
- },
- {
- name: "exclude",
- type: "list",
- element: {
- name: "exclude",
- type: "string"
+ return false;
+ }
+ function isReusableVariableDeclaration(node) {
+ if (node.kind !== 249) {
+ return false;
}
+ var variableDeclarator = node;
+ return variableDeclarator.initializer === undefined;
}
- ];
- function createOptionNameMap(optionDeclarations) {
- var optionsNameMap = ts.createMap();
- var shortOptionNames = ts.createMap();
- ts.forEach(optionDeclarations, function (option) {
- optionsNameMap.set(option.name.toLowerCase(), option);
- if (option.shortName) {
- shortOptionNames.set(option.shortName, option.name);
+ function isReusableParameter(node) {
+ if (node.kind !== 160) {
+ return false;
}
- });
- return { optionsNameMap: optionsNameMap, shortOptionNames: shortOptionNames };
- }
- ts.createOptionNameMap = createOptionNameMap;
- var optionsNameMapCache;
- function getOptionsNameMap() {
- return optionsNameMapCache || (optionsNameMapCache = createOptionNameMap(ts.optionDeclarations));
- }
- ts.getOptionsNameMap = getOptionsNameMap;
- ts.defaultInitCompilerOptions = {
- module: ts.ModuleKind.CommonJS,
- target: 1,
- strict: true,
- esModuleInterop: true,
- forceConsistentCasingInFileNames: true,
- skipLibCheck: true
- };
- function convertEnableAutoDiscoveryToEnable(typeAcquisition) {
- if (typeAcquisition && typeAcquisition.enableAutoDiscovery !== undefined && typeAcquisition.enable === undefined) {
- return {
- enable: typeAcquisition.enableAutoDiscovery,
- include: typeAcquisition.include || [],
- exclude: typeAcquisition.exclude || []
- };
+ var parameter = node;
+ return parameter.initializer === undefined;
}
- return typeAcquisition;
- }
- ts.convertEnableAutoDiscoveryToEnable = convertEnableAutoDiscoveryToEnable;
- function createCompilerDiagnosticForInvalidCustomType(opt) {
- return createDiagnosticForInvalidCustomType(opt, ts.createCompilerDiagnostic);
- }
- ts.createCompilerDiagnosticForInvalidCustomType = createCompilerDiagnosticForInvalidCustomType;
- function createDiagnosticForInvalidCustomType(opt, createDiagnostic) {
- var namesOfType = ts.arrayFrom(opt.type.keys()).map(function (key) { return "'" + key + "'"; }).join(", ");
- return createDiagnostic(ts.Diagnostics.Argument_for_0_option_must_be_Colon_1, "--" + opt.name, namesOfType);
- }
- function parseCustomTypeOption(opt, value, errors) {
- return convertJsonOptionOfCustomType(opt, trimString(value || ""), errors);
- }
- ts.parseCustomTypeOption = parseCustomTypeOption;
- function parseListTypeOption(opt, value, errors) {
- if (value === void 0) { value = ""; }
- value = trimString(value);
- if (ts.startsWith(value, "-")) {
- return undefined;
+ function abortParsingListOrMoveToNextToken(kind) {
+ parsingContextErrors(kind);
+ if (isInSomeParsingContext()) {
+ return true;
+ }
+ nextToken();
+ return false;
}
- if (value === "") {
- return [];
+ function parsingContextErrors(context) {
+ switch (context) {
+ case 0: return parseErrorAtCurrentToken(ts.Diagnostics.Declaration_or_statement_expected);
+ case 1: return parseErrorAtCurrentToken(ts.Diagnostics.Declaration_or_statement_expected);
+ case 2: return parseErrorAtCurrentToken(ts.Diagnostics.case_or_default_expected);
+ case 3: return parseErrorAtCurrentToken(ts.Diagnostics.Statement_expected);
+ case 18:
+ case 4: return parseErrorAtCurrentToken(ts.Diagnostics.Property_or_signature_expected);
+ case 5: return parseErrorAtCurrentToken(ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected);
+ case 6: return parseErrorAtCurrentToken(ts.Diagnostics.Enum_member_expected);
+ case 7: return parseErrorAtCurrentToken(ts.Diagnostics.Expression_expected);
+ case 8:
+ return ts.isKeyword(token())
+ ? parseErrorAtCurrentToken(ts.Diagnostics._0_is_not_allowed_as_a_variable_declaration_name, ts.tokenToString(token()))
+ : parseErrorAtCurrentToken(ts.Diagnostics.Variable_declaration_expected);
+ case 9: return parseErrorAtCurrentToken(ts.Diagnostics.Property_destructuring_pattern_expected);
+ case 10: return parseErrorAtCurrentToken(ts.Diagnostics.Array_element_destructuring_pattern_expected);
+ case 11: return parseErrorAtCurrentToken(ts.Diagnostics.Argument_expression_expected);
+ case 12: return parseErrorAtCurrentToken(ts.Diagnostics.Property_assignment_expected);
+ case 15: return parseErrorAtCurrentToken(ts.Diagnostics.Expression_or_comma_expected);
+ case 17: return parseErrorAtCurrentToken(ts.Diagnostics.Parameter_declaration_expected);
+ case 16: return parseErrorAtCurrentToken(ts.Diagnostics.Parameter_declaration_expected);
+ case 19: return parseErrorAtCurrentToken(ts.Diagnostics.Type_parameter_declaration_expected);
+ case 20: return parseErrorAtCurrentToken(ts.Diagnostics.Type_argument_expected);
+ case 21: return parseErrorAtCurrentToken(ts.Diagnostics.Type_expected);
+ case 22: return parseErrorAtCurrentToken(ts.Diagnostics.Unexpected_token_expected);
+ case 23: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
+ case 13: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
+ case 14: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
+ default: return [undefined];
+ }
}
- var values = value.split(",");
- switch (opt.element.type) {
- case "number":
- return ts.map(values, parseInt);
- case "string":
- return ts.map(values, function (v) { return v || ""; });
- default:
- return ts.mapDefined(values, function (v) { return parseCustomTypeOption(opt.element, v, errors); });
+ function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
+ var saveParsingContext = parsingContext;
+ parsingContext |= 1 << kind;
+ var list = [];
+ var listPos = getNodePos();
+ var commaStart = -1;
+ while (true) {
+ if (isListElement(kind, false)) {
+ var startPos = scanner.getStartPos();
+ list.push(parseListElement(kind, parseElement));
+ commaStart = scanner.getTokenPos();
+ if (parseOptional(27)) {
+ continue;
+ }
+ commaStart = -1;
+ if (isListTerminator(kind)) {
+ break;
+ }
+ parseExpected(27, getExpectedCommaDiagnostic(kind));
+ if (considerSemicolonAsDelimiter && token() === 26 && !scanner.hasPrecedingLineBreak()) {
+ nextToken();
+ }
+ if (startPos === scanner.getStartPos()) {
+ nextToken();
+ }
+ continue;
+ }
+ if (isListTerminator(kind)) {
+ break;
+ }
+ if (abortParsingListOrMoveToNextToken(kind)) {
+ break;
+ }
+ }
+ parsingContext = saveParsingContext;
+ return createNodeArray(list, listPos, undefined, commaStart >= 0);
}
- }
- ts.parseListTypeOption = parseListTypeOption;
- function getOptionName(option) {
- return option.name;
- }
- function createUnknownOptionError(unknownOption, diagnostics, createDiagnostics, unknownOptionErrorText) {
- var possibleOption = ts.getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
- return possibleOption ?
- createDiagnostics(diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) :
- createDiagnostics(diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
- }
- function parseCommandLineWorker(diagnostics, commandLine, readFile) {
- var options = {};
- var watchOptions;
- var fileNames = [];
- var errors = [];
- parseStrings(commandLine);
- return {
- options: options,
- watchOptions: watchOptions,
- fileNames: fileNames,
- errors: errors
- };
- function parseStrings(args) {
- var i = 0;
- while (i < args.length) {
- var s = args[i];
- i++;
- if (s.charCodeAt(0) === 64) {
- parseResponseFile(s.slice(1));
+ function getExpectedCommaDiagnostic(kind) {
+ return kind === 6 ? ts.Diagnostics.An_enum_member_name_must_be_followed_by_a_or : undefined;
+ }
+ function createMissingList() {
+ var list = createNodeArray([], getNodePos());
+ list.isMissingList = true;
+ return list;
+ }
+ function isMissingList(arr) {
+ return !!arr.isMissingList;
+ }
+ function parseBracketedList(kind, parseElement, open, close) {
+ if (parseExpected(open)) {
+ var result = parseDelimitedList(kind, parseElement);
+ parseExpected(close);
+ return result;
+ }
+ return createMissingList();
+ }
+ function parseEntityName(allowReservedWords, diagnosticMessage) {
+ var pos = getNodePos();
+ var entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage);
+ var dotPos = getNodePos();
+ while (parseOptional(24)) {
+ if (token() === 29) {
+ entity.jsdocDotPos = dotPos;
+ break;
}
- else if (s.charCodeAt(0) === 45) {
- var inputOptionName = s.slice(s.charCodeAt(1) === 45 ? 2 : 1);
- var opt = getOptionDeclarationFromName(diagnostics.getOptionsNameMap, inputOptionName, true);
- if (opt) {
- i = parseOptionValue(args, i, diagnostics, opt, options, errors);
- }
- else {
- var watchOpt = getOptionDeclarationFromName(watchOptionsDidYouMeanDiagnostics.getOptionsNameMap, inputOptionName, true);
- if (watchOpt) {
- i = parseOptionValue(args, i, watchOptionsDidYouMeanDiagnostics, watchOpt, watchOptions || (watchOptions = {}), errors);
- }
- else {
- errors.push(createUnknownOptionError(inputOptionName, diagnostics, ts.createCompilerDiagnostic, s));
- }
+ dotPos = getNodePos();
+ entity = finishNode(factory.createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, false)), pos);
+ }
+ return entity;
+ }
+ function createQualifiedName(entity, name) {
+ return finishNode(factory.createQualifiedName(entity, name), entity.pos);
+ }
+ function parseRightSideOfDot(allowIdentifierNames, allowPrivateIdentifiers) {
+ if (scanner.hasPrecedingLineBreak() && ts.tokenIsIdentifierOrKeyword(token())) {
+ var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
+ if (matchesPattern) {
+ return createMissingNode(78, true, ts.Diagnostics.Identifier_expected);
+ }
+ }
+ if (token() === 79) {
+ var node = parsePrivateIdentifier();
+ return allowPrivateIdentifiers ? node : createMissingNode(78, true, ts.Diagnostics.Identifier_expected);
+ }
+ return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
+ }
+ function parseTemplateSpans(isTaggedTemplate) {
+ var pos = getNodePos();
+ var list = [];
+ var node;
+ do {
+ node = parseTemplateSpan(isTaggedTemplate);
+ list.push(node);
+ } while (node.literal.kind === 16);
+ return createNodeArray(list, pos);
+ }
+ function parseTemplateExpression(isTaggedTemplate) {
+ var pos = getNodePos();
+ return finishNode(factory.createTemplateExpression(parseTemplateHead(isTaggedTemplate), parseTemplateSpans(isTaggedTemplate)), pos);
+ }
+ function parseTemplateType() {
+ var pos = getNodePos();
+ return finishNode(factory.createTemplateLiteralType(parseTemplateHead(false), parseTemplateTypeSpans()), pos);
+ }
+ function parseTemplateTypeSpans() {
+ var pos = getNodePos();
+ var list = [];
+ var node;
+ do {
+ node = parseTemplateTypeSpan();
+ list.push(node);
+ } while (node.literal.kind === 16);
+ return createNodeArray(list, pos);
+ }
+ function parseTemplateTypeSpan() {
+ var pos = getNodePos();
+ return finishNode(factory.createTemplateLiteralTypeSpan(parseType(), parseLiteralOfTemplateSpan(false)), pos);
+ }
+ function parseLiteralOfTemplateSpan(isTaggedTemplate) {
+ if (token() === 19) {
+ reScanTemplateToken(isTaggedTemplate);
+ return parseTemplateMiddleOrTemplateTail();
+ }
+ else {
+ return parseExpectedToken(17, ts.Diagnostics._0_expected, ts.tokenToString(19));
+ }
+ }
+ function parseTemplateSpan(isTaggedTemplate) {
+ var pos = getNodePos();
+ return finishNode(factory.createTemplateSpan(allowInAnd(parseExpression), parseLiteralOfTemplateSpan(isTaggedTemplate)), pos);
+ }
+ function parseLiteralNode() {
+ return parseLiteralLikeNode(token());
+ }
+ function parseTemplateHead(isTaggedTemplate) {
+ if (isTaggedTemplate) {
+ reScanTemplateHeadOrNoSubstitutionTemplate();
+ }
+ var fragment = parseLiteralLikeNode(token());
+ ts.Debug.assert(fragment.kind === 15, "Template head has wrong token kind");
+ return fragment;
+ }
+ function parseTemplateMiddleOrTemplateTail() {
+ var fragment = parseLiteralLikeNode(token());
+ ts.Debug.assert(fragment.kind === 16 || fragment.kind === 17, "Template fragment has wrong token kind");
+ return fragment;
+ }
+ function getTemplateLiteralRawText(kind) {
+ var isLast = kind === 14 || kind === 17;
+ var tokenText = scanner.getTokenText();
+ return tokenText.substring(1, tokenText.length - (scanner.isUnterminated() ? 0 : isLast ? 1 : 2));
+ }
+ function parseLiteralLikeNode(kind) {
+ var pos = getNodePos();
+ var node = ts.isTemplateLiteralKind(kind) ? factory.createTemplateLiteralLikeNode(kind, scanner.getTokenValue(), getTemplateLiteralRawText(kind), scanner.getTokenFlags() & 2048) :
+ kind === 8 ? factory.createNumericLiteral(scanner.getTokenValue(), scanner.getNumericLiteralFlags()) :
+ kind === 10 ? factory.createStringLiteral(scanner.getTokenValue(), undefined, scanner.hasExtendedUnicodeEscape()) :
+ ts.isLiteralKind(kind) ? factory.createLiteralLikeNode(kind, scanner.getTokenValue()) :
+ ts.Debug.fail();
+ if (scanner.hasExtendedUnicodeEscape()) {
+ node.hasExtendedUnicodeEscape = true;
+ }
+ if (scanner.isUnterminated()) {
+ node.isUnterminated = true;
+ }
+ nextToken();
+ return finishNode(node, pos);
+ }
+ function parseEntityNameOfTypeReference() {
+ return parseEntityName(true, ts.Diagnostics.Type_expected);
+ }
+ function parseTypeArgumentsOfTypeReference() {
+ if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29) {
+ return parseBracketedList(20, parseType, 29, 31);
+ }
+ }
+ function parseTypeReference() {
+ var pos = getNodePos();
+ return finishNode(factory.createTypeReferenceNode(parseEntityNameOfTypeReference(), parseTypeArgumentsOfTypeReference()), pos);
+ }
+ function typeHasArrowFunctionBlockingParseError(node) {
+ switch (node.kind) {
+ case 173:
+ return ts.nodeIsMissing(node.typeName);
+ case 174:
+ case 175: {
+ var _a = node, parameters = _a.parameters, type = _a.type;
+ return isMissingList(parameters) || typeHasArrowFunctionBlockingParseError(type);
+ }
+ case 186:
+ return typeHasArrowFunctionBlockingParseError(node.type);
+ default:
+ return false;
+ }
+ }
+ function parseThisTypePredicate(lhs) {
+ nextToken();
+ return finishNode(factory.createTypePredicateNode(undefined, lhs, parseType()), lhs.pos);
+ }
+ function parseThisTypeNode() {
+ var pos = getNodePos();
+ nextToken();
+ return finishNode(factory.createThisTypeNode(), pos);
+ }
+ function parseJSDocAllType() {
+ var pos = getNodePos();
+ nextToken();
+ return finishNode(factory.createJSDocAllType(), pos);
+ }
+ function parseJSDocNonNullableType() {
+ var pos = getNodePos();
+ nextToken();
+ return finishNode(factory.createJSDocNonNullableType(parseNonArrayType()), pos);
+ }
+ function parseJSDocUnknownOrNullableType() {
+ var pos = getNodePos();
+ nextToken();
+ if (token() === 27 ||
+ token() === 19 ||
+ token() === 21 ||
+ token() === 31 ||
+ token() === 62 ||
+ token() === 51) {
+ return finishNode(factory.createJSDocUnknownType(), pos);
+ }
+ else {
+ return finishNode(factory.createJSDocNullableType(parseType()), pos);
+ }
+ }
+ function parseJSDocFunctionType() {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ if (lookAhead(nextTokenIsOpenParen)) {
+ nextToken();
+ var parameters = parseParameters(4 | 32);
+ var type = parseReturnType(58, false);
+ return withJSDoc(finishNode(factory.createJSDocFunctionType(parameters, type), pos), hasJSDoc);
+ }
+ return finishNode(factory.createTypeReferenceNode(parseIdentifierName(), undefined), pos);
+ }
+ function parseJSDocParameter() {
+ var pos = getNodePos();
+ var name;
+ if (token() === 107 || token() === 102) {
+ name = parseIdentifierName();
+ parseExpected(58);
+ }
+ return finishNode(factory.createParameterDeclaration(undefined, undefined, undefined, name, undefined, parseJSDocType(), undefined), pos);
+ }
+ function parseJSDocType() {
+ scanner.setInJSDocType(true);
+ var pos = getNodePos();
+ if (parseOptional(139)) {
+ var moduleTag = factory.createJSDocNamepathType(undefined);
+ terminate: while (true) {
+ switch (token()) {
+ case 19:
+ case 1:
+ case 27:
+ case 5:
+ break terminate;
+ default:
+ nextTokenJSDoc();
}
}
+ scanner.setInJSDocType(false);
+ return finishNode(moduleTag, pos);
+ }
+ var hasDotDotDot = parseOptional(25);
+ var type = parseTypeOrTypePredicate();
+ scanner.setInJSDocType(false);
+ if (hasDotDotDot) {
+ type = finishNode(factory.createJSDocVariadicType(type), pos);
+ }
+ if (token() === 62) {
+ nextToken();
+ return finishNode(factory.createJSDocOptionalType(type), pos);
+ }
+ return type;
+ }
+ function parseTypeQuery() {
+ var pos = getNodePos();
+ parseExpected(111);
+ return finishNode(factory.createTypeQueryNode(parseEntityName(true)), pos);
+ }
+ function parseTypeParameter() {
+ var pos = getNodePos();
+ var name = parseIdentifier();
+ var constraint;
+ var expression;
+ if (parseOptional(93)) {
+ if (isStartOfType() || !isStartOfExpression()) {
+ constraint = parseType();
+ }
else {
- fileNames.push(s);
+ expression = parseUnaryExpressionOrHigher();
+ }
+ }
+ var defaultType = parseOptional(62) ? parseType() : undefined;
+ var node = factory.createTypeParameterDeclaration(name, constraint, defaultType);
+ node.expression = expression;
+ return finishNode(node, pos);
+ }
+ function parseTypeParameters() {
+ if (token() === 29) {
+ return parseBracketedList(19, parseTypeParameter, 29, 31);
+ }
+ }
+ function isStartOfParameter(isJSDocParameter) {
+ return token() === 25 ||
+ isBindingIdentifierOrPrivateIdentifierOrPattern() ||
+ ts.isModifierKind(token()) ||
+ token() === 59 ||
+ isStartOfType(!isJSDocParameter);
+ }
+ function parseNameOfParameter(modifiers) {
+ var name = parseIdentifierOrPattern(ts.Diagnostics.Private_identifiers_cannot_be_used_as_parameters);
+ if (ts.getFullWidth(name) === 0 && !ts.some(modifiers) && ts.isModifierKind(token())) {
+ nextToken();
+ }
+ return name;
+ }
+ function parseParameterInOuterAwaitContext() {
+ return parseParameterWorker(true);
+ }
+ function parseParameter() {
+ return parseParameterWorker(false);
+ }
+ function parseParameterWorker(inOuterAwaitContext) {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ if (token() === 107) {
+ var node_1 = factory.createParameterDeclaration(undefined, undefined, undefined, createIdentifier(true), undefined, parseTypeAnnotation(), undefined);
+ return withJSDoc(finishNode(node_1, pos), hasJSDoc);
+ }
+ var decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : parseDecorators();
+ var savedTopLevel = topLevel;
+ topLevel = false;
+ var modifiers = parseModifiers();
+ var node = withJSDoc(finishNode(factory.createParameterDeclaration(decorators, modifiers, parseOptionalToken(25), parseNameOfParameter(modifiers), parseOptionalToken(57), parseTypeAnnotation(), parseInitializer()), pos), hasJSDoc);
+ topLevel = savedTopLevel;
+ return node;
+ }
+ function parseReturnType(returnToken, isType) {
+ if (shouldParseReturnType(returnToken, isType)) {
+ return parseTypeOrTypePredicate();
+ }
+ }
+ function shouldParseReturnType(returnToken, isType) {
+ if (returnToken === 38) {
+ parseExpected(returnToken);
+ return true;
+ }
+ else if (parseOptional(58)) {
+ return true;
+ }
+ else if (isType && token() === 38) {
+ parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(58));
+ nextToken();
+ return true;
+ }
+ return false;
+ }
+ function parseParametersWorker(flags) {
+ var savedYieldContext = inYieldContext();
+ var savedAwaitContext = inAwaitContext();
+ setYieldContext(!!(flags & 1));
+ setAwaitContext(!!(flags & 2));
+ var parameters = flags & 32 ?
+ parseDelimitedList(17, parseJSDocParameter) :
+ parseDelimitedList(16, savedAwaitContext ? parseParameterInOuterAwaitContext : parseParameter);
+ setYieldContext(savedYieldContext);
+ setAwaitContext(savedAwaitContext);
+ return parameters;
+ }
+ function parseParameters(flags) {
+ if (!parseExpected(20)) {
+ return createMissingList();
+ }
+ var parameters = parseParametersWorker(flags);
+ parseExpected(21);
+ return parameters;
+ }
+ function parseTypeMemberSemicolon() {
+ if (parseOptional(27)) {
+ return;
+ }
+ parseSemicolon();
+ }
+ function parseSignatureMember(kind) {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ if (kind === 170) {
+ parseExpected(102);
+ }
+ var typeParameters = parseTypeParameters();
+ var parameters = parseParameters(4);
+ var type = parseReturnType(58, true);
+ parseTypeMemberSemicolon();
+ var node = kind === 169
+ ? factory.createCallSignature(typeParameters, parameters, type)
+ : factory.createConstructSignature(typeParameters, parameters, type);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function isIndexSignature() {
+ return token() === 22 && lookAhead(isUnambiguouslyIndexSignature);
+ }
+ function isUnambiguouslyIndexSignature() {
+ nextToken();
+ if (token() === 25 || token() === 23) {
+ return true;
+ }
+ if (ts.isModifierKind(token())) {
+ nextToken();
+ if (isIdentifier()) {
+ return true;
}
}
+ else if (!isIdentifier()) {
+ return false;
+ }
+ else {
+ nextToken();
+ }
+ if (token() === 58 || token() === 27) {
+ return true;
+ }
+ if (token() !== 57) {
+ return false;
+ }
+ nextToken();
+ return token() === 58 || token() === 27 || token() === 23;
+ }
+ function parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ var parameters = parseBracketedList(16, parseParameter, 22, 23);
+ var type = parseTypeAnnotation();
+ parseTypeMemberSemicolon();
+ var node = factory.createIndexSignature(decorators, modifiers, parameters, type);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers) {
+ var name = parsePropertyName();
+ var questionToken = parseOptionalToken(57);
+ var node;
+ if (token() === 20 || token() === 29) {
+ var typeParameters = parseTypeParameters();
+ var parameters = parseParameters(4);
+ var type = parseReturnType(58, true);
+ node = factory.createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type);
+ }
+ else {
+ var type = parseTypeAnnotation();
+ node = factory.createPropertySignature(modifiers, name, questionToken, type);
+ if (token() === 62)
+ node.initializer = parseInitializer();
+ }
+ parseTypeMemberSemicolon();
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function isTypeMemberStart() {
+ if (token() === 20 || token() === 29) {
+ return true;
+ }
+ var idToken = false;
+ while (ts.isModifierKind(token())) {
+ idToken = true;
+ nextToken();
+ }
+ if (token() === 22) {
+ return true;
+ }
+ if (isLiteralPropertyName()) {
+ idToken = true;
+ nextToken();
+ }
+ if (idToken) {
+ return token() === 20 ||
+ token() === 29 ||
+ token() === 57 ||
+ token() === 58 ||
+ token() === 27 ||
+ canParseSemicolon();
+ }
+ return false;
}
- function parseResponseFile(fileName) {
- var text = tryReadFile(fileName, readFile || (function (fileName) { return ts.sys.readFile(fileName); }));
- if (!ts.isString(text)) {
- errors.push(text);
- return;
+ function parseTypeMember() {
+ if (token() === 20 || token() === 29) {
+ return parseSignatureMember(169);
}
- var args = [];
- var pos = 0;
- while (true) {
- while (pos < text.length && text.charCodeAt(pos) <= 32)
- pos++;
- if (pos >= text.length)
- break;
- var start = pos;
- if (text.charCodeAt(start) === 34) {
- pos++;
- while (pos < text.length && text.charCodeAt(pos) !== 34)
- pos++;
- if (pos < text.length) {
- args.push(text.substring(start + 1, pos));
- pos++;
- }
- else {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName));
- }
- }
- else {
- while (text.charCodeAt(pos) > 32)
- pos++;
- args.push(text.substring(start, pos));
- }
+ if (token() === 102 && lookAhead(nextTokenIsOpenParenOrLessThan)) {
+ return parseSignatureMember(170);
}
- parseStrings(args);
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ var modifiers = parseModifiers();
+ if (isIndexSignature()) {
+ return parseIndexSignatureDeclaration(pos, hasJSDoc, undefined, modifiers);
+ }
+ return parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers);
}
- }
- ts.parseCommandLineWorker = parseCommandLineWorker;
- function parseOptionValue(args, i, diagnostics, opt, options, errors) {
- if (opt.isTSConfigOnly) {
- var optValue = args[i];
- if (optValue === "null") {
- options[opt.name] = undefined;
- i++;
+ function nextTokenIsOpenParenOrLessThan() {
+ nextToken();
+ return token() === 20 || token() === 29;
+ }
+ function nextTokenIsDot() {
+ return nextToken() === 24;
+ }
+ function nextTokenIsOpenParenOrLessThanOrDot() {
+ switch (nextToken()) {
+ case 20:
+ case 29:
+ case 24:
+ return true;
}
- else if (opt.type === "boolean") {
- if (optValue === "false") {
- options[opt.name] = false;
- i++;
- }
- else {
- if (optValue === "true")
- i++;
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line, opt.name));
- }
+ return false;
+ }
+ function parseTypeLiteral() {
+ var pos = getNodePos();
+ return finishNode(factory.createTypeLiteralNode(parseObjectTypeMembers()), pos);
+ }
+ function parseObjectTypeMembers() {
+ var members;
+ if (parseExpected(18)) {
+ members = parseList(4, parseTypeMember);
+ parseExpected(19);
}
else {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line, opt.name));
- if (optValue && !ts.startsWith(optValue, "-"))
- i++;
+ members = createMissingList();
}
+ return members;
}
- else {
- if (!args[i] && opt.type !== "boolean") {
- errors.push(ts.createCompilerDiagnostic(diagnostics.optionTypeMismatchDiagnostic, opt.name, getCompilerOptionValueTypeString(opt)));
+ function isStartOfMappedType() {
+ nextToken();
+ if (token() === 39 || token() === 40) {
+ return nextToken() === 142;
}
- if (args[i] !== "null") {
- switch (opt.type) {
- case "number":
- options[opt.name] = parseInt(args[i]);
- i++;
- break;
- case "boolean":
- var optValue = args[i];
- options[opt.name] = optValue !== "false";
- if (optValue === "false" || optValue === "true") {
- i++;
- }
- break;
- case "string":
- options[opt.name] = args[i] || "";
- i++;
- break;
- case "list":
- var 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;
+ if (token() === 142) {
+ nextToken();
+ }
+ return token() === 22 && nextTokenIsIdentifier() && nextToken() === 100;
+ }
+ function parseMappedTypeParameter() {
+ var pos = getNodePos();
+ var name = parseIdentifierName();
+ parseExpected(100);
+ var type = parseType();
+ return finishNode(factory.createTypeParameterDeclaration(name, type, undefined), pos);
+ }
+ function parseMappedType() {
+ var pos = getNodePos();
+ parseExpected(18);
+ var readonlyToken;
+ if (token() === 142 || token() === 39 || token() === 40) {
+ readonlyToken = parseTokenNode();
+ if (readonlyToken.kind !== 142) {
+ parseExpected(142);
}
}
- else {
- options[opt.name] = undefined;
- i++;
+ parseExpected(22);
+ var typeParameter = parseMappedTypeParameter();
+ var nameType = parseOptional(126) ? parseType() : undefined;
+ parseExpected(23);
+ var questionToken;
+ if (token() === 57 || token() === 39 || token() === 40) {
+ questionToken = parseTokenNode();
+ if (questionToken.kind !== 57) {
+ parseExpected(57);
+ }
}
+ var type = parseTypeAnnotation();
+ parseSemicolon();
+ parseExpected(19);
+ return finishNode(factory.createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type), pos);
}
- return i;
- }
- ts.compilerOptionsDidYouMeanDiagnostics = {
- getOptionsNameMap: getOptionsNameMap,
- optionDeclarations: ts.optionDeclarations,
- unknownOptionDiagnostic: ts.Diagnostics.Unknown_compiler_option_0,
- unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
- optionTypeMismatchDiagnostic: ts.Diagnostics.Compiler_option_0_expects_an_argument
- };
- function parseCommandLine(commandLine, readFile) {
- return parseCommandLineWorker(ts.compilerOptionsDidYouMeanDiagnostics, commandLine, readFile);
- }
- ts.parseCommandLine = parseCommandLine;
- function getOptionFromName(optionName, allowShort) {
- return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
- }
- ts.getOptionFromName = getOptionFromName;
- function getOptionDeclarationFromName(getOptionNameMap, optionName, allowShort) {
- if (allowShort === void 0) { allowShort = false; }
- optionName = optionName.toLowerCase();
- var _a = getOptionNameMap(), optionsNameMap = _a.optionsNameMap, shortOptionNames = _a.shortOptionNames;
- if (allowShort) {
- var short = shortOptionNames.get(optionName);
- if (short !== undefined) {
- optionName = short;
+ function parseTupleElementType() {
+ var pos = getNodePos();
+ if (parseOptional(25)) {
+ return finishNode(factory.createRestTypeNode(parseType()), pos);
+ }
+ var type = parseType();
+ if (ts.isJSDocNullableType(type) && type.pos === type.type.pos) {
+ var node = factory.createOptionalTypeNode(type.type);
+ ts.setTextRange(node, type);
+ node.flags = type.flags;
+ return node;
}
+ return type;
}
- return optionsNameMap.get(optionName);
- }
- var buildOptionsNameMapCache;
- function getBuildOptionsNameMap() {
- return buildOptionsNameMapCache || (buildOptionsNameMapCache = createOptionNameMap(ts.buildOpts));
- }
- var buildOptionsDidYouMeanDiagnostics = {
- getOptionsNameMap: getBuildOptionsNameMap,
- optionDeclarations: ts.buildOpts,
- unknownOptionDiagnostic: ts.Diagnostics.Unknown_build_option_0,
- unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_build_option_0_Did_you_mean_1,
- optionTypeMismatchDiagnostic: ts.Diagnostics.Build_option_0_requires_a_value_of_type_1
- };
- function parseBuildCommand(args) {
- var _a = parseCommandLineWorker(buildOptionsDidYouMeanDiagnostics, args), options = _a.options, watchOptions = _a.watchOptions, projects = _a.fileNames, errors = _a.errors;
- var buildOptions = options;
- if (projects.length === 0) {
- projects.push(".");
+ function isNextTokenColonOrQuestionColon() {
+ return nextToken() === 58 || (token() === 57 && nextToken() === 58);
}
- if (buildOptions.clean && buildOptions.force) {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "force"));
+ function isTupleElementName() {
+ if (token() === 25) {
+ return ts.tokenIsIdentifierOrKeyword(nextToken()) && isNextTokenColonOrQuestionColon();
+ }
+ return ts.tokenIsIdentifierOrKeyword(token()) && isNextTokenColonOrQuestionColon();
}
- if (buildOptions.clean && buildOptions.verbose) {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "verbose"));
+ function parseTupleElementNameOrTupleElementType() {
+ if (lookAhead(isTupleElementName)) {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ var dotDotDotToken = parseOptionalToken(25);
+ var name = parseIdentifierName();
+ var questionToken = parseOptionalToken(57);
+ parseExpected(58);
+ var type = parseTupleElementType();
+ var node = factory.createNamedTupleMember(dotDotDotToken, name, questionToken, type);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ return parseTupleElementType();
}
- if (buildOptions.clean && buildOptions.watch) {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "watch"));
+ function parseTupleType() {
+ var pos = getNodePos();
+ return finishNode(factory.createTupleTypeNode(parseBracketedList(21, parseTupleElementNameOrTupleElementType, 22, 23)), pos);
}
- if (buildOptions.watch && buildOptions.dry) {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "dry"));
+ function parseParenthesizedType() {
+ var pos = getNodePos();
+ parseExpected(20);
+ var type = parseType();
+ parseExpected(21);
+ return finishNode(factory.createParenthesizedType(type), pos);
}
- return { buildOptions: buildOptions, watchOptions: watchOptions, projects: projects, errors: errors };
- }
- ts.parseBuildCommand = parseBuildCommand;
- function getDiagnosticText(_message) {
- var _args = [];
- for (var _i = 1; _i < arguments.length; _i++) {
- _args[_i - 1] = arguments[_i];
+ function parseFunctionOrConstructorType() {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ var isConstructorType = parseOptional(102);
+ var typeParameters = parseTypeParameters();
+ var parameters = parseParameters(4);
+ var type = parseReturnType(38, false);
+ var node = isConstructorType
+ ? factory.createConstructorTypeNode(typeParameters, parameters, type)
+ : factory.createFunctionTypeNode(typeParameters, parameters, type);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- var diagnostic = ts.createCompilerDiagnostic.apply(undefined, arguments);
- return diagnostic.messageText;
- }
- ts.getDiagnosticText = getDiagnosticText;
- function getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend, extraFileExtensions) {
- var configFileText = tryReadFile(configFileName, function (fileName) { return host.readFile(fileName); });
- if (!ts.isString(configFileText)) {
- host.onUnRecoverableConfigFileDiagnostic(configFileText);
- return undefined;
+ function parseKeywordAndNoDot() {
+ var node = parseTokenNode();
+ return token() === 24 ? undefined : node;
}
- var result = ts.parseJsonText(configFileName, configFileText);
- var cwd = host.getCurrentDirectory();
- result.path = ts.toPath(configFileName, cwd, ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames));
- result.resolvedPath = result.path;
- result.originalFileName = result.fileName;
- return parseJsonSourceFileConfigFileContent(result, host, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), cwd), optionsToExtend, ts.getNormalizedAbsolutePath(configFileName, cwd), undefined, extraFileExtensions, extendedConfigCache, watchOptionsToExtend);
- }
- ts.getParsedCommandLineOfConfigFile = getParsedCommandLineOfConfigFile;
- function readConfigFile(fileName, readFile) {
- var textOrDiagnostic = tryReadFile(fileName, readFile);
- return ts.isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
- }
- ts.readConfigFile = readConfigFile;
- function parseConfigFileTextToJson(fileName, jsonText) {
- var jsonSourceFile = ts.parseJsonText(fileName, jsonText);
- return {
- config: convertToObject(jsonSourceFile, jsonSourceFile.parseDiagnostics),
- error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined
- };
- }
- ts.parseConfigFileTextToJson = parseConfigFileTextToJson;
- function readJsonConfigFile(fileName, readFile) {
- var textOrDiagnostic = tryReadFile(fileName, readFile);
- return ts.isString(textOrDiagnostic) ? ts.parseJsonText(fileName, textOrDiagnostic) : { parseDiagnostics: [textOrDiagnostic] };
- }
- ts.readJsonConfigFile = readJsonConfigFile;
- function tryReadFile(fileName, readFile) {
- var text;
- try {
- text = readFile(fileName);
+ function parseLiteralTypeNode(negative) {
+ var pos = getNodePos();
+ if (negative) {
+ nextToken();
+ }
+ var expression = token() === 109 || token() === 94 || token() === 103 ?
+ parseTokenNode() :
+ parseLiteralLikeNode(token());
+ if (negative) {
+ expression = finishNode(factory.createPrefixUnaryExpression(40, expression), pos);
+ }
+ return finishNode(factory.createLiteralTypeNode(expression), pos);
}
- catch (e) {
- return ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
+ function isStartOfTypeOfImportType() {
+ nextToken();
+ return token() === 99;
}
- return text === undefined ? ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0, fileName) : text;
- }
- ts.tryReadFile = tryReadFile;
- function commandLineOptionsToMap(options) {
- return ts.arrayToMap(options, getOptionName);
- }
- var typeAcquisitionDidYouMeanDiagnostics = {
- optionDeclarations: ts.typeAcquisitionDeclarations,
- unknownOptionDiagnostic: ts.Diagnostics.Unknown_type_acquisition_option_0,
- unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_type_acquisition_option_0_Did_you_mean_1,
- };
- var watchOptionsNameMapCache;
- function getWatchOptionsNameMap() {
- return watchOptionsNameMapCache || (watchOptionsNameMapCache = createOptionNameMap(ts.optionsForWatch));
- }
- var watchOptionsDidYouMeanDiagnostics = {
- getOptionsNameMap: getWatchOptionsNameMap,
- optionDeclarations: ts.optionsForWatch,
- unknownOptionDiagnostic: ts.Diagnostics.Unknown_watch_option_0,
- unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_watch_option_0_Did_you_mean_1,
- optionTypeMismatchDiagnostic: ts.Diagnostics.Watch_option_0_requires_a_value_of_type_1
- };
- var commandLineCompilerOptionsMapCache;
- function getCommandLineCompilerOptionsMap() {
- return commandLineCompilerOptionsMapCache || (commandLineCompilerOptionsMapCache = commandLineOptionsToMap(ts.optionDeclarations));
- }
- var commandLineWatchOptionsMapCache;
- function getCommandLineWatchOptionsMap() {
- return commandLineWatchOptionsMapCache || (commandLineWatchOptionsMapCache = commandLineOptionsToMap(ts.optionsForWatch));
- }
- var commandLineTypeAcquisitionMapCache;
- function getCommandLineTypeAcquisitionMap() {
- return commandLineTypeAcquisitionMapCache || (commandLineTypeAcquisitionMapCache = commandLineOptionsToMap(ts.typeAcquisitionDeclarations));
- }
- var _tsconfigRootOptions;
- function getTsconfigRootOptionsMap() {
- if (_tsconfigRootOptions === undefined) {
- _tsconfigRootOptions = {
- name: undefined,
- type: "object",
- elementOptions: commandLineOptionsToMap([
- {
- name: "compilerOptions",
- type: "object",
- elementOptions: getCommandLineCompilerOptionsMap(),
- extraKeyDiagnostics: ts.compilerOptionsDidYouMeanDiagnostics,
- },
- {
- name: "watchOptions",
- type: "object",
- elementOptions: getCommandLineWatchOptionsMap(),
- extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics,
- },
- {
- name: "typingOptions",
- type: "object",
- elementOptions: getCommandLineTypeAcquisitionMap(),
- extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics,
- },
- {
- name: "typeAcquisition",
- type: "object",
- elementOptions: getCommandLineTypeAcquisitionMap(),
- extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics
- },
- {
- name: "extends",
- type: "string"
- },
- {
- name: "references",
- type: "list",
- element: {
- name: "references",
- type: "object"
- }
- },
- {
- name: "files",
- type: "list",
- element: {
- name: "files",
- type: "string"
+ function parseImportType() {
+ sourceFlags |= 1048576;
+ var pos = getNodePos();
+ var isTypeOf = parseOptional(111);
+ parseExpected(99);
+ parseExpected(20);
+ var type = parseType();
+ parseExpected(21);
+ var qualifier = parseOptional(24) ? parseEntityNameOfTypeReference() : undefined;
+ var typeArguments = parseTypeArgumentsOfTypeReference();
+ return finishNode(factory.createImportTypeNode(type, qualifier, typeArguments, isTypeOf), pos);
+ }
+ function nextTokenIsNumericOrBigIntLiteral() {
+ nextToken();
+ return token() === 8 || token() === 9;
+ }
+ function parseNonArrayType() {
+ switch (token()) {
+ case 128:
+ case 152:
+ case 147:
+ case 144:
+ case 155:
+ case 148:
+ case 131:
+ case 150:
+ case 141:
+ case 145:
+ return tryParse(parseKeywordAndNoDot) || parseTypeReference();
+ case 65:
+ scanner.reScanAsteriskEqualsToken();
+ case 41:
+ return parseJSDocAllType();
+ case 60:
+ scanner.reScanQuestionToken();
+ case 57:
+ return parseJSDocUnknownOrNullableType();
+ case 97:
+ return parseJSDocFunctionType();
+ case 53:
+ return parseJSDocNonNullableType();
+ case 14:
+ case 10:
+ case 8:
+ case 9:
+ case 109:
+ case 94:
+ case 103:
+ return parseLiteralTypeNode();
+ case 40:
+ return lookAhead(nextTokenIsNumericOrBigIntLiteral) ? parseLiteralTypeNode(true) : parseTypeReference();
+ case 113:
+ return parseTokenNode();
+ case 107: {
+ var thisKeyword = parseThisTypeNode();
+ if (token() === 137 && !scanner.hasPrecedingLineBreak()) {
+ return parseThisTypePredicate(thisKeyword);
+ }
+ else {
+ return thisKeyword;
+ }
+ }
+ case 111:
+ return lookAhead(isStartOfTypeOfImportType) ? parseImportType() : parseTypeQuery();
+ case 18:
+ return lookAhead(isStartOfMappedType) ? parseMappedType() : parseTypeLiteral();
+ case 22:
+ return parseTupleType();
+ case 20:
+ return parseParenthesizedType();
+ case 99:
+ return parseImportType();
+ case 127:
+ return lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? parseAssertsTypePredicate() : parseTypeReference();
+ case 15:
+ return parseTemplateType();
+ default:
+ return parseTypeReference();
+ }
+ }
+ function isStartOfType(inStartOfParameter) {
+ switch (token()) {
+ case 128:
+ case 152:
+ case 147:
+ case 144:
+ case 155:
+ case 131:
+ case 142:
+ case 148:
+ case 151:
+ case 113:
+ case 150:
+ case 103:
+ case 107:
+ case 111:
+ case 141:
+ case 18:
+ case 22:
+ case 29:
+ case 51:
+ case 50:
+ case 102:
+ case 10:
+ case 8:
+ case 9:
+ case 109:
+ case 94:
+ case 145:
+ case 41:
+ case 57:
+ case 53:
+ case 25:
+ case 135:
+ case 99:
+ case 127:
+ case 14:
+ case 15:
+ return true;
+ case 97:
+ return !inStartOfParameter;
+ case 40:
+ return !inStartOfParameter && lookAhead(nextTokenIsNumericOrBigIntLiteral);
+ case 20:
+ return !inStartOfParameter && lookAhead(isStartOfParenthesizedOrFunctionType);
+ default:
+ return isIdentifier();
+ }
+ }
+ function isStartOfParenthesizedOrFunctionType() {
+ nextToken();
+ return token() === 21 || isStartOfParameter(false) || isStartOfType();
+ }
+ function parsePostfixTypeOrHigher() {
+ var pos = getNodePos();
+ var type = parseNonArrayType();
+ while (!scanner.hasPrecedingLineBreak()) {
+ switch (token()) {
+ case 53:
+ nextToken();
+ type = finishNode(factory.createJSDocNonNullableType(type), pos);
+ break;
+ case 57:
+ if (lookAhead(nextTokenIsStartOfType)) {
+ return type;
}
- },
- {
- name: "include",
- type: "list",
- element: {
- name: "include",
- type: "string"
+ nextToken();
+ type = finishNode(factory.createJSDocNullableType(type), pos);
+ break;
+ case 22:
+ parseExpected(22);
+ if (isStartOfType()) {
+ var indexType = parseType();
+ parseExpected(23);
+ type = finishNode(factory.createIndexedAccessTypeNode(type, indexType), pos);
}
- },
- {
- name: "exclude",
- type: "list",
- element: {
- name: "exclude",
- type: "string"
+ else {
+ parseExpected(23);
+ type = finishNode(factory.createArrayTypeNode(type), pos);
}
- },
- ts.compileOnSaveCommandLineOption
- ])
- };
+ break;
+ default:
+ return type;
+ }
+ }
+ return type;
}
- return _tsconfigRootOptions;
- }
- function convertToObject(sourceFile, errors) {
- return convertToObjectWorker(sourceFile, errors, true, undefined, undefined);
- }
- ts.convertToObject = convertToObject;
- function convertToObjectWorker(sourceFile, errors, returnValue, knownRootOptions, jsonConversionNotifier) {
- if (!sourceFile.statements.length) {
- return returnValue ? {} : undefined;
+ function parseTypeOperator(operator) {
+ var pos = getNodePos();
+ parseExpected(operator);
+ return finishNode(factory.createTypeOperatorNode(operator, parseTypeOperatorOrHigher()), pos);
}
- return convertPropertyValueToJson(sourceFile.statements[0].expression, knownRootOptions);
- function isRootOptionMap(knownOptions) {
- return knownRootOptions && knownRootOptions.elementOptions === knownOptions;
+ function parseTypeParameterOfInferType() {
+ var pos = getNodePos();
+ return finishNode(factory.createTypeParameterDeclaration(parseIdentifier(), undefined, undefined), pos);
}
- function convertObjectLiteralExpressionToJson(node, knownOptions, extraKeyDiagnostics, parentOption) {
- var result = returnValue ? {} : undefined;
- var _loop_3 = function (element) {
- if (element.kind !== 281) {
- errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element, ts.Diagnostics.Property_assignment_expected));
- return "continue";
+ function parseInferType() {
+ var pos = getNodePos();
+ parseExpected(135);
+ return finishNode(factory.createInferTypeNode(parseTypeParameterOfInferType()), pos);
+ }
+ function parseTypeOperatorOrHigher() {
+ var operator = token();
+ switch (operator) {
+ case 138:
+ case 151:
+ case 142:
+ return parseTypeOperator(operator);
+ case 135:
+ return parseInferType();
+ }
+ return parsePostfixTypeOrHigher();
+ }
+ function parseFunctionOrConstructorTypeToError(isInUnionType) {
+ if (isStartOfFunctionTypeOrConstructorType()) {
+ var type = parseFunctionOrConstructorType();
+ var diagnostic = void 0;
+ if (ts.isFunctionTypeNode(type)) {
+ diagnostic = isInUnionType
+ ? ts.Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_a_union_type
+ : ts.Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
}
- if (element.questionToken) {
- errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.questionToken, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?"));
+ else {
+ diagnostic = isInUnionType
+ ? ts.Diagnostics.Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type
+ : ts.Diagnostics.Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
}
- if (!isDoubleQuotedString(element.name)) {
- errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, ts.Diagnostics.String_literal_with_double_quotes_expected));
+ parseErrorAtRange(type, diagnostic);
+ return type;
+ }
+ return undefined;
+ }
+ function parseUnionOrIntersectionType(operator, parseConstituentType, createTypeNode) {
+ var pos = getNodePos();
+ var isUnionType = operator === 51;
+ var hasLeadingOperator = parseOptional(operator);
+ var type = hasLeadingOperator && parseFunctionOrConstructorTypeToError(isUnionType)
+ || parseConstituentType();
+ if (token() === operator || hasLeadingOperator) {
+ var types = [type];
+ while (parseOptional(operator)) {
+ types.push(parseFunctionOrConstructorTypeToError(isUnionType) || parseConstituentType());
}
- var textOfKey = ts.isComputedNonLiteralName(element.name) ? undefined : ts.getTextOfPropertyName(element.name);
- var keyText = textOfKey && ts.unescapeLeadingUnderscores(textOfKey);
- var option = keyText && knownOptions ? knownOptions.get(keyText) : undefined;
- if (keyText && extraKeyDiagnostics && !option) {
- if (knownOptions) {
- errors.push(createUnknownOptionError(keyText, extraKeyDiagnostics, function (message, arg0, arg1) { return ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, message, arg0, arg1); }));
- }
- else {
- errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, extraKeyDiagnostics.unknownOptionDiagnostic, keyText));
- }
+ type = finishNode(createTypeNode(createNodeArray(types, pos)), pos);
+ }
+ return type;
+ }
+ function parseIntersectionTypeOrHigher() {
+ return parseUnionOrIntersectionType(50, parseTypeOperatorOrHigher, factory.createIntersectionTypeNode);
+ }
+ function parseUnionTypeOrHigher() {
+ return parseUnionOrIntersectionType(51, parseIntersectionTypeOrHigher, factory.createUnionTypeNode);
+ }
+ function isStartOfFunctionTypeOrConstructorType() {
+ if (token() === 29) {
+ return true;
+ }
+ if (token() === 20 && lookAhead(isUnambiguouslyStartOfFunctionType)) {
+ return true;
+ }
+ return token() === 102;
+ }
+ function skipParameterStart() {
+ if (ts.isModifierKind(token())) {
+ parseModifiers();
+ }
+ if (isIdentifier() || token() === 107) {
+ nextToken();
+ return true;
+ }
+ if (token() === 22 || token() === 18) {
+ var previousErrorCount = parseDiagnostics.length;
+ parseIdentifierOrPattern();
+ return previousErrorCount === parseDiagnostics.length;
+ }
+ return false;
+ }
+ function isUnambiguouslyStartOfFunctionType() {
+ nextToken();
+ if (token() === 21 || token() === 25) {
+ return true;
+ }
+ if (skipParameterStart()) {
+ if (token() === 58 || token() === 27 ||
+ token() === 57 || token() === 62) {
+ return true;
}
- var value = convertPropertyValueToJson(element.initializer, option);
- if (typeof keyText !== "undefined") {
- if (returnValue) {
- result[keyText] = value;
- }
- if (jsonConversionNotifier &&
- (parentOption || isRootOptionMap(knownOptions))) {
- var 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);
- }
- }
+ if (token() === 21) {
+ nextToken();
+ if (token() === 38) {
+ return true;
}
}
- };
- for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
- var element = _a[_i];
- _loop_3(element);
}
- return result;
+ return false;
}
- function convertArrayLiteralExpressionToJson(elements, elementOption) {
- if (!returnValue) {
- return elements.forEach(function (element) { return convertPropertyValueToJson(element, elementOption); });
+ function parseTypeOrTypePredicate() {
+ var pos = getNodePos();
+ var typePredicateVariable = isIdentifier() && tryParse(parseTypePredicatePrefix);
+ var type = parseType();
+ if (typePredicateVariable) {
+ return finishNode(factory.createTypePredicateNode(undefined, typePredicateVariable, type), pos);
+ }
+ else {
+ return type;
}
- return ts.filter(elements.map(function (element) { return convertPropertyValueToJson(element, elementOption); }), function (v) { return v !== undefined; });
}
- function convertPropertyValueToJson(valueExpression, option) {
- switch (valueExpression.kind) {
- case 106:
- reportInvalidOptionValue(option && option.type !== "boolean");
- return true;
- case 91:
- reportInvalidOptionValue(option && option.type !== "boolean");
- return false;
- case 100:
- reportInvalidOptionValue(option && option.name === "extends");
- return null;
- case 10:
- if (!isDoubleQuotedString(valueExpression)) {
- errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.String_literal_with_double_quotes_expected));
- }
- reportInvalidOptionValue(option && (ts.isString(option.type) && option.type !== "string"));
- var text = valueExpression.text;
- if (option && !ts.isString(option.type)) {
- var customOption = option;
- if (!customOption.type.has(text.toLowerCase())) {
- errors.push(createDiagnosticForInvalidCustomType(customOption, function (message, arg0, arg1) { return ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, message, arg0, arg1); }));
- }
- }
- return text;
+ function parseTypePredicatePrefix() {
+ var id = parseIdentifier();
+ if (token() === 137 && !scanner.hasPrecedingLineBreak()) {
+ nextToken();
+ return id;
+ }
+ }
+ function parseAssertsTypePredicate() {
+ var pos = getNodePos();
+ var assertsModifier = parseExpectedToken(127);
+ var parameterName = token() === 107 ? parseThisTypeNode() : parseIdentifier();
+ var type = parseOptional(137) ? parseType() : undefined;
+ return finishNode(factory.createTypePredicateNode(assertsModifier, parameterName, type), pos);
+ }
+ function parseType() {
+ return doOutsideOfContext(40960, parseTypeWorker);
+ }
+ function parseTypeWorker(noConditionalTypes) {
+ if (isStartOfFunctionTypeOrConstructorType()) {
+ return parseFunctionOrConstructorType();
+ }
+ var pos = getNodePos();
+ var type = parseUnionTypeOrHigher();
+ if (!noConditionalTypes && !scanner.hasPrecedingLineBreak() && parseOptional(93)) {
+ var extendsType = parseTypeWorker(true);
+ parseExpected(57);
+ var trueType = parseTypeWorker();
+ parseExpected(58);
+ var falseType = parseTypeWorker();
+ return finishNode(factory.createConditionalTypeNode(type, extendsType, trueType, falseType), pos);
+ }
+ return type;
+ }
+ function parseTypeAnnotation() {
+ return parseOptional(58) ? parseType() : undefined;
+ }
+ function isStartOfLeftHandSideExpression() {
+ switch (token()) {
+ case 107:
+ case 105:
+ case 103:
+ case 109:
+ case 94:
case 8:
- reportInvalidOptionValue(option && option.type !== "number");
- return Number(valueExpression.text);
- case 207:
- if (valueExpression.operator !== 40 || valueExpression.operand.kind !== 8) {
- break;
- }
- reportInvalidOptionValue(option && option.type !== "number");
- return -Number(valueExpression.operand.text);
- case 193:
- reportInvalidOptionValue(option && option.type !== "object");
- var objectLiteralExpression = valueExpression;
- if (option) {
- var _a = option, elementOptions = _a.elementOptions, extraKeyDiagnostics = _a.extraKeyDiagnostics, optionName = _a.name;
- return convertObjectLiteralExpressionToJson(objectLiteralExpression, elementOptions, extraKeyDiagnostics, optionName);
- }
- else {
- return convertObjectLiteralExpressionToJson(objectLiteralExpression, undefined, undefined, undefined);
+ case 9:
+ case 10:
+ case 14:
+ case 15:
+ case 20:
+ case 22:
+ case 18:
+ case 97:
+ case 83:
+ case 102:
+ case 43:
+ case 67:
+ case 78:
+ return true;
+ case 99:
+ return lookAhead(nextTokenIsOpenParenOrLessThanOrDot);
+ default:
+ return isIdentifier();
+ }
+ }
+ function isStartOfExpression() {
+ if (isStartOfLeftHandSideExpression()) {
+ return true;
+ }
+ switch (token()) {
+ case 39:
+ case 40:
+ case 54:
+ case 53:
+ case 88:
+ case 111:
+ case 113:
+ case 45:
+ case 46:
+ case 29:
+ case 130:
+ case 124:
+ case 79:
+ return true;
+ default:
+ if (isBinaryOperator()) {
+ return true;
}
- case 192:
- reportInvalidOptionValue(option && option.type !== "list");
- return convertArrayLiteralExpressionToJson(valueExpression.elements, option && option.element);
+ return isIdentifier();
}
- if (option) {
- reportInvalidOptionValue(true);
+ }
+ function isStartOfExpressionStatement() {
+ return token() !== 18 &&
+ token() !== 97 &&
+ token() !== 83 &&
+ token() !== 59 &&
+ isStartOfExpression();
+ }
+ function parseExpression() {
+ var saveDecoratorContext = inDecoratorContext();
+ if (saveDecoratorContext) {
+ setDecoratorContext(false);
}
- else {
- errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal));
+ var pos = getNodePos();
+ var expr = parseAssignmentExpressionOrHigher();
+ var operatorToken;
+ while ((operatorToken = parseOptionalToken(27))) {
+ expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(), pos);
}
- return undefined;
- function reportInvalidOptionValue(isError) {
- if (isError) {
- errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option)));
- }
+ if (saveDecoratorContext) {
+ setDecoratorContext(true);
}
+ return expr;
}
- function isDoubleQuotedString(node) {
- return ts.isStringLiteral(node) && ts.isStringDoubleQuoted(node, sourceFile);
+ function parseInitializer() {
+ return parseOptional(62) ? parseAssignmentExpressionOrHigher() : undefined;
}
- }
- ts.convertToObjectWorker = convertToObjectWorker;
- function getCompilerOptionValueTypeString(option) {
- return option.type === "list" ?
- "Array" :
- ts.isString(option.type) ? option.type : "string";
- }
- function isCompilerOptionsValue(option, value) {
- if (option) {
- if (isNullOrUndefined(value))
- return true;
- if (option.type === "list") {
- return ts.isArray(value);
+ function parseAssignmentExpressionOrHigher() {
+ if (isYieldExpression()) {
+ return parseYieldExpression();
}
- var expectedType = ts.isString(option.type) ? option.type : "string";
- return typeof value === expectedType;
+ var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
+ if (arrowExpression) {
+ return arrowExpression;
+ }
+ var pos = getNodePos();
+ var expr = parseBinaryExpressionOrHigher(0);
+ if (expr.kind === 78 && token() === 38) {
+ return parseSimpleArrowFunctionExpression(pos, expr, undefined);
+ }
+ if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
+ return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(), pos);
+ }
+ return parseConditionalExpressionRest(expr, pos);
}
- return false;
- }
- function convertToTSConfig(configParseResult, configFileName, host) {
- var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames);
- var files = ts.map(ts.filter(configParseResult.fileNames, (!configParseResult.configFileSpecs || !configParseResult.configFileSpecs.validatedIncludeSpecs) ? function (_) { return true; } : matchesSpecs(configFileName, configParseResult.configFileSpecs.validatedIncludeSpecs, configParseResult.configFileSpecs.validatedExcludeSpecs, host)), function (f) { return ts.getRelativePathFromFile(ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), ts.getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName); });
- var optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames });
- var watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
- var config = __assign(__assign({ compilerOptions: __assign(__assign({}, optionMapToObject(optionMap)), { showConfig: undefined, configFile: undefined, configFilePath: undefined, help: undefined, init: undefined, listFiles: undefined, listEmittedFiles: undefined, project: undefined, build: undefined, version: undefined }), watchOptions: watchOptionMap && optionMapToObject(watchOptionMap), references: ts.map(configParseResult.projectReferences, function (r) { return (__assign(__assign({}, r), { path: r.originalPath ? r.originalPath : "", originalPath: undefined })); }), files: ts.length(files) ? files : undefined }, (configParseResult.configFileSpecs ? {
- include: filterSameAsDefaultInclude(configParseResult.configFileSpecs.validatedIncludeSpecs),
- exclude: configParseResult.configFileSpecs.validatedExcludeSpecs
- } : {})), { compileOnSave: !!configParseResult.compileOnSave ? true : undefined });
- return config;
- }
- ts.convertToTSConfig = convertToTSConfig;
- function optionMapToObject(optionMap) {
- return __assign({}, ts.arrayFrom(optionMap.entries()).reduce(function (prev, cur) {
- var _a;
- return (__assign(__assign({}, prev), (_a = {}, _a[cur[0]] = cur[1], _a)));
- }, {}));
- }
- function filterSameAsDefaultInclude(specs) {
- if (!ts.length(specs))
- return undefined;
- if (ts.length(specs) !== 1)
- return specs;
- if (specs[0] === "**/*")
- return undefined;
- return specs;
- }
- function matchesSpecs(path, includeSpecs, excludeSpecs, host) {
- if (!includeSpecs)
- return function (_) { return true; };
- var patterns = ts.getFileMatcherPatterns(path, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
- var excludeRe = patterns.excludePattern && ts.getRegexFromPattern(patterns.excludePattern, host.useCaseSensitiveFileNames);
- var includeRe = patterns.includeFilePattern && ts.getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames);
- if (includeRe) {
- if (excludeRe) {
- return function (path) { return !(includeRe.test(path) && !excludeRe.test(path)); };
+ function isYieldExpression() {
+ if (token() === 124) {
+ if (inYieldContext()) {
+ return true;
+ }
+ return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine);
}
- return function (path) { return !includeRe.test(path); };
+ return false;
}
- if (excludeRe) {
- return function (path) { return excludeRe.test(path); };
+ function nextTokenIsIdentifierOnSameLine() {
+ nextToken();
+ return !scanner.hasPrecedingLineBreak() && isIdentifier();
}
- return function (_) { return true; };
- }
- function getCustomTypeMapOfCommandLineOption(optionDefinition) {
- if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean" || optionDefinition.type === "object") {
- return undefined;
+ function parseYieldExpression() {
+ var pos = getNodePos();
+ nextToken();
+ if (!scanner.hasPrecedingLineBreak() &&
+ (token() === 41 || isStartOfExpression())) {
+ return finishNode(factory.createYieldExpression(parseOptionalToken(41), parseAssignmentExpressionOrHigher()), pos);
+ }
+ else {
+ return finishNode(factory.createYieldExpression(undefined, undefined), pos);
+ }
}
- else if (optionDefinition.type === "list") {
- return getCustomTypeMapOfCommandLineOption(optionDefinition.element);
+ function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier) {
+ ts.Debug.assert(token() === 38, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
+ var parameter = factory.createParameterDeclaration(undefined, undefined, undefined, identifier, undefined, undefined, undefined);
+ finishNode(parameter, identifier.pos);
+ var parameters = createNodeArray([parameter], parameter.pos, parameter.end);
+ var equalsGreaterThanToken = parseExpectedToken(38);
+ var body = parseArrowFunctionExpressionBody(!!asyncModifier);
+ var node = factory.createArrowFunction(asyncModifier, undefined, parameters, undefined, equalsGreaterThanToken, body);
+ return addJSDocComment(finishNode(node, pos));
}
- else {
- return optionDefinition.type;
+ function tryParseParenthesizedArrowFunctionExpression() {
+ var triState = isParenthesizedArrowFunctionExpression();
+ if (triState === 0) {
+ return undefined;
+ }
+ return triState === 1 ?
+ parseParenthesizedArrowFunctionExpression(true) :
+ tryParse(parsePossibleParenthesizedArrowFunctionExpression);
}
- }
- function getNameOfCompilerOptionValue(value, customTypeMap) {
- return ts.forEachEntry(customTypeMap, function (mapValue, key) {
- if (mapValue === value) {
- return key;
+ function isParenthesizedArrowFunctionExpression() {
+ if (token() === 20 || token() === 29 || token() === 129) {
+ return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
}
- });
- }
- function serializeCompilerOptions(options, pathOptions) {
- return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
- }
- function serializeWatchOptions(options) {
- return serializeOptionBaseObject(options, getWatchOptionsNameMap());
- }
- function serializeOptionBaseObject(options, _a, pathOptions) {
- var optionsNameMap = _a.optionsNameMap;
- var result = ts.createMap();
- var getCanonicalFileName = pathOptions && ts.createGetCanonicalFileName(pathOptions.useCaseSensitiveFileNames);
- var _loop_4 = function (name) {
- if (ts.hasProperty(options, name)) {
- if (optionsNameMap.has(name) && optionsNameMap.get(name).category === ts.Diagnostics.Command_line_Options) {
- return "continue";
+ if (token() === 38) {
+ return 1;
+ }
+ return 0;
+ }
+ function isParenthesizedArrowFunctionExpressionWorker() {
+ if (token() === 129) {
+ nextToken();
+ if (scanner.hasPrecedingLineBreak()) {
+ return 0;
}
- var value = options[name];
- var optionDefinition = optionsNameMap.get(name.toLowerCase());
- if (optionDefinition) {
- var customTypeMap_1 = getCustomTypeMapOfCommandLineOption(optionDefinition);
- if (!customTypeMap_1) {
- if (pathOptions && optionDefinition.isFilePath) {
- result.set(name, ts.getRelativePathFromFile(pathOptions.configFilePath, ts.getNormalizedAbsolutePath(value, ts.getDirectoryPath(pathOptions.configFilePath)), getCanonicalFileName));
- }
- else {
- result.set(name, value);
- }
+ if (token() !== 20 && token() !== 29) {
+ return 0;
+ }
+ }
+ var first = token();
+ var second = nextToken();
+ if (first === 20) {
+ if (second === 21) {
+ var third = nextToken();
+ switch (third) {
+ case 38:
+ case 58:
+ case 18:
+ return 1;
+ default:
+ return 0;
}
- else {
- if (optionDefinition.type === "list") {
- result.set(name, value.map(function (element) { return getNameOfCompilerOptionValue(element, customTypeMap_1); }));
+ }
+ if (second === 22 || second === 18) {
+ return 2;
+ }
+ if (second === 25) {
+ return 1;
+ }
+ if (ts.isModifierKind(second) && second !== 129 && lookAhead(nextTokenIsIdentifier)) {
+ return 1;
+ }
+ if (!isIdentifier() && second !== 107) {
+ return 0;
+ }
+ switch (nextToken()) {
+ case 58:
+ return 1;
+ case 57:
+ nextToken();
+ if (token() === 58 || token() === 27 || token() === 62 || token() === 21) {
+ return 1;
}
- else {
- result.set(name, getNameOfCompilerOptionValue(value, customTypeMap_1));
+ return 0;
+ case 27:
+ case 62:
+ case 21:
+ return 2;
+ }
+ return 0;
+ }
+ else {
+ ts.Debug.assert(first === 29);
+ if (!isIdentifier()) {
+ return 0;
+ }
+ if (languageVariant === 1) {
+ var isArrowFunctionInJsx = lookAhead(function () {
+ var third = nextToken();
+ if (third === 93) {
+ var fourth = nextToken();
+ switch (fourth) {
+ case 62:
+ case 31:
+ return false;
+ default:
+ return true;
+ }
+ }
+ else if (third === 27) {
+ return true;
}
+ return false;
+ });
+ if (isArrowFunctionInJsx) {
+ return 1;
}
+ return 0;
+ }
+ return 2;
+ }
+ }
+ function parsePossibleParenthesizedArrowFunctionExpression() {
+ var tokenPos = scanner.getTokenPos();
+ if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) {
+ return undefined;
+ }
+ var result = parseParenthesizedArrowFunctionExpression(false);
+ if (!result) {
+ (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos);
+ }
+ return result;
+ }
+ function tryParseAsyncSimpleArrowFunctionExpression() {
+ if (token() === 129) {
+ if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1) {
+ var pos = getNodePos();
+ var asyncModifier = parseModifiersForArrowFunction();
+ var expr = parseBinaryExpressionOrHigher(0);
+ return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier);
}
}
- };
- for (var name in options) {
- _loop_4(name);
+ return undefined;
}
- return result;
- }
- function generateTSConfig(options, fileNames, newLine) {
- var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions);
- var compilerOptionsMap = serializeCompilerOptions(compilerOptions);
- return writeConfigurations();
- function getDefaultValueForOption(option) {
- switch (option.type) {
- case "number":
+ function isUnParenthesizedAsyncArrowFunctionWorker() {
+ if (token() === 129) {
+ nextToken();
+ if (scanner.hasPrecedingLineBreak() || token() === 38) {
+ return 0;
+ }
+ var expr = parseBinaryExpressionOrHigher(0);
+ if (!scanner.hasPrecedingLineBreak() && expr.kind === 78 && token() === 38) {
return 1;
- case "boolean":
- return true;
- case "string":
- return option.isFilePath ? "./" : "";
- case "list":
- return [];
- case "object":
- return {};
- default:
- var iterResult = option.type.keys().next();
- if (!iterResult.done)
- return iterResult.value;
- return ts.Debug.fail("Expected 'option.type' to have entries.");
+ }
}
+ return 0;
}
- function makePadding(paddingLength) {
- return Array(paddingLength + 1).join(" ");
+ function parseParenthesizedArrowFunctionExpression(allowAmbiguity) {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ var modifiers = parseModifiersForArrowFunction();
+ var isAsync = ts.some(modifiers, ts.isAsyncModifier) ? 2 : 0;
+ var typeParameters = parseTypeParameters();
+ var parameters;
+ if (!parseExpected(20)) {
+ if (!allowAmbiguity) {
+ return undefined;
+ }
+ parameters = createMissingList();
+ }
+ else {
+ parameters = parseParametersWorker(isAsync);
+ if (!parseExpected(21) && !allowAmbiguity) {
+ return undefined;
+ }
+ }
+ var type = parseReturnType(58, false);
+ if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
+ return undefined;
+ }
+ var hasJSDocFunctionType = type && ts.isJSDocFunctionType(type);
+ if (!allowAmbiguity && token() !== 38 && (hasJSDocFunctionType || token() !== 18)) {
+ return undefined;
+ }
+ var lastToken = token();
+ var equalsGreaterThanToken = parseExpectedToken(38);
+ var body = (lastToken === 38 || lastToken === 18)
+ ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier))
+ : parseIdentifier();
+ var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- function isAllowedOption(_a) {
- var category = _a.category, name = _a.name;
- return category !== undefined
- && category !== ts.Diagnostics.Command_line_Options
- && (category !== ts.Diagnostics.Advanced_Options || compilerOptionsMap.has(name));
+ function parseArrowFunctionExpressionBody(isAsync) {
+ if (token() === 18) {
+ return parseFunctionBlock(isAsync ? 2 : 0);
+ }
+ if (token() !== 26 &&
+ token() !== 97 &&
+ token() !== 83 &&
+ isStartOfStatement() &&
+ !isStartOfExpressionStatement()) {
+ return parseFunctionBlock(16 | (isAsync ? 2 : 0));
+ }
+ var savedTopLevel = topLevel;
+ topLevel = false;
+ var node = isAsync
+ ? doInAwaitContext(parseAssignmentExpressionOrHigher)
+ : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
+ topLevel = savedTopLevel;
+ return node;
}
- function writeConfigurations() {
- var categorizedOptions = ts.createMultiMap();
- for (var _i = 0, optionDeclarations_1 = ts.optionDeclarations; _i < optionDeclarations_1.length; _i++) {
- var option = optionDeclarations_1[_i];
- var category = option.category;
- if (isAllowedOption(option)) {
- categorizedOptions.add(ts.getLocaleSpecificMessage(category), option);
- }
+ function parseConditionalExpressionRest(leftOperand, pos) {
+ var questionToken = parseOptionalToken(57);
+ if (!questionToken) {
+ return leftOperand;
}
- var marginLength = 0;
- var seenKnownKeys = 0;
- var entries = [];
- categorizedOptions.forEach(function (options, category) {
- if (entries.length !== 0) {
- entries.push({ value: "" });
+ var colonToken;
+ return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher), colonToken = parseExpectedToken(58), ts.nodeIsPresent(colonToken)
+ ? parseAssignmentExpressionOrHigher()
+ : createMissingNode(78, false, ts.Diagnostics._0_expected, ts.tokenToString(58))), pos);
+ }
+ function parseBinaryExpressionOrHigher(precedence) {
+ var pos = getNodePos();
+ var leftOperand = parseUnaryExpressionOrHigher();
+ return parseBinaryExpressionRest(precedence, leftOperand, pos);
+ }
+ function isInOrOfKeyword(t) {
+ return t === 100 || t === 156;
+ }
+ function parseBinaryExpressionRest(precedence, leftOperand, pos) {
+ while (true) {
+ reScanGreaterToken();
+ var newPrecedence = ts.getBinaryOperatorPrecedence(token());
+ var consumeCurrentOperator = token() === 42 ?
+ newPrecedence >= precedence :
+ newPrecedence > precedence;
+ if (!consumeCurrentOperator) {
+ break;
}
- entries.push({ value: "/* " + category + " */" });
- for (var _i = 0, options_1 = options; _i < options_1.length; _i++) {
- var option = options_1[_i];
- var optionName = void 0;
- if (compilerOptionsMap.has(option.name)) {
- optionName = "\"" + option.name + "\": " + JSON.stringify(compilerOptionsMap.get(option.name)) + ((seenKnownKeys += 1) === compilerOptionsMap.size ? "" : ",");
+ if (token() === 100 && inDisallowInContext()) {
+ break;
+ }
+ if (token() === 126) {
+ if (scanner.hasPrecedingLineBreak()) {
+ break;
}
else {
- optionName = "// \"" + option.name + "\": " + JSON.stringify(getDefaultValueForOption(option)) + ",";
+ nextToken();
+ leftOperand = makeAsExpression(leftOperand, parseType());
}
- entries.push({
- value: optionName,
- description: "/* " + (option.description && ts.getLocaleSpecificMessage(option.description) || option.name) + " */"
- });
- marginLength = Math.max(optionName.length, marginLength);
}
- });
- var tab = makePadding(2);
- var result = [];
- result.push("{");
- result.push(tab + "\"compilerOptions\": {");
- result.push("" + tab + tab + "/* " + ts.getLocaleSpecificMessage(ts.Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_json_to_read_more_about_this_file) + " */");
- result.push("");
- for (var _a = 0, entries_3 = entries; _a < entries_3.length; _a++) {
- var entry = entries_3[_a];
- var value = entry.value, _b = entry.description, description = _b === void 0 ? "" : _b;
- result.push(value && "" + tab + tab + value + (description && (makePadding(marginLength - value.length + 2) + description)));
- }
- if (fileNames.length) {
- result.push(tab + "},");
- result.push(tab + "\"files\": [");
- for (var i = 0; i < fileNames.length; i++) {
- result.push("" + tab + tab + JSON.stringify(fileNames[i]) + (i === fileNames.length - 1 ? "" : ","));
+ else {
+ leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence), pos);
}
- result.push(tab + "]");
- }
- else {
- result.push(tab + "}");
}
- result.push("}");
- return result.join(newLine) + newLine;
+ return leftOperand;
}
- }
- ts.generateTSConfig = generateTSConfig;
- function convertToOptionsWithAbsolutePaths(options, toAbsolutePath) {
- var result = {};
- var optionsNameMap = getOptionsNameMap().optionsNameMap;
- for (var name in options) {
- if (ts.hasProperty(options, name)) {
- result[name] = convertToOptionValueWithAbsolutePaths(optionsNameMap.get(name.toLowerCase()), options[name], toAbsolutePath);
+ function isBinaryOperator() {
+ if (inDisallowInContext() && token() === 100) {
+ return false;
}
+ return ts.getBinaryOperatorPrecedence(token()) > 0;
}
- if (result.configFilePath) {
- result.configFilePath = toAbsolutePath(result.configFilePath);
+ function makeBinaryExpression(left, operatorToken, right, pos) {
+ return finishNode(factory.createBinaryExpression(left, operatorToken, right), pos);
}
- return result;
- }
- ts.convertToOptionsWithAbsolutePaths = convertToOptionsWithAbsolutePaths;
- function convertToOptionValueWithAbsolutePaths(option, value, toAbsolutePath) {
- if (option && !isNullOrUndefined(value)) {
- if (option.type === "list") {
- var values = value;
- if (option.element.isFilePath && values.length) {
- return values.map(toAbsolutePath);
+ function makeAsExpression(left, right) {
+ return finishNode(factory.createAsExpression(left, right), left.pos);
+ }
+ function parsePrefixUnaryExpression() {
+ var pos = getNodePos();
+ return finishNode(factory.createPrefixUnaryExpression(token(), nextTokenAnd(parseSimpleUnaryExpression)), pos);
+ }
+ function parseDeleteExpression() {
+ var pos = getNodePos();
+ return finishNode(factory.createDeleteExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
+ }
+ function parseTypeOfExpression() {
+ var pos = getNodePos();
+ return finishNode(factory.createTypeOfExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
+ }
+ function parseVoidExpression() {
+ var pos = getNodePos();
+ return finishNode(factory.createVoidExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
+ }
+ function isAwaitExpression() {
+ if (token() === 130) {
+ if (inAwaitContext()) {
+ return true;
}
+ return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine);
}
- else if (option.isFilePath) {
- return toAbsolutePath(value);
- }
+ return false;
}
- return value;
- }
- function parseJsonConfigFileContent(json, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) {
- return parseJsonConfigFileContentWorker(json, undefined, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
- }
- ts.parseJsonConfigFileContent = parseJsonConfigFileContent;
- function parseJsonSourceFileConfigFileContent(sourceFile, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) {
- return parseJsonConfigFileContentWorker(undefined, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
- }
- ts.parseJsonSourceFileConfigFileContent = parseJsonSourceFileConfigFileContent;
- function setConfigFileInOptions(options, configFile) {
- if (configFile) {
- Object.defineProperty(options, "configFile", { enumerable: false, writable: false, value: configFile });
+ function parseAwaitExpression() {
+ var pos = getNodePos();
+ return finishNode(factory.createAwaitExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
}
- }
- ts.setConfigFileInOptions = setConfigFileInOptions;
- function isNullOrUndefined(x) {
- return x === undefined || x === null;
- }
- function directoryOfCombinedPath(fileName, basePath) {
- return ts.getDirectoryPath(ts.getNormalizedAbsolutePath(fileName, basePath));
- }
- function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache) {
- if (existingOptions === void 0) { existingOptions = {}; }
- if (resolutionStack === void 0) { resolutionStack = []; }
- if (extraFileExtensions === void 0) { extraFileExtensions = []; }
- ts.Debug.assert((json === undefined && sourceFile !== undefined) || (json !== undefined && sourceFile === undefined));
- var errors = [];
- var parsedConfig = parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache);
- var raw = parsedConfig.raw;
- var options = ts.extend(existingOptions, parsedConfig.options || {});
- var watchOptions = existingWatchOptions && parsedConfig.watchOptions ?
- ts.extend(existingWatchOptions, parsedConfig.watchOptions) :
- parsedConfig.watchOptions || existingWatchOptions;
- options.configFilePath = configFileName && ts.normalizeSlashes(configFileName);
- setConfigFileInOptions(options, sourceFile);
- var projectReferences;
- var _a = getFileNames(), fileNames = _a.fileNames, wildcardDirectories = _a.wildcardDirectories, spec = _a.spec;
- return {
- options: options,
- watchOptions: watchOptions,
- fileNames: fileNames,
- projectReferences: projectReferences,
- typeAcquisition: parsedConfig.typeAcquisition || getDefaultTypeAcquisition(),
- raw: raw,
- errors: errors,
- wildcardDirectories: wildcardDirectories,
- compileOnSave: !!raw.compileOnSave,
- configFileSpecs: spec
- };
- function getFileNames() {
- var filesSpecs;
- if (ts.hasProperty(raw, "files") && !isNullOrUndefined(raw.files)) {
- if (ts.isArray(raw.files)) {
- filesSpecs = raw.files;
- var hasReferences = ts.hasProperty(raw, "references") && !isNullOrUndefined(raw.references);
- var hasZeroOrNoReferences = !hasReferences || raw.references.length === 0;
- var hasExtends = ts.hasProperty(raw, "extends");
- if (filesSpecs.length === 0 && hasZeroOrNoReferences && !hasExtends) {
- if (sourceFile) {
- var fileName = configFileName || "tsconfig.json";
- var diagnosticMessage = ts.Diagnostics.The_files_list_in_config_file_0_is_empty;
- var nodeValue = ts.firstDefined(ts.getTsConfigPropArray(sourceFile, "files"), function (property) { return property.initializer; });
- var error = nodeValue
- ? ts.createDiagnosticForNodeInSourceFile(sourceFile, nodeValue, diagnosticMessage, fileName)
- : ts.createCompilerDiagnostic(diagnosticMessage, fileName);
- errors.push(error);
- }
- else {
- createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.The_files_list_in_config_file_0_is_empty, configFileName || "tsconfig.json");
- }
- }
+ function parseUnaryExpressionOrHigher() {
+ if (isUpdateExpression()) {
+ var pos = getNodePos();
+ var updateExpression = parseUpdateExpression();
+ return token() === 42 ?
+ parseBinaryExpressionRest(ts.getBinaryOperatorPrecedence(token()), updateExpression, pos) :
+ updateExpression;
+ }
+ var unaryOperator = token();
+ var simpleUnaryExpression = parseSimpleUnaryExpression();
+ if (token() === 42) {
+ var pos = ts.skipTrivia(sourceText, simpleUnaryExpression.pos);
+ var end = simpleUnaryExpression.end;
+ if (simpleUnaryExpression.kind === 206) {
+ parseErrorAt(pos, end, ts.Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
}
else {
- createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "files", "Array");
+ parseErrorAt(pos, end, ts.Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, ts.tokenToString(unaryOperator));
}
}
- var includeSpecs;
- if (ts.hasProperty(raw, "include") && !isNullOrUndefined(raw.include)) {
- if (ts.isArray(raw.include)) {
- includeSpecs = raw.include;
+ return simpleUnaryExpression;
+ }
+ function parseSimpleUnaryExpression() {
+ switch (token()) {
+ case 39:
+ case 40:
+ case 54:
+ case 53:
+ return parsePrefixUnaryExpression();
+ case 88:
+ return parseDeleteExpression();
+ case 111:
+ return parseTypeOfExpression();
+ case 113:
+ return parseVoidExpression();
+ case 29:
+ return parseTypeAssertion();
+ case 130:
+ if (isAwaitExpression()) {
+ return parseAwaitExpression();
+ }
+ default:
+ return parseUpdateExpression();
+ }
+ }
+ function isUpdateExpression() {
+ switch (token()) {
+ case 39:
+ case 40:
+ case 54:
+ case 53:
+ case 88:
+ case 111:
+ case 113:
+ case 130:
+ return false;
+ case 29:
+ if (languageVariant !== 1) {
+ return false;
+ }
+ default:
+ return true;
+ }
+ }
+ function parseUpdateExpression() {
+ if (token() === 45 || token() === 46) {
+ var pos = getNodePos();
+ return finishNode(factory.createPrefixUnaryExpression(token(), nextTokenAnd(parseLeftHandSideExpressionOrHigher)), pos);
+ }
+ else if (languageVariant === 1 && token() === 29 && lookAhead(nextTokenIsIdentifierOrKeywordOrGreaterThan)) {
+ return parseJsxElementOrSelfClosingElementOrFragment(true);
+ }
+ var expression = parseLeftHandSideExpressionOrHigher();
+ ts.Debug.assert(ts.isLeftHandSideExpression(expression));
+ if ((token() === 45 || token() === 46) && !scanner.hasPrecedingLineBreak()) {
+ var operator = token();
+ nextToken();
+ return finishNode(factory.createPostfixUnaryExpression(expression, operator), expression.pos);
+ }
+ return expression;
+ }
+ function parseLeftHandSideExpressionOrHigher() {
+ var pos = getNodePos();
+ var expression;
+ if (token() === 99) {
+ if (lookAhead(nextTokenIsOpenParenOrLessThan)) {
+ sourceFlags |= 1048576;
+ expression = parseTokenNode();
+ }
+ else if (lookAhead(nextTokenIsDot)) {
+ nextToken();
+ nextToken();
+ expression = finishNode(factory.createMetaProperty(99, parseIdentifierName()), pos);
+ sourceFlags |= 2097152;
}
else {
- createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "include", "Array");
+ expression = parseMemberExpressionOrHigher();
}
}
- var excludeSpecs;
- if (ts.hasProperty(raw, "exclude") && !isNullOrUndefined(raw.exclude)) {
- if (ts.isArray(raw.exclude)) {
- excludeSpecs = raw.exclude;
- }
- else {
- createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "exclude", "Array");
+ else {
+ expression = token() === 105 ? parseSuperExpression() : parseMemberExpressionOrHigher();
+ }
+ return parseCallExpressionRest(pos, expression);
+ }
+ function parseMemberExpressionOrHigher() {
+ var pos = getNodePos();
+ var expression = parsePrimaryExpression();
+ return parseMemberExpressionRest(pos, expression, true);
+ }
+ function parseSuperExpression() {
+ var pos = getNodePos();
+ var expression = parseTokenNode();
+ if (token() === 29) {
+ var startPos = getNodePos();
+ var typeArguments = tryParse(parseTypeArgumentsInExpression);
+ if (typeArguments !== undefined) {
+ parseErrorAt(startPos, getNodePos(), ts.Diagnostics.super_may_not_use_type_arguments);
}
}
- else if (raw.compilerOptions) {
- var outDir = raw.compilerOptions.outDir;
- var declarationDir = raw.compilerOptions.declarationDir;
- if (outDir || declarationDir) {
- excludeSpecs = [outDir, declarationDir].filter(function (d) { return !!d; });
+ if (token() === 20 || token() === 24 || token() === 22) {
+ return expression;
+ }
+ parseExpectedToken(24, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
+ return finishNode(factory.createPropertyAccessExpression(expression, parseRightSideOfDot(true, true)), pos);
+ }
+ function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext, topInvalidNodePosition) {
+ var pos = getNodePos();
+ var opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext);
+ var result;
+ if (opening.kind === 275) {
+ var children = parseJsxChildren(opening);
+ var closingElement = parseJsxClosingElement(inExpressionContext);
+ if (!tagNamesAreEquivalent(opening.tagName, closingElement.tagName)) {
+ parseErrorAtRange(closingElement, ts.Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, ts.getTextOfNodeFromSourceText(sourceText, opening.tagName));
}
+ result = finishNode(factory.createJsxElement(opening, children, closingElement), pos);
}
- if (filesSpecs === undefined && includeSpecs === undefined) {
- includeSpecs = ["**/*"];
+ else if (opening.kind === 278) {
+ result = finishNode(factory.createJsxFragment(opening, parseJsxChildren(opening), parseJsxClosingFragment(inExpressionContext)), pos);
}
- var result = matchFileNames(filesSpecs, includeSpecs, excludeSpecs, configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath, options, host, errors, extraFileExtensions, sourceFile);
- if (shouldReportNoInputFiles(result, canJsonReportNoInutFiles(raw), resolutionStack)) {
- errors.push(getErrorForNoInputFiles(result.spec, configFileName));
+ else {
+ ts.Debug.assert(opening.kind === 274);
+ result = opening;
}
- if (ts.hasProperty(raw, "references") && !isNullOrUndefined(raw.references)) {
- if (ts.isArray(raw.references)) {
- for (var _i = 0, _a = raw.references; _i < _a.length; _i++) {
- var ref = _a[_i];
- if (typeof ref.path !== "string") {
- createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string");
- }
- else {
- (projectReferences || (projectReferences = [])).push({
- path: ts.getNormalizedAbsolutePath(ref.path, basePath),
- originalPath: ref.path,
- prepend: ref.prepend,
- circular: ref.circular
- });
- }
- }
- }
- else {
- createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "references", "Array");
+ if (inExpressionContext && token() === 29) {
+ var topBadPos_1 = typeof topInvalidNodePosition === "undefined" ? result.pos : topInvalidNodePosition;
+ var invalidElement = tryParse(function () { return parseJsxElementOrSelfClosingElementOrFragment(true, topBadPos_1); });
+ if (invalidElement) {
+ var operatorToken = createMissingNode(27, false);
+ ts.setTextRangePosWidth(operatorToken, invalidElement.pos, 0);
+ parseErrorAt(ts.skipTrivia(sourceText, topBadPos_1), invalidElement.end, ts.Diagnostics.JSX_expressions_must_have_one_parent_element);
+ return finishNode(factory.createBinaryExpression(result, operatorToken, invalidElement), pos);
}
}
return result;
}
- function createCompilerDiagnosticOnlyIfJson(message, arg0, arg1) {
- if (!sourceFile) {
- errors.push(ts.createCompilerDiagnostic(message, arg0, arg1));
+ function parseJsxText() {
+ var pos = getNodePos();
+ var node = factory.createJsxText(scanner.getTokenValue(), currentToken === 12);
+ currentToken = scanner.scanJsxToken();
+ return finishNode(node, pos);
+ }
+ function parseJsxChild(openingTag, token) {
+ switch (token) {
+ case 1:
+ if (ts.isJsxOpeningFragment(openingTag)) {
+ parseErrorAtRange(openingTag, ts.Diagnostics.JSX_fragment_has_no_corresponding_closing_tag);
+ }
+ else {
+ var tag = openingTag.tagName;
+ var start = ts.skipTrivia(sourceText, tag.pos);
+ parseErrorAt(start, tag.end, ts.Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, ts.getTextOfNodeFromSourceText(sourceText, openingTag.tagName));
+ }
+ return undefined;
+ case 30:
+ case 7:
+ return undefined;
+ case 11:
+ case 12:
+ return parseJsxText();
+ case 18:
+ return parseJsxExpression(false);
+ case 29:
+ return parseJsxElementOrSelfClosingElementOrFragment(false);
+ default:
+ return ts.Debug.assertNever(token);
}
}
- }
- function isErrorNoInputFiles(error) {
- return error.code === ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2.code;
- }
- function getErrorForNoInputFiles(_a, configFileName) {
- var includeSpecs = _a.includeSpecs, excludeSpecs = _a.excludeSpecs;
- return ts.createCompilerDiagnostic(ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2, configFileName || "tsconfig.json", JSON.stringify(includeSpecs || []), JSON.stringify(excludeSpecs || []));
- }
- function shouldReportNoInputFiles(result, canJsonReportNoInutFiles, resolutionStack) {
- return result.fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0);
- }
- function canJsonReportNoInutFiles(raw) {
- return !ts.hasProperty(raw, "files") && !ts.hasProperty(raw, "references");
- }
- ts.canJsonReportNoInutFiles = canJsonReportNoInutFiles;
- function updateErrorForNoInputFiles(result, configFileName, configFileSpecs, configParseDiagnostics, canJsonReportNoInutFiles) {
- var existingErrors = configParseDiagnostics.length;
- if (shouldReportNoInputFiles(result, canJsonReportNoInutFiles)) {
- configParseDiagnostics.push(getErrorForNoInputFiles(configFileSpecs, configFileName));
+ function parseJsxChildren(openingTag) {
+ var list = [];
+ var listPos = getNodePos();
+ var saveParsingContext = parsingContext;
+ parsingContext |= 1 << 14;
+ while (true) {
+ var child = parseJsxChild(openingTag, currentToken = scanner.reScanJsxToken());
+ if (!child)
+ break;
+ list.push(child);
+ }
+ parsingContext = saveParsingContext;
+ return createNodeArray(list, listPos);
}
- else {
- ts.filterMutate(configParseDiagnostics, function (error) { return !isErrorNoInputFiles(error); });
+ function parseJsxAttributes() {
+ var pos = getNodePos();
+ return finishNode(factory.createJsxAttributes(parseList(13, parseJsxAttribute)), pos);
}
- return existingErrors !== configParseDiagnostics.length;
- }
- ts.updateErrorForNoInputFiles = updateErrorForNoInputFiles;
- function isSuccessfulParsedTsconfig(value) {
- return !!value.options;
- }
- function parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache) {
- basePath = ts.normalizeSlashes(basePath);
- var resolvedPath = ts.getNormalizedAbsolutePath(configFileName || "", basePath);
- if (resolutionStack.indexOf(resolvedPath) >= 0) {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, __spreadArrays(resolutionStack, [resolvedPath]).join(" -> ")));
- return { raw: json || convertToObject(sourceFile, errors) };
+ function parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext) {
+ var pos = getNodePos();
+ parseExpected(29);
+ if (token() === 31) {
+ scanJsxText();
+ return finishNode(factory.createJsxOpeningFragment(), pos);
+ }
+ var tagName = parseJsxElementName();
+ var typeArguments = tryParseTypeArguments();
+ var attributes = parseJsxAttributes();
+ var node;
+ if (token() === 31) {
+ scanJsxText();
+ node = factory.createJsxOpeningElement(tagName, typeArguments, attributes);
+ }
+ else {
+ parseExpected(43);
+ if (inExpressionContext) {
+ parseExpected(31);
+ }
+ else {
+ parseExpected(31, undefined, false);
+ scanJsxText();
+ }
+ node = factory.createJsxSelfClosingElement(tagName, typeArguments, attributes);
+ }
+ return finishNode(node, pos);
}
- var ownConfig = json ?
- parseOwnConfigOfJson(json, host, basePath, configFileName, errors) :
- parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors);
- if (ownConfig.extendedConfigPath) {
- resolutionStack = resolutionStack.concat([resolvedPath]);
- var extendedConfig = getExtendedConfig(sourceFile, ownConfig.extendedConfigPath, host, basePath, resolutionStack, errors, extendedConfigCache);
- if (extendedConfig && isSuccessfulParsedTsconfig(extendedConfig)) {
- var baseRaw_1 = extendedConfig.raw;
- var raw_1 = ownConfig.raw;
- var setPropertyInRawIfNotUndefined = function (propertyName) {
- var value = raw_1[propertyName] || baseRaw_1[propertyName];
- if (value) {
- raw_1[propertyName] = value;
- }
- };
- setPropertyInRawIfNotUndefined("include");
- setPropertyInRawIfNotUndefined("exclude");
- setPropertyInRawIfNotUndefined("files");
- if (raw_1.compileOnSave === undefined) {
- raw_1.compileOnSave = baseRaw_1.compileOnSave;
+ function parseJsxElementName() {
+ var pos = getNodePos();
+ scanJsxIdentifier();
+ var expression = token() === 107 ?
+ parseTokenNode() : parseIdentifierName();
+ while (parseOptional(24)) {
+ expression = finishNode(factory.createPropertyAccessExpression(expression, parseRightSideOfDot(true, false)), pos);
+ }
+ return expression;
+ }
+ function parseJsxExpression(inExpressionContext) {
+ var pos = getNodePos();
+ if (!parseExpected(18)) {
+ return undefined;
+ }
+ var dotDotDotToken;
+ var expression;
+ if (token() !== 19) {
+ dotDotDotToken = parseOptionalToken(25);
+ expression = parseExpression();
+ }
+ if (inExpressionContext) {
+ parseExpected(19);
+ }
+ else {
+ if (parseExpected(19, undefined, false)) {
+ scanJsxText();
}
- ownConfig.options = ts.assign({}, extendedConfig.options, ownConfig.options);
- ownConfig.watchOptions = ownConfig.watchOptions && extendedConfig.watchOptions ?
- ts.assign({}, extendedConfig.watchOptions, ownConfig.watchOptions) :
- ownConfig.watchOptions || extendedConfig.watchOptions;
}
+ return finishNode(factory.createJsxExpression(dotDotDotToken, expression), pos);
}
- return ownConfig;
- }
- function parseOwnConfigOfJson(json, host, basePath, configFileName, errors) {
- if (ts.hasProperty(json, "excludes")) {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
+ function parseJsxAttribute() {
+ if (token() === 18) {
+ return parseJsxSpreadAttribute();
+ }
+ scanJsxIdentifier();
+ var pos = getNodePos();
+ return finishNode(factory.createJsxAttribute(parseIdentifierName(), token() !== 62 ? undefined :
+ scanJsxAttributeValue() === 10 ? parseLiteralNode() :
+ parseJsxExpression(true)), pos);
}
- var options = convertCompilerOptionsFromJsonWorker(json.compilerOptions, basePath, errors, configFileName);
- var typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition || json.typingOptions, basePath, errors, configFileName);
- var watchOptions = convertWatchOptionsFromJsonWorker(json.watchOptions, basePath, errors);
- json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);
- var extendedConfigPath;
- if (json.extends) {
- if (!ts.isString(json.extends)) {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string"));
+ function parseJsxSpreadAttribute() {
+ var pos = getNodePos();
+ parseExpected(18);
+ parseExpected(25);
+ var expression = parseExpression();
+ parseExpected(19);
+ return finishNode(factory.createJsxSpreadAttribute(expression), pos);
+ }
+ function parseJsxClosingElement(inExpressionContext) {
+ var pos = getNodePos();
+ parseExpected(30);
+ var tagName = parseJsxElementName();
+ if (inExpressionContext) {
+ parseExpected(31);
}
else {
- var newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
- extendedConfigPath = getExtendsConfigPath(json.extends, host, newBase, errors, ts.createCompilerDiagnostic);
+ parseExpected(31, undefined, false);
+ scanJsxText();
}
+ return finishNode(factory.createJsxClosingElement(tagName), pos);
}
- return { raw: json, options: options, watchOptions: watchOptions, typeAcquisition: typeAcquisition, extendedConfigPath: extendedConfigPath };
- }
- function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors) {
- var options = getDefaultCompilerOptions(configFileName);
- var typeAcquisition, typingOptionstypeAcquisition;
- var watchOptions;
- var extendedConfigPath;
- var optionsIterator = {
- onSetValidOptionKeyValueInParent: function (parentOption, option, value) {
- var currentOption;
- switch (parentOption) {
- case "compilerOptions":
- currentOption = options;
- break;
- case "watchOptions":
- currentOption = (watchOptions || (watchOptions = {}));
- break;
- case "typeAcquisition":
- currentOption = (typeAcquisition || (typeAcquisition = getDefaultTypeAcquisition(configFileName)));
- break;
- case "typingOptions":
- currentOption = (typingOptionstypeAcquisition || (typingOptionstypeAcquisition = getDefaultTypeAcquisition(configFileName)));
- break;
- default:
- ts.Debug.fail("Unknown option");
- }
- currentOption[option.name] = normalizeOptionValue(option, basePath, value);
- },
- onSetValidOptionKeyValueInRoot: function (key, _keyNode, value, valueNode) {
- switch (key) {
- case "extends":
- var newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
- extendedConfigPath = getExtendsConfigPath(value, host, newBase, errors, function (message, arg0) {
- return ts.createDiagnosticForNodeInSourceFile(sourceFile, valueNode, message, arg0);
- });
- return;
- }
- },
- onSetUnknownOptionKeyValueInRoot: function (key, keyNode, _value, _valueNode) {
- if (key === "excludes") {
- errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, keyNode, ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
- }
+ function parseJsxClosingFragment(inExpressionContext) {
+ var pos = getNodePos();
+ parseExpected(30);
+ if (ts.tokenIsIdentifierOrKeyword(token())) {
+ parseErrorAtRange(parseJsxElementName(), ts.Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment);
}
- };
- var json = convertToObjectWorker(sourceFile, errors, true, getTsconfigRootOptionsMap(), optionsIterator);
- if (!typeAcquisition) {
- if (typingOptionstypeAcquisition) {
- typeAcquisition = (typingOptionstypeAcquisition.enableAutoDiscovery !== undefined) ?
- {
- enable: typingOptionstypeAcquisition.enableAutoDiscovery,
- include: typingOptionstypeAcquisition.include,
- exclude: typingOptionstypeAcquisition.exclude
- } :
- typingOptionstypeAcquisition;
+ if (inExpressionContext) {
+ parseExpected(31);
}
else {
- typeAcquisition = getDefaultTypeAcquisition(configFileName);
+ parseExpected(31, undefined, false);
+ scanJsxText();
}
+ return finishNode(factory.createJsxJsxClosingFragment(), pos);
}
- return { raw: json, options: options, watchOptions: watchOptions, typeAcquisition: typeAcquisition, extendedConfigPath: extendedConfigPath };
- }
- function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiagnostic) {
- extendedConfig = ts.normalizeSlashes(extendedConfig);
- if (ts.isRootedDiskPath(extendedConfig) || ts.startsWith(extendedConfig, "./") || ts.startsWith(extendedConfig, "../")) {
- var extendedConfigPath = ts.getNormalizedAbsolutePath(extendedConfig, basePath);
- if (!host.fileExists(extendedConfigPath) && !ts.endsWith(extendedConfigPath, ".json")) {
- extendedConfigPath = extendedConfigPath + ".json";
- if (!host.fileExists(extendedConfigPath)) {
- errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig));
- return undefined;
- }
- }
- return extendedConfigPath;
+ function parseTypeAssertion() {
+ var pos = getNodePos();
+ parseExpected(29);
+ var type = parseType();
+ parseExpected(31);
+ var expression = parseSimpleUnaryExpression();
+ return finishNode(factory.createTypeAssertion(type, expression), pos);
}
- var resolved = ts.nodeModuleNameResolver(extendedConfig, ts.combinePaths(basePath, "tsconfig.json"), { moduleResolution: ts.ModuleResolutionKind.NodeJs }, host, undefined, undefined, true);
- if (resolved.resolvedModule) {
- return resolved.resolvedModule.resolvedFileName;
+ function nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate() {
+ nextToken();
+ return ts.tokenIsIdentifierOrKeyword(token())
+ || token() === 22
+ || isTemplateStartOfTaggedTemplate();
}
- errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig));
- return undefined;
- }
- function getExtendedConfig(sourceFile, extendedConfigPath, host, basePath, resolutionStack, errors, extendedConfigCache) {
- var _a;
- var path = host.useCaseSensitiveFileNames ? extendedConfigPath : ts.toFileNameLowerCase(extendedConfigPath);
- var value;
- var extendedResult;
- var extendedConfig;
- if (extendedConfigCache && (value = extendedConfigCache.get(path))) {
- (extendedResult = value.extendedResult, extendedConfig = value.extendedConfig);
+ function isStartOfOptionalPropertyOrElementAccessChain() {
+ return token() === 28
+ && lookAhead(nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate);
}
- else {
- extendedResult = readJsonConfigFile(extendedConfigPath, function (path) { return host.readFile(path); });
- if (!extendedResult.parseDiagnostics.length) {
- var extendedDirname = ts.getDirectoryPath(extendedConfigPath);
- extendedConfig = parseConfig(undefined, extendedResult, host, extendedDirname, ts.getBaseFileName(extendedConfigPath), resolutionStack, errors, extendedConfigCache);
- if (isSuccessfulParsedTsconfig(extendedConfig)) {
- var relativeDifference_1 = ts.convertToRelativePath(extendedDirname, basePath, ts.identity);
- var updatePath_1 = function (path) { return ts.isRootedDiskPath(path) ? path : ts.combinePaths(relativeDifference_1, path); };
- var mapPropertiesInRawIfNotUndefined = function (propertyName) {
- if (raw_2[propertyName]) {
- raw_2[propertyName] = ts.map(raw_2[propertyName], updatePath_1);
- }
- };
- var raw_2 = extendedConfig.raw;
- mapPropertiesInRawIfNotUndefined("include");
- mapPropertiesInRawIfNotUndefined("exclude");
- mapPropertiesInRawIfNotUndefined("files");
- }
- }
- if (extendedConfigCache) {
- extendedConfigCache.set(path, { extendedResult: extendedResult, extendedConfig: extendedConfig });
+ function tryReparseOptionalChain(node) {
+ if (node.flags & 32) {
+ return true;
}
- }
- if (sourceFile) {
- sourceFile.extendedSourceFiles = [extendedResult.fileName];
- if (extendedResult.extendedSourceFiles) {
- (_a = sourceFile.extendedSourceFiles).push.apply(_a, extendedResult.extendedSourceFiles);
+ if (ts.isNonNullExpression(node)) {
+ var expr = node.expression;
+ while (ts.isNonNullExpression(expr) && !(expr.flags & 32)) {
+ expr = expr.expression;
+ }
+ if (expr.flags & 32) {
+ while (ts.isNonNullExpression(node)) {
+ node.flags |= 32;
+ node = node.expression;
+ }
+ return true;
+ }
}
- }
- if (extendedResult.parseDiagnostics.length) {
- errors.push.apply(errors, extendedResult.parseDiagnostics);
- return undefined;
- }
- return extendedConfig;
- }
- function convertCompileOnSaveOptionFromJson(jsonOption, basePath, errors) {
- if (!ts.hasProperty(jsonOption, ts.compileOnSaveCommandLineOption.name)) {
return false;
}
- var result = convertJsonOption(ts.compileOnSaveCommandLineOption, jsonOption.compileOnSave, basePath, errors);
- return typeof result === "boolean" && result;
- }
- function convertCompilerOptionsFromJson(jsonOptions, basePath, configFileName) {
- var errors = [];
- var options = convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);
- return { options: options, errors: errors };
- }
- ts.convertCompilerOptionsFromJson = convertCompilerOptionsFromJson;
- function convertTypeAcquisitionFromJson(jsonOptions, basePath, configFileName) {
- var errors = [];
- var options = convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName);
- return { options: options, errors: errors };
- }
- ts.convertTypeAcquisitionFromJson = convertTypeAcquisitionFromJson;
- function getDefaultCompilerOptions(configFileName) {
- var options = configFileName && ts.getBaseFileName(configFileName) === "jsconfig.json"
- ? { allowJs: true, maxNodeModuleJsDepth: 2, allowSyntheticDefaultImports: true, skipLibCheck: true, noEmit: true }
- : {};
- return options;
- }
- function convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
- var options = getDefaultCompilerOptions(configFileName);
- convertOptionsFromJson(getCommandLineCompilerOptionsMap(), jsonOptions, basePath, options, ts.compilerOptionsDidYouMeanDiagnostics, errors);
- if (configFileName) {
- options.configFilePath = ts.normalizeSlashes(configFileName);
- }
- return options;
- }
- function getDefaultTypeAcquisition(configFileName) {
- return { enable: !!configFileName && ts.getBaseFileName(configFileName) === "jsconfig.json", include: [], exclude: [] };
- }
- function convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
- var options = getDefaultTypeAcquisition(configFileName);
- var typeAcquisition = convertEnableAutoDiscoveryToEnable(jsonOptions);
- convertOptionsFromJson(getCommandLineTypeAcquisitionMap(), typeAcquisition, basePath, options, typeAcquisitionDidYouMeanDiagnostics, errors);
- return options;
- }
- function convertWatchOptionsFromJsonWorker(jsonOptions, basePath, errors) {
- return convertOptionsFromJson(getCommandLineWatchOptionsMap(), jsonOptions, basePath, undefined, watchOptionsDidYouMeanDiagnostics, errors);
- }
- function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOptions, diagnostics, errors) {
- if (!jsonOptions) {
- return;
+ function parsePropertyAccessExpressionRest(pos, expression, questionDotToken) {
+ var name = parseRightSideOfDot(true, true);
+ var isOptionalChain = questionDotToken || tryReparseOptionalChain(expression);
+ var propertyAccess = isOptionalChain ?
+ factory.createPropertyAccessChain(expression, questionDotToken, name) :
+ factory.createPropertyAccessExpression(expression, name);
+ if (isOptionalChain && ts.isPrivateIdentifier(propertyAccess.name)) {
+ parseErrorAtRange(propertyAccess.name, ts.Diagnostics.An_optional_chain_cannot_contain_private_identifiers);
+ }
+ return finishNode(propertyAccess, pos);
}
- for (var id in jsonOptions) {
- var opt = optionsNameMap.get(id);
- if (opt) {
- (defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
+ function parseElementAccessExpressionRest(pos, expression, questionDotToken) {
+ var argumentExpression;
+ if (token() === 23) {
+ argumentExpression = createMissingNode(78, true, ts.Diagnostics.An_element_access_expression_should_take_an_argument);
}
else {
- errors.push(createUnknownOptionError(id, diagnostics, ts.createCompilerDiagnostic));
+ var argument = allowInAnd(parseExpression);
+ if (ts.isStringOrNumericLiteralLike(argument)) {
+ argument.text = internIdentifier(argument.text);
+ }
+ argumentExpression = argument;
}
+ parseExpected(23);
+ var indexedAccess = questionDotToken || tryReparseOptionalChain(expression) ?
+ factory.createElementAccessChain(expression, questionDotToken, argumentExpression) :
+ factory.createElementAccessExpression(expression, argumentExpression);
+ return finishNode(indexedAccess, pos);
}
- return defaultOptions;
- }
- function convertJsonOption(opt, value, basePath, errors) {
- if (isCompilerOptionsValue(opt, value)) {
- var optType = opt.type;
- if (optType === "list" && ts.isArray(value)) {
- return convertJsonOptionOfListType(opt, value, basePath, errors);
+ function parseMemberExpressionRest(pos, expression, allowOptionalChain) {
+ while (true) {
+ var questionDotToken = void 0;
+ var isPropertyAccess = false;
+ if (allowOptionalChain && isStartOfOptionalPropertyOrElementAccessChain()) {
+ questionDotToken = parseExpectedToken(28);
+ isPropertyAccess = ts.tokenIsIdentifierOrKeyword(token());
+ }
+ else {
+ isPropertyAccess = parseOptional(24);
+ }
+ if (isPropertyAccess) {
+ expression = parsePropertyAccessExpressionRest(pos, expression, questionDotToken);
+ continue;
+ }
+ if (!questionDotToken && token() === 53 && !scanner.hasPrecedingLineBreak()) {
+ nextToken();
+ expression = finishNode(factory.createNonNullExpression(expression), pos);
+ continue;
+ }
+ if ((questionDotToken || !inDecoratorContext()) && parseOptional(22)) {
+ expression = parseElementAccessExpressionRest(pos, expression, questionDotToken);
+ continue;
+ }
+ if (isTemplateStartOfTaggedTemplate()) {
+ expression = parseTaggedTemplateRest(pos, expression, questionDotToken, undefined);
+ continue;
+ }
+ return expression;
}
- else if (!ts.isString(optType)) {
- return convertJsonOptionOfCustomType(opt, value, errors);
+ }
+ function isTemplateStartOfTaggedTemplate() {
+ return token() === 14 || token() === 15;
+ }
+ function parseTaggedTemplateRest(pos, tag, questionDotToken, typeArguments) {
+ var tagExpression = factory.createTaggedTemplateExpression(tag, typeArguments, token() === 14 ?
+ (reScanTemplateHeadOrNoSubstitutionTemplate(), parseLiteralNode()) :
+ parseTemplateExpression(true));
+ if (questionDotToken || tag.flags & 32) {
+ tagExpression.flags |= 32;
}
- return normalizeNonListOptionValue(opt, basePath, value);
+ tagExpression.questionDotToken = questionDotToken;
+ return finishNode(tagExpression, pos);
}
- else {
- errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
+ function parseCallExpressionRest(pos, expression) {
+ while (true) {
+ expression = parseMemberExpressionRest(pos, expression, true);
+ var questionDotToken = parseOptionalToken(28);
+ if (token() === 29 || token() === 47) {
+ var typeArguments = tryParse(parseTypeArgumentsInExpression);
+ if (typeArguments) {
+ if (isTemplateStartOfTaggedTemplate()) {
+ expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
+ continue;
+ }
+ var argumentList = parseArgumentList();
+ var callExpr = questionDotToken || tryReparseOptionalChain(expression) ?
+ factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) :
+ factory.createCallExpression(expression, typeArguments, argumentList);
+ expression = finishNode(callExpr, pos);
+ continue;
+ }
+ }
+ else if (token() === 20) {
+ var argumentList = parseArgumentList();
+ var callExpr = questionDotToken || tryReparseOptionalChain(expression) ?
+ factory.createCallChain(expression, questionDotToken, undefined, argumentList) :
+ factory.createCallExpression(expression, undefined, argumentList);
+ expression = finishNode(callExpr, pos);
+ continue;
+ }
+ if (questionDotToken) {
+ var name = createMissingNode(78, false, ts.Diagnostics.Identifier_expected);
+ expression = finishNode(factory.createPropertyAccessChain(expression, questionDotToken, name), pos);
+ }
+ break;
+ }
+ return expression;
}
- }
- function normalizeOptionValue(option, basePath, value) {
- if (isNullOrUndefined(value))
- return undefined;
- if (option.type === "list") {
- var listOption_1 = option;
- if (listOption_1.element.isFilePath || !ts.isString(listOption_1.element.type)) {
- return ts.filter(ts.map(value, function (v) { return normalizeOptionValue(listOption_1.element, basePath, v); }), function (v) { return !!v; });
+ function parseArgumentList() {
+ parseExpected(20);
+ var result = parseDelimitedList(11, parseArgumentExpression);
+ parseExpected(21);
+ return result;
+ }
+ function parseTypeArgumentsInExpression() {
+ if (reScanLessThanToken() !== 29) {
+ return undefined;
}
- return value;
+ nextToken();
+ var typeArguments = parseDelimitedList(20, parseType);
+ if (!parseExpected(31)) {
+ return undefined;
+ }
+ return typeArguments && canFollowTypeArgumentsInExpression()
+ ? typeArguments
+ : undefined;
}
- else if (!ts.isString(option.type)) {
- return option.type.get(ts.isString(value) ? value.toLowerCase() : value);
+ function canFollowTypeArgumentsInExpression() {
+ switch (token()) {
+ case 20:
+ case 14:
+ case 15:
+ case 24:
+ case 21:
+ case 23:
+ case 58:
+ case 26:
+ case 57:
+ case 34:
+ case 36:
+ case 35:
+ case 37:
+ case 55:
+ case 56:
+ case 60:
+ case 52:
+ case 50:
+ case 51:
+ case 19:
+ case 1:
+ return true;
+ case 27:
+ case 18:
+ default:
+ return false;
+ }
}
- return normalizeNonListOptionValue(option, basePath, value);
- }
- function normalizeNonListOptionValue(option, basePath, value) {
- if (option.isFilePath) {
- value = ts.getNormalizedAbsolutePath(value, basePath);
- if (value === "") {
- value = ".";
+ function parsePrimaryExpression() {
+ switch (token()) {
+ case 8:
+ case 9:
+ case 10:
+ case 14:
+ return parseLiteralNode();
+ case 107:
+ case 105:
+ case 103:
+ case 109:
+ case 94:
+ return parseTokenNode();
+ case 20:
+ return parseParenthesizedExpression();
+ case 22:
+ return parseArrayLiteralExpression();
+ case 18:
+ return parseObjectLiteralExpression();
+ case 129:
+ if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) {
+ break;
+ }
+ return parseFunctionExpression();
+ case 83:
+ return parseClassExpression();
+ case 97:
+ return parseFunctionExpression();
+ case 102:
+ return parseNewExpressionOrNewDotTarget();
+ case 43:
+ case 67:
+ if (reScanSlashToken() === 13) {
+ return parseLiteralNode();
+ }
+ break;
+ case 15:
+ return parseTemplateExpression(false);
}
+ return parseIdentifier(ts.Diagnostics.Expression_expected);
}
- return value;
- }
- function convertJsonOptionOfCustomType(opt, value, errors) {
- if (isNullOrUndefined(value))
- return undefined;
- var key = value.toLowerCase();
- var val = opt.type.get(key);
- if (val !== undefined) {
- return val;
+ function parseParenthesizedExpression() {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ parseExpected(20);
+ var expression = allowInAnd(parseExpression);
+ parseExpected(21);
+ return withJSDoc(finishNode(factory.createParenthesizedExpression(expression), pos), hasJSDoc);
}
- else {
- errors.push(createCompilerDiagnosticForInvalidCustomType(opt));
+ function parseSpreadElement() {
+ var pos = getNodePos();
+ parseExpected(25);
+ var expression = parseAssignmentExpressionOrHigher();
+ return finishNode(factory.createSpreadElement(expression), pos);
}
- }
- function convertJsonOptionOfListType(option, values, basePath, errors) {
- return ts.filter(ts.map(values, function (v) { return convertJsonOption(option.element, v, basePath, errors); }), function (v) { return !!v; });
- }
- function trimString(s) {
- return typeof s.trim === "function" ? s.trim() : s.replace(/^[\s]+|[\s]+$/g, "");
- }
- var invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/;
- var invalidDotDotAfterRecursiveWildcardPattern = /(^|\/)\*\*\/(.*\/)?\.\.($|\/)/;
- var watchRecursivePattern = /\/[^/]*?[*?][^/]*\//;
- var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/;
- function matchFileNames(filesSpecs, includeSpecs, excludeSpecs, basePath, options, host, errors, extraFileExtensions, jsonSourceFile) {
- basePath = ts.normalizePath(basePath);
- var validatedIncludeSpecs, validatedExcludeSpecs;
- if (includeSpecs) {
- validatedIncludeSpecs = validateSpecs(includeSpecs, errors, false, jsonSourceFile, "include");
+ function parseArgumentOrArrayLiteralElement() {
+ return token() === 25 ? parseSpreadElement() :
+ token() === 27 ? finishNode(factory.createOmittedExpression(), getNodePos()) :
+ parseAssignmentExpressionOrHigher();
}
- if (excludeSpecs) {
- validatedExcludeSpecs = validateSpecs(excludeSpecs, errors, true, jsonSourceFile, "exclude");
+ function parseArgumentExpression() {
+ return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
}
- var wildcardDirectories = getWildcardDirectories(validatedIncludeSpecs, validatedExcludeSpecs, basePath, host.useCaseSensitiveFileNames);
- var spec = { filesSpecs: filesSpecs, includeSpecs: includeSpecs, excludeSpecs: excludeSpecs, validatedIncludeSpecs: validatedIncludeSpecs, validatedExcludeSpecs: validatedExcludeSpecs, wildcardDirectories: wildcardDirectories };
- return getFileNamesFromConfigSpecs(spec, basePath, options, host, extraFileExtensions);
- }
- function getFileNamesFromConfigSpecs(spec, basePath, options, host, extraFileExtensions) {
- if (extraFileExtensions === void 0) { extraFileExtensions = []; }
- basePath = ts.normalizePath(basePath);
- var keyMapper = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames);
- var literalFileMap = ts.createMap();
- var wildcardFileMap = ts.createMap();
- var wildCardJsonFileMap = ts.createMap();
- var filesSpecs = spec.filesSpecs, validatedIncludeSpecs = spec.validatedIncludeSpecs, validatedExcludeSpecs = spec.validatedExcludeSpecs, wildcardDirectories = spec.wildcardDirectories;
- var supportedExtensions = ts.getSupportedExtensions(options, extraFileExtensions);
- var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
- if (filesSpecs) {
- for (var _i = 0, filesSpecs_1 = filesSpecs; _i < filesSpecs_1.length; _i++) {
- var fileName = filesSpecs_1[_i];
- var file = ts.getNormalizedAbsolutePath(fileName, basePath);
- literalFileMap.set(keyMapper(file), file);
- }
+ function parseArrayLiteralExpression() {
+ var pos = getNodePos();
+ parseExpected(22);
+ var multiLine = scanner.hasPrecedingLineBreak();
+ var elements = parseDelimitedList(15, parseArgumentOrArrayLiteralElement);
+ parseExpected(23);
+ return finishNode(factory.createArrayLiteralExpression(elements, multiLine), pos);
}
- var jsonOnlyIncludeRegexes;
- if (validatedIncludeSpecs && validatedIncludeSpecs.length > 0) {
- var _loop_5 = function (file) {
- if (ts.fileExtensionIs(file, ".json")) {
- if (!jsonOnlyIncludeRegexes) {
- var includes = validatedIncludeSpecs.filter(function (s) { return ts.endsWith(s, ".json"); });
- var includeFilePatterns = ts.map(ts.getRegularExpressionsForWildcards(includes, basePath, "files"), function (pattern) { return "^" + pattern + "$"; });
- jsonOnlyIncludeRegexes = includeFilePatterns ? includeFilePatterns.map(function (pattern) { return ts.getRegexFromPattern(pattern, host.useCaseSensitiveFileNames); }) : ts.emptyArray;
- }
- var includeIndex = ts.findIndex(jsonOnlyIncludeRegexes, function (re) { return re.test(file); });
- if (includeIndex !== -1) {
- var key_1 = keyMapper(file);
- if (!literalFileMap.has(key_1) && !wildCardJsonFileMap.has(key_1)) {
- wildCardJsonFileMap.set(key_1, file);
- }
- }
- return "continue";
- }
- if (hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMapper)) {
- return "continue";
- }
- removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);
- var key = keyMapper(file);
- if (!literalFileMap.has(key) && !wildcardFileMap.has(key)) {
- wildcardFileMap.set(key, file);
- }
- };
- for (var _a = 0, _b = host.readDirectory(basePath, supportedExtensionsWithJsonIfResolveJsonModule, validatedExcludeSpecs, validatedIncludeSpecs, undefined); _a < _b.length; _a++) {
- var file = _b[_a];
- _loop_5(file);
+ function parseObjectLiteralElement() {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ if (parseOptionalToken(25)) {
+ var expression = parseAssignmentExpressionOrHigher();
+ return withJSDoc(finishNode(factory.createSpreadAssignment(expression), pos), hasJSDoc);
+ }
+ var decorators = parseDecorators();
+ var modifiers = parseModifiers();
+ if (parseContextualModifier(134)) {
+ return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 167);
+ }
+ if (parseContextualModifier(146)) {
+ return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 168);
+ }
+ var asteriskToken = parseOptionalToken(41);
+ var tokenIsIdentifier = isIdentifier();
+ var name = parsePropertyName();
+ var questionToken = parseOptionalToken(57);
+ var exclamationToken = parseOptionalToken(53);
+ if (asteriskToken || token() === 20 || token() === 29) {
+ return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, exclamationToken);
+ }
+ var node;
+ var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58);
+ if (isShorthandPropertyAssignment) {
+ var equalsToken = parseOptionalToken(62);
+ var objectAssignmentInitializer = equalsToken ? allowInAnd(parseAssignmentExpressionOrHigher) : undefined;
+ node = factory.createShorthandPropertyAssignment(name, objectAssignmentInitializer);
+ node.equalsToken = equalsToken;
+ }
+ else {
+ parseExpected(58);
+ var initializer = allowInAnd(parseAssignmentExpressionOrHigher);
+ node = factory.createPropertyAssignment(name, initializer);
}
+ node.decorators = decorators;
+ node.modifiers = modifiers;
+ node.questionToken = questionToken;
+ node.exclamationToken = exclamationToken;
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- var literalFiles = ts.arrayFrom(literalFileMap.values());
- var wildcardFiles = ts.arrayFrom(wildcardFileMap.values());
- return {
- fileNames: literalFiles.concat(wildcardFiles, ts.arrayFrom(wildCardJsonFileMap.values())),
- wildcardDirectories: wildcardDirectories,
- spec: spec
- };
- }
- ts.getFileNamesFromConfigSpecs = getFileNamesFromConfigSpecs;
- function validateSpecs(specs, errors, allowTrailingRecursion, jsonSourceFile, specKey) {
- return specs.filter(function (spec) {
- var diag = specToDiagnostic(spec, allowTrailingRecursion);
- if (diag !== undefined) {
- errors.push(createDiagnostic(diag, spec));
+ function parseObjectLiteralExpression() {
+ var pos = getNodePos();
+ var openBracePosition = scanner.getTokenPos();
+ parseExpected(18);
+ var multiLine = scanner.hasPrecedingLineBreak();
+ var properties = parseDelimitedList(12, parseObjectLiteralElement, true);
+ if (!parseExpected(19)) {
+ var lastError = ts.lastOrUndefined(parseDiagnostics);
+ if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
+ ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
+ }
}
- return diag === undefined;
- });
- function createDiagnostic(message, spec) {
- var element = ts.getTsConfigPropArrayElementValue(jsonSourceFile, specKey, spec);
- return element ?
- ts.createDiagnosticForNodeInSourceFile(jsonSourceFile, element, message, spec) :
- ts.createCompilerDiagnostic(message, spec);
+ return finishNode(factory.createObjectLiteralExpression(properties, multiLine), pos);
}
- }
- function specToDiagnostic(spec, allowTrailingRecursion) {
- if (!allowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) {
- return ts.Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0;
+ function parseFunctionExpression() {
+ var saveDecoratorContext = inDecoratorContext();
+ if (saveDecoratorContext) {
+ setDecoratorContext(false);
+ }
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ var modifiers = parseModifiers();
+ parseExpected(97);
+ var asteriskToken = parseOptionalToken(41);
+ var isGenerator = asteriskToken ? 1 : 0;
+ var isAsync = ts.some(modifiers, ts.isAsyncModifier) ? 2 : 0;
+ var name = isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalBindingIdentifier) :
+ isGenerator ? doInYieldContext(parseOptionalBindingIdentifier) :
+ isAsync ? doInAwaitContext(parseOptionalBindingIdentifier) :
+ parseOptionalBindingIdentifier();
+ var typeParameters = parseTypeParameters();
+ var parameters = parseParameters(isGenerator | isAsync);
+ var type = parseReturnType(58, false);
+ var body = parseFunctionBlock(isGenerator | isAsync);
+ if (saveDecoratorContext) {
+ setDecoratorContext(true);
+ }
+ var node = factory.createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- else if (invalidDotDotAfterRecursiveWildcardPattern.test(spec)) {
- return ts.Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0;
+ function parseOptionalBindingIdentifier() {
+ return isBindingIdentifier() ? parseBindingIdentifier() : undefined;
}
- }
- function getWildcardDirectories(include, exclude, path, useCaseSensitiveFileNames) {
- var rawExcludeRegex = ts.getRegularExpressionForWildcard(exclude, path, "exclude");
- var excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
- var wildcardDirectories = {};
- if (include !== undefined) {
- var recursiveKeys = [];
- for (var _i = 0, include_1 = include; _i < include_1.length; _i++) {
- var file = include_1[_i];
- var spec = ts.normalizePath(ts.combinePaths(path, file));
- if (excludeRegex && excludeRegex.test(spec)) {
- continue;
- }
- var match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames);
- if (match) {
- var key = match.key, flags = match.flags;
- var existingFlags = wildcardDirectories[key];
- if (existingFlags === undefined || existingFlags < flags) {
- wildcardDirectories[key] = flags;
- if (flags === 1) {
- recursiveKeys.push(key);
- }
- }
+ function parseNewExpressionOrNewDotTarget() {
+ var pos = getNodePos();
+ parseExpected(102);
+ if (parseOptional(24)) {
+ var name = parseIdentifierName();
+ return finishNode(factory.createMetaProperty(102, name), pos);
+ }
+ var expressionPos = getNodePos();
+ var expression = parsePrimaryExpression();
+ var typeArguments;
+ while (true) {
+ expression = parseMemberExpressionRest(expressionPos, expression, false);
+ typeArguments = tryParse(parseTypeArgumentsInExpression);
+ if (isTemplateStartOfTaggedTemplate()) {
+ ts.Debug.assert(!!typeArguments, "Expected a type argument list; all plain tagged template starts should be consumed in 'parseMemberExpressionRest'");
+ expression = parseTaggedTemplateRest(expressionPos, expression, undefined, typeArguments);
+ typeArguments = undefined;
}
+ break;
}
- for (var key in wildcardDirectories) {
- if (ts.hasProperty(wildcardDirectories, key)) {
- for (var _a = 0, recursiveKeys_1 = recursiveKeys; _a < recursiveKeys_1.length; _a++) {
- var recursiveKey = recursiveKeys_1[_a];
- if (key !== recursiveKey && ts.containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
- delete wildcardDirectories[key];
- }
+ var argumentsArray;
+ if (token() === 20) {
+ argumentsArray = parseArgumentList();
+ }
+ else if (typeArguments) {
+ parseErrorAt(pos, scanner.getStartPos(), ts.Diagnostics.A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list);
+ }
+ return finishNode(factory.createNewExpression(expression, typeArguments, argumentsArray), pos);
+ }
+ function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) {
+ var pos = getNodePos();
+ var openBracePosition = scanner.getTokenPos();
+ if (parseExpected(18, diagnosticMessage) || ignoreMissingOpenBrace) {
+ var multiLine = scanner.hasPrecedingLineBreak();
+ var statements = parseList(1, parseStatement);
+ if (!parseExpected(19)) {
+ var lastError = ts.lastOrUndefined(parseDiagnostics);
+ if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
+ ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
}
}
+ return finishNode(factory.createBlock(statements, multiLine), pos);
+ }
+ else {
+ var statements = createMissingList();
+ return finishNode(factory.createBlock(statements, undefined), pos);
}
}
- return wildcardDirectories;
- }
- function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames) {
- var match = wildcardDirectoryPattern.exec(spec);
- if (match) {
- return {
- key: useCaseSensitiveFileNames ? match[0] : ts.toFileNameLowerCase(match[0]),
- flags: watchRecursivePattern.test(spec) ? 1 : 0
- };
+ function parseFunctionBlock(flags, diagnosticMessage) {
+ var savedYieldContext = inYieldContext();
+ setYieldContext(!!(flags & 1));
+ var savedAwaitContext = inAwaitContext();
+ setAwaitContext(!!(flags & 2));
+ var savedTopLevel = topLevel;
+ topLevel = false;
+ var saveDecoratorContext = inDecoratorContext();
+ if (saveDecoratorContext) {
+ setDecoratorContext(false);
+ }
+ var block = parseBlock(!!(flags & 16), diagnosticMessage);
+ if (saveDecoratorContext) {
+ setDecoratorContext(true);
+ }
+ topLevel = savedTopLevel;
+ setYieldContext(savedYieldContext);
+ setAwaitContext(savedAwaitContext);
+ return block;
}
- if (ts.isImplicitGlob(spec)) {
- return { key: spec, flags: 1 };
+ function parseEmptyStatement() {
+ var pos = getNodePos();
+ parseExpected(26);
+ return finishNode(factory.createEmptyStatement(), pos);
}
- return undefined;
- }
- function hasFileWithHigherPriorityExtension(file, literalFiles, wildcardFiles, extensions, keyMapper) {
- var extensionPriority = ts.getExtensionPriority(file, extensions);
- var adjustedExtensionPriority = ts.adjustExtensionPriority(extensionPriority, extensions);
- for (var i = 0; i < adjustedExtensionPriority; i++) {
- var higherPriorityExtension = extensions[i];
- var higherPriorityPath = keyMapper(ts.changeExtension(file, higherPriorityExtension));
- if (literalFiles.has(higherPriorityPath) || wildcardFiles.has(higherPriorityPath)) {
- return true;
- }
+ function parseIfStatement() {
+ var pos = getNodePos();
+ parseExpected(98);
+ parseExpected(20);
+ var expression = allowInAnd(parseExpression);
+ parseExpected(21);
+ var thenStatement = parseStatement();
+ var elseStatement = parseOptional(90) ? parseStatement() : undefined;
+ return finishNode(factory.createIfStatement(expression, thenStatement, elseStatement), pos);
}
- return false;
- }
- function removeWildcardFilesWithLowerPriorityExtension(file, wildcardFiles, extensions, keyMapper) {
- var extensionPriority = ts.getExtensionPriority(file, extensions);
- var nextExtensionPriority = ts.getNextLowestExtensionPriority(extensionPriority, extensions);
- for (var i = nextExtensionPriority; i < extensions.length; i++) {
- var lowerPriorityExtension = extensions[i];
- var lowerPriorityPath = keyMapper(ts.changeExtension(file, lowerPriorityExtension));
- wildcardFiles.delete(lowerPriorityPath);
+ function parseDoStatement() {
+ var pos = getNodePos();
+ parseExpected(89);
+ var statement = parseStatement();
+ parseExpected(114);
+ parseExpected(20);
+ var expression = allowInAnd(parseExpression);
+ parseExpected(21);
+ parseOptional(26);
+ return finishNode(factory.createDoStatement(statement, expression), pos);
}
- }
- function convertCompilerOptionsForTelemetry(opts) {
- var out = {};
- for (var key in opts) {
- if (opts.hasOwnProperty(key)) {
- var type = getOptionFromName(key);
- if (type !== undefined) {
- out[key] = getOptionValueWithEmptyStrings(opts[key], type);
+ function parseWhileStatement() {
+ var pos = getNodePos();
+ parseExpected(114);
+ parseExpected(20);
+ var expression = allowInAnd(parseExpression);
+ parseExpected(21);
+ var statement = parseStatement();
+ return finishNode(factory.createWhileStatement(expression, statement), pos);
+ }
+ function parseForOrForInOrForOfStatement() {
+ var pos = getNodePos();
+ parseExpected(96);
+ var awaitToken = parseOptionalToken(130);
+ parseExpected(20);
+ var initializer;
+ if (token() !== 26) {
+ if (token() === 112 || token() === 118 || token() === 84) {
+ initializer = parseVariableDeclarationList(true);
+ }
+ else {
+ initializer = disallowInAnd(parseExpression);
}
}
+ var node;
+ if (awaitToken ? parseExpected(156) : parseOptional(156)) {
+ var expression = allowInAnd(parseAssignmentExpressionOrHigher);
+ parseExpected(21);
+ node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement());
+ }
+ else if (parseOptional(100)) {
+ var expression = allowInAnd(parseExpression);
+ parseExpected(21);
+ node = factory.createForInStatement(initializer, expression, parseStatement());
+ }
+ else {
+ parseExpected(26);
+ var condition = token() !== 26 && token() !== 21
+ ? allowInAnd(parseExpression)
+ : undefined;
+ parseExpected(26);
+ var incrementor = token() !== 21
+ ? allowInAnd(parseExpression)
+ : undefined;
+ parseExpected(21);
+ node = factory.createForStatement(initializer, condition, incrementor, parseStatement());
+ }
+ return finishNode(node, pos);
}
- return out;
- }
- ts.convertCompilerOptionsForTelemetry = convertCompilerOptionsForTelemetry;
- function getOptionValueWithEmptyStrings(value, option) {
- switch (option.type) {
- case "object":
- return "";
- case "string":
- return "";
- case "number":
- return typeof value === "number" ? value : "";
- case "boolean":
- return typeof value === "boolean" ? value : "";
- case "list":
- var elementType_1 = option.element;
- return ts.isArray(value) ? value.map(function (v) { return getOptionValueWithEmptyStrings(v, elementType_1); }) : "";
- default:
- return ts.forEachEntry(option.type, function (optionEnumValue, optionStringValue) {
- if (optionEnumValue === value) {
- return optionStringValue;
- }
- });
+ function parseBreakOrContinueStatement(kind) {
+ var pos = getNodePos();
+ parseExpected(kind === 241 ? 80 : 85);
+ var label = canParseSemicolon() ? undefined : parseIdentifier();
+ parseSemicolon();
+ var node = kind === 241
+ ? factory.createBreakStatement(label)
+ : factory.createContinueStatement(label);
+ return finishNode(node, pos);
}
- }
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- function trace(host) {
- host.trace(ts.formatMessage.apply(undefined, arguments));
- }
- ts.trace = trace;
- function isTraceEnabled(compilerOptions, host) {
- return !!compilerOptions.traceResolution && host.trace !== undefined;
- }
- ts.isTraceEnabled = isTraceEnabled;
- function withPackageId(packageInfo, r) {
- var packageId;
- if (r && packageInfo) {
- var packageJsonContent = packageInfo.packageJsonContent;
- if (typeof packageJsonContent.name === "string" && typeof packageJsonContent.version === "string") {
- packageId = {
- name: packageJsonContent.name,
- subModuleName: r.path.slice(packageInfo.packageDirectory.length + ts.directorySeparator.length),
- version: packageJsonContent.version
- };
- }
+ function parseReturnStatement() {
+ var pos = getNodePos();
+ parseExpected(104);
+ var expression = canParseSemicolon() ? undefined : allowInAnd(parseExpression);
+ parseSemicolon();
+ return finishNode(factory.createReturnStatement(expression), pos);
}
- return r && { path: r.path, extension: r.ext, packageId: packageId };
- }
- function noPackageId(r) {
- return withPackageId(undefined, r);
- }
- function removeIgnoredPackageId(r) {
- if (r) {
- ts.Debug.assert(r.packageId === undefined);
- return { path: r.path, ext: r.extension };
+ function parseWithStatement() {
+ var pos = getNodePos();
+ parseExpected(115);
+ parseExpected(20);
+ var expression = allowInAnd(parseExpression);
+ parseExpected(21);
+ var statement = doInsideOfContext(16777216, parseStatement);
+ return finishNode(factory.createWithStatement(expression, statement), pos);
}
- }
- var Extensions;
- (function (Extensions) {
- Extensions[Extensions["TypeScript"] = 0] = "TypeScript";
- Extensions[Extensions["JavaScript"] = 1] = "JavaScript";
- Extensions[Extensions["Json"] = 2] = "Json";
- Extensions[Extensions["TSConfig"] = 3] = "TSConfig";
- Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly";
- })(Extensions || (Extensions = {}));
- function resolvedTypeScriptOnly(resolved) {
- if (!resolved) {
- return undefined;
+ function parseCaseClause() {
+ var pos = getNodePos();
+ parseExpected(81);
+ var expression = allowInAnd(parseExpression);
+ parseExpected(58);
+ var statements = parseList(3, parseStatement);
+ return finishNode(factory.createCaseClause(expression, statements), pos);
}
- ts.Debug.assert(ts.extensionIsTS(resolved.extension));
- return { fileName: resolved.path, packageId: resolved.packageId };
- }
- function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, resultFromCache) {
- var _a;
- if (resultFromCache) {
- (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations);
- return resultFromCache;
+ function parseDefaultClause() {
+ var pos = getNodePos();
+ parseExpected(87);
+ parseExpected(58);
+ var statements = parseList(3, parseStatement);
+ return finishNode(factory.createDefaultClause(statements), pos);
}
- return {
- resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId },
- failedLookupLocations: failedLookupLocations
- };
- }
- function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
- if (!ts.hasProperty(jsonContent, fieldName)) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.package_json_does_not_have_a_0_field, fieldName);
- }
- return;
+ function parseCaseOrDefaultClause() {
+ return token() === 81 ? parseCaseClause() : parseDefaultClause();
}
- var value = jsonContent[fieldName];
- if (typeof value !== typeOfTag || value === null) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, fieldName, typeOfTag, value === null ? "null" : typeof value);
- }
- return;
+ function parseCaseBlock() {
+ var pos = getNodePos();
+ parseExpected(18);
+ var clauses = parseList(2, parseCaseOrDefaultClause);
+ parseExpected(19);
+ return finishNode(factory.createCaseBlock(clauses), pos);
}
- return value;
- }
- function readPackageJsonPathField(jsonContent, fieldName, baseDirectory, state) {
- var fileName = readPackageJsonField(jsonContent, fieldName, "string", state);
- if (fileName === undefined) {
- return;
+ function parseSwitchStatement() {
+ var pos = getNodePos();
+ parseExpected(106);
+ parseExpected(20);
+ var expression = allowInAnd(parseExpression);
+ parseExpected(21);
+ var caseBlock = parseCaseBlock();
+ return finishNode(factory.createSwitchStatement(expression, caseBlock), pos);
}
- if (!fileName) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.package_json_had_a_falsy_0_field, fieldName);
+ function parseThrowStatement() {
+ var pos = getNodePos();
+ parseExpected(108);
+ var expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression);
+ if (expression === undefined) {
+ identifierCount++;
+ expression = finishNode(factory.createIdentifier(""), getNodePos());
}
- return;
+ parseSemicolon();
+ return finishNode(factory.createThrowStatement(expression), pos);
}
- var path = ts.normalizePath(ts.combinePaths(baseDirectory, fileName));
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path);
+ function parseTryStatement() {
+ var pos = getNodePos();
+ parseExpected(110);
+ var tryBlock = parseBlock(false);
+ var catchClause = token() === 82 ? parseCatchClause() : undefined;
+ var finallyBlock;
+ if (!catchClause || token() === 95) {
+ parseExpected(95);
+ finallyBlock = parseBlock(false);
+ }
+ return finishNode(factory.createTryStatement(tryBlock, catchClause, finallyBlock), pos);
}
- return path;
- }
- function readPackageJsonTypesFields(jsonContent, baseDirectory, state) {
- return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state)
- || readPackageJsonPathField(jsonContent, "types", baseDirectory, state);
- }
- function readPackageJsonTSConfigField(jsonContent, baseDirectory, state) {
- return readPackageJsonPathField(jsonContent, "tsconfig", baseDirectory, state);
- }
- function readPackageJsonMainField(jsonContent, baseDirectory, state) {
- return readPackageJsonPathField(jsonContent, "main", baseDirectory, state);
- }
- function readPackageJsonTypesVersionsField(jsonContent, state) {
- var typesVersions = readPackageJsonField(jsonContent, "typesVersions", "object", state);
- if (typesVersions === undefined)
- return;
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_field_with_version_specific_path_mappings);
+ function parseCatchClause() {
+ var pos = getNodePos();
+ parseExpected(82);
+ var variableDeclaration;
+ if (parseOptional(20)) {
+ variableDeclaration = parseVariableDeclaration();
+ parseExpected(21);
+ }
+ else {
+ variableDeclaration = undefined;
+ }
+ var block = parseBlock(false);
+ return finishNode(factory.createCatchClause(variableDeclaration, block), pos);
}
- return typesVersions;
- }
- function readPackageJsonTypesVersionPaths(jsonContent, state) {
- var typesVersions = readPackageJsonTypesVersionsField(jsonContent, state);
- if (typesVersions === undefined)
- return;
- if (state.traceEnabled) {
- for (var key in typesVersions) {
- if (ts.hasProperty(typesVersions, key) && !ts.VersionRange.tryParse(key)) {
- trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range, key);
+ function parseDebuggerStatement() {
+ var pos = getNodePos();
+ parseExpected(86);
+ parseSemicolon();
+ return finishNode(factory.createDebuggerStatement(), pos);
+ }
+ function parseExpressionOrLabeledStatement() {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ var node;
+ var hasParen = token() === 20;
+ var expression = allowInAnd(parseExpression);
+ if (ts.isIdentifier(expression) && parseOptional(58)) {
+ node = factory.createLabeledStatement(expression, parseStatement());
+ }
+ else {
+ parseSemicolon();
+ node = factory.createExpressionStatement(expression);
+ if (hasParen) {
+ hasJSDoc = false;
}
}
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- var result = getPackageJsonTypesVersionsPaths(typesVersions);
- if (!result) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, ts.versionMajorMinor);
- }
- return;
+ function nextTokenIsIdentifierOrKeywordOnSameLine() {
+ nextToken();
+ return ts.tokenIsIdentifierOrKeyword(token()) && !scanner.hasPrecedingLineBreak();
}
- var bestVersionKey = result.version, bestVersionPaths = result.paths;
- if (typeof bestVersionPaths !== "object") {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, "typesVersions['" + bestVersionKey + "']", "object", typeof bestVersionPaths);
- }
- return;
+ function nextTokenIsClassKeywordOnSameLine() {
+ nextToken();
+ return token() === 83 && !scanner.hasPrecedingLineBreak();
}
- return result;
- }
- var typeScriptVersion;
- function getPackageJsonTypesVersionsPaths(typesVersions) {
- if (!typeScriptVersion)
- typeScriptVersion = new ts.Version(ts.version);
- for (var key in typesVersions) {
- if (!ts.hasProperty(typesVersions, key))
- continue;
- var keyRange = ts.VersionRange.tryParse(key);
- if (keyRange === undefined) {
- continue;
+ function nextTokenIsFunctionKeywordOnSameLine() {
+ nextToken();
+ return token() === 97 && !scanner.hasPrecedingLineBreak();
+ }
+ function nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine() {
+ nextToken();
+ return (ts.tokenIsIdentifierOrKeyword(token()) || token() === 8 || token() === 9 || token() === 10) && !scanner.hasPrecedingLineBreak();
+ }
+ function isDeclaration() {
+ while (true) {
+ switch (token()) {
+ case 112:
+ case 118:
+ case 84:
+ case 97:
+ case 83:
+ case 91:
+ return true;
+ case 117:
+ case 149:
+ return nextTokenIsIdentifierOnSameLine();
+ case 139:
+ case 140:
+ return nextTokenIsIdentifierOrStringLiteralOnSameLine();
+ case 125:
+ case 129:
+ case 133:
+ case 120:
+ case 121:
+ case 122:
+ case 142:
+ nextToken();
+ if (scanner.hasPrecedingLineBreak()) {
+ return false;
+ }
+ continue;
+ case 154:
+ nextToken();
+ return token() === 18 || token() === 78 || token() === 92;
+ case 99:
+ nextToken();
+ return token() === 10 || token() === 41 ||
+ token() === 18 || ts.tokenIsIdentifierOrKeyword(token());
+ case 92:
+ var currentToken_1 = nextToken();
+ if (currentToken_1 === 149) {
+ currentToken_1 = lookAhead(nextToken);
+ }
+ if (currentToken_1 === 62 || currentToken_1 === 41 ||
+ currentToken_1 === 18 || currentToken_1 === 87 ||
+ currentToken_1 === 126) {
+ return true;
+ }
+ continue;
+ case 123:
+ nextToken();
+ continue;
+ default:
+ return false;
+ }
}
- if (keyRange.test(typeScriptVersion)) {
- return { version: key, paths: typesVersions[key] };
+ }
+ function isStartOfDeclaration() {
+ return lookAhead(isDeclaration);
+ }
+ function isStartOfStatement() {
+ switch (token()) {
+ case 59:
+ case 26:
+ case 18:
+ case 112:
+ case 118:
+ case 97:
+ case 83:
+ case 91:
+ case 98:
+ case 89:
+ case 114:
+ case 96:
+ case 85:
+ case 80:
+ case 104:
+ case 115:
+ case 106:
+ case 108:
+ case 110:
+ case 86:
+ case 82:
+ case 95:
+ return true;
+ case 99:
+ return isStartOfDeclaration() || lookAhead(nextTokenIsOpenParenOrLessThanOrDot);
+ case 84:
+ case 92:
+ return isStartOfDeclaration();
+ case 129:
+ case 133:
+ case 117:
+ case 139:
+ case 140:
+ case 149:
+ case 154:
+ return true;
+ case 122:
+ case 120:
+ case 121:
+ case 123:
+ case 142:
+ return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
+ default:
+ return isStartOfExpression();
}
}
- }
- ts.getPackageJsonTypesVersionsPaths = getPackageJsonTypesVersionsPaths;
- function getEffectiveTypeRoots(options, host) {
- if (options.typeRoots) {
- return options.typeRoots;
- }
- var currentDirectory;
- if (options.configFilePath) {
- currentDirectory = ts.getDirectoryPath(options.configFilePath);
- }
- else if (host.getCurrentDirectory) {
- currentDirectory = host.getCurrentDirectory();
- }
- if (currentDirectory !== undefined) {
- return getDefaultTypeRoots(currentDirectory, host);
+ function nextTokenIsIdentifierOrStartOfDestructuring() {
+ nextToken();
+ return isIdentifier() || token() === 18 || token() === 22;
}
- }
- ts.getEffectiveTypeRoots = getEffectiveTypeRoots;
- function getDefaultTypeRoots(currentDirectory, host) {
- if (!host.directoryExists) {
- return [ts.combinePaths(currentDirectory, nodeModulesAtTypes)];
+ function isLetDeclaration() {
+ return lookAhead(nextTokenIsIdentifierOrStartOfDestructuring);
}
- var typeRoots;
- ts.forEachAncestorDirectory(ts.normalizePath(currentDirectory), function (directory) {
- var atTypes = ts.combinePaths(directory, nodeModulesAtTypes);
- if (host.directoryExists(atTypes)) {
- (typeRoots || (typeRoots = [])).push(atTypes);
+ function parseStatement() {
+ switch (token()) {
+ case 26:
+ return parseEmptyStatement();
+ case 18:
+ return parseBlock(false);
+ case 112:
+ return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), undefined, undefined);
+ case 118:
+ if (isLetDeclaration()) {
+ return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), undefined, undefined);
+ }
+ break;
+ case 97:
+ return parseFunctionDeclaration(getNodePos(), hasPrecedingJSDocComment(), undefined, undefined);
+ case 83:
+ return parseClassDeclaration(getNodePos(), hasPrecedingJSDocComment(), undefined, undefined);
+ case 98:
+ return parseIfStatement();
+ case 89:
+ return parseDoStatement();
+ case 114:
+ return parseWhileStatement();
+ case 96:
+ return parseForOrForInOrForOfStatement();
+ case 85:
+ return parseBreakOrContinueStatement(240);
+ case 80:
+ return parseBreakOrContinueStatement(241);
+ case 104:
+ return parseReturnStatement();
+ case 115:
+ return parseWithStatement();
+ case 106:
+ return parseSwitchStatement();
+ case 108:
+ return parseThrowStatement();
+ case 110:
+ case 82:
+ case 95:
+ return parseTryStatement();
+ case 86:
+ return parseDebuggerStatement();
+ case 59:
+ return parseDeclaration();
+ case 129:
+ case 117:
+ case 149:
+ case 139:
+ case 140:
+ case 133:
+ case 84:
+ case 91:
+ case 92:
+ case 99:
+ case 120:
+ case 121:
+ case 122:
+ case 125:
+ case 123:
+ case 142:
+ case 154:
+ if (isStartOfDeclaration()) {
+ return parseDeclaration();
+ }
+ break;
}
- return undefined;
- });
- return typeRoots;
- }
- var nodeModulesAtTypes = ts.combinePaths("node_modules", "@types");
- function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference) {
- var traceEnabled = isTraceEnabled(options, host);
- if (redirectedReference) {
- options = redirectedReference.commandLine.options;
+ return parseExpressionOrLabeledStatement();
}
- var failedLookupLocations = [];
- var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations };
- var typeRoots = getEffectiveTypeRoots(options, host);
- if (traceEnabled) {
- if (containingFile === undefined) {
- if (typeRoots === undefined) {
- trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);
- }
- else {
- trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);
+ function isDeclareModifier(modifier) {
+ return modifier.kind === 133;
+ }
+ function parseDeclaration() {
+ var isAmbient = ts.some(lookAhead(function () { return (parseDecorators(), parseModifiers()); }), isDeclareModifier);
+ if (isAmbient) {
+ var node = tryReuseAmbientDeclaration();
+ if (node) {
+ return node;
}
}
- else {
- if (typeRoots === undefined) {
- trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);
- }
- else {
- trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ var decorators = parseDecorators();
+ var modifiers = parseModifiers();
+ if (isAmbient) {
+ for (var _i = 0, _a = modifiers; _i < _a.length; _i++) {
+ var m = _a[_i];
+ m.flags |= 8388608;
}
+ return doInsideOfContext(8388608, function () { return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers); });
}
- if (redirectedReference) {
- trace(host, ts.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
+ else {
+ return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers);
}
}
- var resolved = primaryLookup();
- var primary = true;
- if (!resolved) {
- resolved = secondaryLookup();
- primary = false;
- }
- var resolvedTypeReferenceDirective;
- if (resolved) {
- var fileName = resolved.fileName, packageId = resolved.packageId;
- var resolvedFileName = options.preserveSymlinks ? fileName : realPath(fileName, host, traceEnabled);
- if (traceEnabled) {
- if (packageId) {
- trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, resolvedFileName, ts.packageIdToString(packageId), primary);
- }
- else {
- trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFileName, primary);
+ function tryReuseAmbientDeclaration() {
+ return doInsideOfContext(8388608, function () {
+ var node = currentNode(parsingContext);
+ if (node) {
+ return consumeNode(node);
}
- }
- resolvedTypeReferenceDirective = { primary: primary, resolvedFileName: resolvedFileName, packageId: packageId, isExternalLibraryImport: pathContainsNodeModules(fileName) };
+ });
}
- return { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations };
- function primaryLookup() {
- if (typeRoots && typeRoots.length) {
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
- }
- return ts.firstDefined(typeRoots, function (typeRoot) {
- var candidate = ts.combinePaths(typeRoot, typeReferenceDirectiveName);
- var candidateDirectory = ts.getDirectoryPath(candidate);
- var directoryExists = ts.directoryProbablyExists(candidateDirectory, host);
- if (!directoryExists && traceEnabled) {
- trace(host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);
+ function parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers) {
+ switch (token()) {
+ case 112:
+ case 118:
+ case 84:
+ return parseVariableStatement(pos, hasJSDoc, decorators, modifiers);
+ case 97:
+ return parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers);
+ case 83:
+ return parseClassDeclaration(pos, hasJSDoc, decorators, modifiers);
+ case 117:
+ return parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers);
+ case 149:
+ return parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers);
+ case 91:
+ return parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers);
+ case 154:
+ case 139:
+ case 140:
+ return parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
+ case 99:
+ return parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers);
+ case 92:
+ nextToken();
+ switch (token()) {
+ case 87:
+ case 62:
+ return parseExportAssignment(pos, hasJSDoc, decorators, modifiers);
+ case 126:
+ return parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers);
+ default:
+ return parseExportDeclaration(pos, hasJSDoc, decorators, modifiers);
}
- return resolvedTypeScriptOnly(loadNodeModuleFromDirectory(Extensions.DtsOnly, candidate, !directoryExists, moduleResolutionState));
- });
+ default:
+ if (decorators || modifiers) {
+ var missing = createMissingNode(271, true, ts.Diagnostics.Declaration_expected);
+ ts.setTextRangePos(missing, pos);
+ missing.decorators = decorators;
+ missing.modifiers = modifiers;
+ return missing;
+ }
+ return undefined;
}
- else {
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);
- }
+ }
+ function nextTokenIsIdentifierOrStringLiteralOnSameLine() {
+ nextToken();
+ return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token() === 10);
+ }
+ function parseFunctionBlockOrSemicolon(flags, diagnosticMessage) {
+ if (token() !== 18 && canParseSemicolon()) {
+ parseSemicolon();
+ return;
}
+ return parseFunctionBlock(flags, diagnosticMessage);
}
- function secondaryLookup() {
- var initialLocationForSecondaryLookup = containingFile && ts.getDirectoryPath(containingFile);
- if (initialLocationForSecondaryLookup !== undefined) {
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
- }
- var result = void 0;
- if (!ts.isExternalModuleNameRelative(typeReferenceDirectiveName)) {
- var searchResult = loadModuleFromNearestNodeModulesDirectory(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, undefined, undefined);
- result = searchResult && searchResult.value;
- }
- else {
- var candidate = ts.normalizePathAndParts(ts.combinePaths(initialLocationForSecondaryLookup, typeReferenceDirectiveName)).path;
- result = nodeLoadModuleByRelativeName(Extensions.DtsOnly, candidate, false, moduleResolutionState, true);
- }
- var resolvedFile = resolvedTypeScriptOnly(result);
- if (!resolvedFile && traceEnabled) {
- trace(host, ts.Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);
- }
- return resolvedFile;
+ function parseArrayBindingElement() {
+ var pos = getNodePos();
+ if (token() === 27) {
+ return finishNode(factory.createOmittedExpression(), pos);
+ }
+ var dotDotDotToken = parseOptionalToken(25);
+ var name = parseIdentifierOrPattern();
+ var initializer = parseInitializer();
+ return finishNode(factory.createBindingElement(dotDotDotToken, undefined, name, initializer), pos);
+ }
+ function parseObjectBindingElement() {
+ var pos = getNodePos();
+ var dotDotDotToken = parseOptionalToken(25);
+ var tokenIsIdentifier = isBindingIdentifier();
+ var propertyName = parsePropertyName();
+ var name;
+ if (tokenIsIdentifier && token() !== 58) {
+ name = propertyName;
+ propertyName = undefined;
}
else {
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);
- }
+ parseExpected(58);
+ name = parseIdentifierOrPattern();
}
+ var initializer = parseInitializer();
+ return finishNode(factory.createBindingElement(dotDotDotToken, propertyName, name, initializer), pos);
}
- }
- ts.resolveTypeReferenceDirective = resolveTypeReferenceDirective;
- function getAutomaticTypeDirectiveNames(options, host) {
- if (options.types) {
- return options.types;
- }
- var result = [];
- if (host.directoryExists && host.getDirectories) {
- var typeRoots = getEffectiveTypeRoots(options, host);
- if (typeRoots) {
- for (var _i = 0, typeRoots_1 = typeRoots; _i < typeRoots_1.length; _i++) {
- var root = typeRoots_1[_i];
- if (host.directoryExists(root)) {
- for (var _a = 0, _b = host.getDirectories(root); _a < _b.length; _a++) {
- var typeDirectivePath = _b[_a];
- var normalized = ts.normalizePath(typeDirectivePath);
- var packageJsonPath = ts.combinePaths(root, normalized, "package.json");
- var isNotNeededPackage = host.fileExists(packageJsonPath) && ts.readJson(packageJsonPath, host).typings === null;
- if (!isNotNeededPackage) {
- var baseFileName = ts.getBaseFileName(normalized);
- if (baseFileName.charCodeAt(0) !== 46) {
- result.push(baseFileName);
- }
- }
- }
- }
- }
- }
+ function parseObjectBindingPattern() {
+ var pos = getNodePos();
+ parseExpected(18);
+ var elements = parseDelimitedList(9, parseObjectBindingElement);
+ parseExpected(19);
+ return finishNode(factory.createObjectBindingPattern(elements), pos);
}
- return result;
- }
- ts.getAutomaticTypeDirectiveNames = getAutomaticTypeDirectiveNames;
- function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options) {
- return createModuleResolutionCacheWithMaps(createCacheWithRedirects(options), createCacheWithRedirects(options), currentDirectory, getCanonicalFileName);
- }
- ts.createModuleResolutionCache = createModuleResolutionCache;
- function createCacheWithRedirects(options) {
- var ownMap = ts.createMap();
- var redirectsMap = ts.createMap();
- return {
- ownMap: ownMap,
- redirectsMap: redirectsMap,
- getOrCreateMapOfCacheRedirects: getOrCreateMapOfCacheRedirects,
- clear: clear,
- setOwnOptions: setOwnOptions,
- setOwnMap: setOwnMap
- };
- function setOwnOptions(newOptions) {
- options = newOptions;
+ function parseArrayBindingPattern() {
+ var pos = getNodePos();
+ parseExpected(22);
+ var elements = parseDelimitedList(10, parseArrayBindingElement);
+ parseExpected(23);
+ return finishNode(factory.createArrayBindingPattern(elements), pos);
}
- function setOwnMap(newOwnMap) {
- ownMap = newOwnMap;
+ function isBindingIdentifierOrPrivateIdentifierOrPattern() {
+ return token() === 18
+ || token() === 22
+ || token() === 79
+ || isBindingIdentifier();
}
- function getOrCreateMapOfCacheRedirects(redirectedReference) {
- if (!redirectedReference) {
- return ownMap;
+ function parseIdentifierOrPattern(privateIdentifierDiagnosticMessage) {
+ if (token() === 22) {
+ return parseArrayBindingPattern();
}
- var path = redirectedReference.sourceFile.path;
- var redirects = redirectsMap.get(path);
- if (!redirects) {
- redirects = !options || ts.optionsHaveModuleResolutionChanges(options, redirectedReference.commandLine.options) ? ts.createMap() : ownMap;
- redirectsMap.set(path, redirects);
+ if (token() === 18) {
+ return parseObjectBindingPattern();
}
- return redirects;
- }
- function clear() {
- ownMap.clear();
- redirectsMap.clear();
+ return parseBindingIdentifier(privateIdentifierDiagnosticMessage);
}
- }
- ts.createCacheWithRedirects = createCacheWithRedirects;
- function createModuleResolutionCacheWithMaps(directoryToModuleNameMap, moduleNameToDirectoryMap, currentDirectory, getCanonicalFileName) {
- return { getOrCreateCacheForDirectory: getOrCreateCacheForDirectory, getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, directoryToModuleNameMap: directoryToModuleNameMap, moduleNameToDirectoryMap: moduleNameToDirectoryMap };
- function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
- var path = ts.toPath(directoryName, currentDirectory, getCanonicalFileName);
- return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, ts.createMap);
- }
- function getOrCreateCacheForModuleName(nonRelativeModuleName, redirectedReference) {
- ts.Debug.assert(!ts.isExternalModuleNameRelative(nonRelativeModuleName));
- return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, nonRelativeModuleName, createPerModuleNameCache);
+ function parseVariableDeclarationAllowExclamation() {
+ return parseVariableDeclaration(true);
}
- function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {
- var cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
- var result = cache.get(key);
- if (!result) {
- result = create();
- cache.set(key, result);
+ function parseVariableDeclaration(allowExclamation) {
+ var pos = getNodePos();
+ var name = parseIdentifierOrPattern(ts.Diagnostics.Private_identifiers_are_not_allowed_in_variable_declarations);
+ var exclamationToken;
+ if (allowExclamation && name.kind === 78 &&
+ token() === 53 && !scanner.hasPrecedingLineBreak()) {
+ exclamationToken = parseTokenNode();
}
- return result;
+ var type = parseTypeAnnotation();
+ var initializer = isInOrOfKeyword(token()) ? undefined : parseInitializer();
+ var node = factory.createVariableDeclaration(name, exclamationToken, type, initializer);
+ return finishNode(node, pos);
}
- function createPerModuleNameCache() {
- var directoryPathMap = ts.createMap();
- return { get: get, set: set };
- function get(directory) {
- return directoryPathMap.get(ts.toPath(directory, currentDirectory, getCanonicalFileName));
+ function parseVariableDeclarationList(inForStatementInitializer) {
+ var pos = getNodePos();
+ var flags = 0;
+ switch (token()) {
+ case 112:
+ break;
+ case 118:
+ flags |= 1;
+ break;
+ case 84:
+ flags |= 2;
+ break;
+ default:
+ ts.Debug.fail();
}
- function set(directory, result) {
- var path = ts.toPath(directory, currentDirectory, getCanonicalFileName);
- if (directoryPathMap.has(path)) {
- return;
- }
- directoryPathMap.set(path, result);
- var resolvedFileName = result.resolvedModule &&
- (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);
- var commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName);
- var current = path;
- while (current !== commonPrefix) {
- var parent = ts.getDirectoryPath(current);
- if (parent === current || directoryPathMap.has(parent)) {
- break;
- }
- directoryPathMap.set(parent, result);
- current = parent;
- }
+ nextToken();
+ var declarations;
+ if (token() === 156 && lookAhead(canFollowContextualOfKeyword)) {
+ declarations = createMissingList();
}
- function getCommonPrefix(directory, resolution) {
- var resolutionDirectory = ts.toPath(ts.getDirectoryPath(resolution), currentDirectory, getCanonicalFileName);
- var i = 0;
- var limit = Math.min(directory.length, resolutionDirectory.length);
- while (i < limit && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) {
- i++;
- }
- if (i === directory.length && (resolutionDirectory.length === i || resolutionDirectory[i] === ts.directorySeparator)) {
- return directory;
- }
- var rootLength = ts.getRootLength(directory);
- if (i < rootLength) {
- return undefined;
- }
- var sep = directory.lastIndexOf(ts.directorySeparator, i - 1);
- if (sep === -1) {
- return undefined;
- }
- return directory.substr(0, Math.max(sep, rootLength));
+ else {
+ var savedDisallowIn = inDisallowInContext();
+ setDisallowInContext(inForStatementInitializer);
+ declarations = parseDelimitedList(8, inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation);
+ setDisallowInContext(savedDisallowIn);
}
+ return finishNode(factory.createVariableDeclarationList(declarations, flags), pos);
}
- }
- ts.createModuleResolutionCacheWithMaps = createModuleResolutionCacheWithMaps;
- function resolveModuleNameFromCache(moduleName, containingFile, cache) {
- var containingDirectory = ts.getDirectoryPath(containingFile);
- var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
- return perFolderCache && perFolderCache.get(moduleName);
- }
- ts.resolveModuleNameFromCache = resolveModuleNameFromCache;
- function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
- var traceEnabled = isTraceEnabled(compilerOptions, host);
- if (redirectedReference) {
- compilerOptions = redirectedReference.commandLine.options;
+ function canFollowContextualOfKeyword() {
+ return nextTokenIsIdentifier() && nextToken() === 21;
}
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
- if (redirectedReference) {
- trace(host, ts.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
- }
+ function parseVariableStatement(pos, hasJSDoc, decorators, modifiers) {
+ var declarationList = parseVariableDeclarationList(false);
+ parseSemicolon();
+ var node = factory.createVariableStatement(modifiers, declarationList);
+ node.decorators = decorators;
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- var containingDirectory = ts.getDirectoryPath(containingFile);
- var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference);
- var result = perFolderCache && perFolderCache.get(moduleName);
- if (result) {
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
+ function parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ var savedAwaitContext = inAwaitContext();
+ var modifierFlags = ts.modifiersToFlags(modifiers);
+ parseExpected(97);
+ var asteriskToken = parseOptionalToken(41);
+ var name = modifierFlags & 512 ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
+ var isGenerator = asteriskToken ? 1 : 0;
+ var isAsync = modifierFlags & 256 ? 2 : 0;
+ var typeParameters = parseTypeParameters();
+ if (modifierFlags & 1)
+ setAwaitContext(true);
+ var parameters = parseParameters(isGenerator | isAsync);
+ var type = parseReturnType(58, false);
+ var body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, ts.Diagnostics.or_expected);
+ setAwaitContext(savedAwaitContext);
+ var node = factory.createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function parseConstructorName() {
+ if (token() === 132) {
+ return parseExpected(132);
+ }
+ if (token() === 10 && lookAhead(nextToken) === 20) {
+ return tryParse(function () {
+ var literalNode = parseLiteralNode();
+ return literalNode.text === "constructor" ? literalNode : undefined;
+ });
}
}
- else {
- var moduleResolution = compilerOptions.moduleResolution;
- if (moduleResolution === undefined) {
- moduleResolution = ts.getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS ? ts.ModuleResolutionKind.NodeJs : ts.ModuleResolutionKind.Classic;
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Module_resolution_kind_is_not_specified_using_0, ts.ModuleResolutionKind[moduleResolution]);
+ function tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ return tryParse(function () {
+ if (parseConstructorName()) {
+ var typeParameters = parseTypeParameters();
+ var parameters = parseParameters(0);
+ var type = parseReturnType(58, false);
+ var body = parseFunctionBlockOrSemicolon(0, ts.Diagnostics.or_expected);
+ var node = factory.createConstructorDeclaration(decorators, modifiers, parameters, body);
+ node.typeParameters = typeParameters;
+ node.type = type;
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
+ });
+ }
+ function parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, exclamationToken, diagnosticMessage) {
+ var isGenerator = asteriskToken ? 1 : 0;
+ var isAsync = ts.some(modifiers, ts.isAsyncModifier) ? 2 : 0;
+ var typeParameters = parseTypeParameters();
+ var parameters = parseParameters(isGenerator | isAsync);
+ var type = parseReturnType(58, false);
+ var body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, diagnosticMessage);
+ var node = factory.createMethodDeclaration(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) {
+ var exclamationToken = !questionToken && !scanner.hasPrecedingLineBreak() ? parseOptionalToken(53) : undefined;
+ var type = parseTypeAnnotation();
+ var initializer = doOutsideOfContext(8192 | 32768 | 4096, parseInitializer);
+ parseSemicolon();
+ var node = factory.createPropertyDeclaration(decorators, modifiers, name, questionToken || exclamationToken, type, initializer);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ var asteriskToken = parseOptionalToken(41);
+ var name = parsePropertyName();
+ var questionToken = parseOptionalToken(57);
+ if (asteriskToken || token() === 20 || token() === 29) {
+ return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, undefined, ts.Diagnostics.or_expected);
+ }
+ return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken);
+ }
+ function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind) {
+ var name = parsePropertyName();
+ var typeParameters = parseTypeParameters();
+ var parameters = parseParameters(0);
+ var type = parseReturnType(58, false);
+ var body = parseFunctionBlockOrSemicolon(0);
+ var node = kind === 167
+ ? factory.createGetAccessorDeclaration(decorators, modifiers, name, parameters, type, body)
+ : factory.createSetAccessorDeclaration(decorators, modifiers, name, parameters, body);
+ node.typeParameters = typeParameters;
+ if (type && node.kind === 168)
+ node.type = type;
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function isClassMemberStart() {
+ var idToken;
+ if (token() === 59) {
+ return true;
}
- else {
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ts.ModuleResolutionKind[moduleResolution]);
+ while (ts.isModifierKind(token())) {
+ idToken = token();
+ if (ts.isClassMemberModifier(idToken)) {
+ return true;
}
+ nextToken();
}
- ts.perfLogger.logStartResolveModule(moduleName);
- switch (moduleResolution) {
- case ts.ModuleResolutionKind.NodeJs:
- result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
- break;
- case ts.ModuleResolutionKind.Classic:
- result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
- break;
- default:
- return ts.Debug.fail("Unexpected moduleResolution: " + moduleResolution);
+ if (token() === 41) {
+ return true;
}
- if (result && result.resolvedModule)
- ts.perfLogger.logInfoEvent("Module \"" + moduleName + "\" resolved to \"" + result.resolvedModule.resolvedFileName + "\"");
- ts.perfLogger.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null");
- if (perFolderCache) {
- perFolderCache.set(moduleName, result);
- if (!ts.isExternalModuleNameRelative(moduleName)) {
- cache.getOrCreateCacheForModuleName(moduleName, redirectedReference).set(containingDirectory, result);
- }
+ if (isLiteralPropertyName()) {
+ idToken = token();
+ nextToken();
}
- }
- if (traceEnabled) {
- if (result.resolvedModule) {
- if (result.resolvedModule.packageId) {
- trace(host, ts.Diagnostics.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2, moduleName, result.resolvedModule.resolvedFileName, ts.packageIdToString(result.resolvedModule.packageId));
+ if (token() === 22) {
+ return true;
+ }
+ if (idToken !== undefined) {
+ if (!ts.isKeyword(idToken) || idToken === 146 || idToken === 134) {
+ return true;
}
- else {
- trace(host, ts.Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);
+ switch (token()) {
+ case 20:
+ case 29:
+ case 53:
+ case 58:
+ case 62:
+ case 57:
+ return true;
+ default:
+ return canParseSemicolon();
}
}
- else {
- trace(host, ts.Diagnostics.Module_name_0_was_not_resolved, moduleName);
- }
- }
- return result;
- }
- ts.resolveModuleName = resolveModuleName;
- function tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state) {
- var resolved = tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state);
- if (resolved)
- return resolved.value;
- if (!ts.isExternalModuleNameRelative(moduleName)) {
- return tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state);
- }
- else {
- return tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state);
+ return false;
}
- }
- function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state) {
- var _a = state.compilerOptions, baseUrl = _a.baseUrl, paths = _a.paths;
- if (baseUrl && paths && !ts.pathIsRelative(moduleName)) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName);
- trace(state.host, ts.Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
+ function parseDecoratorExpression() {
+ if (inAwaitContext() && token() === 130) {
+ var pos = getNodePos();
+ var awaitExpression = parseIdentifier(ts.Diagnostics.Expression_expected);
+ nextToken();
+ var memberExpression = parseMemberExpressionRest(pos, awaitExpression, true);
+ return parseCallExpressionRest(pos, memberExpression);
}
- return tryLoadModuleUsingPaths(extensions, moduleName, baseUrl, paths, loader, false, state);
+ return parseLeftHandSideExpressionOrHigher();
}
- }
- function tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state) {
- if (!state.compilerOptions.rootDirs) {
- return undefined;
+ function tryParseDecorator() {
+ var pos = getNodePos();
+ if (!parseOptional(59)) {
+ return undefined;
+ }
+ var expression = doInDecoratorContext(parseDecoratorExpression);
+ return finishNode(factory.createDecorator(expression), pos);
}
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName);
+ function parseDecorators() {
+ var pos = getNodePos();
+ var list, decorator;
+ while (decorator = tryParseDecorator()) {
+ list = ts.append(list, decorator);
+ }
+ return list && createNodeArray(list, pos);
}
- var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName));
- var matchedRootDir;
- var matchedNormalizedPrefix;
- for (var _i = 0, _a = state.compilerOptions.rootDirs; _i < _a.length; _i++) {
- var rootDir = _a[_i];
- var normalizedRoot = ts.normalizePath(rootDir);
- if (!ts.endsWith(normalizedRoot, ts.directorySeparator)) {
- normalizedRoot += ts.directorySeparator;
+ function tryParseModifier(permitInvalidConstAsModifier) {
+ var pos = getNodePos();
+ var kind = token();
+ if (token() === 84 && permitInvalidConstAsModifier) {
+ if (!tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) {
+ return undefined;
+ }
}
- var isLongestMatchingPrefix = ts.startsWith(candidate, normalizedRoot) &&
- (matchedNormalizedPrefix === undefined || matchedNormalizedPrefix.length < normalizedRoot.length);
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2, normalizedRoot, candidate, isLongestMatchingPrefix);
+ else {
+ if (!parseAnyContextualModifier()) {
+ return undefined;
+ }
}
- if (isLongestMatchingPrefix) {
- matchedNormalizedPrefix = normalizedRoot;
- matchedRootDir = rootDir;
+ return finishNode(factory.createToken(kind), pos);
+ }
+ function parseModifiers(permitInvalidConstAsModifier) {
+ var pos = getNodePos();
+ var list, modifier;
+ while (modifier = tryParseModifier(permitInvalidConstAsModifier)) {
+ list = ts.append(list, modifier);
}
+ return list && createNodeArray(list, pos);
}
- if (matchedNormalizedPrefix) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix);
+ function parseModifiersForArrowFunction() {
+ var modifiers;
+ if (token() === 129) {
+ var pos = getNodePos();
+ nextToken();
+ var modifier = finishNode(factory.createToken(129), pos);
+ modifiers = createNodeArray([modifier], pos);
}
- var suffix = candidate.substr(matchedNormalizedPrefix.length);
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate);
+ return modifiers;
+ }
+ function parseClassElement() {
+ var pos = getNodePos();
+ if (token() === 26) {
+ nextToken();
+ return finishNode(factory.createSemicolonClassElement(), pos);
}
- var resolvedFileName = loader(extensions, candidate, !ts.directoryProbablyExists(containingDirectory, state.host), state);
- if (resolvedFileName) {
- return resolvedFileName;
+ var hasJSDoc = hasPrecedingJSDocComment();
+ var decorators = parseDecorators();
+ var modifiers = parseModifiers(true);
+ if (parseContextualModifier(134)) {
+ return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 167);
}
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Trying_other_entries_in_rootDirs);
+ if (parseContextualModifier(146)) {
+ return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 168);
}
- for (var _b = 0, _c = state.compilerOptions.rootDirs; _b < _c.length; _b++) {
- var rootDir = _c[_b];
- if (rootDir === matchedRootDir) {
- continue;
+ if (token() === 132 || token() === 10) {
+ var constructorDeclaration = tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers);
+ if (constructorDeclaration) {
+ return constructorDeclaration;
}
- var candidate_1 = ts.combinePaths(ts.normalizePath(rootDir), suffix);
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate_1);
+ }
+ if (isIndexSignature()) {
+ return parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers);
+ }
+ if (ts.tokenIsIdentifierOrKeyword(token()) ||
+ token() === 10 ||
+ token() === 8 ||
+ token() === 41 ||
+ token() === 22) {
+ var isAmbient = ts.some(modifiers, isDeclareModifier);
+ if (isAmbient) {
+ for (var _i = 0, _a = modifiers; _i < _a.length; _i++) {
+ var m = _a[_i];
+ m.flags |= 8388608;
+ }
+ return doInsideOfContext(8388608, function () { return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers); });
}
- var baseDirectory = ts.getDirectoryPath(candidate_1);
- var resolvedFileName_1 = loader(extensions, candidate_1, !ts.directoryProbablyExists(baseDirectory, state.host), state);
- if (resolvedFileName_1) {
- return resolvedFileName_1;
+ else {
+ return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers);
}
}
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Module_resolution_using_rootDirs_has_failed);
+ if (decorators || modifiers) {
+ var name = createMissingNode(78, true, ts.Diagnostics.Declaration_expected);
+ return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, undefined);
}
+ return ts.Debug.fail("Should not have attempted to parse class member declaration.");
}
- return undefined;
- }
- function tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state) {
- var baseUrl = state.compilerOptions.baseUrl;
- if (!baseUrl) {
- return undefined;
- }
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName);
- }
- var candidate = ts.normalizePath(ts.combinePaths(baseUrl, moduleName));
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, baseUrl, candidate);
+ function parseClassExpression() {
+ return parseClassDeclarationOrExpression(getNodePos(), hasPrecedingJSDocComment(), undefined, undefined, 221);
}
- return loader(extensions, candidate, !ts.directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state);
- }
- function resolveJSModule(moduleName, initialDir, host) {
- var _a = tryResolveJSModuleWorker(moduleName, initialDir, host), resolvedModule = _a.resolvedModule, failedLookupLocations = _a.failedLookupLocations;
- if (!resolvedModule) {
- throw new Error("Could not resolve JS module '" + moduleName + "' starting at '" + initialDir + "'. Looked in: " + failedLookupLocations.join(", "));
+ function parseClassDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ return parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, 252);
}
- return resolvedModule.resolvedFileName;
- }
- ts.resolveJSModule = resolveJSModule;
- function tryResolveJSModule(moduleName, initialDir, host) {
- var resolvedModule = tryResolveJSModuleWorker(moduleName, initialDir, host).resolvedModule;
- return resolvedModule && resolvedModule.resolvedFileName;
- }
- ts.tryResolveJSModule = tryResolveJSModule;
- var jsOnlyExtensions = [Extensions.JavaScript];
- var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript];
- var tsPlusJsonExtensions = __spreadArrays(tsExtensions, [Extensions.Json]);
- var tsconfigExtensions = [Extensions.TSConfig];
- function tryResolveJSModuleWorker(moduleName, initialDir, host) {
- return nodeModuleNameResolverWorker(moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, undefined, jsOnlyExtensions, undefined);
- }
- function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, lookupConfig) {
- return nodeModuleNameResolverWorker(moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, lookupConfig ? tsconfigExtensions : (compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions), redirectedReference);
- }
- ts.nodeModuleNameResolver = nodeModuleNameResolver;
- function nodeModuleNameResolverWorker(moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) {
- var _a, _b;
- var traceEnabled = isTraceEnabled(compilerOptions, host);
- var failedLookupLocations = [];
- var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations };
- var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
- return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, state.resultFromCache);
- function tryResolve(extensions) {
- var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, true); };
- var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state);
- if (resolved) {
- return toSearchResult({ resolved: resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) });
- }
- if (!ts.isExternalModuleNameRelative(moduleName)) {
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions]);
- }
- var resolved_1 = loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, containingDirectory, state, cache, redirectedReference);
- if (!resolved_1)
- return undefined;
- var resolvedValue = resolved_1.value;
- if (!compilerOptions.preserveSymlinks && resolvedValue && !resolvedValue.originalPath) {
- var path = realPath(resolvedValue.path, host, traceEnabled);
- var originalPath = path === resolvedValue.path ? undefined : resolvedValue.path;
- resolvedValue = __assign(__assign({}, resolvedValue), { path: path, originalPath: originalPath });
- }
- return { value: resolvedValue && { resolved: resolvedValue, isExternalLibraryImport: true } };
+ function parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, kind) {
+ var savedAwaitContext = inAwaitContext();
+ parseExpected(83);
+ var name = parseNameOfClassDeclarationOrExpression();
+ var typeParameters = parseTypeParameters();
+ if (ts.some(modifiers, ts.isExportModifier))
+ setAwaitContext(true);
+ var heritageClauses = parseHeritageClauses();
+ var members;
+ if (parseExpected(18)) {
+ members = parseClassMembers();
+ parseExpected(19);
}
else {
- var _a = ts.normalizePathAndParts(ts.combinePaths(containingDirectory, moduleName)), candidate = _a.path, parts = _a.parts;
- var resolved_2 = nodeLoadModuleByRelativeName(extensions, candidate, false, state, true);
- return resolved_2 && toSearchResult({ resolved: resolved_2, isExternalLibraryImport: ts.contains(parts, "node_modules") });
+ members = createMissingList();
}
+ setAwaitContext(savedAwaitContext);
+ var node = kind === 252
+ ? factory.createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members)
+ : factory.createClassExpression(decorators, modifiers, name, typeParameters, heritageClauses, members);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- }
- function realPath(path, host, traceEnabled) {
- if (!host.realpath) {
- return path;
- }
- var real = ts.normalizePath(host.realpath(path));
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Resolving_real_path_for_0_result_1, path, real);
- }
- ts.Debug.assert(host.fileExists(real), path + " linked to nonexistent file " + real);
- return real;
- }
- function nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, considerPackageJson) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1, candidate, Extensions[extensions]);
+ function parseNameOfClassDeclarationOrExpression() {
+ return isBindingIdentifier() && !isImplementsClause()
+ ? createIdentifier(isBindingIdentifier())
+ : undefined;
}
- if (!ts.hasTrailingDirectorySeparator(candidate)) {
- if (!onlyRecordFailures) {
- var parentOfCandidate = ts.getDirectoryPath(candidate);
- if (!ts.directoryProbablyExists(parentOfCandidate, state.host)) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, parentOfCandidate);
- }
- onlyRecordFailures = true;
- }
- }
- var resolvedFromFile = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state);
- if (resolvedFromFile) {
- var packageDirectory = considerPackageJson ? parseNodeModuleFromPath(resolvedFromFile) : undefined;
- var packageInfo = packageDirectory ? getPackageJsonInfo(packageDirectory, false, state) : undefined;
- return withPackageId(packageInfo, resolvedFromFile);
- }
+ function isImplementsClause() {
+ return token() === 116 && lookAhead(nextTokenIsIdentifierOrKeyword);
}
- if (!onlyRecordFailures) {
- var candidateExists = ts.directoryProbablyExists(candidate, state.host);
- if (!candidateExists) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidate);
- }
- onlyRecordFailures = true;
+ function parseHeritageClauses() {
+ if (isHeritageClause()) {
+ return parseList(22, parseHeritageClause);
}
- }
- return loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson);
- }
- ts.nodeModulesPathPart = "/node_modules/";
- function pathContainsNodeModules(path) {
- return ts.stringContains(path, ts.nodeModulesPathPart);
- }
- ts.pathContainsNodeModules = pathContainsNodeModules;
- function parseNodeModuleFromPath(resolved) {
- var path = ts.normalizePath(resolved.path);
- var idx = path.lastIndexOf(ts.nodeModulesPathPart);
- if (idx === -1) {
return undefined;
}
- var indexAfterNodeModules = idx + ts.nodeModulesPathPart.length;
- var indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterNodeModules);
- if (path.charCodeAt(indexAfterNodeModules) === 64) {
- indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterPackageName);
- }
- return path.slice(0, indexAfterPackageName);
- }
- function moveToNextDirectorySeparatorIfAvailable(path, prevSeparatorIndex) {
- var nextSeparatorIndex = path.indexOf(ts.directorySeparator, prevSeparatorIndex + 1);
- return nextSeparatorIndex === -1 ? prevSeparatorIndex : nextSeparatorIndex;
- }
- function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) {
- return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state));
- }
- function loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) {
- if (extensions === Extensions.Json || extensions === Extensions.TSConfig) {
- var extensionLess = ts.tryRemoveExtension(candidate, ".json");
- return (extensionLess === undefined && extensions === Extensions.Json) ? undefined : tryAddingExtensions(extensionLess || candidate, extensions, onlyRecordFailures, state);
+ function parseHeritageClause() {
+ var pos = getNodePos();
+ var tok = token();
+ ts.Debug.assert(tok === 93 || tok === 116);
+ nextToken();
+ var types = parseDelimitedList(7, parseExpressionWithTypeArguments);
+ return finishNode(factory.createHeritageClause(tok, types), pos);
}
- var resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, onlyRecordFailures, state);
- if (resolvedByAddingExtension) {
- return resolvedByAddingExtension;
+ function parseExpressionWithTypeArguments() {
+ var pos = getNodePos();
+ var expression = parseLeftHandSideExpressionOrHigher();
+ var typeArguments = tryParseTypeArguments();
+ return finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
}
- if (ts.hasJSFileExtension(candidate)) {
- var extensionless = ts.removeFileExtension(candidate);
- if (state.traceEnabled) {
- var extension = candidate.substring(extensionless.length);
- trace(state.host, ts.Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
- }
- return tryAddingExtensions(extensionless, extensions, onlyRecordFailures, state);
+ function tryParseTypeArguments() {
+ return token() === 29 ?
+ parseBracketedList(20, parseType, 29, 31) : undefined;
}
- }
- function tryAddingExtensions(candidate, extensions, onlyRecordFailures, state) {
- if (!onlyRecordFailures) {
- var directory = ts.getDirectoryPath(candidate);
- if (directory) {
- onlyRecordFailures = !ts.directoryProbablyExists(directory, state.host);
- }
+ function isHeritageClause() {
+ return token() === 93 || token() === 116;
}
- switch (extensions) {
- case Extensions.DtsOnly:
- return tryExtension(".d.ts");
- case Extensions.TypeScript:
- return tryExtension(".ts") || tryExtension(".tsx") || tryExtension(".d.ts");
- case Extensions.JavaScript:
- return tryExtension(".js") || tryExtension(".jsx");
- case Extensions.TSConfig:
- case Extensions.Json:
- return tryExtension(".json");
+ function parseClassMembers() {
+ return parseList(5, parseClassElement);
}
- function tryExtension(ext) {
- var path = tryFile(candidate + ext, onlyRecordFailures, state);
- return path === undefined ? undefined : { path: path, ext: ext };
+ function parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ parseExpected(117);
+ var name = parseIdentifier();
+ var typeParameters = parseTypeParameters();
+ var heritageClauses = parseHeritageClauses();
+ var members = parseObjectTypeMembers();
+ var node = factory.createInterfaceDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ parseExpected(149);
+ var name = parseIdentifier();
+ var typeParameters = parseTypeParameters();
+ parseExpected(62);
+ var type = token() === 136 && tryParse(parseKeywordAndNoDot) || parseType();
+ parseSemicolon();
+ var node = factory.createTypeAliasDeclaration(decorators, modifiers, name, typeParameters, type);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- }
- function tryFile(fileName, onlyRecordFailures, state) {
- if (!onlyRecordFailures) {
- if (state.host.fileExists(fileName)) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
- }
- return fileName;
+ function parseEnumMember() {
+ var pos = getNodePos();
+ var hasJSDoc = hasPrecedingJSDocComment();
+ var name = parsePropertyName();
+ var initializer = allowInAnd(parseInitializer);
+ return withJSDoc(finishNode(factory.createEnumMember(name, initializer), pos), hasJSDoc);
+ }
+ function parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ parseExpected(91);
+ var name = parseIdentifier();
+ var members;
+ if (parseExpected(18)) {
+ members = doOutsideOfYieldAndAwaitContext(function () { return parseDelimitedList(6, parseEnumMember); });
+ parseExpected(19);
}
else {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.File_0_does_not_exist, fileName);
- }
+ members = createMissingList();
}
+ var node = factory.createEnumDeclaration(decorators, modifiers, name, members);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- state.failedLookupLocations.push(fileName);
- return undefined;
- }
- function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson) {
- if (considerPackageJson === void 0) { considerPackageJson = true; }
- var packageInfo = considerPackageJson ? getPackageJsonInfo(candidate, onlyRecordFailures, state) : undefined;
- var packageJsonContent = packageInfo && packageInfo.packageJsonContent;
- var versionPaths = packageInfo && packageInfo.versionPaths;
- return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths));
- }
- function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
- var host = state.host, traceEnabled = state.traceEnabled;
- var directoryExists = !onlyRecordFailures && ts.directoryProbablyExists(packageDirectory, host);
- var packageJsonPath = ts.combinePaths(packageDirectory, "package.json");
- if (directoryExists && host.fileExists(packageJsonPath)) {
- var packageJsonContent = ts.readJson(packageJsonPath, host);
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath);
+ function parseModuleBlock() {
+ var pos = getNodePos();
+ var statements;
+ if (parseExpected(18)) {
+ statements = parseList(1, parseStatement);
+ parseExpected(19);
}
- var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
- return { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths };
- }
- else {
- if (directoryExists && traceEnabled) {
- trace(host, ts.Diagnostics.File_0_does_not_exist, packageJsonPath);
+ else {
+ statements = createMissingList();
}
- state.failedLookupLocations.push(packageJsonPath);
+ return finishNode(factory.createModuleBlock(statements), pos);
}
- }
- function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
- var packageFile;
- if (jsonContent) {
- switch (extensions) {
- case Extensions.JavaScript:
- case Extensions.Json:
- packageFile = readPackageJsonMainField(jsonContent, candidate, state);
- break;
- case Extensions.TypeScript:
- packageFile = readPackageJsonTypesFields(jsonContent, candidate, state) || readPackageJsonMainField(jsonContent, candidate, state);
- break;
- case Extensions.DtsOnly:
- packageFile = readPackageJsonTypesFields(jsonContent, candidate, state);
- break;
- case Extensions.TSConfig:
- packageFile = readPackageJsonTSConfigField(jsonContent, candidate, state);
- break;
- default:
- return ts.Debug.assertNever(extensions);
+ function parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags) {
+ var namespaceFlag = flags & 16;
+ var name = parseIdentifier();
+ var body = parseOptional(24)
+ ? parseModuleOrNamespaceDeclaration(getNodePos(), false, undefined, undefined, 4 | namespaceFlag)
+ : parseModuleBlock();
+ var node = factory.createModuleDeclaration(decorators, modifiers, name, body, flags);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ var flags = 0;
+ var name;
+ if (token() === 154) {
+ name = parseIdentifier();
+ flags |= 1024;
+ }
+ else {
+ name = parseLiteralNode();
+ name.text = internIdentifier(name.text);
+ }
+ var body;
+ if (token() === 18) {
+ body = parseModuleBlock();
+ }
+ else {
+ parseSemicolon();
}
+ var node = factory.createModuleDeclaration(decorators, modifiers, name, body, flags);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- var loader = function (extensions, candidate, onlyRecordFailures, state) {
- var fromFile = tryFile(candidate, onlyRecordFailures, state);
- if (fromFile) {
- var resolved = resolvedIfExtensionMatches(extensions, fromFile);
- if (resolved) {
- return noPackageId(resolved);
- }
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.File_0_has_an_unsupported_extension_so_skipping_it, fromFile);
- }
+ function parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ var flags = 0;
+ if (token() === 154) {
+ return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
}
- var nextExtensions = extensions === Extensions.DtsOnly ? Extensions.TypeScript : extensions;
- return nodeLoadModuleByRelativeName(nextExtensions, candidate, onlyRecordFailures, state, false);
- };
- var onlyRecordFailuresForPackageFile = packageFile ? !ts.directoryProbablyExists(ts.getDirectoryPath(packageFile), state.host) : undefined;
- var onlyRecordFailuresForIndex = onlyRecordFailures || !ts.directoryProbablyExists(candidate, state.host);
- var indexPath = ts.combinePaths(candidate, extensions === Extensions.TSConfig ? "tsconfig" : "index");
- if (versionPaths && (!packageFile || ts.containsPath(candidate, packageFile))) {
- var moduleName = ts.getRelativePathFromDirectory(candidate, packageFile || indexPath, false);
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, ts.version, moduleName);
+ else if (parseOptional(140)) {
+ flags |= 16;
}
- var result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
- if (result) {
- return removeIgnoredPackageId(result.value);
+ else {
+ parseExpected(139);
+ if (token() === 10) {
+ return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
+ }
}
+ return parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags);
}
- var packageFileResult = packageFile && removeIgnoredPackageId(loader(extensions, packageFile, onlyRecordFailuresForPackageFile, state));
- if (packageFileResult)
- return packageFileResult;
- return loadModuleFromFile(extensions, indexPath, onlyRecordFailuresForIndex, state);
- }
- function resolvedIfExtensionMatches(extensions, path) {
- var ext = ts.tryGetExtensionFromPath(path);
- return ext !== undefined && extensionIsOk(extensions, ext) ? { path: path, ext: ext } : undefined;
- }
- function extensionIsOk(extensions, extension) {
- switch (extensions) {
- case Extensions.JavaScript:
- return extension === ".js" || extension === ".jsx";
- case Extensions.TSConfig:
- case Extensions.Json:
- return extension === ".json";
- case Extensions.TypeScript:
- return extension === ".ts" || extension === ".tsx" || extension === ".d.ts";
- case Extensions.DtsOnly:
- return extension === ".d.ts";
+ function isExternalModuleReference() {
+ return token() === 143 &&
+ lookAhead(nextTokenIsOpenParen);
}
- }
- function parsePackageName(moduleName) {
- var idx = moduleName.indexOf(ts.directorySeparator);
- if (moduleName[0] === "@") {
- idx = moduleName.indexOf(ts.directorySeparator, idx + 1);
+ function nextTokenIsOpenParen() {
+ return nextToken() === 20;
}
- return idx === -1 ? { packageName: moduleName, rest: "" } : { packageName: moduleName.slice(0, idx), rest: moduleName.slice(idx + 1) };
- }
- ts.parsePackageName = parsePackageName;
- function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) {
- return loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, false, cache, redirectedReference);
- }
- function loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, directory, state) {
- return loadModuleFromNearestNodeModulesDirectoryWorker(Extensions.DtsOnly, moduleName, directory, state, true, undefined, undefined);
- }
- function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
- var perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, redirectedReference);
- return ts.forEachAncestorDirectory(ts.normalizeSlashes(directory), function (ancestorDirectory) {
- if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
- var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
- if (resolutionFromCache) {
- return resolutionFromCache;
- }
- return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, ancestorDirectory, state, typesScopeOnly));
- }
- });
- }
- function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly) {
- var nodeModulesFolder = ts.combinePaths(directory, "node_modules");
- var nodeModulesFolderExists = ts.directoryProbablyExists(nodeModulesFolder, state.host);
- if (!nodeModulesFolderExists && state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder);
+ function nextTokenIsSlash() {
+ return nextToken() === 43;
}
- var packageResult = typesScopeOnly ? undefined : loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state);
- if (packageResult) {
- return packageResult;
+ function parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ parseExpected(126);
+ parseExpected(140);
+ var name = parseIdentifier();
+ parseSemicolon();
+ var node = factory.createNamespaceExportDeclaration(name);
+ node.decorators = decorators;
+ node.modifiers = modifiers;
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- if (extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) {
- var nodeModulesAtTypes_1 = ts.combinePaths(nodeModulesFolder, "@types");
- var nodeModulesAtTypesExists = nodeModulesFolderExists;
- if (nodeModulesFolderExists && !ts.directoryProbablyExists(nodeModulesAtTypes_1, state.host)) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesAtTypes_1);
- }
- nodeModulesAtTypesExists = false;
+ function parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ parseExpected(99);
+ var afterImportPos = scanner.getStartPos();
+ var identifier;
+ if (isIdentifier()) {
+ identifier = parseIdentifier();
}
- return loadModuleFromSpecificNodeModulesDirectory(Extensions.DtsOnly, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes_1, nodeModulesAtTypesExists, state);
- }
- }
- function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state) {
- var candidate = ts.normalizePath(ts.combinePaths(nodeModulesDirectory, moduleName));
- var packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state);
- if (packageInfo) {
- var fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
- if (fromFile) {
- return noPackageId(fromFile);
+ var isTypeOnly = false;
+ if (token() !== 153 &&
+ (identifier === null || identifier === void 0 ? void 0 : identifier.escapedText) === "type" &&
+ (isIdentifier() || tokenAfterImportDefinitelyProducesImportDeclaration())) {
+ isTypeOnly = true;
+ identifier = isIdentifier() ? parseIdentifier() : undefined;
}
- var fromDirectory = loadNodeModuleFromDirectoryWorker(extensions, candidate, !nodeModulesDirectoryExists, state, packageInfo.packageJsonContent, packageInfo.versionPaths);
- return withPackageId(packageInfo, fromDirectory);
+ if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration()) {
+ return parseImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers, identifier, isTypeOnly);
+ }
+ var importClause;
+ if (identifier ||
+ token() === 41 ||
+ token() === 18) {
+ importClause = parseImportClause(identifier, afterImportPos, isTypeOnly);
+ parseExpected(153);
+ }
+ var moduleSpecifier = parseModuleSpecifier();
+ parseSemicolon();
+ var node = factory.createImportDeclaration(decorators, modifiers, importClause, moduleSpecifier);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function tokenAfterImportDefinitelyProducesImportDeclaration() {
+ return token() === 41 || token() === 18;
+ }
+ function tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() {
+ return token() === 27 || token() === 153;
}
- var loader = function (extensions, candidate, onlyRecordFailures, state) {
- var pathAndExtension = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) ||
- loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo && packageInfo.packageJsonContent, packageInfo && packageInfo.versionPaths);
- return withPackageId(packageInfo, pathAndExtension);
- };
- var _a = parsePackageName(moduleName), packageName = _a.packageName, rest = _a.rest;
- if (rest !== "") {
- var packageDirectory = ts.combinePaths(nodeModulesDirectory, packageName);
- packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
- if (packageInfo && packageInfo.versionPaths) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, packageInfo.versionPaths.version, ts.version, rest);
- }
- var packageDirectoryExists = nodeModulesDirectoryExists && ts.directoryProbablyExists(packageDirectory, state.host);
- var fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.versionPaths.paths, loader, !packageDirectoryExists, state);
- if (fromPaths) {
- return fromPaths.value;
- }
+ function parseImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers, identifier, isTypeOnly) {
+ parseExpected(62);
+ var moduleReference = parseModuleReference();
+ parseSemicolon();
+ var node = factory.createImportEqualsDeclaration(decorators, modifiers, identifier, moduleReference);
+ var finished = withJSDoc(finishNode(node, pos), hasJSDoc);
+ if (isTypeOnly) {
+ parseErrorAtRange(finished, ts.Diagnostics.Only_ECMAScript_imports_may_use_import_type);
}
+ return finished;
}
- return loader(extensions, candidate, !nodeModulesDirectoryExists, state);
- }
- function tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, loader, onlyRecordFailures, state) {
- var matchedPattern = ts.matchPatternOrExact(ts.getOwnKeys(paths), moduleName);
- if (matchedPattern) {
- var matchedStar_1 = ts.isString(matchedPattern) ? undefined : ts.matchedText(matchedPattern, moduleName);
- var matchedPatternText = ts.isString(matchedPattern) ? matchedPattern : ts.patternText(matchedPattern);
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
+ function parseImportClause(identifier, pos, isTypeOnly) {
+ var namedBindings;
+ if (!identifier ||
+ parseOptional(27)) {
+ namedBindings = token() === 41 ? parseNamespaceImport() : parseNamedImportsOrExports(264);
}
- var resolved = ts.forEach(paths[matchedPatternText], function (subst) {
- var path = matchedStar_1 ? subst.replace("*", matchedStar_1) : subst;
- var candidate = ts.normalizePath(ts.combinePaths(baseDirectory, path));
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path);
- }
- var extension = ts.tryGetExtensionFromPath(candidate);
- if (extension !== undefined) {
- var path_1 = tryFile(candidate, onlyRecordFailures, state);
- if (path_1 !== undefined) {
- return noPackageId({ path: path_1, ext: extension });
- }
- }
- return loader(extensions, candidate, onlyRecordFailures || !ts.directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state);
- });
- return { value: resolved };
+ return finishNode(factory.createImportClause(isTypeOnly, identifier, namedBindings), pos);
}
- }
- var mangledScopedPackageSeparator = "__";
- function mangleScopedPackageNameWithTrace(packageName, state) {
- var mangled = mangleScopedPackageName(packageName);
- if (state.traceEnabled && mangled !== packageName) {
- trace(state.host, ts.Diagnostics.Scoped_package_detected_looking_in_0, mangled);
+ function parseModuleReference() {
+ return isExternalModuleReference()
+ ? parseExternalModuleReference()
+ : parseEntityName(false);
}
- return mangled;
- }
- function getTypesPackageName(packageName) {
- return "@types/" + mangleScopedPackageName(packageName);
- }
- ts.getTypesPackageName = getTypesPackageName;
- function mangleScopedPackageName(packageName) {
- if (ts.startsWith(packageName, "@")) {
- var replaceSlash = packageName.replace(ts.directorySeparator, mangledScopedPackageSeparator);
- if (replaceSlash !== packageName) {
- return replaceSlash.slice(1);
+ function parseExternalModuleReference() {
+ var pos = getNodePos();
+ parseExpected(143);
+ parseExpected(20);
+ var expression = parseModuleSpecifier();
+ parseExpected(21);
+ return finishNode(factory.createExternalModuleReference(expression), pos);
+ }
+ function parseModuleSpecifier() {
+ if (token() === 10) {
+ var result = parseLiteralNode();
+ result.text = internIdentifier(result.text);
+ return result;
+ }
+ else {
+ return parseExpression();
}
}
- return packageName;
- }
- ts.mangleScopedPackageName = mangleScopedPackageName;
- function getPackageNameFromTypesPackageName(mangledName) {
- var withoutAtTypePrefix = ts.removePrefix(mangledName, "@types/");
- if (withoutAtTypePrefix !== mangledName) {
- return unmangleScopedPackageName(withoutAtTypePrefix);
+ function parseNamespaceImport() {
+ var pos = getNodePos();
+ parseExpected(41);
+ parseExpected(126);
+ var name = parseIdentifier();
+ return finishNode(factory.createNamespaceImport(name), pos);
}
- return mangledName;
- }
- ts.getPackageNameFromTypesPackageName = getPackageNameFromTypesPackageName;
- function unmangleScopedPackageName(typesPackageName) {
- return ts.stringContains(typesPackageName, mangledScopedPackageSeparator) ?
- "@" + typesPackageName.replace(mangledScopedPackageSeparator, ts.directorySeparator) :
- typesPackageName;
- }
- ts.unmangleScopedPackageName = unmangleScopedPackageName;
- function tryFindNonRelativeModuleNameInCache(cache, moduleName, containingDirectory, state) {
- var result = cache && cache.get(containingDirectory);
- if (result) {
- if (state.traceEnabled) {
- trace(state.host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
- }
- state.resultFromCache = result;
- return { value: result.resolvedModule && { path: result.resolvedModule.resolvedFileName, originalPath: result.resolvedModule.originalPath || true, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId } };
+ function parseNamedImportsOrExports(kind) {
+ var pos = getNodePos();
+ var node = kind === 264
+ ? factory.createNamedImports(parseBracketedList(23, parseImportSpecifier, 18, 19))
+ : factory.createNamedExports(parseBracketedList(23, parseExportSpecifier, 18, 19));
+ return finishNode(node, pos);
}
- }
- function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
- var traceEnabled = isTraceEnabled(compilerOptions, host);
- var failedLookupLocations = [];
- var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations };
- var containingDirectory = ts.getDirectoryPath(containingFile);
- var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
- return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, false, failedLookupLocations, state.resultFromCache);
- function tryResolve(extensions) {
- var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
- if (resolvedUsingSettings) {
- return { value: resolvedUsingSettings };
+ function parseExportSpecifier() {
+ return parseImportOrExportSpecifier(270);
+ }
+ function parseImportSpecifier() {
+ return parseImportOrExportSpecifier(265);
+ }
+ function parseImportOrExportSpecifier(kind) {
+ var pos = getNodePos();
+ var checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier();
+ var checkIdentifierStart = scanner.getTokenPos();
+ var checkIdentifierEnd = scanner.getTextPos();
+ var identifierName = parseIdentifierName();
+ var propertyName;
+ var name;
+ if (token() === 126) {
+ propertyName = identifierName;
+ parseExpected(126);
+ checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier();
+ checkIdentifierStart = scanner.getTokenPos();
+ checkIdentifierEnd = scanner.getTextPos();
+ name = parseIdentifierName();
}
- if (!ts.isExternalModuleNameRelative(moduleName)) {
- var perModuleNameCache_1 = cache && cache.getOrCreateCacheForModuleName(moduleName, redirectedReference);
- var resolved_3 = ts.forEachAncestorDirectory(containingDirectory, function (directory) {
- var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache_1, moduleName, directory, state);
- if (resolutionFromCache) {
- return resolutionFromCache;
- }
- var searchName = ts.normalizePath(ts.combinePaths(directory, moduleName));
- return toSearchResult(loadModuleFromFileNoPackageId(extensions, searchName, false, state));
- });
- if (resolved_3) {
- return resolved_3;
+ else {
+ name = identifierName;
+ }
+ if (kind === 265 && checkIdentifierIsKeyword) {
+ parseErrorAt(checkIdentifierStart, checkIdentifierEnd, ts.Diagnostics.Identifier_expected);
+ }
+ var node = kind === 265
+ ? factory.createImportSpecifier(propertyName, name)
+ : factory.createExportSpecifier(propertyName, name);
+ return finishNode(node, pos);
+ }
+ function parseNamespaceExport(pos) {
+ return finishNode(factory.createNamespaceExport(parseIdentifierName()), pos);
+ }
+ function parseExportDeclaration(pos, hasJSDoc, decorators, modifiers) {
+ var savedAwaitContext = inAwaitContext();
+ setAwaitContext(true);
+ var exportClause;
+ var moduleSpecifier;
+ var isTypeOnly = parseOptional(149);
+ var namespaceExportPos = getNodePos();
+ if (parseOptional(41)) {
+ if (parseOptional(126)) {
+ exportClause = parseNamespaceExport(namespaceExportPos);
}
- if (extensions === Extensions.TypeScript) {
- return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
+ parseExpected(153);
+ moduleSpecifier = parseModuleSpecifier();
+ }
+ else {
+ exportClause = parseNamedImportsOrExports(268);
+ if (token() === 153 || (token() === 10 && !scanner.hasPrecedingLineBreak())) {
+ parseExpected(153);
+ moduleSpecifier = parseModuleSpecifier();
}
}
+ parseSemicolon();
+ setAwaitContext(savedAwaitContext);
+ var node = factory.createExportDeclaration(decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
+ }
+ function parseExportAssignment(pos, hasJSDoc, decorators, modifiers) {
+ var savedAwaitContext = inAwaitContext();
+ setAwaitContext(true);
+ var isExportEquals;
+ if (parseOptional(62)) {
+ isExportEquals = true;
+ }
else {
- var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName));
- return toSearchResult(loadModuleFromFileNoPackageId(extensions, candidate, false, state));
+ parseExpected(87);
}
+ var expression = parseAssignmentExpressionOrHigher();
+ parseSemicolon();
+ setAwaitContext(savedAwaitContext);
+ var node = factory.createExportAssignment(decorators, modifiers, isExportEquals, expression);
+ return withJSDoc(finishNode(node, pos), hasJSDoc);
}
- }
- ts.classicNameResolver = classicNameResolver;
- function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, host, globalCache) {
- var traceEnabled = isTraceEnabled(compilerOptions, host);
- if (traceEnabled) {
- trace(host, ts.Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache);
+ function setExternalModuleIndicator(sourceFile) {
+ sourceFile.externalModuleIndicator =
+ ts.forEach(sourceFile.statements, isAnExternalModuleIndicatorNode) ||
+ getImportMetaIfNecessary(sourceFile);
}
- var failedLookupLocations = [];
- var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations };
- var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, false);
- return createResolvedModuleWithFailedLookupLocations(resolved, true, failedLookupLocations, state.resultFromCache);
- }
- ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache;
- function toSearchResult(value) {
- return value !== undefined ? { value: value } : undefined;
- }
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- function getModuleInstanceState(node, visited) {
- if (node.body && !node.body.parent) {
- setParentPointers(node, node.body);
+ function isAnExternalModuleIndicatorNode(node) {
+ return hasModifierOfKind(node, 92)
+ || ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)
+ || ts.isImportDeclaration(node)
+ || ts.isExportAssignment(node)
+ || ts.isExportDeclaration(node) ? node : undefined;
}
- return node.body ? getModuleInstanceStateCached(node.body, visited) : 1;
- }
- ts.getModuleInstanceState = getModuleInstanceState;
- function getModuleInstanceStateCached(node, visited) {
- if (visited === void 0) { visited = ts.createMap(); }
- var nodeId = "" + ts.getNodeId(node);
- if (visited.has(nodeId)) {
- return visited.get(nodeId) || 0;
+ function getImportMetaIfNecessary(sourceFile) {
+ return sourceFile.flags & 2097152 ?
+ walkTreeForExternalModuleIndicators(sourceFile) :
+ undefined;
}
- visited.set(nodeId, undefined);
- var result = getModuleInstanceStateWorker(node, visited);
- visited.set(nodeId, result);
- return result;
- }
- function getModuleInstanceStateWorker(node, visited) {
- switch (node.kind) {
- case 246:
- case 247:
- return 0;
- case 248:
- if (ts.isEnumConst(node)) {
- return 2;
+ function walkTreeForExternalModuleIndicators(node) {
+ return isImportMeta(node) ? node : forEachChild(node, walkTreeForExternalModuleIndicators);
+ }
+ function hasModifierOfKind(node, kind) {
+ return ts.some(node.modifiers, function (m) { return m.kind === kind; });
+ }
+ function isImportMeta(node) {
+ return ts.isMetaProperty(node) && node.keywordToken === 99 && node.name.escapedText === "meta";
+ }
+ var JSDocParser;
+ (function (JSDocParser) {
+ function parseJSDocTypeExpressionForTests(content, start, length) {
+ initializeState("file.js", content, 99, undefined, 1);
+ scanner.setText(content, start, length);
+ currentToken = scanner.scan();
+ var jsDocTypeExpression = parseJSDocTypeExpression();
+ var sourceFile = createSourceFile("file.js", 99, 1, false, [], factory.createToken(1), 0);
+ var diagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile);
+ if (jsDocDiagnostics) {
+ sourceFile.jsDocDiagnostics = ts.attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
+ }
+ clearState();
+ return jsDocTypeExpression ? { jsDocTypeExpression: jsDocTypeExpression, diagnostics: diagnostics } : undefined;
+ }
+ JSDocParser.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests;
+ function parseJSDocTypeExpression(mayOmitBraces) {
+ var pos = getNodePos();
+ var hasBrace = (mayOmitBraces ? parseOptional : parseExpected)(18);
+ var type = doInsideOfContext(4194304, parseJSDocType);
+ if (!mayOmitBraces || hasBrace) {
+ parseExpectedJSDoc(19);
+ }
+ var result = factory.createJSDocTypeExpression(type);
+ fixupParentReferences(result);
+ return finishNode(result, pos);
+ }
+ JSDocParser.parseJSDocTypeExpression = parseJSDocTypeExpression;
+ function parseJSDocNameReference() {
+ var pos = getNodePos();
+ var hasBrace = parseOptional(18);
+ var entityName = parseEntityName(false);
+ if (hasBrace) {
+ parseExpectedJSDoc(19);
+ }
+ var result = factory.createJSDocNameReference(entityName);
+ fixupParentReferences(result);
+ return finishNode(result, pos);
+ }
+ JSDocParser.parseJSDocNameReference = parseJSDocNameReference;
+ function parseIsolatedJSDocComment(content, start, length) {
+ initializeState("", content, 99, undefined, 1);
+ var jsDoc = doInsideOfContext(4194304, function () { return parseJSDocCommentWorker(start, length); });
+ var sourceFile = { languageVariant: 0, text: content };
+ var diagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile);
+ clearState();
+ return jsDoc ? { jsDoc: jsDoc, diagnostics: diagnostics } : undefined;
+ }
+ JSDocParser.parseIsolatedJSDocComment = parseIsolatedJSDocComment;
+ function parseJSDocComment(parent, start, length) {
+ var saveToken = currentToken;
+ var saveParseDiagnosticsLength = parseDiagnostics.length;
+ var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
+ var comment = doInsideOfContext(4194304, function () { return parseJSDocCommentWorker(start, length); });
+ ts.setParent(comment, parent);
+ if (contextFlags & 131072) {
+ if (!jsDocDiagnostics) {
+ jsDocDiagnostics = [];
+ }
+ jsDocDiagnostics.push.apply(jsDocDiagnostics, parseDiagnostics);
+ }
+ currentToken = saveToken;
+ parseDiagnostics.length = saveParseDiagnosticsLength;
+ parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
+ return comment;
+ }
+ JSDocParser.parseJSDocComment = parseJSDocComment;
+ function parseJSDocCommentWorker(start, length) {
+ if (start === void 0) { start = 0; }
+ var content = sourceText;
+ var end = length === undefined ? content.length : start + length;
+ length = end - start;
+ ts.Debug.assert(start >= 0);
+ ts.Debug.assert(start <= end);
+ ts.Debug.assert(end <= content.length);
+ if (!isJSDocLikeText(content, start)) {
+ return undefined;
+ }
+ var tags;
+ var tagsPos;
+ var tagsEnd;
+ var comments = [];
+ return scanner.scanRange(start + 3, length - 5, function () {
+ var state = 1;
+ var margin;
+ var indent = start - (content.lastIndexOf("\n", start) + 1) + 4;
+ function pushComment(text) {
+ if (!margin) {
+ margin = indent;
+ }
+ comments.push(text);
+ indent += text.length;
+ }
+ nextTokenJSDoc();
+ while (parseOptionalJsdoc(5))
+ ;
+ if (parseOptionalJsdoc(4)) {
+ state = 0;
+ indent = 0;
+ }
+ loop: while (true) {
+ switch (token()) {
+ case 59:
+ if (state === 0 || state === 1) {
+ removeTrailingWhitespace(comments);
+ addTag(parseTag(indent));
+ state = 0;
+ margin = undefined;
+ }
+ else {
+ pushComment(scanner.getTokenText());
+ }
+ break;
+ case 4:
+ comments.push(scanner.getTokenText());
+ state = 0;
+ indent = 0;
+ break;
+ case 41:
+ var asterisk = scanner.getTokenText();
+ if (state === 1 || state === 2) {
+ state = 2;
+ pushComment(asterisk);
+ }
+ else {
+ state = 1;
+ indent += asterisk.length;
+ }
+ break;
+ case 5:
+ var whitespace = scanner.getTokenText();
+ if (state === 2) {
+ comments.push(whitespace);
+ }
+ else if (margin !== undefined && indent + whitespace.length > margin) {
+ comments.push(whitespace.slice(margin - indent));
+ }
+ indent += whitespace.length;
+ break;
+ case 1:
+ break loop;
+ default:
+ state = 2;
+ pushComment(scanner.getTokenText());
+ break;
+ }
+ nextTokenJSDoc();
+ }
+ removeLeadingNewlines(comments);
+ removeTrailingWhitespace(comments);
+ return createJSDocComment();
+ });
+ function removeLeadingNewlines(comments) {
+ while (comments.length && (comments[0] === "\n" || comments[0] === "\r")) {
+ comments.shift();
+ }
+ }
+ function removeTrailingWhitespace(comments) {
+ while (comments.length && comments[comments.length - 1].trim() === "") {
+ comments.pop();
+ }
+ }
+ function createJSDocComment() {
+ var comment = comments.length ? comments.join("") : undefined;
+ var tagsArray = tags && createNodeArray(tags, tagsPos, tagsEnd);
+ return finishNode(factory.createJSDocComment(comment, tagsArray), start, end);
+ }
+ function isNextNonwhitespaceTokenEndOfFile() {
+ while (true) {
+ nextTokenJSDoc();
+ if (token() === 1) {
+ return true;
+ }
+ if (!(token() === 5 || token() === 4)) {
+ return false;
+ }
+ }
+ }
+ function skipWhitespace() {
+ if (token() === 5 || token() === 4) {
+ if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) {
+ return;
+ }
+ }
+ while (token() === 5 || token() === 4) {
+ nextTokenJSDoc();
+ }
+ }
+ function skipWhitespaceOrAsterisk() {
+ if (token() === 5 || token() === 4) {
+ if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) {
+ return "";
+ }
+ }
+ var precedingLineBreak = scanner.hasPrecedingLineBreak();
+ var seenLineBreak = false;
+ var indentText = "";
+ while ((precedingLineBreak && token() === 41) || token() === 5 || token() === 4) {
+ indentText += scanner.getTokenText();
+ if (token() === 4) {
+ precedingLineBreak = true;
+ seenLineBreak = true;
+ indentText = "";
+ }
+ else if (token() === 41) {
+ precedingLineBreak = false;
+ }
+ nextTokenJSDoc();
+ }
+ return seenLineBreak ? indentText : "";
+ }
+ function parseTag(margin) {
+ ts.Debug.assert(token() === 59);
+ var start = scanner.getTokenPos();
+ nextTokenJSDoc();
+ var tagName = parseJSDocIdentifierName(undefined);
+ var indentText = skipWhitespaceOrAsterisk();
+ var tag;
+ switch (tagName.escapedText) {
+ case "author":
+ tag = parseAuthorTag(start, tagName, margin, indentText);
+ break;
+ case "implements":
+ tag = parseImplementsTag(start, tagName, margin, indentText);
+ break;
+ case "augments":
+ case "extends":
+ tag = parseAugmentsTag(start, tagName, margin, indentText);
+ break;
+ case "class":
+ case "constructor":
+ tag = parseSimpleTag(start, factory.createJSDocClassTag, tagName, margin, indentText);
+ break;
+ case "public":
+ tag = parseSimpleTag(start, factory.createJSDocPublicTag, tagName, margin, indentText);
+ break;
+ case "private":
+ tag = parseSimpleTag(start, factory.createJSDocPrivateTag, tagName, margin, indentText);
+ break;
+ case "protected":
+ tag = parseSimpleTag(start, factory.createJSDocProtectedTag, tagName, margin, indentText);
+ break;
+ case "readonly":
+ tag = parseSimpleTag(start, factory.createJSDocReadonlyTag, tagName, margin, indentText);
+ break;
+ case "deprecated":
+ hasDeprecatedTag = true;
+ tag = parseSimpleTag(start, factory.createJSDocDeprecatedTag, tagName, margin, indentText);
+ break;
+ case "this":
+ tag = parseThisTag(start, tagName, margin, indentText);
+ break;
+ case "enum":
+ tag = parseEnumTag(start, tagName, margin, indentText);
+ break;
+ case "arg":
+ case "argument":
+ case "param":
+ return parseParameterOrPropertyTag(start, tagName, 2, margin);
+ case "return":
+ case "returns":
+ tag = parseReturnTag(start, tagName, margin, indentText);
+ break;
+ case "template":
+ tag = parseTemplateTag(start, tagName, margin, indentText);
+ break;
+ case "type":
+ tag = parseTypeTag(start, tagName, margin, indentText);
+ break;
+ case "typedef":
+ tag = parseTypedefTag(start, tagName, margin, indentText);
+ break;
+ case "callback":
+ tag = parseCallbackTag(start, tagName, margin, indentText);
+ break;
+ case "see":
+ tag = parseSeeTag(start, tagName, margin, indentText);
+ break;
+ default:
+ tag = parseUnknownTag(start, tagName, margin, indentText);
+ break;
+ }
+ return tag;
+ }
+ function parseTrailingTagComments(pos, end, margin, indentText) {
+ if (!indentText) {
+ margin += end - pos;
+ }
+ return parseTagComments(margin, indentText.slice(margin));
+ }
+ function parseTagComments(indent, initialMargin) {
+ var comments = [];
+ var state = 0;
+ var margin;
+ function pushComment(text) {
+ if (!margin) {
+ margin = indent;
+ }
+ comments.push(text);
+ indent += text.length;
+ }
+ if (initialMargin !== undefined) {
+ if (initialMargin !== "") {
+ pushComment(initialMargin);
+ }
+ state = 1;
+ }
+ var tok = token();
+ loop: while (true) {
+ switch (tok) {
+ case 4:
+ state = 0;
+ comments.push(scanner.getTokenText());
+ indent = 0;
+ break;
+ case 59:
+ if (state === 3) {
+ comments.push(scanner.getTokenText());
+ break;
+ }
+ scanner.setTextPos(scanner.getTextPos() - 1);
+ case 1:
+ break loop;
+ case 5:
+ if (state === 2 || state === 3) {
+ pushComment(scanner.getTokenText());
+ }
+ else {
+ var whitespace = scanner.getTokenText();
+ if (margin !== undefined && indent + whitespace.length > margin) {
+ comments.push(whitespace.slice(margin - indent));
+ }
+ indent += whitespace.length;
+ }
+ break;
+ case 18:
+ state = 2;
+ if (lookAhead(function () { return nextTokenJSDoc() === 59 && ts.tokenIsIdentifierOrKeyword(nextTokenJSDoc()) && scanner.getTokenText() === "link"; })) {
+ pushComment(scanner.getTokenText());
+ nextTokenJSDoc();
+ pushComment(scanner.getTokenText());
+ nextTokenJSDoc();
+ }
+ pushComment(scanner.getTokenText());
+ break;
+ case 61:
+ if (state === 3) {
+ state = 2;
+ }
+ else {
+ state = 3;
+ }
+ pushComment(scanner.getTokenText());
+ break;
+ case 41:
+ if (state === 0) {
+ state = 1;
+ indent += 1;
+ break;
+ }
+ default:
+ if (state !== 3) {
+ state = 2;
+ }
+ pushComment(scanner.getTokenText());
+ break;
+ }
+ tok = nextTokenJSDoc();
+ }
+ removeLeadingNewlines(comments);
+ removeTrailingWhitespace(comments);
+ return comments.length === 0 ? undefined : comments.join("");
}
- break;
- case 254:
- case 253:
- if (!(ts.hasModifier(node, 1))) {
- return 0;
+ function parseUnknownTag(start, tagName, indent, indentText) {
+ var end = getNodePos();
+ return finishNode(factory.createJSDocUnknownTag(tagName, parseTrailingTagComments(start, end, indent, indentText)), start, end);
}
- break;
- case 260:
- var exportDeclaration = node;
- if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === 261) {
- var state = 0;
- for (var _i = 0, _a = exportDeclaration.exportClause.elements; _i < _a.length; _i++) {
- var specifier = _a[_i];
- var specifierState = getModuleInstanceStateForAliasTarget(specifier, visited);
- if (specifierState > state) {
- state = specifierState;
- }
- if (state === 1) {
- return state;
+ 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 ? parseJSDocTypeExpression() : undefined;
+ }
+ function parseBracketNameInPropertyAndParamTag() {
+ var isBracketed = parseOptionalJsdoc(22);
+ if (isBracketed) {
+ skipWhitespace();
+ }
+ var isBackquoted = parseOptionalJsdoc(61);
+ var name = parseJSDocEntityName();
+ if (isBackquoted) {
+ parseExpectedTokenJSDoc(61);
+ }
+ if (isBracketed) {
+ skipWhitespace();
+ if (parseOptionalToken(62)) {
+ parseExpression();
}
+ parseExpected(23);
}
- return state;
+ return { name: name, isBracketed: isBracketed };
}
- break;
- case 250: {
- var state_1 = 0;
- ts.forEachChild(node, function (n) {
- var childState = getModuleInstanceStateCached(n, visited);
- switch (childState) {
- case 0:
- return;
- case 2:
- state_1 = 2;
- return;
- case 1:
- state_1 = 1;
+ function isObjectOrObjectArrayTypeReference(node) {
+ switch (node.kind) {
+ case 145:
return true;
+ case 178:
+ return isObjectOrObjectArrayTypeReference(node.elementType);
default:
- ts.Debug.assertNever(childState);
+ return ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.escapedText === "Object" && !node.typeArguments;
}
- });
- return state_1;
- }
- case 249:
- return getModuleInstanceState(node, visited);
- case 75:
- if (node.isInJSDocNamespace) {
- return 0;
}
- }
- return 1;
- }
- function getModuleInstanceStateForAliasTarget(specifier, visited) {
- var name = specifier.propertyName || specifier.name;
- var p = specifier.parent;
- while (p) {
- if (ts.isBlock(p) || ts.isModuleBlock(p) || ts.isSourceFile(p)) {
- var statements = p.statements;
- var found = void 0;
- for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) {
- var statement = statements_1[_i];
- if (ts.nodeHasName(statement, name)) {
- if (!statement.parent) {
- setParentPointers(p, statement);
- }
- var state = getModuleInstanceStateCached(statement, visited);
- if (found === undefined || state > found) {
- found = state;
+ function parseParameterOrPropertyTag(start, tagName, target, indent) {
+ var typeExpression = tryParseTypeExpression();
+ var isNameFirst = !typeExpression;
+ skipWhitespaceOrAsterisk();
+ var _a = parseBracketNameInPropertyAndParamTag(), name = _a.name, isBracketed = _a.isBracketed;
+ skipWhitespace();
+ if (isNameFirst) {
+ typeExpression = tryParseTypeExpression();
+ }
+ var comment = parseTagComments(indent + scanner.getStartPos() - start);
+ var nestedTypeLiteral = target !== 4 && parseNestedTypeLiteral(typeExpression, name, target, indent);
+ if (nestedTypeLiteral) {
+ typeExpression = nestedTypeLiteral;
+ isNameFirst = true;
+ }
+ var result = target === 1
+ ? factory.createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment)
+ : factory.createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment);
+ return finishNode(result, start);
+ }
+ function parseNestedTypeLiteral(typeExpression, name, target, indent) {
+ if (typeExpression && isObjectOrObjectArrayTypeReference(typeExpression.type)) {
+ var pos = getNodePos();
+ var child = void 0;
+ var children = void 0;
+ while (child = tryParse(function () { return parseChildParameterOrPropertyTag(target, indent, name); })) {
+ if (child.kind === 326 || child.kind === 333) {
+ children = ts.append(children, child);
+ }
}
- if (found === 1) {
- return found;
+ if (children) {
+ var literal = finishNode(factory.createJSDocTypeLiteral(children, typeExpression.type.kind === 178), pos);
+ return finishNode(factory.createJSDocTypeExpression(literal), pos);
}
}
}
- if (found !== undefined) {
- return found;
+ function parseReturnTag(start, tagName, indent, indentText) {
+ if (ts.some(tags, ts.isJSDocReturnTag)) {
+ parseErrorAt(tagName.pos, scanner.getTokenPos(), ts.Diagnostics._0_tag_already_specified, tagName.escapedText);
+ }
+ var typeExpression = tryParseTypeExpression();
+ var end = getNodePos();
+ return finishNode(factory.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start, end, indent, indentText)), start, end);
}
- }
- p = p.parent;
- }
- return 1;
- }
- function initFlowNode(node) {
- ts.Debug.attachFlowNodeDebugInfo(node);
- return node;
- }
- var binder = createBinder();
- function bindSourceFile(file, options) {
- ts.performance.mark("beforeBind");
- ts.perfLogger.logStartBindFile("" + file.fileName);
- binder(file, options);
- ts.perfLogger.logStopBindFile();
- ts.performance.mark("afterBind");
- ts.performance.measure("Bind", "beforeBind", "afterBind");
- }
- ts.bindSourceFile = bindSourceFile;
- function createBinder() {
- var file;
- var options;
- var languageVersion;
- var parent;
- var container;
- var thisParentContainer;
- var blockScopeContainer;
- var lastContainer;
- var delayedTypeAliases;
- var seenThisKeyword;
- var currentFlow;
- var currentBreakTarget;
- var currentContinueTarget;
- var currentReturnTarget;
- var currentTrueTarget;
- var currentFalseTarget;
- var currentExceptionTarget;
- var preSwitchCaseFlow;
- var activeLabelList;
- var hasExplicitReturn;
- var emitFlags;
- var inStrictMode;
- var symbolCount = 0;
- var Symbol;
- var classifiableNames;
- var unreachableFlow = { flags: 1 };
- var reportedUnreachableFlow = { flags: 1 };
- var subtreeTransformFlags = 0;
- var skipTransformFlagAggregation;
- function createDiagnosticForNode(node, message, arg0, arg1, arg2) {
- return ts.createDiagnosticForNodeInSourceFile(ts.getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);
- }
- function bindSourceFile(f, opts) {
- file = f;
- options = opts;
- languageVersion = ts.getEmitScriptTarget(options);
- inStrictMode = bindInStrictMode(file, opts);
- classifiableNames = ts.createUnderscoreEscapedMap();
- symbolCount = 0;
- skipTransformFlagAggregation = file.isDeclarationFile;
- Symbol = ts.objectAllocator.getSymbolConstructor();
- ts.Debug.attachFlowNodeDebugInfo(unreachableFlow);
- ts.Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);
- if (!file.locals) {
- bind(file);
- file.symbolCount = symbolCount;
- file.classifiableNames = classifiableNames;
- delayedBindJSDocTypedefTag();
- }
- file = undefined;
- options = undefined;
- languageVersion = undefined;
- parent = undefined;
- container = undefined;
- thisParentContainer = undefined;
- blockScopeContainer = undefined;
- lastContainer = undefined;
- delayedTypeAliases = undefined;
- seenThisKeyword = false;
- currentFlow = undefined;
- currentBreakTarget = undefined;
- currentContinueTarget = undefined;
- currentReturnTarget = undefined;
- currentTrueTarget = undefined;
- currentFalseTarget = undefined;
- currentExceptionTarget = undefined;
- activeLabelList = undefined;
- hasExplicitReturn = false;
- emitFlags = 0;
- subtreeTransformFlags = 0;
- }
- return bindSourceFile;
- function bindInStrictMode(file, opts) {
- if (ts.getStrictOptionValue(opts, "alwaysStrict") && !file.isDeclarationFile) {
- return true;
- }
- else {
- return !!file.externalModuleIndicator;
- }
- }
- function createSymbol(flags, name) {
- symbolCount++;
- return new Symbol(flags, name);
- }
- function addDeclarationToSymbol(symbol, node, symbolFlags) {
- symbol.flags |= symbolFlags;
- node.symbol = symbol;
- symbol.declarations = ts.appendIfUnique(symbol.declarations, node);
- if (symbolFlags & (32 | 384 | 1536 | 3) && !symbol.exports) {
- symbol.exports = ts.createSymbolTable();
- }
- if (symbolFlags & (32 | 64 | 2048 | 4096) && !symbol.members) {
- symbol.members = ts.createSymbolTable();
- }
- if (symbol.constEnumOnlyModule && (symbol.flags & (16 | 32 | 256))) {
- symbol.constEnumOnlyModule = false;
- }
- if (symbolFlags & 111551) {
- ts.setValueDeclaration(symbol, node);
- }
- }
- function getDeclarationName(node) {
- if (node.kind === 259) {
- return node.isExportEquals ? "export=" : "default";
- }
- var name = ts.getNameOfDeclaration(node);
- if (name) {
- if (ts.isAmbientModule(node)) {
- var moduleName = ts.getTextOfIdentifierOrLiteral(name);
- return (ts.isGlobalScopeAugmentation(node) ? "__global" : "\"" + moduleName + "\"");
+ function parseTypeTag(start, tagName, indent, indentText) {
+ if (ts.some(tags, ts.isJSDocTypeTag)) {
+ parseErrorAt(tagName.pos, scanner.getTokenPos(), ts.Diagnostics._0_tag_already_specified, tagName.escapedText);
+ }
+ var typeExpression = parseJSDocTypeExpression(true);
+ var end = getNodePos();
+ var comments = indent !== undefined && indentText !== undefined ? parseTrailingTagComments(start, end, indent, indentText) : undefined;
+ return finishNode(factory.createJSDocTypeTag(tagName, typeExpression, comments), start, end);
}
- if (name.kind === 154) {
- var nameExpression = name.expression;
- if (ts.isStringOrNumericLiteralLike(nameExpression)) {
- return ts.escapeLeadingUnderscores(nameExpression.text);
+ function parseSeeTag(start, tagName, indent, indentText) {
+ var nameExpression = parseJSDocNameReference();
+ var end = getNodePos();
+ var comments = indent !== undefined && indentText !== undefined ? parseTrailingTagComments(start, end, indent, indentText) : undefined;
+ return finishNode(factory.createJSDocSeeTag(tagName, nameExpression, comments), start, end);
+ }
+ function parseAuthorTag(start, tagName, indent, indentText) {
+ var authorInfoWithEmail = tryParse(function () { return tryParseAuthorNameAndEmail(); });
+ if (!authorInfoWithEmail) {
+ var end_1 = getNodePos();
+ return finishNode(factory.createJSDocAuthorTag(tagName, parseTrailingTagComments(start, end_1, indent, indentText)), start, end_1);
}
- if (ts.isSignedNumericLiteral(nameExpression)) {
- return ts.tokenToString(nameExpression.operator) + nameExpression.operand.text;
+ var comments = authorInfoWithEmail;
+ if (lookAhead(function () { return nextToken() !== 4; })) {
+ var comment = parseTagComments(indent);
+ if (comment) {
+ comments += comment;
+ }
}
- ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression));
- return ts.getPropertyNameForKnownSymbolName(ts.idText(nameExpression.name));
+ return finishNode(factory.createJSDocAuthorTag(tagName, comments), start);
}
- if (ts.isWellKnownSymbolSyntactically(name)) {
- return ts.getPropertyNameForKnownSymbolName(ts.idText(name.name));
+ function tryParseAuthorNameAndEmail() {
+ var comments = [];
+ var seenLessThan = false;
+ var seenGreaterThan = false;
+ var token = scanner.getToken();
+ loop: while (true) {
+ switch (token) {
+ case 78:
+ case 5:
+ case 24:
+ case 59:
+ comments.push(scanner.getTokenText());
+ break;
+ case 29:
+ if (seenLessThan || seenGreaterThan) {
+ return;
+ }
+ seenLessThan = true;
+ comments.push(scanner.getTokenText());
+ break;
+ case 31:
+ if (!seenLessThan || seenGreaterThan) {
+ return;
+ }
+ seenGreaterThan = true;
+ comments.push(scanner.getTokenText());
+ scanner.setTextPos(scanner.getTokenPos() + 1);
+ break loop;
+ case 4:
+ case 1:
+ break loop;
+ }
+ token = nextTokenJSDoc();
+ }
+ if (seenLessThan && seenGreaterThan) {
+ return comments.length === 0 ? undefined : comments.join("");
+ }
}
- if (ts.isPrivateIdentifier(name)) {
- var containingClass = ts.getContainingClass(node);
- if (!containingClass) {
- return undefined;
+ function parseImplementsTag(start, tagName, margin, indentText) {
+ var className = parseExpressionWithTypeArgumentsForAugments();
+ var end = getNodePos();
+ return finishNode(factory.createJSDocImplementsTag(tagName, className, parseTrailingTagComments(start, end, margin, indentText)), start, end);
+ }
+ function parseAugmentsTag(start, tagName, margin, indentText) {
+ var className = parseExpressionWithTypeArgumentsForAugments();
+ var end = getNodePos();
+ return finishNode(factory.createJSDocAugmentsTag(tagName, className, parseTrailingTagComments(start, end, margin, indentText)), start, end);
+ }
+ function parseExpressionWithTypeArgumentsForAugments() {
+ var usedBrace = parseOptional(18);
+ var pos = getNodePos();
+ var expression = parsePropertyAccessEntityNameExpression();
+ var typeArguments = tryParseTypeArguments();
+ var node = factory.createExpressionWithTypeArguments(expression, typeArguments);
+ var res = finishNode(node, pos);
+ if (usedBrace) {
+ parseExpected(19);
}
- var containingClassSymbol = containingClass.symbol;
- return ts.getSymbolNameForPrivateIdentifier(containingClassSymbol, name.escapedText);
+ return res;
}
- return ts.isPropertyNameLiteral(name) ? ts.getEscapedTextOfIdentifierOrLiteral(name) : undefined;
- }
- switch (node.kind) {
- case 162:
- return "__constructor";
- case 170:
- case 165:
- case 305:
- return "__call";
- case 171:
- case 166:
- return "__new";
- case 167:
- return "__index";
- case 260:
- return "__export";
- case 290:
- return "export=";
- case 209:
- if (ts.getAssignmentDeclarationKind(node) === 2) {
- return "export=";
+ function parsePropertyAccessEntityNameExpression() {
+ var pos = getNodePos();
+ var node = parseJSDocIdentifierName();
+ while (parseOptional(24)) {
+ var name = parseJSDocIdentifierName();
+ node = finishNode(factory.createPropertyAccessExpression(node, name), pos);
}
- ts.Debug.fail("Unknown binary declaration kind");
- break;
- case 300:
- return (ts.isJSDocConstructSignature(node) ? "__new" : "__call");
- case 156:
- ts.Debug.assert(node.parent.kind === 300, "Impossible parameter parent kind", function () { return "parent is: " + (ts.SyntaxKind ? ts.SyntaxKind[node.parent.kind] : node.parent.kind) + ", expected JSDocFunctionType"; });
- var functionType = node.parent;
- var index = functionType.parameters.indexOf(node);
- return "arg" + index;
- }
- }
- function getDisplayName(node) {
- return ts.isNamedDeclaration(node) ? ts.declarationNameToString(node.name) : ts.unescapeLeadingUnderscores(ts.Debug.checkDefined(getDeclarationName(node)));
- }
- function declareSymbol(symbolTable, parent, node, includes, excludes, isReplaceableByMethod) {
- ts.Debug.assert(!ts.hasDynamicName(node));
- var isDefaultExport = ts.hasModifier(node, 512) || ts.isExportSpecifier(node) && node.name.escapedText === "default";
- var name = isDefaultExport && parent ? "default" : getDeclarationName(node);
- var symbol;
- if (name === undefined) {
- symbol = createSymbol(0, "__missing");
- }
- else {
- symbol = symbolTable.get(name);
- if (includes & 2885600) {
- classifiableNames.set(name, true);
+ return node;
}
- if (!symbol) {
- symbolTable.set(name, symbol = createSymbol(0, name));
- if (isReplaceableByMethod)
- symbol.isReplaceableByMethod = true;
+ function parseSimpleTag(start, createTag, tagName, margin, indentText) {
+ var end = getNodePos();
+ return finishNode(createTag(tagName, parseTrailingTagComments(start, end, margin, indentText)), start, end);
}
- else if (isReplaceableByMethod && !symbol.isReplaceableByMethod) {
- return symbol;
+ function parseThisTag(start, tagName, margin, indentText) {
+ var typeExpression = parseJSDocTypeExpression(true);
+ skipWhitespace();
+ var end = getNodePos();
+ return finishNode(factory.createJSDocThisTag(tagName, typeExpression, parseTrailingTagComments(start, end, margin, indentText)), start, end);
}
- else if (symbol.flags & excludes) {
- if (symbol.isReplaceableByMethod) {
- symbolTable.set(name, symbol = createSymbol(0, name));
- }
- else if (!(includes & 3 && symbol.flags & 67108864)) {
- if (ts.isNamedDeclaration(node)) {
- node.name.parent = node;
+ function parseEnumTag(start, tagName, margin, indentText) {
+ var typeExpression = parseJSDocTypeExpression(true);
+ skipWhitespace();
+ var end = getNodePos();
+ return finishNode(factory.createJSDocEnumTag(tagName, typeExpression, parseTrailingTagComments(start, end, margin, indentText)), start, end);
+ }
+ function parseTypedefTag(start, tagName, indent, indentText) {
+ var _a;
+ var typeExpression = tryParseTypeExpression();
+ skipWhitespaceOrAsterisk();
+ var fullName = parseJSDocTypeNameWithNamespace();
+ skipWhitespace();
+ var comment = parseTagComments(indent);
+ var end;
+ if (!typeExpression || isObjectOrObjectArrayTypeReference(typeExpression.type)) {
+ var child = void 0;
+ var childTypeTag = void 0;
+ var jsDocPropertyTags = void 0;
+ var hasChildren = false;
+ while (child = tryParse(function () { return parseChildPropertyTag(indent); })) {
+ hasChildren = true;
+ if (child.kind === 329) {
+ if (childTypeTag) {
+ parseErrorAtCurrentToken(ts.Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags);
+ var lastError = ts.lastOrUndefined(parseDiagnostics);
+ if (lastError) {
+ ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, 0, 0, ts.Diagnostics.The_tag_was_first_specified_here));
+ }
+ break;
+ }
+ else {
+ childTypeTag = child;
+ }
+ }
+ else {
+ jsDocPropertyTags = ts.append(jsDocPropertyTags, child);
+ }
}
- var message_1 = symbol.flags & 2
- ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
- : ts.Diagnostics.Duplicate_identifier_0;
- var messageNeedsName_1 = true;
- if (symbol.flags & 384 || includes & 384) {
- message_1 = ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations;
- messageNeedsName_1 = false;
+ if (hasChildren) {
+ var isArrayType = typeExpression && typeExpression.type.kind === 178;
+ var jsdocTypeLiteral = factory.createJSDocTypeLiteral(jsDocPropertyTags, isArrayType);
+ typeExpression = childTypeTag && childTypeTag.typeExpression && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ?
+ childTypeTag.typeExpression :
+ finishNode(jsdocTypeLiteral, start);
+ end = typeExpression.end;
}
- var multipleDefaultExports_1 = false;
- if (ts.length(symbol.declarations)) {
- if (isDefaultExport) {
- message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
- messageNeedsName_1 = false;
- multipleDefaultExports_1 = true;
+ }
+ end = end || comment !== undefined ?
+ getNodePos() :
+ ((_a = fullName !== null && fullName !== void 0 ? fullName : typeExpression) !== null && _a !== void 0 ? _a : tagName).end;
+ if (!comment) {
+ comment = parseTrailingTagComments(start, end, indent, indentText);
+ }
+ var typedefTag = factory.createJSDocTypedefTag(tagName, typeExpression, fullName, comment);
+ return finishNode(typedefTag, start, end);
+ }
+ function parseJSDocTypeNameWithNamespace(nested) {
+ var pos = scanner.getTokenPos();
+ if (!ts.tokenIsIdentifierOrKeyword(token())) {
+ return undefined;
+ }
+ var typeNameOrNamespaceName = parseJSDocIdentifierName();
+ if (parseOptional(24)) {
+ var body = parseJSDocTypeNameWithNamespace(true);
+ var jsDocNamespaceNode = factory.createModuleDeclaration(undefined, undefined, typeNameOrNamespaceName, body, nested ? 4 : undefined);
+ return finishNode(jsDocNamespaceNode, pos);
+ }
+ if (nested) {
+ typeNameOrNamespaceName.isInJSDocNamespace = true;
+ }
+ return typeNameOrNamespaceName;
+ }
+ function parseCallbackTagParameters(indent) {
+ var pos = getNodePos();
+ var child;
+ var parameters;
+ while (child = tryParse(function () { return parseChildParameterOrPropertyTag(4, indent); })) {
+ parameters = ts.append(parameters, child);
+ }
+ return createNodeArray(parameters || [], pos);
+ }
+ function parseCallbackTag(start, tagName, indent, indentText) {
+ var fullName = parseJSDocTypeNameWithNamespace();
+ skipWhitespace();
+ var comment = parseTagComments(indent);
+ var parameters = parseCallbackTagParameters(indent);
+ var returnTag = tryParse(function () {
+ if (parseOptionalJsdoc(59)) {
+ var tag = parseTag(indent);
+ if (tag && tag.kind === 327) {
+ return tag;
}
- else {
- if (symbol.declarations && symbol.declarations.length &&
- (node.kind === 259 && !node.isExportEquals)) {
- message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
- messageNeedsName_1 = false;
- multipleDefaultExports_1 = true;
+ }
+ });
+ var typeExpression = finishNode(factory.createJSDocSignature(undefined, parameters, returnTag), start);
+ var end = getNodePos();
+ if (!comment) {
+ comment = parseTrailingTagComments(start, end, indent, indentText);
+ }
+ return finishNode(factory.createJSDocCallbackTag(tagName, typeExpression, fullName, comment), start, end);
+ }
+ function escapedTextsEqual(a, b) {
+ while (!ts.isIdentifier(a) || !ts.isIdentifier(b)) {
+ if (!ts.isIdentifier(a) && !ts.isIdentifier(b) && a.right.escapedText === b.right.escapedText) {
+ a = a.left;
+ b = b.left;
+ }
+ else {
+ return false;
+ }
+ }
+ return a.escapedText === b.escapedText;
+ }
+ function parseChildPropertyTag(indent) {
+ return parseChildParameterOrPropertyTag(1, indent);
+ }
+ function parseChildParameterOrPropertyTag(target, indent, name) {
+ var canParseTag = true;
+ var seenAsterisk = false;
+ while (true) {
+ switch (nextTokenJSDoc()) {
+ case 59:
+ if (canParseTag) {
+ var child = tryParseChildTag(target, indent);
+ if (child && (child.kind === 326 || child.kind === 333) &&
+ target !== 4 &&
+ name && (ts.isIdentifier(child.name) || !escapedTextsEqual(name, child.name.left))) {
+ return false;
+ }
+ return child;
+ }
+ seenAsterisk = false;
+ break;
+ case 4:
+ canParseTag = true;
+ seenAsterisk = false;
+ break;
+ case 41:
+ if (seenAsterisk) {
+ canParseTag = false;
}
- }
- }
- var relatedInformation_1 = [];
- if (ts.isTypeAliasDeclaration(node) && ts.nodeIsMissing(node.type) && ts.hasModifier(node, 1) && symbol.flags & (2097152 | 788968 | 1920)) {
- relatedInformation_1.push(createDiagnosticForNode(node, ts.Diagnostics.Did_you_mean_0, "export type { " + ts.unescapeLeadingUnderscores(node.name.escapedText) + " }"));
+ seenAsterisk = true;
+ break;
+ case 78:
+ canParseTag = false;
+ break;
+ case 1:
+ return false;
}
- var declarationName_1 = ts.getNameOfDeclaration(node) || node;
- ts.forEach(symbol.declarations, function (declaration, index) {
- var decl = ts.getNameOfDeclaration(declaration) || declaration;
- var diag = createDiagnosticForNode(decl, message_1, messageNeedsName_1 ? getDisplayName(declaration) : undefined);
- file.bindDiagnostics.push(multipleDefaultExports_1 ? ts.addRelatedInfo(diag, createDiagnosticForNode(declarationName_1, index === 0 ? ts.Diagnostics.Another_export_default_is_here : ts.Diagnostics.and_here)) : diag);
- if (multipleDefaultExports_1) {
- relatedInformation_1.push(createDiagnosticForNode(decl, ts.Diagnostics.The_first_export_default_is_here));
- }
- });
- var diag = createDiagnosticForNode(declarationName_1, message_1, messageNeedsName_1 ? getDisplayName(node) : undefined);
- file.bindDiagnostics.push(ts.addRelatedInfo.apply(void 0, __spreadArrays([diag], relatedInformation_1)));
- symbol = createSymbol(0, name);
}
}
- }
- addDeclarationToSymbol(symbol, node, includes);
- if (symbol.parent) {
- ts.Debug.assert(symbol.parent === parent, "Existing symbol parent should match new one");
- }
- else {
- symbol.parent = parent;
- }
- return symbol;
- }
- function declareModuleMember(node, symbolFlags, symbolExcludes) {
- var hasExportModifier = ts.getCombinedModifierFlags(node) & 1;
- if (symbolFlags & 2097152) {
- if (node.kind === 263 || (node.kind === 253 && hasExportModifier)) {
- return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
- }
- else {
- return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
- }
- }
- else {
- if (ts.isJSDocTypeAlias(node))
- ts.Debug.assert(ts.isInJSFile(node));
- if ((!ts.isAmbientModule(node) && (hasExportModifier || container.flags & 64)) || ts.isJSDocTypeAlias(node)) {
- if (!container.locals || (ts.hasModifier(node, 512) && !getDeclarationName(node))) {
- return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
+ function tryParseChildTag(target, indent) {
+ ts.Debug.assert(token() === 59);
+ var start = scanner.getStartPos();
+ nextTokenJSDoc();
+ var tagName = parseJSDocIdentifierName();
+ skipWhitespace();
+ var t;
+ switch (tagName.escapedText) {
+ case "type":
+ return target === 1 && parseTypeTag(start, tagName);
+ case "prop":
+ case "property":
+ t = 1;
+ break;
+ case "arg":
+ case "argument":
+ case "param":
+ t = 2 | 4;
+ break;
+ default:
+ return false;
}
- var exportKind = symbolFlags & 111551 ? 1048576 : 0;
- var local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes);
- local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
- node.localSymbol = local;
- return local;
+ if (!(target & t)) {
+ return false;
+ }
+ return parseParameterOrPropertyTag(start, tagName, target, indent);
}
- else {
- return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
+ function parseTemplateTagTypeParameter() {
+ var typeParameterPos = getNodePos();
+ var name = parseJSDocIdentifierName(ts.Diagnostics.Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces);
+ return finishNode(factory.createTypeParameterDeclaration(name, undefined, undefined), typeParameterPos);
}
- }
- }
- function bindContainer(node, containerFlags) {
- var saveContainer = container;
- var saveThisParentContainer = thisParentContainer;
- var savedBlockScopeContainer = blockScopeContainer;
- if (containerFlags & 1) {
- if (node.kind !== 202) {
- thisParentContainer = container;
+ function parseTemplateTagTypeParameters() {
+ var pos = getNodePos();
+ var typeParameters = [];
+ do {
+ skipWhitespace();
+ typeParameters.push(parseTemplateTagTypeParameter());
+ skipWhitespaceOrAsterisk();
+ } while (parseOptionalJsdoc(27));
+ return createNodeArray(typeParameters, pos);
}
- container = blockScopeContainer = node;
- if (containerFlags & 32) {
- container.locals = ts.createSymbolTable();
+ function parseTemplateTag(start, tagName, indent, indentText) {
+ var constraint = token() === 18 ? parseJSDocTypeExpression() : undefined;
+ var typeParameters = parseTemplateTagTypeParameters();
+ var end = getNodePos();
+ return finishNode(factory.createJSDocTemplateTag(tagName, constraint, typeParameters, parseTrailingTagComments(start, end, indent, indentText)), start, end);
}
- addToContainerChain(container);
- }
- else if (containerFlags & 2) {
- blockScopeContainer = node;
- blockScopeContainer.locals = undefined;
- }
- if (containerFlags & 4) {
- var saveCurrentFlow = currentFlow;
- var saveBreakTarget = currentBreakTarget;
- var saveContinueTarget = currentContinueTarget;
- var saveReturnTarget = currentReturnTarget;
- var saveExceptionTarget = currentExceptionTarget;
- var saveActiveLabelList = activeLabelList;
- var saveHasExplicitReturn = hasExplicitReturn;
- var isIIFE = containerFlags & 16 && !ts.hasModifier(node, 256) &&
- !node.asteriskToken && !!ts.getImmediatelyInvokedFunctionExpression(node);
- if (!isIIFE) {
- currentFlow = initFlowNode({ flags: 2 });
- if (containerFlags & (16 | 128)) {
- currentFlow.node = node;
+ function parseOptionalJsdoc(t) {
+ if (token() === t) {
+ nextTokenJSDoc();
+ return true;
}
+ return false;
}
- currentReturnTarget = isIIFE || node.kind === 162 ? createBranchLabel() : undefined;
- currentExceptionTarget = undefined;
- currentBreakTarget = undefined;
- currentContinueTarget = undefined;
- activeLabelList = undefined;
- hasExplicitReturn = false;
- bindChildren(node);
- node.flags &= ~2816;
- if (!(currentFlow.flags & 1) && containerFlags & 8 && ts.nodeIsPresent(node.body)) {
- node.flags |= 256;
- if (hasExplicitReturn)
- node.flags |= 512;
- node.endFlowNode = currentFlow;
- }
- if (node.kind === 290) {
- node.flags |= emitFlags;
- }
- if (currentReturnTarget) {
- addAntecedent(currentReturnTarget, currentFlow);
- currentFlow = finishFlowLabel(currentReturnTarget);
- if (node.kind === 162) {
- node.returnFlowNode = currentFlow;
+ function parseJSDocEntityName() {
+ var entity = parseJSDocIdentifierName();
+ if (parseOptional(22)) {
+ parseExpected(23);
}
+ while (parseOptional(24)) {
+ var name = parseJSDocIdentifierName();
+ if (parseOptional(22)) {
+ parseExpected(23);
+ }
+ entity = createQualifiedName(entity, name);
+ }
+ return entity;
}
- if (!isIIFE) {
- currentFlow = saveCurrentFlow;
+ function parseJSDocIdentifierName(message) {
+ if (!ts.tokenIsIdentifierOrKeyword(token())) {
+ return createMissingNode(78, !message, message || ts.Diagnostics.Identifier_expected);
+ }
+ identifierCount++;
+ var pos = scanner.getTokenPos();
+ var end = scanner.getTextPos();
+ var originalKeywordKind = token();
+ var text = internIdentifier(scanner.getTokenValue());
+ var result = finishNode(factory.createIdentifier(text, undefined, originalKeywordKind), pos, end);
+ nextTokenJSDoc();
+ return result;
}
- currentBreakTarget = saveBreakTarget;
- currentContinueTarget = saveContinueTarget;
- currentReturnTarget = saveReturnTarget;
- currentExceptionTarget = saveExceptionTarget;
- activeLabelList = saveActiveLabelList;
- hasExplicitReturn = saveHasExplicitReturn;
- }
- else if (containerFlags & 64) {
- seenThisKeyword = false;
- bindChildren(node);
- node.flags = seenThisKeyword ? node.flags | 128 : node.flags & ~128;
- }
- else {
- bindChildren(node);
- }
- container = saveContainer;
- thisParentContainer = saveThisParentContainer;
- blockScopeContainer = savedBlockScopeContainer;
- }
- function bindChildren(node) {
- if (skipTransformFlagAggregation) {
- bindChildrenWorker(node);
- }
- else if (node.transformFlags & 536870912) {
- skipTransformFlagAggregation = true;
- bindChildrenWorker(node);
- skipTransformFlagAggregation = false;
- subtreeTransformFlags |= node.transformFlags & ~getTransformFlagsSubtreeExclusions(node.kind);
- }
- else {
- var savedSubtreeTransformFlags = subtreeTransformFlags;
- subtreeTransformFlags = 0;
- bindChildrenWorker(node);
- subtreeTransformFlags = savedSubtreeTransformFlags | computeTransformFlagsForNode(node, subtreeTransformFlags);
- }
- }
- function bindEachFunctionsFirst(nodes) {
- bindEach(nodes, function (n) { return n.kind === 244 ? bind(n) : undefined; });
- bindEach(nodes, function (n) { return n.kind !== 244 ? bind(n) : undefined; });
- }
- function bindEach(nodes, bindFunction) {
- if (bindFunction === void 0) { bindFunction = bind; }
- if (nodes === undefined) {
- return;
}
- if (skipTransformFlagAggregation) {
- ts.forEach(nodes, bindFunction);
+ })(JSDocParser = Parser.JSDocParser || (Parser.JSDocParser = {}));
+ })(Parser || (Parser = {}));
+ var IncrementalParser;
+ (function (IncrementalParser) {
+ function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) {
+ aggressiveChecks = aggressiveChecks || ts.Debug.shouldAssert(2);
+ checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks);
+ if (ts.textChangeRangeIsUnchanged(textChangeRange)) {
+ return sourceFile;
}
- else {
- var savedSubtreeTransformFlags = subtreeTransformFlags;
- subtreeTransformFlags = 0;
- var nodeArrayFlags = 0;
- for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
- var node = nodes_2[_i];
- bindFunction(node);
- nodeArrayFlags |= node.transformFlags & ~536870912;
- }
- nodes.transformFlags = nodeArrayFlags | 536870912;
- subtreeTransformFlags |= savedSubtreeTransformFlags;
+ if (sourceFile.statements.length === 0) {
+ return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, undefined, true, sourceFile.scriptKind);
}
+ var incrementalSourceFile = sourceFile;
+ ts.Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed);
+ incrementalSourceFile.hasBeenIncrementallyParsed = true;
+ Parser.fixupParentReferences(incrementalSourceFile);
+ var oldText = sourceFile.text;
+ var syntaxCursor = createSyntaxCursor(sourceFile);
+ var changeRange = extendToAffectedRange(sourceFile, textChangeRange);
+ checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks);
+ ts.Debug.assert(changeRange.span.start <= textChangeRange.span.start);
+ ts.Debug.assert(ts.textSpanEnd(changeRange.span) === ts.textSpanEnd(textChangeRange.span));
+ ts.Debug.assert(ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)) === ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange)));
+ var delta = ts.textChangeRangeNewSpan(changeRange).length - changeRange.span.length;
+ updateTokenPositionsAndMarkElements(incrementalSourceFile, changeRange.span.start, ts.textSpanEnd(changeRange.span), ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)), delta, oldText, newText, aggressiveChecks);
+ var result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, true, sourceFile.scriptKind);
+ result.commentDirectives = getNewCommentDirectives(sourceFile.commentDirectives, result.commentDirectives, changeRange.span.start, ts.textSpanEnd(changeRange.span), delta, oldText, newText, aggressiveChecks);
+ return result;
}
- function bindEachChild(node) {
- ts.forEachChild(node, bind, bindEach);
- }
- function bindChildrenWorker(node) {
- if (checkUnreachable(node)) {
- bindEachChild(node);
- bindJSDoc(node);
- return;
- }
- if (node.kind >= 225 && node.kind <= 241 && !options.allowUnreachableCode) {
- node.flowNode = currentFlow;
- }
- switch (node.kind) {
- case 229:
- bindWhileStatement(node);
- break;
- case 228:
- bindDoStatement(node);
- break;
- case 230:
- bindForStatement(node);
- break;
- case 231:
- case 232:
- bindForInOrForOfStatement(node);
- break;
- case 227:
- bindIfStatement(node);
- break;
- case 235:
- case 239:
- bindReturnOrThrow(node);
- break;
- case 234:
- case 233:
- bindBreakOrContinueStatement(node);
- break;
- case 240:
- bindTryStatement(node);
- break;
- case 237:
- bindSwitchStatement(node);
- break;
- case 251:
- bindCaseBlock(node);
- break;
- case 277:
- bindCaseClause(node);
- break;
- case 226:
- bindExpressionStatement(node);
- break;
- case 238:
- bindLabeledStatement(node);
- break;
- case 207:
- bindPrefixUnaryExpressionFlow(node);
- break;
- case 208:
- bindPostfixUnaryExpressionFlow(node);
- break;
- case 209:
- bindBinaryExpressionFlow(node);
- break;
- case 203:
- bindDeleteExpressionFlow(node);
- break;
- case 210:
- bindConditionalExpressionFlow(node);
- break;
- case 242:
- bindVariableDeclarationFlow(node);
- break;
- case 194:
- case 195:
- bindAccessExpressionFlow(node);
- break;
- case 196:
- bindCallExpressionFlow(node);
- break;
- case 218:
- bindNonNullExpressionFlow(node);
- break;
- case 322:
- case 315:
- case 316:
- bindJSDocTypeAlias(node);
- break;
- case 290: {
- bindEachFunctionsFirst(node.statements);
- bind(node.endOfFileToken);
- break;
+ IncrementalParser.updateSourceFile = updateSourceFile;
+ function getNewCommentDirectives(oldDirectives, newDirectives, changeStart, changeRangeOldEnd, delta, oldText, newText, aggressiveChecks) {
+ if (!oldDirectives)
+ return newDirectives;
+ var commentDirectives;
+ var addedNewlyScannedDirectives = false;
+ for (var _i = 0, oldDirectives_1 = oldDirectives; _i < oldDirectives_1.length; _i++) {
+ var directive = oldDirectives_1[_i];
+ var range = directive.range, type = directive.type;
+ if (range.end < changeStart) {
+ commentDirectives = ts.append(commentDirectives, directive);
}
- case 223:
- case 250:
- bindEachFunctionsFirst(node.statements);
- break;
- default:
- bindEachChild(node);
- break;
- }
- bindJSDoc(node);
- }
- function isNarrowingExpression(expr) {
- switch (expr.kind) {
- case 75:
- case 104:
- case 194:
- case 195:
- return containsNarrowableReference(expr);
- case 196:
- return hasNarrowableArgument(expr);
- case 200:
- return isNarrowingExpression(expr.expression);
- case 209:
- return isNarrowingBinaryExpression(expr);
- case 207:
- return expr.operator === 53 && isNarrowingExpression(expr.operand);
- case 204:
- return isNarrowingExpression(expr.expression);
- }
- return false;
- }
- function isNarrowableReference(expr) {
- return expr.kind === 75 || expr.kind === 104 || expr.kind === 102 ||
- (ts.isPropertyAccessExpression(expr) || ts.isNonNullExpression(expr) || ts.isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) ||
- ts.isElementAccessExpression(expr) && ts.isStringOrNumericLiteralLike(expr.argumentExpression) && isNarrowableReference(expr.expression);
- }
- function containsNarrowableReference(expr) {
- return isNarrowableReference(expr) || ts.isOptionalChain(expr) && containsNarrowableReference(expr.expression);
- }
- function hasNarrowableArgument(expr) {
- if (expr.arguments) {
- for (var _i = 0, _a = expr.arguments; _i < _a.length; _i++) {
- var argument = _a[_i];
- if (containsNarrowableReference(argument)) {
- return true;
+ else if (range.pos > changeRangeOldEnd) {
+ addNewlyScannedDirectives();
+ var updatedDirective = {
+ range: { pos: range.pos + delta, end: range.end + delta },
+ type: type
+ };
+ commentDirectives = ts.append(commentDirectives, updatedDirective);
+ if (aggressiveChecks) {
+ ts.Debug.assert(oldText.substring(range.pos, range.end) === newText.substring(updatedDirective.range.pos, updatedDirective.range.end));
}
}
}
- if (expr.expression.kind === 194 &&
- containsNarrowableReference(expr.expression.expression)) {
- return true;
- }
- return false;
- }
- function isNarrowingTypeofOperands(expr1, expr2) {
- return ts.isTypeOfExpression(expr1) && isNarrowableOperand(expr1.expression) && ts.isStringLiteralLike(expr2);
- }
- function isNarrowableInOperands(left, right) {
- return ts.isStringLiteralLike(left) && isNarrowingExpression(right);
- }
- function isNarrowingBinaryExpression(expr) {
- switch (expr.operatorToken.kind) {
- case 62:
- return containsNarrowableReference(expr.left);
- case 34:
- case 35:
- case 36:
- case 37:
- return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) ||
- isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right);
- case 98:
- return isNarrowableOperand(expr.left);
- case 97:
- return isNarrowableInOperands(expr.left, expr.right);
- case 27:
- return isNarrowingExpression(expr.right);
- }
- return false;
- }
- function isNarrowableOperand(expr) {
- switch (expr.kind) {
- case 200:
- return isNarrowableOperand(expr.expression);
- case 209:
- switch (expr.operatorToken.kind) {
- case 62:
- return isNarrowableOperand(expr.left);
- case 27:
- return isNarrowableOperand(expr.right);
- }
- }
- return containsNarrowableReference(expr);
- }
- function createBranchLabel() {
- return initFlowNode({ flags: 4, antecedents: undefined });
- }
- function createLoopLabel() {
- return initFlowNode({ flags: 8, antecedents: undefined });
- }
- function createReduceLabel(target, antecedents, antecedent) {
- return initFlowNode({ flags: 1024, target: target, antecedents: antecedents, antecedent: antecedent });
- }
- function setFlowNodeReferenced(flow) {
- flow.flags |= flow.flags & 2048 ? 4096 : 2048;
- }
- function addAntecedent(label, antecedent) {
- if (!(antecedent.flags & 1) && !ts.contains(label.antecedents, antecedent)) {
- (label.antecedents || (label.antecedents = [])).push(antecedent);
- setFlowNodeReferenced(antecedent);
- }
- }
- function createFlowCondition(flags, antecedent, expression) {
- if (antecedent.flags & 1) {
- return antecedent;
- }
- if (!expression) {
- return flags & 32 ? antecedent : unreachableFlow;
- }
- if ((expression.kind === 106 && flags & 64 ||
- expression.kind === 91 && flags & 32) &&
- !ts.isExpressionOfOptionalChainRoot(expression) && !ts.isNullishCoalesce(expression.parent)) {
- return unreachableFlow;
- }
- if (!isNarrowingExpression(expression)) {
- return antecedent;
- }
- setFlowNodeReferenced(antecedent);
- return initFlowNode({ flags: flags, antecedent: antecedent, node: expression });
- }
- function createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) {
- setFlowNodeReferenced(antecedent);
- return initFlowNode({ flags: 128, antecedent: antecedent, switchStatement: switchStatement, clauseStart: clauseStart, clauseEnd: clauseEnd });
- }
- function createFlowMutation(flags, antecedent, node) {
- setFlowNodeReferenced(antecedent);
- var result = initFlowNode({ flags: flags, antecedent: antecedent, node: node });
- if (currentExceptionTarget) {
- addAntecedent(currentExceptionTarget, result);
+ addNewlyScannedDirectives();
+ return commentDirectives;
+ function addNewlyScannedDirectives() {
+ if (addedNewlyScannedDirectives)
+ return;
+ addedNewlyScannedDirectives = true;
+ if (!commentDirectives) {
+ commentDirectives = newDirectives;
+ }
+ else if (newDirectives) {
+ commentDirectives.push.apply(commentDirectives, newDirectives);
+ }
}
- return result;
- }
- function createFlowCall(antecedent, node) {
- setFlowNodeReferenced(antecedent);
- return initFlowNode({ flags: 512, antecedent: antecedent, node: node });
}
- function finishFlowLabel(flow) {
- var antecedents = flow.antecedents;
- if (!antecedents) {
- return unreachableFlow;
- }
- if (antecedents.length === 1) {
- return antecedents[0];
+ function moveElementEntirelyPastChangeRange(element, isArray, delta, oldText, newText, aggressiveChecks) {
+ if (isArray) {
+ visitArray(element);
}
- return flow;
- }
- function isStatementCondition(node) {
- var parent = node.parent;
- switch (parent.kind) {
- case 227:
- case 229:
- case 228:
- return parent.expression === node;
- case 230:
- case 210:
- return parent.condition === node;
+ else {
+ visitNode(element);
}
- return false;
- }
- function isLogicalExpression(node) {
- while (true) {
- if (node.kind === 200) {
- node = node.expression;
+ return;
+ function visitNode(node) {
+ var text = "";
+ if (aggressiveChecks && shouldCheckNode(node)) {
+ text = oldText.substring(node.pos, node.end);
}
- else if (node.kind === 207 && node.operator === 53) {
- node = node.operand;
+ if (node._children) {
+ node._children = undefined;
+ }
+ ts.setTextRangePosEnd(node, node.pos + delta, node.end + delta);
+ if (aggressiveChecks && shouldCheckNode(node)) {
+ ts.Debug.assert(text === newText.substring(node.pos, node.end));
}
- else {
- return node.kind === 209 && (node.operatorToken.kind === 55 ||
- node.operatorToken.kind === 56 ||
- node.operatorToken.kind === 60);
+ forEachChild(node, visitNode, visitArray);
+ if (ts.hasJSDocNodes(node)) {
+ for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) {
+ var jsDocComment = _a[_i];
+ visitNode(jsDocComment);
+ }
}
+ checkNodePositions(node, aggressiveChecks);
}
- }
- function isTopLevelLogicalExpression(node) {
- while (ts.isParenthesizedExpression(node.parent) ||
- ts.isPrefixUnaryExpression(node.parent) && node.parent.operator === 53) {
- node = node.parent;
+ function visitArray(array) {
+ array._children = undefined;
+ ts.setTextRangePosEnd(array, array.pos + delta, array.end + delta);
+ for (var _i = 0, array_8 = array; _i < array_8.length; _i++) {
+ var node = array_8[_i];
+ visitNode(node);
+ }
}
- return !isStatementCondition(node) &&
- !isLogicalExpression(node.parent) &&
- !(ts.isOptionalChain(node.parent) && node.parent.expression === node);
- }
- function doWithConditionalBranches(action, value, trueTarget, falseTarget) {
- var savedTrueTarget = currentTrueTarget;
- var savedFalseTarget = currentFalseTarget;
- currentTrueTarget = trueTarget;
- currentFalseTarget = falseTarget;
- action(value);
- currentTrueTarget = savedTrueTarget;
- currentFalseTarget = savedFalseTarget;
}
- function bindCondition(node, trueTarget, falseTarget) {
- doWithConditionalBranches(bind, node, trueTarget, falseTarget);
- if (!node || !isLogicalExpression(node) && !(ts.isOptionalChain(node) && ts.isOutermostOptionalChain(node))) {
- addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node));
- addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node));
+ function shouldCheckNode(node) {
+ switch (node.kind) {
+ case 10:
+ case 8:
+ case 78:
+ return true;
}
+ return false;
}
- function bindIterativeStatement(node, breakTarget, continueTarget) {
- var saveBreakTarget = currentBreakTarget;
- var saveContinueTarget = currentContinueTarget;
- currentBreakTarget = breakTarget;
- currentContinueTarget = continueTarget;
- bind(node);
- currentBreakTarget = saveBreakTarget;
- currentContinueTarget = saveContinueTarget;
- }
- function setContinueTarget(node, target) {
- var label = activeLabelList;
- while (label && node.parent.kind === 238) {
- label.continueTarget = target;
- label = label.next;
- node = node.parent;
+ function adjustIntersectingElement(element, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta) {
+ ts.Debug.assert(element.end >= changeStart, "Adjusting an element that was entirely before the change range");
+ ts.Debug.assert(element.pos <= changeRangeOldEnd, "Adjusting an element that was entirely after the change range");
+ ts.Debug.assert(element.pos <= element.end);
+ var pos = Math.min(element.pos, changeRangeNewEnd);
+ var end = element.end >= changeRangeOldEnd ?
+ element.end + delta :
+ Math.min(element.end, changeRangeNewEnd);
+ ts.Debug.assert(pos <= end);
+ if (element.parent) {
+ ts.Debug.assertGreaterThanOrEqual(pos, element.parent.pos);
+ ts.Debug.assertLessThanOrEqual(end, element.parent.end);
}
- return target;
+ ts.setTextRangePosEnd(element, pos, end);
}
- function bindWhileStatement(node) {
- var preWhileLabel = setContinueTarget(node, createLoopLabel());
- var preBodyLabel = createBranchLabel();
- var postWhileLabel = createBranchLabel();
- addAntecedent(preWhileLabel, currentFlow);
- currentFlow = preWhileLabel;
- bindCondition(node.expression, preBodyLabel, postWhileLabel);
- currentFlow = finishFlowLabel(preBodyLabel);
- bindIterativeStatement(node.statement, postWhileLabel, preWhileLabel);
- addAntecedent(preWhileLabel, currentFlow);
- currentFlow = finishFlowLabel(postWhileLabel);
- }
- function bindDoStatement(node) {
- var preDoLabel = createLoopLabel();
- var preConditionLabel = setContinueTarget(node, createBranchLabel());
- var postDoLabel = createBranchLabel();
- addAntecedent(preDoLabel, currentFlow);
- currentFlow = preDoLabel;
- bindIterativeStatement(node.statement, postDoLabel, preConditionLabel);
- addAntecedent(preConditionLabel, currentFlow);
- currentFlow = finishFlowLabel(preConditionLabel);
- bindCondition(node.expression, preDoLabel, postDoLabel);
- currentFlow = finishFlowLabel(postDoLabel);
- }
- function bindForStatement(node) {
- var preLoopLabel = setContinueTarget(node, createLoopLabel());
- var preBodyLabel = createBranchLabel();
- var postLoopLabel = createBranchLabel();
- bind(node.initializer);
- addAntecedent(preLoopLabel, currentFlow);
- currentFlow = preLoopLabel;
- bindCondition(node.condition, preBodyLabel, postLoopLabel);
- currentFlow = finishFlowLabel(preBodyLabel);
- bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
- bind(node.incrementor);
- addAntecedent(preLoopLabel, currentFlow);
- currentFlow = finishFlowLabel(postLoopLabel);
- }
- function bindForInOrForOfStatement(node) {
- var preLoopLabel = setContinueTarget(node, createLoopLabel());
- var postLoopLabel = createBranchLabel();
- bind(node.expression);
- addAntecedent(preLoopLabel, currentFlow);
- currentFlow = preLoopLabel;
- if (node.kind === 232) {
- bind(node.awaitModifier);
- }
- addAntecedent(postLoopLabel, currentFlow);
- bind(node.initializer);
- if (node.initializer.kind !== 243) {
- bindAssignmentTargetFlow(node.initializer);
+ function checkNodePositions(node, aggressiveChecks) {
+ if (aggressiveChecks) {
+ var pos_2 = node.pos;
+ var visitNode_1 = function (child) {
+ ts.Debug.assert(child.pos >= pos_2);
+ pos_2 = child.end;
+ };
+ if (ts.hasJSDocNodes(node)) {
+ for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) {
+ var jsDocComment = _a[_i];
+ visitNode_1(jsDocComment);
+ }
+ }
+ forEachChild(node, visitNode_1);
+ ts.Debug.assert(pos_2 <= node.end);
}
- bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
- addAntecedent(preLoopLabel, currentFlow);
- currentFlow = finishFlowLabel(postLoopLabel);
- }
- function bindIfStatement(node) {
- var thenLabel = createBranchLabel();
- var elseLabel = createBranchLabel();
- var postIfLabel = createBranchLabel();
- bindCondition(node.expression, thenLabel, elseLabel);
- currentFlow = finishFlowLabel(thenLabel);
- bind(node.thenStatement);
- addAntecedent(postIfLabel, currentFlow);
- currentFlow = finishFlowLabel(elseLabel);
- bind(node.elseStatement);
- addAntecedent(postIfLabel, currentFlow);
- currentFlow = finishFlowLabel(postIfLabel);
}
- function bindReturnOrThrow(node) {
- bind(node.expression);
- if (node.kind === 235) {
- hasExplicitReturn = true;
- if (currentReturnTarget) {
- addAntecedent(currentReturnTarget, currentFlow);
+ function updateTokenPositionsAndMarkElements(sourceFile, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta, oldText, newText, aggressiveChecks) {
+ visitNode(sourceFile);
+ return;
+ function visitNode(child) {
+ ts.Debug.assert(child.pos <= child.end);
+ if (child.pos > changeRangeOldEnd) {
+ moveElementEntirelyPastChangeRange(child, false, delta, oldText, newText, aggressiveChecks);
+ return;
+ }
+ var fullEnd = child.end;
+ if (fullEnd >= changeStart) {
+ child.intersectsChange = true;
+ child._children = undefined;
+ adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
+ forEachChild(child, visitNode, visitArray);
+ if (ts.hasJSDocNodes(child)) {
+ for (var _i = 0, _a = child.jsDoc; _i < _a.length; _i++) {
+ var jsDocComment = _a[_i];
+ visitNode(jsDocComment);
+ }
+ }
+ checkNodePositions(child, aggressiveChecks);
+ return;
}
+ ts.Debug.assert(fullEnd < changeStart);
}
- currentFlow = unreachableFlow;
- }
- function findActiveLabel(name) {
- for (var label = activeLabelList; label; label = label.next) {
- if (label.name === name) {
- return label;
+ function visitArray(array) {
+ ts.Debug.assert(array.pos <= array.end);
+ if (array.pos > changeRangeOldEnd) {
+ moveElementEntirelyPastChangeRange(array, true, delta, oldText, newText, aggressiveChecks);
+ return;
+ }
+ var fullEnd = array.end;
+ if (fullEnd >= changeStart) {
+ array.intersectsChange = true;
+ array._children = undefined;
+ adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
+ for (var _i = 0, array_9 = array; _i < array_9.length; _i++) {
+ var node = array_9[_i];
+ visitNode(node);
+ }
+ return;
}
+ ts.Debug.assert(fullEnd < changeStart);
}
- return undefined;
}
- function bindBreakOrContinueFlow(node, breakTarget, continueTarget) {
- var flowLabel = node.kind === 234 ? breakTarget : continueTarget;
- if (flowLabel) {
- addAntecedent(flowLabel, currentFlow);
- currentFlow = unreachableFlow;
+ function extendToAffectedRange(sourceFile, changeRange) {
+ var maxLookahead = 1;
+ var start = changeRange.span.start;
+ for (var i = 0; start > 0 && i <= maxLookahead; i++) {
+ var nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start);
+ ts.Debug.assert(nearestNode.pos <= start);
+ var position = nearestNode.pos;
+ start = Math.max(0, position - 1);
}
+ var finalSpan = ts.createTextSpanFromBounds(start, ts.textSpanEnd(changeRange.span));
+ var finalLength = changeRange.newLength + (changeRange.span.start - start);
+ return ts.createTextChangeRange(finalSpan, finalLength);
}
- function bindBreakOrContinueStatement(node) {
- bind(node.label);
- if (node.label) {
- var activeLabel = findActiveLabel(node.label.escapedText);
- if (activeLabel) {
- activeLabel.referenced = true;
- bindBreakOrContinueFlow(node, activeLabel.breakTarget, activeLabel.continueTarget);
+ function findNearestNodeStartingBeforeOrAtPosition(sourceFile, position) {
+ var bestResult = sourceFile;
+ var lastNodeEntirelyBeforePosition;
+ forEachChild(sourceFile, visit);
+ if (lastNodeEntirelyBeforePosition) {
+ var lastChildOfLastEntireNodeBeforePosition = getLastDescendant(lastNodeEntirelyBeforePosition);
+ if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) {
+ bestResult = lastChildOfLastEntireNodeBeforePosition;
}
}
- else {
- bindBreakOrContinueFlow(node, currentBreakTarget, currentContinueTarget);
- }
- }
- function bindTryStatement(node) {
- var saveReturnTarget = currentReturnTarget;
- var saveExceptionTarget = currentExceptionTarget;
- var normalExitLabel = createBranchLabel();
- var returnLabel = createBranchLabel();
- var exceptionLabel = createBranchLabel();
- if (node.finallyBlock) {
- currentReturnTarget = returnLabel;
- }
- addAntecedent(exceptionLabel, currentFlow);
- currentExceptionTarget = exceptionLabel;
- bind(node.tryBlock);
- addAntecedent(normalExitLabel, currentFlow);
- if (node.catchClause) {
- currentFlow = finishFlowLabel(exceptionLabel);
- exceptionLabel = createBranchLabel();
- addAntecedent(exceptionLabel, currentFlow);
- currentExceptionTarget = exceptionLabel;
- bind(node.catchClause);
- addAntecedent(normalExitLabel, currentFlow);
+ return bestResult;
+ function getLastDescendant(node) {
+ while (true) {
+ var lastChild = ts.getLastChild(node);
+ if (lastChild) {
+ node = lastChild;
+ }
+ else {
+ return node;
+ }
+ }
}
- currentReturnTarget = saveReturnTarget;
- currentExceptionTarget = saveExceptionTarget;
- if (node.finallyBlock) {
- var finallyLabel = createBranchLabel();
- finallyLabel.antecedents = ts.concatenate(ts.concatenate(normalExitLabel.antecedents, exceptionLabel.antecedents), returnLabel.antecedents);
- currentFlow = finallyLabel;
- bind(node.finallyBlock);
- if (currentFlow.flags & 1) {
- currentFlow = unreachableFlow;
+ function visit(child) {
+ if (ts.nodeIsMissing(child)) {
+ return;
}
- else {
- if (currentReturnTarget && returnLabel.antecedents) {
- addAntecedent(currentReturnTarget, createReduceLabel(finallyLabel, returnLabel.antecedents, currentFlow));
+ if (child.pos <= position) {
+ if (child.pos >= bestResult.pos) {
+ bestResult = child;
+ }
+ if (position < child.end) {
+ forEachChild(child, visit);
+ return true;
+ }
+ else {
+ ts.Debug.assert(child.end <= position);
+ lastNodeEntirelyBeforePosition = child;
}
- currentFlow = normalExitLabel.antecedents ? createReduceLabel(finallyLabel, normalExitLabel.antecedents, currentFlow) : unreachableFlow;
}
- }
- else {
- currentFlow = finishFlowLabel(normalExitLabel);
+ else {
+ ts.Debug.assert(child.pos > position);
+ return true;
+ }
}
}
- function bindSwitchStatement(node) {
- var postSwitchLabel = createBranchLabel();
- bind(node.expression);
- var saveBreakTarget = currentBreakTarget;
- var savePreSwitchCaseFlow = preSwitchCaseFlow;
- currentBreakTarget = postSwitchLabel;
- preSwitchCaseFlow = currentFlow;
- bind(node.caseBlock);
- addAntecedent(postSwitchLabel, currentFlow);
- var hasDefault = ts.forEach(node.caseBlock.clauses, function (c) { return c.kind === 278; });
- node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents;
- if (!hasDefault) {
- addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0));
+ function checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks) {
+ var oldText = sourceFile.text;
+ if (textChangeRange) {
+ ts.Debug.assert((oldText.length - textChangeRange.span.length + textChangeRange.newLength) === newText.length);
+ if (aggressiveChecks || ts.Debug.shouldAssert(3)) {
+ var oldTextPrefix = oldText.substr(0, textChangeRange.span.start);
+ var newTextPrefix = newText.substr(0, textChangeRange.span.start);
+ ts.Debug.assert(oldTextPrefix === newTextPrefix);
+ var oldTextSuffix = oldText.substring(ts.textSpanEnd(textChangeRange.span), oldText.length);
+ var newTextSuffix = newText.substring(ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange)), newText.length);
+ ts.Debug.assert(oldTextSuffix === newTextSuffix);
+ }
}
- currentBreakTarget = saveBreakTarget;
- preSwitchCaseFlow = savePreSwitchCaseFlow;
- currentFlow = finishFlowLabel(postSwitchLabel);
}
- function bindCaseBlock(node) {
- var savedSubtreeTransformFlags = subtreeTransformFlags;
- subtreeTransformFlags = 0;
- var clauses = node.clauses;
- var isNarrowingSwitch = isNarrowingExpression(node.parent.expression);
- var fallthroughFlow = unreachableFlow;
- for (var i = 0; i < clauses.length; i++) {
- var clauseStart = i;
- while (!clauses[i].statements.length && i + 1 < clauses.length) {
- bind(clauses[i]);
- i++;
+ function createSyntaxCursor(sourceFile) {
+ var currentArray = sourceFile.statements;
+ var currentArrayIndex = 0;
+ ts.Debug.assert(currentArrayIndex < currentArray.length);
+ var current = currentArray[currentArrayIndex];
+ var lastQueriedPosition = -1;
+ return {
+ currentNode: function (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;
+ ts.Debug.assert(!current || current.pos === position);
+ return current;
}
- var preCaseLabel = createBranchLabel();
- addAntecedent(preCaseLabel, isNarrowingSwitch ? createFlowSwitchClause(preSwitchCaseFlow, node.parent, clauseStart, i + 1) : preSwitchCaseFlow);
- addAntecedent(preCaseLabel, fallthroughFlow);
- currentFlow = finishFlowLabel(preCaseLabel);
- var clause = clauses[i];
- bind(clause);
- fallthroughFlow = currentFlow;
- if (!(currentFlow.flags & 1) && i !== clauses.length - 1 && options.noFallthroughCasesInSwitch) {
- clause.fallthroughFlowNode = currentFlow;
+ };
+ function findHighestListElementThatStartsAtPosition(position) {
+ currentArray = undefined;
+ currentArrayIndex = -1;
+ current = undefined;
+ forEachChild(sourceFile, visitNode, visitArray);
+ return;
+ function visitNode(node) {
+ if (position >= node.pos && position < node.end) {
+ forEachChild(node, visitNode, visitArray);
+ return true;
+ }
+ return false;
+ }
+ function visitArray(array) {
+ if (position >= array.pos && position < array.end) {
+ for (var i = 0; i < array.length; i++) {
+ var 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, visitNode, visitArray);
+ return true;
+ }
+ }
+ }
+ }
+ }
+ return false;
}
}
- clauses.transformFlags = subtreeTransformFlags | 536870912;
- subtreeTransformFlags |= savedSubtreeTransformFlags;
}
- function bindCaseClause(node) {
- var saveCurrentFlow = currentFlow;
- currentFlow = preSwitchCaseFlow;
- bind(node.expression);
- currentFlow = saveCurrentFlow;
- bindEach(node.statements);
+ IncrementalParser.createSyntaxCursor = createSyntaxCursor;
+ })(IncrementalParser || (IncrementalParser = {}));
+ function isDeclarationFileName(fileName) {
+ return ts.fileExtensionIs(fileName, ".d.ts");
+ }
+ ts.isDeclarationFileName = isDeclarationFileName;
+ function processCommentPragmas(context, sourceText) {
+ var pragmas = [];
+ for (var _i = 0, _a = ts.getLeadingCommentRanges(sourceText, 0) || ts.emptyArray; _i < _a.length; _i++) {
+ var range = _a[_i];
+ var comment = sourceText.substring(range.pos, range.end);
+ extractPragmas(pragmas, range, comment);
}
- function bindExpressionStatement(node) {
- bind(node.expression);
- if (node.expression.kind === 196) {
- var call = node.expression;
- if (ts.isDottedName(call.expression)) {
- currentFlow = createFlowCall(currentFlow, call);
+ context.pragmas = new ts.Map();
+ for (var _b = 0, pragmas_1 = pragmas; _b < pragmas_1.length; _b++) {
+ var pragma = pragmas_1[_b];
+ if (context.pragmas.has(pragma.name)) {
+ var currentValue = context.pragmas.get(pragma.name);
+ if (currentValue instanceof Array) {
+ currentValue.push(pragma.args);
}
+ else {
+ context.pragmas.set(pragma.name, [currentValue, pragma.args]);
+ }
+ continue;
}
+ context.pragmas.set(pragma.name, pragma.args);
}
- function bindLabeledStatement(node) {
- var postStatementLabel = createBranchLabel();
- activeLabelList = {
- next: activeLabelList,
- name: node.label.escapedText,
- breakTarget: postStatementLabel,
- continueTarget: undefined,
- referenced: false
- };
- bind(node.label);
- bind(node.statement);
- if (!activeLabelList.referenced && !options.allowUnusedLabels) {
- errorOrSuggestionOnNode(ts.unusedLabelIsError(options), node.label, ts.Diagnostics.Unused_label);
- }
- activeLabelList = activeLabelList.next;
- addAntecedent(postStatementLabel, currentFlow);
- currentFlow = finishFlowLabel(postStatementLabel);
- }
- function bindDestructuringTargetFlow(node) {
- if (node.kind === 209 && node.operatorToken.kind === 62) {
- bindAssignmentTargetFlow(node.left);
- }
- else {
- bindAssignmentTargetFlow(node);
+ }
+ ts.processCommentPragmas = processCommentPragmas;
+ function processPragmasIntoFields(context, reportDiagnostic) {
+ context.checkJsDirective = undefined;
+ context.referencedFiles = [];
+ context.typeReferenceDirectives = [];
+ context.libReferenceDirectives = [];
+ context.amdDependencies = [];
+ context.hasNoDefaultLib = false;
+ context.pragmas.forEach(function (entryOrList, key) {
+ switch (key) {
+ case "reference": {
+ var referencedFiles_1 = context.referencedFiles;
+ var typeReferenceDirectives_1 = context.typeReferenceDirectives;
+ var libReferenceDirectives_1 = context.libReferenceDirectives;
+ ts.forEach(ts.toArray(entryOrList), function (arg) {
+ var _a = arg.arguments, types = _a.types, lib = _a.lib, path = _a.path;
+ if (arg.arguments["no-default-lib"]) {
+ context.hasNoDefaultLib = true;
+ }
+ else if (types) {
+ typeReferenceDirectives_1.push({ pos: types.pos, end: types.end, fileName: types.value });
+ }
+ else if (lib) {
+ libReferenceDirectives_1.push({ pos: lib.pos, end: lib.end, fileName: lib.value });
+ }
+ else if (path) {
+ referencedFiles_1.push({ pos: path.pos, end: path.end, fileName: path.value });
+ }
+ else {
+ reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, ts.Diagnostics.Invalid_reference_directive_syntax);
+ }
+ });
+ break;
+ }
+ case "amd-dependency": {
+ context.amdDependencies = ts.map(ts.toArray(entryOrList), function (x) { return ({ name: x.arguments.name, path: x.arguments.path }); });
+ break;
+ }
+ case "amd-module": {
+ if (entryOrList instanceof Array) {
+ for (var _i = 0, entryOrList_1 = entryOrList; _i < entryOrList_1.length; _i++) {
+ var entry = entryOrList_1[_i];
+ if (context.moduleName) {
+ reportDiagnostic(entry.range.pos, entry.range.end - entry.range.pos, ts.Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments);
+ }
+ context.moduleName = entry.arguments.name;
+ }
+ }
+ else {
+ context.moduleName = entryOrList.arguments.name;
+ }
+ break;
+ }
+ case "ts-nocheck":
+ case "ts-check": {
+ ts.forEach(ts.toArray(entryOrList), function (entry) {
+ if (!context.checkJsDirective || entry.range.pos > context.checkJsDirective.pos) {
+ context.checkJsDirective = {
+ enabled: key === "ts-check",
+ end: entry.range.end,
+ pos: entry.range.pos
+ };
+ }
+ });
+ break;
+ }
+ case "jsx":
+ case "jsxfrag":
+ case "jsximportsource":
+ case "jsxruntime":
+ return;
+ default: ts.Debug.fail("Unhandled pragma kind");
}
+ });
+ }
+ ts.processPragmasIntoFields = processPragmasIntoFields;
+ var namedArgRegExCache = new ts.Map();
+ function getNamedArgRegEx(name) {
+ if (namedArgRegExCache.has(name)) {
+ return namedArgRegExCache.get(name);
}
- function bindAssignmentTargetFlow(node) {
- if (isNarrowableReference(node)) {
- currentFlow = createFlowMutation(16, currentFlow, node);
+ var result = new RegExp("(\\s" + name + "\\s*=\\s*)('|\")(.+?)\\2", "im");
+ namedArgRegExCache.set(name, result);
+ return result;
+ }
+ var tripleSlashXMLCommentStartRegEx = /^\/\/\/\s*<(\S+)\s.*?\/>/im;
+ var singleLinePragmaRegEx = /^\/\/\/?\s*@(\S+)\s*(.*)\s*$/im;
+ function extractPragmas(pragmas, range, text) {
+ var tripleSlash = range.kind === 2 && tripleSlashXMLCommentStartRegEx.exec(text);
+ if (tripleSlash) {
+ var name = tripleSlash[1].toLowerCase();
+ var pragma = ts.commentPragmas[name];
+ if (!pragma || !(pragma.kind & 1)) {
+ return;
}
- else if (node.kind === 192) {
- for (var _i = 0, _a = node.elements; _i < _a.length; _i++) {
- var e = _a[_i];
- if (e.kind === 213) {
- bindAssignmentTargetFlow(e.expression);
+ if (pragma.args) {
+ var argument = {};
+ for (var _i = 0, _a = pragma.args; _i < _a.length; _i++) {
+ var arg = _a[_i];
+ var matcher = getNamedArgRegEx(arg.name);
+ var matchResult = matcher.exec(text);
+ if (!matchResult && !arg.optional) {
+ return;
}
- else {
- bindDestructuringTargetFlow(e);
+ else if (matchResult) {
+ if (arg.captureSpan) {
+ var startPos = range.pos + matchResult.index + matchResult[1].length + matchResult[2].length;
+ argument[arg.name] = {
+ value: matchResult[3],
+ pos: startPos,
+ end: startPos + matchResult[3].length
+ };
+ }
+ else {
+ argument[arg.name] = matchResult[3];
+ }
}
}
+ pragmas.push({ name: name, args: { arguments: argument, range: range } });
}
- else if (node.kind === 193) {
- for (var _b = 0, _c = node.properties; _b < _c.length; _b++) {
- var p = _c[_b];
- if (p.kind === 281) {
- bindDestructuringTargetFlow(p.initializer);
- }
- else if (p.kind === 282) {
- bindAssignmentTargetFlow(p.name);
- }
- else if (p.kind === 283) {
- bindAssignmentTargetFlow(p.expression);
- }
- }
+ else {
+ pragmas.push({ name: name, args: { arguments: {}, range: range } });
}
+ return;
}
- function bindLogicalExpression(node, trueTarget, falseTarget) {
- var preRightLabel = createBranchLabel();
- if (node.operatorToken.kind === 55) {
- bindCondition(node.left, preRightLabel, falseTarget);
+ var singleLine = range.kind === 2 && singleLinePragmaRegEx.exec(text);
+ if (singleLine) {
+ return addPragmaForMatch(pragmas, range, 2, singleLine);
+ }
+ if (range.kind === 3) {
+ var multiLinePragmaRegEx = /\s*@(\S+)\s*(.*)\s*$/gim;
+ var multiLineMatch = void 0;
+ while (multiLineMatch = multiLinePragmaRegEx.exec(text)) {
+ addPragmaForMatch(pragmas, range, 4, multiLineMatch);
}
- else {
- bindCondition(node.left, trueTarget, preRightLabel);
+ }
+ }
+ function addPragmaForMatch(pragmas, range, kind, match) {
+ if (!match)
+ return;
+ var name = match[1].toLowerCase();
+ var pragma = ts.commentPragmas[name];
+ if (!pragma || !(pragma.kind & kind)) {
+ return;
+ }
+ var args = match[2];
+ var argument = getNamedPragmaArguments(pragma, args);
+ if (argument === "fail")
+ return;
+ pragmas.push({ name: name, args: { arguments: argument, range: range } });
+ return;
+ }
+ function getNamedPragmaArguments(pragma, text) {
+ if (!text)
+ return {};
+ if (!pragma.args)
+ return {};
+ var args = text.split(/\s+/);
+ var argMap = {};
+ for (var i = 0; i < pragma.args.length; i++) {
+ var argument = pragma.args[i];
+ if (!args[i] && !argument.optional) {
+ return "fail";
}
- currentFlow = finishFlowLabel(preRightLabel);
- bind(node.operatorToken);
- bindCondition(node.right, trueTarget, falseTarget);
+ if (argument.captureSpan) {
+ return ts.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 === 78) {
+ return lhs.escapedText === rhs.escapedText;
+ }
+ if (lhs.kind === 107) {
+ return true;
+ }
+ return lhs.name.escapedText === rhs.name.escapedText &&
+ tagNamesAreEquivalent(lhs.expression, rhs.expression);
+ }
+ ts.tagNamesAreEquivalent = tagNamesAreEquivalent;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ ts.compileOnSaveCommandLineOption = { name: "compileOnSave", type: "boolean" };
+ var jsxOptionMap = new ts.Map(ts.getEntries({
+ "preserve": 1,
+ "react-native": 3,
+ "react": 2,
+ "react-jsx": 4,
+ "react-jsxdev": 5,
+ }));
+ ts.inverseJsxOptionMap = new ts.Map(ts.arrayFrom(ts.mapIterator(jsxOptionMap.entries(), function (_a) {
+ var key = _a[0], value = _a[1];
+ return ["" + 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"],
+ ["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"],
+ ["es2020.bigint", "lib.es2020.bigint.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"],
+ ["esnext.array", "lib.es2019.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.esnext.string.d.ts"],
+ ["esnext.promise", "lib.esnext.promise.d.ts"],
+ ["esnext.weakref", "lib.esnext.weakref.d.ts"]
+ ];
+ ts.libs = libEntries.map(function (entry) { return entry[0]; });
+ ts.libMap = new ts.Map(libEntries);
+ ts.optionsForWatch = [
+ {
+ name: "watchFile",
+ type: new ts.Map(ts.getEntries({
+ fixedpollinginterval: ts.WatchFileKind.FixedPollingInterval,
+ prioritypollinginterval: ts.WatchFileKind.PriorityPollingInterval,
+ dynamicprioritypolling: ts.WatchFileKind.DynamicPriorityPolling,
+ usefsevents: ts.WatchFileKind.UseFsEvents,
+ usefseventsonparentdirectory: ts.WatchFileKind.UseFsEventsOnParentDirectory,
+ })),
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_DynamicPriorityPolling_UseFsEvents_UseFsEventsOnParentDirectory,
+ },
+ {
+ name: "watchDirectory",
+ type: new ts.Map(ts.getEntries({
+ usefsevents: ts.WatchDirectoryKind.UseFsEvents,
+ fixedpollinginterval: ts.WatchDirectoryKind.FixedPollingInterval,
+ dynamicprioritypolling: ts.WatchDirectoryKind.DynamicPriorityPolling,
+ })),
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively_Colon_UseFsEvents_default_FixedPollingInterval_DynamicPriorityPolling,
+ },
+ {
+ name: "fallbackPolling",
+ type: new ts.Map(ts.getEntries({
+ fixedinterval: ts.PollingWatchKind.FixedInterval,
+ priorityinterval: ts.PollingWatchKind.PriorityInterval,
+ dynamicpriority: ts.PollingWatchKind.DynamicPriority,
+ })),
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_FixedInterval_default_PriorityInterval_DynamicPriority,
+ },
+ {
+ name: "synchronousWatchDirectory",
+ type: "boolean",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively,
+ },
+ ];
+ ts.commonOptionsWithBuild = [
+ {
+ name: "help",
+ shortName: "h",
+ type: "boolean",
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Print_this_message,
+ },
+ {
+ name: "help",
+ shortName: "?",
+ type: "boolean"
+ },
+ {
+ name: "watch",
+ shortName: "w",
+ type: "boolean",
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Watch_input_files,
+ },
+ {
+ name: "preserveWatchOutput",
+ type: "boolean",
+ showInSimplifiedHelpView: false,
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen,
+ },
+ {
+ name: "listFiles",
+ type: "boolean",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Print_names_of_files_part_of_the_compilation
+ },
+ {
+ name: "listEmittedFiles",
+ type: "boolean",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Print_names_of_generated_files_part_of_the_compilation
+ },
+ {
+ name: "pretty",
+ type: "boolean",
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental
+ },
+ {
+ name: "traceResolution",
+ type: "boolean",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Enable_tracing_of_the_name_resolution_process
+ },
+ {
+ name: "diagnostics",
+ type: "boolean",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Show_diagnostic_information
+ },
+ {
+ name: "extendedDiagnostics",
+ type: "boolean",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Show_verbose_diagnostic_information
+ },
+ {
+ name: "generateCpuProfile",
+ type: "string",
+ isFilePath: true,
+ paramType: ts.Diagnostics.FILE_OR_DIRECTORY,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Generates_a_CPU_profile
+ },
+ {
+ name: "generateTrace",
+ type: "string",
+ isFilePath: true,
+ isCommandLineOnly: true,
+ paramType: ts.Diagnostics.DIRECTORY,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Generates_an_event_trace_and_a_list_of_types
+ },
+ {
+ name: "incremental",
+ shortName: "i",
+ type: "boolean",
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Enable_incremental_compilation,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "assumeChangesOnlyAffectDirectDependencies",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ affectsEmit: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it
+ },
+ {
+ name: "locale",
+ type: "string",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.The_locale_used_when_displaying_messages_to_the_user_e_g_en_us
+ },
+ ];
+ ts.optionDeclarations = __spreadArrays(ts.commonOptionsWithBuild, [
+ {
+ name: "all",
+ type: "boolean",
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Show_all_compiler_options,
+ },
+ {
+ name: "version",
+ shortName: "v",
+ type: "boolean",
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Print_the_compiler_s_version,
+ },
+ {
+ name: "init",
+ type: "boolean",
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file,
+ },
+ {
+ name: "project",
+ shortName: "p",
+ type: "string",
+ isFilePath: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Command_line_Options,
+ paramType: ts.Diagnostics.FILE_OR_DIRECTORY,
+ description: ts.Diagnostics.Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json,
+ },
+ {
+ name: "build",
+ type: "boolean",
+ shortName: "b",
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Build_one_or_more_projects_and_their_dependencies_if_out_of_date
+ },
+ {
+ name: "showConfig",
+ type: "boolean",
+ category: ts.Diagnostics.Command_line_Options,
+ isCommandLineOnly: true,
+ description: ts.Diagnostics.Print_the_final_configuration_instead_of_building
+ },
+ {
+ name: "listFilesOnly",
+ type: "boolean",
+ category: ts.Diagnostics.Command_line_Options,
+ affectsSemanticDiagnostics: true,
+ affectsEmit: true,
+ isCommandLineOnly: true,
+ description: ts.Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing
+ },
+ {
+ name: "target",
+ shortName: "t",
+ type: new ts.Map(ts.getEntries({
+ es3: 0,
+ es5: 1,
+ es6: 2,
+ es2015: 2,
+ es2016: 3,
+ es2017: 4,
+ es2018: 5,
+ es2019: 6,
+ es2020: 7,
+ esnext: 99,
+ })),
+ affectsSourceFile: true,
+ affectsModuleResolution: true,
+ affectsEmit: true,
+ paramType: ts.Diagnostics.VERSION,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_ES2020_or_ESNEXT,
+ },
+ {
+ name: "module",
+ shortName: "m",
+ type: new ts.Map(ts.getEntries({
+ none: ts.ModuleKind.None,
+ commonjs: ts.ModuleKind.CommonJS,
+ amd: ts.ModuleKind.AMD,
+ system: ts.ModuleKind.System,
+ umd: ts.ModuleKind.UMD,
+ es6: ts.ModuleKind.ES2015,
+ es2015: ts.ModuleKind.ES2015,
+ es2020: ts.ModuleKind.ES2020,
+ esnext: ts.ModuleKind.ESNext
+ })),
+ affectsModuleResolution: true,
+ affectsEmit: true,
+ paramType: ts.Diagnostics.KIND,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Specify_module_code_generation_Colon_none_commonjs_amd_system_umd_es2015_es2020_or_ESNext,
+ },
+ {
+ name: "lib",
+ type: "list",
+ element: {
+ name: "lib",
+ type: ts.libMap
+ },
+ affectsModuleResolution: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Specify_library_files_to_be_included_in_the_compilation,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "allowJs",
+ type: "boolean",
+ affectsModuleResolution: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Allow_javascript_files_to_be_compiled
+ },
+ {
+ name: "checkJs",
+ type: "boolean",
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Report_errors_in_js_files
+ },
+ {
+ name: "jsx",
+ type: jsxOptionMap,
+ affectsSourceFile: true,
+ affectsEmit: true,
+ affectsModuleResolution: true,
+ paramType: ts.Diagnostics.KIND,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Specify_JSX_code_generation_Colon_preserve_react_native_or_react,
+ },
+ {
+ name: "declaration",
+ shortName: "d",
+ type: "boolean",
+ affectsEmit: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Generates_corresponding_d_ts_file,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "declarationMap",
+ type: "boolean",
+ affectsEmit: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Generates_a_sourcemap_for_each_corresponding_d_ts_file,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "emitDeclarationOnly",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Only_emit_d_ts_declaration_files,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "sourceMap",
+ type: "boolean",
+ affectsEmit: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Generates_corresponding_map_file,
+ },
+ {
+ name: "outFile",
+ type: "string",
+ affectsEmit: true,
+ isFilePath: true,
+ paramType: ts.Diagnostics.FILE,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "outDir",
+ type: "string",
+ affectsEmit: true,
+ isFilePath: true,
+ paramType: ts.Diagnostics.DIRECTORY,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Redirect_output_structure_to_the_directory,
+ },
+ {
+ name: "rootDir",
+ type: "string",
+ affectsEmit: true,
+ isFilePath: true,
+ paramType: ts.Diagnostics.LOCATION,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir,
+ },
+ {
+ name: "composite",
+ type: "boolean",
+ affectsEmit: true,
+ isTSConfigOnly: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Enable_project_compilation,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "tsBuildInfoFile",
+ type: "string",
+ affectsEmit: true,
+ isFilePath: true,
+ paramType: ts.Diagnostics.FILE,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Specify_file_to_store_incremental_compilation_information,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "removeComments",
+ type: "boolean",
+ affectsEmit: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Do_not_emit_comments_to_output,
+ },
+ {
+ name: "noEmit",
+ type: "boolean",
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Do_not_emit_outputs,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "importHelpers",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Import_emit_helpers_from_tslib
+ },
+ {
+ name: "importsNotUsedAsValues",
+ type: new ts.Map(ts.getEntries({
+ remove: 0,
+ preserve: 1,
+ error: 2
+ })),
+ affectsEmit: true,
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types
+ },
+ {
+ name: "downlevelIteration",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3
+ },
+ {
+ name: "isolatedModules",
+ type: "boolean",
+ category: ts.Diagnostics.Basic_Options,
+ description: ts.Diagnostics.Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule,
+ transpileOptionValue: true
+ },
+ {
+ name: "strict",
+ type: "boolean",
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Strict_Type_Checking_Options,
+ description: ts.Diagnostics.Enable_all_strict_type_checking_options
+ },
+ {
+ name: "noImplicitAny",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ strictFlag: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Strict_Type_Checking_Options,
+ description: ts.Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type
+ },
+ {
+ name: "strictNullChecks",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ strictFlag: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Strict_Type_Checking_Options,
+ description: ts.Diagnostics.Enable_strict_null_checks
+ },
+ {
+ name: "strictFunctionTypes",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ strictFlag: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Strict_Type_Checking_Options,
+ description: ts.Diagnostics.Enable_strict_checking_of_function_types
+ },
+ {
+ name: "strictBindCallApply",
+ type: "boolean",
+ strictFlag: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Strict_Type_Checking_Options,
+ description: ts.Diagnostics.Enable_strict_bind_call_and_apply_methods_on_functions
+ },
+ {
+ name: "strictPropertyInitialization",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ strictFlag: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Strict_Type_Checking_Options,
+ description: ts.Diagnostics.Enable_strict_checking_of_property_initialization_in_classes
+ },
+ {
+ name: "noImplicitThis",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ strictFlag: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Strict_Type_Checking_Options,
+ description: ts.Diagnostics.Raise_error_on_this_expressions_with_an_implied_any_type,
+ },
+ {
+ name: "alwaysStrict",
+ type: "boolean",
+ affectsSourceFile: true,
+ strictFlag: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Strict_Type_Checking_Options,
+ description: ts.Diagnostics.Parse_in_strict_mode_and_emit_use_strict_for_each_source_file
+ },
+ {
+ name: "noUnusedLocals",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Additional_Checks,
+ description: ts.Diagnostics.Report_errors_on_unused_locals,
+ },
+ {
+ name: "noUnusedParameters",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Additional_Checks,
+ description: ts.Diagnostics.Report_errors_on_unused_parameters,
+ },
+ {
+ name: "noImplicitReturns",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Additional_Checks,
+ description: ts.Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value
+ },
+ {
+ name: "noFallthroughCasesInSwitch",
+ type: "boolean",
+ affectsBindDiagnostics: true,
+ affectsSemanticDiagnostics: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Additional_Checks,
+ description: ts.Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
+ },
+ {
+ name: "noUncheckedIndexedAccess",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ showInSimplifiedHelpView: false,
+ category: ts.Diagnostics.Additional_Checks,
+ description: ts.Diagnostics.Include_undefined_in_index_signature_results
+ },
+ {
+ name: "moduleResolution",
+ type: new ts.Map(ts.getEntries({
+ node: ts.ModuleResolutionKind.NodeJs,
+ classic: ts.ModuleResolutionKind.Classic,
+ })),
+ affectsModuleResolution: true,
+ paramType: ts.Diagnostics.STRATEGY,
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
+ },
+ {
+ name: "baseUrl",
+ type: "string",
+ affectsModuleResolution: true,
+ isFilePath: true,
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.Base_directory_to_resolve_non_absolute_module_names
+ },
+ {
+ name: "paths",
+ type: "object",
+ affectsModuleResolution: true,
+ isTSConfigOnly: true,
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "rootDirs",
+ type: "list",
+ isTSConfigOnly: true,
+ element: {
+ name: "rootDirs",
+ type: "string",
+ isFilePath: true
+ },
+ affectsModuleResolution: true,
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "typeRoots",
+ type: "list",
+ element: {
+ name: "typeRoots",
+ type: "string",
+ isFilePath: true
+ },
+ affectsModuleResolution: true,
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.List_of_folders_to_include_type_definitions_from
+ },
+ {
+ name: "types",
+ type: "list",
+ element: {
+ name: "types",
+ type: "string"
+ },
+ affectsModuleResolution: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.Type_declaration_files_to_be_included_in_compilation,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "allowSyntheticDefaultImports",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking
+ },
+ {
+ name: "esModuleInterop",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ affectsEmit: true,
+ showInSimplifiedHelpView: true,
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports
+ },
+ {
+ name: "preserveSymlinks",
+ type: "boolean",
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.Do_not_resolve_the_real_path_of_symlinks,
+ },
+ {
+ name: "allowUmdGlobalAccess",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Module_Resolution_Options,
+ description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules,
+ },
+ {
+ name: "sourceRoot",
+ type: "string",
+ affectsEmit: true,
+ paramType: ts.Diagnostics.LOCATION,
+ category: ts.Diagnostics.Source_Map_Options,
+ description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations,
+ },
+ {
+ name: "mapRoot",
+ type: "string",
+ affectsEmit: true,
+ paramType: ts.Diagnostics.LOCATION,
+ category: ts.Diagnostics.Source_Map_Options,
+ description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations,
+ },
+ {
+ name: "inlineSourceMap",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Source_Map_Options,
+ description: ts.Diagnostics.Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file
+ },
+ {
+ name: "inlineSources",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Source_Map_Options,
+ description: ts.Diagnostics.Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap_to_be_set
+ },
+ {
+ name: "experimentalDecorators",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Experimental_Options,
+ description: ts.Diagnostics.Enables_experimental_support_for_ES7_decorators
+ },
+ {
+ name: "emitDecoratorMetadata",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ affectsEmit: true,
+ category: ts.Diagnostics.Experimental_Options,
+ description: ts.Diagnostics.Enables_experimental_support_for_emitting_type_metadata_for_decorators
+ },
+ {
+ name: "jsxFactory",
+ type: "string",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h
+ },
+ {
+ name: "jsxFragmentFactory",
+ type: "string",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compiler_option_is_specified_e_g_Fragment
+ },
+ {
+ name: "jsxImportSource",
+ type: "string",
+ affectsSemanticDiagnostics: true,
+ affectsEmit: true,
+ affectsModuleResolution: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Specify_the_module_specifier_to_be_used_to_import_the_jsx_and_jsxs_factory_functions_from_eg_react
+ },
+ {
+ name: "resolveJsonModule",
+ type: "boolean",
+ affectsModuleResolution: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Include_modules_imported_with_json_extension
+ },
+ {
+ name: "out",
+ type: "string",
+ affectsEmit: true,
+ isFilePath: false,
+ category: ts.Diagnostics.Advanced_Options,
+ paramType: ts.Diagnostics.FILE,
+ description: ts.Diagnostics.Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "reactNamespace",
+ type: "string",
+ affectsEmit: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react_JSX_emit
+ },
+ {
+ name: "skipDefaultLibCheck",
+ type: "boolean",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files
+ },
+ {
+ name: "charset",
+ type: "string",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.The_character_set_of_the_input_files
+ },
+ {
+ name: "emitBOM",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files
+ },
+ {
+ name: "newLine",
+ type: new ts.Map(ts.getEntries({
+ crlf: 0,
+ lf: 1
+ })),
+ affectsEmit: true,
+ paramType: ts.Diagnostics.NEWLINE,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix,
+ },
+ {
+ name: "noErrorTruncation",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_truncate_error_messages
+ },
+ {
+ name: "noLib",
+ type: "boolean",
+ affectsModuleResolution: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_include_the_default_library_file_lib_d_ts,
+ transpileOptionValue: true
+ },
+ {
+ name: "noResolve",
+ type: "boolean",
+ affectsModuleResolution: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files,
+ transpileOptionValue: true
+ },
+ {
+ name: "stripInternal",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_emit_declarations_for_code_that_has_an_internal_annotation,
+ },
+ {
+ name: "disableSizeLimit",
+ type: "boolean",
+ affectsSourceFile: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Disable_size_limitations_on_JavaScript_projects
+ },
+ {
+ name: "disableSourceOfProjectReferenceRedirect",
+ type: "boolean",
+ isTSConfigOnly: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects
+ },
+ {
+ name: "disableSolutionSearching",
+ type: "boolean",
+ isTSConfigOnly: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Disable_solution_searching_for_this_project
+ },
+ {
+ name: "disableReferencedProjectLoad",
+ type: "boolean",
+ isTSConfigOnly: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Disable_loading_referenced_projects
+ },
+ {
+ name: "noImplicitUseStrict",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_emit_use_strict_directives_in_module_output
+ },
+ {
+ name: "noEmitHelpers",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_generate_custom_helper_functions_like_extends_in_compiled_output
+ },
+ {
+ name: "noEmitOnError",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_emit_outputs_if_any_errors_were_reported,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "preserveConstEnums",
+ type: "boolean",
+ affectsEmit: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
+ },
+ {
+ name: "declarationDir",
+ type: "string",
+ affectsEmit: true,
+ isFilePath: true,
+ paramType: ts.Diagnostics.DIRECTORY,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Output_directory_for_generated_declaration_files,
+ transpileOptionValue: undefined
+ },
+ {
+ name: "skipLibCheck",
+ type: "boolean",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Skip_type_checking_of_declaration_files,
+ },
+ {
+ name: "allowUnusedLabels",
+ type: "boolean",
+ affectsBindDiagnostics: true,
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_report_errors_on_unused_labels
+ },
+ {
+ name: "allowUnreachableCode",
+ type: "boolean",
+ affectsBindDiagnostics: true,
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Do_not_report_errors_on_unreachable_code
+ },
+ {
+ name: "suppressExcessPropertyErrors",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Suppress_excess_property_checks_for_object_literals,
+ },
+ {
+ name: "suppressImplicitAnyIndexErrors",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures,
+ },
+ {
+ name: "forceConsistentCasingInFileNames",
+ type: "boolean",
+ affectsModuleResolution: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
+ },
+ {
+ name: "maxNodeModuleJsDepth",
+ type: "number",
+ affectsModuleResolution: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files
+ },
+ {
+ name: "noStrictGenericChecks",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Disable_strict_checking_of_generic_signatures_in_function_types,
+ },
+ {
+ name: "useDefineForClassFields",
+ type: "boolean",
+ affectsSemanticDiagnostics: true,
+ affectsEmit: true,
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Emit_class_fields_with_Define_instead_of_Set,
+ },
+ {
+ name: "keyofStringsOnly",
+ type: "boolean",
+ category: ts.Diagnostics.Advanced_Options,
+ description: ts.Diagnostics.Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols,
+ },
+ {
+ name: "plugins",
+ type: "list",
+ isTSConfigOnly: true,
+ element: {
+ name: "plugin",
+ type: "object"
+ },
+ description: ts.Diagnostics.List_of_language_service_plugins
+ },
+ ]);
+ ts.semanticDiagnosticsOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsSemanticDiagnostics; });
+ ts.affectsEmitOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsEmit; });
+ ts.moduleResolutionOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsModuleResolution; });
+ ts.sourceFileAffectingCompilerOptions = ts.optionDeclarations.filter(function (option) {
+ return !!option.affectsSourceFile || !!option.affectsModuleResolution || !!option.affectsBindDiagnostics;
+ });
+ ts.transpileOptionValueCompilerOptions = ts.optionDeclarations.filter(function (option) {
+ return ts.hasProperty(option, "transpileOptionValue");
+ });
+ ts.buildOpts = __spreadArrays(ts.commonOptionsWithBuild, [
+ {
+ name: "verbose",
+ shortName: "v",
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Enable_verbose_logging,
+ type: "boolean"
+ },
+ {
+ name: "dry",
+ shortName: "d",
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Show_what_would_be_built_or_deleted_if_specified_with_clean,
+ type: "boolean"
+ },
+ {
+ name: "force",
+ shortName: "f",
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Build_all_projects_including_those_that_appear_to_be_up_to_date,
+ type: "boolean"
+ },
+ {
+ name: "clean",
+ category: ts.Diagnostics.Command_line_Options,
+ description: ts.Diagnostics.Delete_the_outputs_of_all_projects,
+ type: "boolean"
}
- function bindPrefixUnaryExpressionFlow(node) {
- if (node.operator === 53) {
- var saveTrueTarget = currentTrueTarget;
- currentTrueTarget = currentFalseTarget;
- currentFalseTarget = saveTrueTarget;
- bindEachChild(node);
- currentFalseTarget = currentTrueTarget;
- currentTrueTarget = saveTrueTarget;
+ ]);
+ ts.typeAcquisitionDeclarations = [
+ {
+ name: "enableAutoDiscovery",
+ type: "boolean",
+ },
+ {
+ name: "enable",
+ type: "boolean",
+ },
+ {
+ name: "include",
+ type: "list",
+ element: {
+ name: "include",
+ type: "string"
}
- else {
- bindEachChild(node);
- if (node.operator === 45 || node.operator === 46) {
- bindAssignmentTargetFlow(node.operand);
- }
+ },
+ {
+ name: "exclude",
+ type: "list",
+ element: {
+ name: "exclude",
+ type: "string"
}
- }
- function bindPostfixUnaryExpressionFlow(node) {
- bindEachChild(node);
- if (node.operator === 45 || node.operator === 46) {
- bindAssignmentTargetFlow(node.operand);
+ },
+ {
+ name: "disableFilenameBasedTypeAcquisition",
+ type: "boolean",
+ },
+ ];
+ function createOptionNameMap(optionDeclarations) {
+ var optionsNameMap = new ts.Map();
+ var shortOptionNames = new ts.Map();
+ ts.forEach(optionDeclarations, function (option) {
+ optionsNameMap.set(option.name.toLowerCase(), option);
+ if (option.shortName) {
+ shortOptionNames.set(option.shortName, option.name);
}
- }
- function bindBinaryExpressionFlow(node) {
- var workStacks = {
- expr: [node],
- state: [1],
- inStrictMode: [undefined],
- parent: [undefined],
- subtreeFlags: [undefined]
+ });
+ return { optionsNameMap: optionsNameMap, shortOptionNames: shortOptionNames };
+ }
+ ts.createOptionNameMap = createOptionNameMap;
+ var optionsNameMapCache;
+ function getOptionsNameMap() {
+ return optionsNameMapCache || (optionsNameMapCache = createOptionNameMap(ts.optionDeclarations));
+ }
+ ts.getOptionsNameMap = getOptionsNameMap;
+ ts.defaultInitCompilerOptions = {
+ module: ts.ModuleKind.CommonJS,
+ target: 1,
+ strict: true,
+ esModuleInterop: true,
+ forceConsistentCasingInFileNames: true,
+ skipLibCheck: true
+ };
+ function convertEnableAutoDiscoveryToEnable(typeAcquisition) {
+ if (typeAcquisition && typeAcquisition.enableAutoDiscovery !== undefined && typeAcquisition.enable === undefined) {
+ return {
+ enable: typeAcquisition.enableAutoDiscovery,
+ include: typeAcquisition.include || [],
+ exclude: typeAcquisition.exclude || []
};
- var stackIndex = 0;
- while (stackIndex >= 0) {
- node = workStacks.expr[stackIndex];
- switch (workStacks.state[stackIndex]) {
- case 0: {
- node.parent = parent;
- var saveInStrictMode = inStrictMode;
- bindWorker(node);
- var saveParent = parent;
- parent = node;
- var subtreeFlagsState = void 0;
- if (skipTransformFlagAggregation) {
- }
- else if (node.transformFlags & 536870912) {
- skipTransformFlagAggregation = true;
- subtreeFlagsState = -1;
- }
- else {
- var savedSubtreeTransformFlags = subtreeTransformFlags;
- subtreeTransformFlags = 0;
- subtreeFlagsState = savedSubtreeTransformFlags;
- }
- advanceState(1, saveInStrictMode, saveParent, subtreeFlagsState);
- break;
- }
- case 1: {
- var operator = node.operatorToken.kind;
- if (operator === 55 || operator === 56 || operator === 60) {
- if (isTopLevelLogicalExpression(node)) {
- var postExpressionLabel = createBranchLabel();
- bindLogicalExpression(node, postExpressionLabel, postExpressionLabel);
- currentFlow = finishFlowLabel(postExpressionLabel);
- }
- else {
- bindLogicalExpression(node, currentTrueTarget, currentFalseTarget);
- }
- completeNode();
- }
- else {
- advanceState(2);
- maybeBind(node.left);
- }
- break;
- }
- case 2: {
- advanceState(3);
- maybeBind(node.operatorToken);
- break;
- }
- case 3: {
- advanceState(4);
- maybeBind(node.right);
- break;
- }
- case 4: {
- var operator = node.operatorToken.kind;
- if (ts.isAssignmentOperator(operator) && !ts.isAssignmentTarget(node)) {
- bindAssignmentTargetFlow(node.left);
- if (operator === 62 && node.left.kind === 195) {
- var elementAccess = node.left;
- if (isNarrowableOperand(elementAccess.expression)) {
- currentFlow = createFlowMutation(256, currentFlow, node);
- }
- }
- }
- completeNode();
- break;
- }
- default: return ts.Debug.fail("Invalid state " + workStacks.state[stackIndex] + " for bindBinaryExpressionFlow");
- }
- }
- function advanceState(state, isInStrictMode, parent, subtreeFlags) {
- workStacks.state[stackIndex] = state;
- if (isInStrictMode !== undefined) {
- workStacks.inStrictMode[stackIndex] = isInStrictMode;
- }
- if (parent !== undefined) {
- workStacks.parent[stackIndex] = parent;
- }
- if (subtreeFlags !== undefined) {
- workStacks.subtreeFlags[stackIndex] = subtreeFlags;
- }
- }
- function completeNode() {
- if (workStacks.inStrictMode[stackIndex] !== undefined) {
- if (workStacks.subtreeFlags[stackIndex] === -1) {
- skipTransformFlagAggregation = false;
- subtreeTransformFlags |= node.transformFlags & ~getTransformFlagsSubtreeExclusions(node.kind);
- }
- else if (workStacks.subtreeFlags[stackIndex] !== undefined) {
- subtreeTransformFlags = workStacks.subtreeFlags[stackIndex] | computeTransformFlagsForNode(node, subtreeTransformFlags);
- }
- inStrictMode = workStacks.inStrictMode[stackIndex];
- parent = workStacks.parent[stackIndex];
- }
- stackIndex--;
- }
- function maybeBind(node) {
- if (node && ts.isBinaryExpression(node)) {
- stackIndex++;
- workStacks.expr[stackIndex] = node;
- workStacks.state[stackIndex] = 0;
- workStacks.inStrictMode[stackIndex] = undefined;
- workStacks.parent[stackIndex] = undefined;
- workStacks.subtreeFlags[stackIndex] = undefined;
- }
- else {
- bind(node);
- }
- }
- }
- function bindDeleteExpressionFlow(node) {
- bindEachChild(node);
- if (node.expression.kind === 194) {
- bindAssignmentTargetFlow(node.expression);
- }
- }
- function bindConditionalExpressionFlow(node) {
- var trueLabel = createBranchLabel();
- var falseLabel = createBranchLabel();
- var postExpressionLabel = createBranchLabel();
- bindCondition(node.condition, trueLabel, falseLabel);
- currentFlow = finishFlowLabel(trueLabel);
- bind(node.questionToken);
- bind(node.whenTrue);
- addAntecedent(postExpressionLabel, currentFlow);
- currentFlow = finishFlowLabel(falseLabel);
- bind(node.colonToken);
- bind(node.whenFalse);
- addAntecedent(postExpressionLabel, currentFlow);
- currentFlow = finishFlowLabel(postExpressionLabel);
- }
- function bindInitializedVariableFlow(node) {
- var name = !ts.isOmittedExpression(node) ? node.name : undefined;
- if (ts.isBindingPattern(name)) {
- for (var _i = 0, _a = name.elements; _i < _a.length; _i++) {
- var child = _a[_i];
- bindInitializedVariableFlow(child);
- }
- }
- else {
- currentFlow = createFlowMutation(16, currentFlow, node);
- }
- }
- function bindVariableDeclarationFlow(node) {
- bindEachChild(node);
- if (node.initializer || ts.isForInOrOfStatement(node.parent.parent)) {
- bindInitializedVariableFlow(node);
- }
- }
- function bindJSDocTypeAlias(node) {
- node.tagName.parent = node;
- if (node.kind !== 316 && node.fullName) {
- setParentPointers(node, node.fullName);
- }
- }
- function bindJSDocClassTag(node) {
- bindEachChild(node);
- var host = ts.getHostSignatureFromJSDoc(node);
- if (host && host.kind !== 161) {
- addDeclarationToSymbol(host.symbol, host, 32);
- }
- }
- function bindOptionalExpression(node, trueTarget, falseTarget) {
- doWithConditionalBranches(bind, node, trueTarget, falseTarget);
- if (!ts.isOptionalChain(node) || ts.isOutermostOptionalChain(node)) {
- addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node));
- addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node));
- }
- }
- function bindOptionalChainRest(node) {
- switch (node.kind) {
- case 194:
- bind(node.questionDotToken);
- bind(node.name);
- break;
- case 195:
- bind(node.questionDotToken);
- bind(node.argumentExpression);
- break;
- case 196:
- bind(node.questionDotToken);
- bindEach(node.typeArguments);
- bindEach(node.arguments);
- break;
- }
- }
- function bindOptionalChain(node, trueTarget, falseTarget) {
- var preChainLabel = ts.isOptionalChainRoot(node) ? createBranchLabel() : undefined;
- bindOptionalExpression(node.expression, preChainLabel || trueTarget, falseTarget);
- if (preChainLabel) {
- currentFlow = finishFlowLabel(preChainLabel);
- }
- doWithConditionalBranches(bindOptionalChainRest, node, trueTarget, falseTarget);
- if (ts.isOutermostOptionalChain(node)) {
- addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node));
- addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node));
- }
- }
- function bindOptionalChainFlow(node) {
- if (isTopLevelLogicalExpression(node)) {
- var postExpressionLabel = createBranchLabel();
- bindOptionalChain(node, postExpressionLabel, postExpressionLabel);
- currentFlow = finishFlowLabel(postExpressionLabel);
- }
- else {
- bindOptionalChain(node, currentTrueTarget, currentFalseTarget);
- }
- }
- function bindNonNullExpressionFlow(node) {
- if (ts.isOptionalChain(node)) {
- bindOptionalChainFlow(node);
- }
- else {
- bindEachChild(node);
- }
- }
- function bindAccessExpressionFlow(node) {
- if (ts.isOptionalChain(node)) {
- bindOptionalChainFlow(node);
- }
- else {
- bindEachChild(node);
- }
- }
- function bindCallExpressionFlow(node) {
- if (ts.isOptionalChain(node)) {
- bindOptionalChainFlow(node);
- }
- else {
- var expr = ts.skipParentheses(node.expression);
- if (expr.kind === 201 || expr.kind === 202) {
- bindEach(node.typeArguments);
- bindEach(node.arguments);
- bind(node.expression);
- }
- else {
- bindEachChild(node);
- }
- }
- if (node.expression.kind === 194) {
- var propertyAccess = node.expression;
- if (ts.isIdentifier(propertyAccess.name) && isNarrowableOperand(propertyAccess.expression) && ts.isPushOrUnshiftIdentifier(propertyAccess.name)) {
- currentFlow = createFlowMutation(256, currentFlow, node);
- }
- }
- }
- function getContainerFlags(node) {
- switch (node.kind) {
- case 214:
- case 245:
- case 248:
- case 193:
- case 173:
- case 304:
- case 274:
- return 1;
- case 246:
- return 1 | 64;
- case 249:
- case 247:
- case 186:
- return 1 | 32;
- case 290:
- return 1 | 4 | 32;
- case 161:
- if (ts.isObjectLiteralOrClassExpressionMethod(node)) {
- return 1 | 4 | 32 | 8 | 128;
- }
- case 162:
- case 244:
- case 160:
- case 163:
- case 164:
- case 165:
- case 305:
- case 300:
- case 170:
- case 166:
- case 167:
- case 171:
- return 1 | 4 | 32 | 8;
- case 201:
- case 202:
- return 1 | 4 | 32 | 8 | 16;
- case 250:
- return 4;
- case 159:
- return node.initializer ? 4 : 0;
- case 280:
- case 230:
- case 231:
- case 232:
- case 251:
- return 2;
- case 223:
- return ts.isFunctionLike(node.parent) ? 0 : 2;
- }
- return 0;
- }
- function addToContainerChain(next) {
- if (lastContainer) {
- lastContainer.nextContainer = next;
- }
- lastContainer = next;
- }
- function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
- switch (container.kind) {
- case 249:
- return declareModuleMember(node, symbolFlags, symbolExcludes);
- case 290:
- return declareSourceFileMember(node, symbolFlags, symbolExcludes);
- case 214:
- case 245:
- return declareClassMember(node, symbolFlags, symbolExcludes);
- case 248:
- return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
- case 173:
- case 304:
- case 193:
- case 246:
- case 274:
- return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
- case 170:
- case 171:
- case 165:
- case 166:
- case 305:
- case 167:
- case 161:
- case 160:
- case 162:
- case 163:
- case 164:
- case 244:
- case 201:
- case 202:
- case 300:
- case 322:
- case 315:
- case 247:
- case 186:
- return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
- }
- }
- function declareClassMember(node, symbolFlags, symbolExcludes) {
- return ts.hasModifier(node, 32)
- ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes)
- : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
}
- function declareSourceFileMember(node, symbolFlags, symbolExcludes) {
- return ts.isExternalModule(file)
- ? declareModuleMember(node, symbolFlags, symbolExcludes)
- : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
+ return typeAcquisition;
+ }
+ ts.convertEnableAutoDiscoveryToEnable = convertEnableAutoDiscoveryToEnable;
+ function createCompilerDiagnosticForInvalidCustomType(opt) {
+ return createDiagnosticForInvalidCustomType(opt, ts.createCompilerDiagnostic);
+ }
+ ts.createCompilerDiagnosticForInvalidCustomType = createCompilerDiagnosticForInvalidCustomType;
+ function createDiagnosticForInvalidCustomType(opt, createDiagnostic) {
+ var namesOfType = ts.arrayFrom(opt.type.keys()).map(function (key) { return "'" + key + "'"; }).join(", ");
+ return createDiagnostic(ts.Diagnostics.Argument_for_0_option_must_be_Colon_1, "--" + opt.name, namesOfType);
+ }
+ function parseCustomTypeOption(opt, value, errors) {
+ return convertJsonOptionOfCustomType(opt, trimString(value || ""), errors);
+ }
+ ts.parseCustomTypeOption = parseCustomTypeOption;
+ function parseListTypeOption(opt, value, errors) {
+ if (value === void 0) { value = ""; }
+ value = trimString(value);
+ if (ts.startsWith(value, "-")) {
+ return undefined;
}
- function hasExportDeclarations(node) {
- var body = ts.isSourceFile(node) ? node : ts.tryCast(node.body, ts.isModuleBlock);
- return !!body && body.statements.some(function (s) { return ts.isExportDeclaration(s) || ts.isExportAssignment(s); });
+ if (value === "") {
+ return [];
}
- function setExportContextFlag(node) {
- if (node.flags & 8388608 && !hasExportDeclarations(node)) {
- node.flags |= 64;
- }
- else {
- node.flags &= ~64;
- }
+ var values = value.split(",");
+ switch (opt.element.type) {
+ case "number":
+ return ts.map(values, parseInt);
+ case "string":
+ return ts.map(values, function (v) { return v || ""; });
+ default:
+ return ts.mapDefined(values, function (v) { return parseCustomTypeOption(opt.element, v, errors); });
}
- function bindModuleDeclaration(node) {
- setExportContextFlag(node);
- if (ts.isAmbientModule(node)) {
- if (ts.hasModifier(node, 1)) {
- errorOnFirstToken(node, ts.Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible);
- }
- if (ts.isModuleAugmentationExternal(node)) {
- declareModuleSymbol(node);
+ }
+ ts.parseListTypeOption = parseListTypeOption;
+ function getOptionName(option) {
+ return option.name;
+ }
+ function createUnknownOptionError(unknownOption, diagnostics, createDiagnostics, unknownOptionErrorText) {
+ var possibleOption = ts.getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
+ return possibleOption ?
+ createDiagnostics(diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) :
+ createDiagnostics(diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
+ }
+ function parseCommandLineWorker(diagnostics, commandLine, readFile) {
+ var options = {};
+ var watchOptions;
+ var fileNames = [];
+ var errors = [];
+ parseStrings(commandLine);
+ return {
+ options: options,
+ watchOptions: watchOptions,
+ fileNames: fileNames,
+ errors: errors
+ };
+ function parseStrings(args) {
+ var i = 0;
+ while (i < args.length) {
+ var s = args[i];
+ i++;
+ if (s.charCodeAt(0) === 64) {
+ parseResponseFile(s.slice(1));
}
- else {
- var pattern = void 0;
- if (node.name.kind === 10) {
- var text = node.name.text;
- if (ts.hasZeroOrOneAsteriskCharacter(text)) {
- pattern = ts.tryParsePattern(text);
+ else if (s.charCodeAt(0) === 45) {
+ var inputOptionName = s.slice(s.charCodeAt(1) === 45 ? 2 : 1);
+ var opt = getOptionDeclarationFromName(diagnostics.getOptionsNameMap, inputOptionName, true);
+ if (opt) {
+ i = parseOptionValue(args, i, diagnostics, opt, options, errors);
+ }
+ else {
+ var watchOpt = getOptionDeclarationFromName(watchOptionsDidYouMeanDiagnostics.getOptionsNameMap, inputOptionName, true);
+ if (watchOpt) {
+ i = parseOptionValue(args, i, watchOptionsDidYouMeanDiagnostics, watchOpt, watchOptions || (watchOptions = {}), errors);
}
else {
- errorOnFirstToken(node.name, ts.Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, text);
+ errors.push(createUnknownOptionError(inputOptionName, diagnostics, ts.createCompilerDiagnostic, s));
}
}
- var symbol = declareSymbolAndAddToSymbolTable(node, 512, 110735);
- file.patternAmbientModules = ts.append(file.patternAmbientModules, pattern && { pattern: pattern, symbol: symbol });
- }
- }
- else {
- var state = declareModuleSymbol(node);
- if (state !== 0) {
- var symbol = node.symbol;
- symbol.constEnumOnlyModule = (!(symbol.flags & (16 | 32 | 256)))
- && state === 2
- && symbol.constEnumOnlyModule !== false;
}
- }
- }
- function declareModuleSymbol(node) {
- var state = getModuleInstanceState(node);
- var instantiated = state !== 0;
- declareSymbolAndAddToSymbolTable(node, instantiated ? 512 : 1024, instantiated ? 110735 : 0);
- return state;
- }
- function bindFunctionOrConstructorType(node) {
- var symbol = createSymbol(131072, getDeclarationName(node));
- addDeclarationToSymbol(symbol, node, 131072);
- var typeLiteralSymbol = createSymbol(2048, "__type");
- addDeclarationToSymbol(typeLiteralSymbol, node, 2048);
- typeLiteralSymbol.members = ts.createSymbolTable();
- typeLiteralSymbol.members.set(symbol.escapedName, symbol);
- }
- function bindObjectLiteralExpression(node) {
- if (inStrictMode && !ts.isAssignmentTarget(node)) {
- var seen = ts.createUnderscoreEscapedMap();
- for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
- var prop = _a[_i];
- if (prop.kind === 283 || prop.name.kind !== 75) {
- continue;
- }
- var identifier = prop.name;
- var currentKind = prop.kind === 281 || prop.kind === 282 || prop.kind === 161
- ? 1
- : 2;
- var existingKind = seen.get(identifier.escapedText);
- if (!existingKind) {
- seen.set(identifier.escapedText, currentKind);
- continue;
- }
- if (currentKind === 1 && existingKind === 1) {
- var span = ts.getErrorSpanForNode(file, identifier);
- file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode));
- }
+ else {
+ fileNames.push(s);
}
}
- return bindAnonymousDeclaration(node, 4096, "__object");
- }
- function bindJsxAttributes(node) {
- return bindAnonymousDeclaration(node, 4096, "__jsxAttributes");
}
- function bindJsxAttribute(node, symbolFlags, symbolExcludes) {
- return declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
- }
- function bindAnonymousDeclaration(node, symbolFlags, name) {
- var symbol = createSymbol(symbolFlags, name);
- if (symbolFlags & (8 | 106500)) {
- symbol.parent = container.symbol;
+ function parseResponseFile(fileName) {
+ var text = tryReadFile(fileName, readFile || (function (fileName) { return ts.sys.readFile(fileName); }));
+ if (!ts.isString(text)) {
+ errors.push(text);
+ return;
}
- addDeclarationToSymbol(symbol, node, symbolFlags);
- return symbol;
- }
- function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) {
- switch (blockScopeContainer.kind) {
- case 249:
- declareModuleMember(node, symbolFlags, symbolExcludes);
+ var args = [];
+ var pos = 0;
+ while (true) {
+ while (pos < text.length && text.charCodeAt(pos) <= 32)
+ pos++;
+ if (pos >= text.length)
break;
- case 290:
- if (ts.isExternalOrCommonJsModule(container)) {
- declareModuleMember(node, symbolFlags, symbolExcludes);
- break;
+ var start = pos;
+ if (text.charCodeAt(start) === 34) {
+ pos++;
+ while (pos < text.length && text.charCodeAt(pos) !== 34)
+ pos++;
+ if (pos < text.length) {
+ args.push(text.substring(start + 1, pos));
+ pos++;
}
- default:
- if (!blockScopeContainer.locals) {
- blockScopeContainer.locals = ts.createSymbolTable();
- addToContainerChain(blockScopeContainer);
+ else {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName));
}
- declareSymbol(blockScopeContainer.locals, undefined, node, symbolFlags, symbolExcludes);
+ }
+ else {
+ while (text.charCodeAt(pos) > 32)
+ pos++;
+ args.push(text.substring(start, pos));
+ }
}
+ parseStrings(args);
}
- function delayedBindJSDocTypedefTag() {
- if (!delayedTypeAliases) {
- return;
+ }
+ ts.parseCommandLineWorker = parseCommandLineWorker;
+ function parseOptionValue(args, i, diagnostics, opt, options, errors) {
+ if (opt.isTSConfigOnly) {
+ var optValue = args[i];
+ if (optValue === "null") {
+ options[opt.name] = undefined;
+ i++;
}
- var saveContainer = container;
- var saveLastContainer = lastContainer;
- var saveBlockScopeContainer = blockScopeContainer;
- var saveParent = parent;
- var saveCurrentFlow = currentFlow;
- for (var _i = 0, delayedTypeAliases_1 = delayedTypeAliases; _i < delayedTypeAliases_1.length; _i++) {
- var typeAlias = delayedTypeAliases_1[_i];
- var host = ts.getJSDocHost(typeAlias);
- container = ts.findAncestor(host.parent, function (n) { return !!(getContainerFlags(n) & 1); }) || file;
- blockScopeContainer = ts.getEnclosingBlockScopeContainer(host) || file;
- currentFlow = initFlowNode({ flags: 2 });
- parent = typeAlias;
- bind(typeAlias.typeExpression);
- var declName = ts.getNameOfDeclaration(typeAlias);
- if ((ts.isJSDocEnumTag(typeAlias) || !typeAlias.fullName) && declName && ts.isPropertyAccessEntityNameExpression(declName.parent)) {
- var isTopLevel = isTopLevelNamespaceAssignment(declName.parent);
- if (isTopLevel) {
- bindPotentiallyMissingNamespaces(file.symbol, declName.parent, isTopLevel, !!ts.findAncestor(declName, function (d) { return ts.isPropertyAccessExpression(d) && d.name.escapedText === "prototype"; }), false);
- var oldContainer = container;
- switch (ts.getAssignmentDeclarationPropertyAccessKind(declName.parent)) {
- case 1:
- case 2:
- if (!ts.isExternalOrCommonJsModule(file)) {
- container = undefined;
- }
- else {
- container = file;
- }
- break;
- case 4:
- container = declName.parent.expression;
- break;
- case 3:
- container = declName.parent.expression.name;
- break;
- case 5:
- container = isExportsOrModuleExportsOrAlias(file, declName.parent.expression) ? file
- : ts.isPropertyAccessExpression(declName.parent.expression) ? declName.parent.expression.name
- : declName.parent.expression;
- break;
- case 0:
- return ts.Debug.fail("Shouldn't have detected typedef or enum on non-assignment declaration");
- }
- if (container) {
- declareModuleMember(typeAlias, 524288, 788968);
- }
- container = oldContainer;
- }
- }
- else if (ts.isJSDocEnumTag(typeAlias) || !typeAlias.fullName || typeAlias.fullName.kind === 75) {
- parent = typeAlias.parent;
- bindBlockScopedDeclaration(typeAlias, 524288, 788968);
+ else if (opt.type === "boolean") {
+ if (optValue === "false") {
+ options[opt.name] = false;
+ i++;
}
else {
- bind(typeAlias.fullName);
+ if (optValue === "true")
+ i++;
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line, opt.name));
}
}
- container = saveContainer;
- lastContainer = saveLastContainer;
- blockScopeContainer = saveBlockScopeContainer;
- parent = saveParent;
- currentFlow = saveCurrentFlow;
- }
- function checkStrictModeIdentifier(node) {
- if (inStrictMode &&
- node.originalKeywordKind >= 113 &&
- node.originalKeywordKind <= 121 &&
- !ts.isIdentifierName(node) &&
- !(node.flags & 8388608) &&
- !(node.flags & 4194304)) {
- if (!file.parseDiagnostics.length) {
- file.bindDiagnostics.push(createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(node)));
- }
+ else {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line, opt.name));
+ if (optValue && !ts.startsWith(optValue, "-"))
+ i++;
}
}
- function getStrictModeIdentifierMessage(node) {
- if (ts.getContainingClass(node)) {
- return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode;
- }
- if (file.externalModuleIndicator) {
- return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode;
+ else {
+ if (!args[i] && opt.type !== "boolean") {
+ errors.push(ts.createCompilerDiagnostic(diagnostics.optionTypeMismatchDiagnostic, opt.name, getCompilerOptionValueTypeString(opt)));
}
- return ts.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(createDiagnosticForNode(node, ts.Diagnostics.constructor_is_a_reserved_word, ts.declarationNameToString(node)));
+ if (args[i] !== "null") {
+ switch (opt.type) {
+ case "number":
+ options[opt.name] = parseInt(args[i]);
+ i++;
+ break;
+ case "boolean":
+ var optValue = args[i];
+ options[opt.name] = optValue !== "false";
+ if (optValue === "false" || optValue === "true") {
+ i++;
+ }
+ break;
+ case "string":
+ options[opt.name] = args[i] || "";
+ i++;
+ break;
+ case "list":
+ var 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;
}
}
- }
- function checkStrictModeBinaryExpression(node) {
- if (inStrictMode && ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) {
- checkStrictModeEvalOrArguments(node, node.left);
+ else {
+ options[opt.name] = undefined;
+ i++;
}
}
- function checkStrictModeCatchClause(node) {
- if (inStrictMode && node.variableDeclaration) {
- checkStrictModeEvalOrArguments(node, node.variableDeclaration.name);
+ return i;
+ }
+ ts.compilerOptionsDidYouMeanDiagnostics = {
+ getOptionsNameMap: getOptionsNameMap,
+ optionDeclarations: ts.optionDeclarations,
+ unknownOptionDiagnostic: ts.Diagnostics.Unknown_compiler_option_0,
+ unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
+ optionTypeMismatchDiagnostic: ts.Diagnostics.Compiler_option_0_expects_an_argument
+ };
+ function parseCommandLine(commandLine, readFile) {
+ return parseCommandLineWorker(ts.compilerOptionsDidYouMeanDiagnostics, commandLine, readFile);
+ }
+ ts.parseCommandLine = parseCommandLine;
+ function getOptionFromName(optionName, allowShort) {
+ return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
+ }
+ ts.getOptionFromName = getOptionFromName;
+ function getOptionDeclarationFromName(getOptionNameMap, optionName, allowShort) {
+ if (allowShort === void 0) { allowShort = false; }
+ optionName = optionName.toLowerCase();
+ var _a = getOptionNameMap(), optionsNameMap = _a.optionsNameMap, shortOptionNames = _a.shortOptionNames;
+ if (allowShort) {
+ var short = shortOptionNames.get(optionName);
+ if (short !== undefined) {
+ optionName = short;
}
}
- function checkStrictModeDeleteExpression(node) {
- if (inStrictMode && node.expression.kind === 75) {
- var span = ts.getErrorSpanForNode(file, node.expression);
- file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode));
- }
+ return optionsNameMap.get(optionName);
+ }
+ var buildOptionsNameMapCache;
+ function getBuildOptionsNameMap() {
+ return buildOptionsNameMapCache || (buildOptionsNameMapCache = createOptionNameMap(ts.buildOpts));
+ }
+ var buildOptionsDidYouMeanDiagnostics = {
+ getOptionsNameMap: getBuildOptionsNameMap,
+ optionDeclarations: ts.buildOpts,
+ unknownOptionDiagnostic: ts.Diagnostics.Unknown_build_option_0,
+ unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_build_option_0_Did_you_mean_1,
+ optionTypeMismatchDiagnostic: ts.Diagnostics.Build_option_0_requires_a_value_of_type_1
+ };
+ function parseBuildCommand(args) {
+ var _a = parseCommandLineWorker(buildOptionsDidYouMeanDiagnostics, args), options = _a.options, watchOptions = _a.watchOptions, projects = _a.fileNames, errors = _a.errors;
+ var buildOptions = options;
+ if (projects.length === 0) {
+ projects.push(".");
}
- function isEvalOrArgumentsIdentifier(node) {
- return ts.isIdentifier(node) && (node.escapedText === "eval" || node.escapedText === "arguments");
+ if (buildOptions.clean && buildOptions.force) {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "force"));
}
- function checkStrictModeEvalOrArguments(contextNode, name) {
- if (name && name.kind === 75) {
- var identifier = name;
- if (isEvalOrArgumentsIdentifier(identifier)) {
- var span = ts.getErrorSpanForNode(file, name);
- file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, getStrictModeEvalOrArgumentsMessage(contextNode), ts.idText(identifier)));
- }
- }
+ if (buildOptions.clean && buildOptions.verbose) {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "verbose"));
}
- function getStrictModeEvalOrArgumentsMessage(node) {
- if (ts.getContainingClass(node)) {
- return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode;
- }
- if (file.externalModuleIndicator) {
- return ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode;
- }
- return ts.Diagnostics.Invalid_use_of_0_in_strict_mode;
+ if (buildOptions.clean && buildOptions.watch) {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "watch"));
}
- function checkStrictModeFunctionName(node) {
- if (inStrictMode) {
- checkStrictModeEvalOrArguments(node, node.name);
- }
+ if (buildOptions.watch && buildOptions.dry) {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "dry"));
}
- function getStrictModeBlockScopeFunctionDeclarationMessage(node) {
- if (ts.getContainingClass(node)) {
- return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode;
- }
- if (file.externalModuleIndicator) {
- return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode;
- }
- return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5;
+ return { buildOptions: buildOptions, watchOptions: watchOptions, projects: projects, errors: errors };
+ }
+ ts.parseBuildCommand = parseBuildCommand;
+ function getDiagnosticText(_message) {
+ var _args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ _args[_i - 1] = arguments[_i];
}
- function checkStrictModeFunctionDeclaration(node) {
- if (languageVersion < 2) {
- if (blockScopeContainer.kind !== 290 &&
- blockScopeContainer.kind !== 249 &&
- !ts.isFunctionLike(blockScopeContainer)) {
- var errorSpan = ts.getErrorSpanForNode(file, node);
- file.bindDiagnostics.push(ts.createFileDiagnostic(file, errorSpan.start, errorSpan.length, getStrictModeBlockScopeFunctionDeclarationMessage(node)));
- }
- }
+ var diagnostic = ts.createCompilerDiagnostic.apply(undefined, arguments);
+ return diagnostic.messageText;
+ }
+ ts.getDiagnosticText = getDiagnosticText;
+ function getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend, extraFileExtensions) {
+ var configFileText = tryReadFile(configFileName, function (fileName) { return host.readFile(fileName); });
+ if (!ts.isString(configFileText)) {
+ host.onUnRecoverableConfigFileDiagnostic(configFileText);
+ return undefined;
}
- function checkStrictModeNumericLiteral(node) {
- if (inStrictMode && node.numericLiteralFlags & 32) {
- file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
- }
+ var result = ts.parseJsonText(configFileName, configFileText);
+ var cwd = host.getCurrentDirectory();
+ result.path = ts.toPath(configFileName, cwd, ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames));
+ result.resolvedPath = result.path;
+ result.originalFileName = result.fileName;
+ return parseJsonSourceFileConfigFileContent(result, host, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), cwd), optionsToExtend, ts.getNormalizedAbsolutePath(configFileName, cwd), undefined, extraFileExtensions, extendedConfigCache, watchOptionsToExtend);
+ }
+ ts.getParsedCommandLineOfConfigFile = getParsedCommandLineOfConfigFile;
+ function readConfigFile(fileName, readFile) {
+ var textOrDiagnostic = tryReadFile(fileName, readFile);
+ return ts.isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
+ }
+ ts.readConfigFile = readConfigFile;
+ function parseConfigFileTextToJson(fileName, jsonText) {
+ var jsonSourceFile = ts.parseJsonText(fileName, jsonText);
+ return {
+ config: convertToObject(jsonSourceFile, jsonSourceFile.parseDiagnostics),
+ error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined
+ };
+ }
+ ts.parseConfigFileTextToJson = parseConfigFileTextToJson;
+ function readJsonConfigFile(fileName, readFile) {
+ var textOrDiagnostic = tryReadFile(fileName, readFile);
+ return ts.isString(textOrDiagnostic) ? ts.parseJsonText(fileName, textOrDiagnostic) : { fileName: fileName, parseDiagnostics: [textOrDiagnostic] };
+ }
+ ts.readJsonConfigFile = readJsonConfigFile;
+ function tryReadFile(fileName, readFile) {
+ var text;
+ try {
+ text = readFile(fileName);
}
- function checkStrictModePostfixUnaryExpression(node) {
- if (inStrictMode) {
- checkStrictModeEvalOrArguments(node, node.operand);
- }
+ catch (e) {
+ return ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
+ }
+ return text === undefined ? ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0, fileName) : text;
+ }
+ ts.tryReadFile = tryReadFile;
+ function commandLineOptionsToMap(options) {
+ return ts.arrayToMap(options, getOptionName);
+ }
+ var typeAcquisitionDidYouMeanDiagnostics = {
+ optionDeclarations: ts.typeAcquisitionDeclarations,
+ unknownOptionDiagnostic: ts.Diagnostics.Unknown_type_acquisition_option_0,
+ unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_type_acquisition_option_0_Did_you_mean_1,
+ };
+ var watchOptionsNameMapCache;
+ function getWatchOptionsNameMap() {
+ return watchOptionsNameMapCache || (watchOptionsNameMapCache = createOptionNameMap(ts.optionsForWatch));
+ }
+ var watchOptionsDidYouMeanDiagnostics = {
+ getOptionsNameMap: getWatchOptionsNameMap,
+ optionDeclarations: ts.optionsForWatch,
+ unknownOptionDiagnostic: ts.Diagnostics.Unknown_watch_option_0,
+ unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_watch_option_0_Did_you_mean_1,
+ optionTypeMismatchDiagnostic: ts.Diagnostics.Watch_option_0_requires_a_value_of_type_1
+ };
+ var commandLineCompilerOptionsMapCache;
+ function getCommandLineCompilerOptionsMap() {
+ return commandLineCompilerOptionsMapCache || (commandLineCompilerOptionsMapCache = commandLineOptionsToMap(ts.optionDeclarations));
+ }
+ var commandLineWatchOptionsMapCache;
+ function getCommandLineWatchOptionsMap() {
+ return commandLineWatchOptionsMapCache || (commandLineWatchOptionsMapCache = commandLineOptionsToMap(ts.optionsForWatch));
+ }
+ var commandLineTypeAcquisitionMapCache;
+ function getCommandLineTypeAcquisitionMap() {
+ return commandLineTypeAcquisitionMapCache || (commandLineTypeAcquisitionMapCache = commandLineOptionsToMap(ts.typeAcquisitionDeclarations));
+ }
+ var _tsconfigRootOptions;
+ function getTsconfigRootOptionsMap() {
+ if (_tsconfigRootOptions === undefined) {
+ _tsconfigRootOptions = {
+ name: undefined,
+ type: "object",
+ elementOptions: commandLineOptionsToMap([
+ {
+ name: "compilerOptions",
+ type: "object",
+ elementOptions: getCommandLineCompilerOptionsMap(),
+ extraKeyDiagnostics: ts.compilerOptionsDidYouMeanDiagnostics,
+ },
+ {
+ name: "watchOptions",
+ type: "object",
+ elementOptions: getCommandLineWatchOptionsMap(),
+ extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics,
+ },
+ {
+ name: "typingOptions",
+ type: "object",
+ elementOptions: getCommandLineTypeAcquisitionMap(),
+ extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics,
+ },
+ {
+ name: "typeAcquisition",
+ type: "object",
+ elementOptions: getCommandLineTypeAcquisitionMap(),
+ extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics
+ },
+ {
+ name: "extends",
+ type: "string"
+ },
+ {
+ name: "references",
+ type: "list",
+ element: {
+ name: "references",
+ type: "object"
+ }
+ },
+ {
+ name: "files",
+ type: "list",
+ element: {
+ name: "files",
+ type: "string"
+ }
+ },
+ {
+ name: "include",
+ type: "list",
+ element: {
+ name: "include",
+ type: "string"
+ }
+ },
+ {
+ name: "exclude",
+ type: "list",
+ element: {
+ name: "exclude",
+ type: "string"
+ }
+ },
+ ts.compileOnSaveCommandLineOption
+ ])
+ };
}
- function checkStrictModePrefixUnaryExpression(node) {
- if (inStrictMode) {
- if (node.operator === 45 || node.operator === 46) {
- checkStrictModeEvalOrArguments(node, node.operand);
- }
- }
+ return _tsconfigRootOptions;
+ }
+ function convertToObject(sourceFile, errors) {
+ return convertToObjectWorker(sourceFile, errors, true, undefined, undefined);
+ }
+ ts.convertToObject = convertToObject;
+ function convertToObjectWorker(sourceFile, errors, returnValue, knownRootOptions, jsonConversionNotifier) {
+ if (!sourceFile.statements.length) {
+ return returnValue ? {} : undefined;
}
- function checkStrictModeWithStatement(node) {
- if (inStrictMode) {
- errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
- }
+ return convertPropertyValueToJson(sourceFile.statements[0].expression, knownRootOptions);
+ function isRootOptionMap(knownOptions) {
+ return knownRootOptions && knownRootOptions.elementOptions === knownOptions;
}
- function checkStrictModeLabeledStatement(node) {
- if (inStrictMode && options.target >= 2) {
- if (ts.isDeclarationStatement(node.statement) || ts.isVariableStatement(node.statement)) {
- errorOnFirstToken(node.label, ts.Diagnostics.A_label_is_not_allowed_here);
+ function convertObjectLiteralExpressionToJson(node, knownOptions, extraKeyDiagnostics, parentOption) {
+ var result = returnValue ? {} : undefined;
+ var _loop_4 = function (element) {
+ if (element.kind !== 288) {
+ errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element, ts.Diagnostics.Property_assignment_expected));
+ return "continue";
}
- }
- }
- function errorOnFirstToken(node, message, arg0, arg1, arg2) {
- var span = ts.getSpanOfTokenAtPosition(file, node.pos);
- file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
- }
- function errorOrSuggestionOnNode(isError, node, message) {
- errorOrSuggestionOnRange(isError, node, node, message);
- }
- function errorOrSuggestionOnRange(isError, startNode, endNode, message) {
- addErrorOrSuggestionDiagnostic(isError, { pos: ts.getTokenPosOfNode(startNode, file), end: endNode.end }, message);
- }
- function addErrorOrSuggestionDiagnostic(isError, range, message) {
- var diag = ts.createFileDiagnostic(file, range.pos, range.end - range.pos, message);
- if (isError) {
- file.bindDiagnostics.push(diag);
- }
- else {
- file.bindSuggestionDiagnostics = ts.append(file.bindSuggestionDiagnostics, __assign(__assign({}, diag), { category: ts.DiagnosticCategory.Suggestion }));
- }
- }
- function bind(node) {
- if (!node) {
- return;
- }
- node.parent = parent;
- var saveInStrictMode = inStrictMode;
- bindWorker(node);
- if (node.kind > 152) {
- var saveParent = parent;
- parent = node;
- var containerFlags = getContainerFlags(node);
- if (containerFlags === 0) {
- bindChildren(node);
+ if (element.questionToken) {
+ errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.questionToken, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?"));
}
- else {
- bindContainer(node, containerFlags);
+ if (!isDoubleQuotedString(element.name)) {
+ errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, ts.Diagnostics.String_literal_with_double_quotes_expected));
}
- parent = saveParent;
- }
- else if (!skipTransformFlagAggregation && (node.transformFlags & 536870912) === 0) {
- subtreeTransformFlags |= computeTransformFlagsForNode(node, 0);
- var saveParent = parent;
- if (node.kind === 1)
- parent = node;
- bindJSDoc(node);
- parent = saveParent;
- }
- inStrictMode = saveInStrictMode;
- }
- function bindJSDoc(node) {
- if (ts.hasJSDocNodes(node)) {
- if (ts.isInJSFile(node)) {
- for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) {
- var j = _a[_i];
- bind(j);
+ var textOfKey = ts.isComputedNonLiteralName(element.name) ? undefined : ts.getTextOfPropertyName(element.name);
+ var keyText = textOfKey && ts.unescapeLeadingUnderscores(textOfKey);
+ var option = keyText && knownOptions ? knownOptions.get(keyText) : undefined;
+ if (keyText && extraKeyDiagnostics && !option) {
+ if (knownOptions) {
+ errors.push(createUnknownOptionError(keyText, extraKeyDiagnostics, function (message, arg0, arg1) { return ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, message, arg0, arg1); }));
}
- }
- else {
- for (var _b = 0, _c = node.jsDoc; _b < _c.length; _b++) {
- var j = _c[_b];
- setParentPointers(node, j);
+ else {
+ errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, extraKeyDiagnostics.unknownOptionDiagnostic, keyText));
}
}
- }
- }
- function updateStrictModeStatementList(statements) {
- if (!inStrictMode) {
- for (var _i = 0, statements_2 = statements; _i < statements_2.length; _i++) {
- var statement = statements_2[_i];
- if (!ts.isPrologueDirective(statement)) {
- return;
+ var value = convertPropertyValueToJson(element.initializer, option);
+ if (typeof keyText !== "undefined") {
+ if (returnValue) {
+ result[keyText] = value;
}
- if (isUseStrictPrologueDirective(statement)) {
- inStrictMode = true;
- return;
+ if (jsonConversionNotifier &&
+ (parentOption || isRootOptionMap(knownOptions))) {
+ var 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);
+ }
+ }
}
}
+ };
+ for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
+ var element = _a[_i];
+ _loop_4(element);
}
+ return result;
}
- function isUseStrictPrologueDirective(node) {
- var nodeText = ts.getSourceTextOfNodeFromSourceFile(file, node.expression);
- return nodeText === '"use strict"' || nodeText === "'use strict'";
+ function convertArrayLiteralExpressionToJson(elements, elementOption) {
+ if (!returnValue) {
+ return elements.forEach(function (element) { return convertPropertyValueToJson(element, elementOption); });
+ }
+ return ts.filter(elements.map(function (element) { return convertPropertyValueToJson(element, elementOption); }), function (v) { return v !== undefined; });
}
- function bindWorker(node) {
- switch (node.kind) {
- case 75:
- if (node.isInJSDocNamespace) {
- var parentNode = node.parent;
- while (parentNode && !ts.isJSDocTypeAlias(parentNode)) {
- parentNode = parentNode.parent;
- }
- bindBlockScopedDeclaration(parentNode, 524288, 788968);
- break;
- }
- case 104:
- if (currentFlow && (ts.isExpression(node) || parent.kind === 282)) {
- node.flowNode = currentFlow;
- }
- return checkStrictModeIdentifier(node);
- case 76:
- return checkPrivateIdentifier(node);
- case 194:
- case 195:
- var expr = node;
- if (currentFlow && isNarrowableReference(expr)) {
- expr.flowNode = currentFlow;
- }
- if (ts.isSpecialPropertyDeclaration(expr)) {
- bindSpecialPropertyDeclaration(expr);
- }
- if (ts.isInJSFile(expr) &&
- file.commonJsModuleIndicator &&
- ts.isModuleExportsAccessExpression(expr) &&
- !lookupSymbolForNameWorker(blockScopeContainer, "module")) {
- declareSymbol(file.locals, undefined, expr.expression, 1 | 134217728, 111550);
+ function convertPropertyValueToJson(valueExpression, option) {
+ switch (valueExpression.kind) {
+ case 109:
+ reportInvalidOptionValue(option && option.type !== "boolean");
+ return true;
+ case 94:
+ reportInvalidOptionValue(option && option.type !== "boolean");
+ return false;
+ case 103:
+ reportInvalidOptionValue(option && option.name === "extends");
+ return null;
+ case 10:
+ if (!isDoubleQuotedString(valueExpression)) {
+ errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.String_literal_with_double_quotes_expected));
}
- break;
- case 209:
- var specialKind = ts.getAssignmentDeclarationKind(node);
- switch (specialKind) {
- case 1:
- bindExportsPropertyAssignment(node);
- break;
- case 2:
- bindModuleExportsAssignment(node);
- break;
- case 3:
- bindPrototypePropertyAssignment(node.left, node);
- break;
- case 6:
- bindPrototypeAssignment(node);
- break;
- case 4:
- bindThisPropertyAssignment(node);
- break;
- case 5:
- bindSpecialPropertyAssignment(node);
- break;
- case 0:
- break;
- default:
- ts.Debug.fail("Unknown binary expression special property assignment kind");
+ reportInvalidOptionValue(option && (ts.isString(option.type) && option.type !== "string"));
+ var text = valueExpression.text;
+ if (option && !ts.isString(option.type)) {
+ var customOption = option;
+ if (!customOption.type.has(text.toLowerCase())) {
+ errors.push(createDiagnosticForInvalidCustomType(customOption, function (message, arg0, arg1) { return ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, message, arg0, arg1); }));
+ }
}
- return checkStrictModeBinaryExpression(node);
- case 280:
- return checkStrictModeCatchClause(node);
- case 203:
- return checkStrictModeDeleteExpression(node);
+ return text;
case 8:
- return checkStrictModeNumericLiteral(node);
- case 208:
- return checkStrictModePostfixUnaryExpression(node);
- case 207:
- return checkStrictModePrefixUnaryExpression(node);
- case 236:
- return checkStrictModeWithStatement(node);
- case 238:
- return checkStrictModeLabeledStatement(node);
- case 183:
- seenThisKeyword = true;
- return;
- case 168:
- break;
- case 155:
- return bindTypeParameter(node);
- case 156:
- return bindParameter(node);
- case 242:
- return bindVariableDeclarationOrBindingElement(node);
- case 191:
- node.flowNode = currentFlow;
- return bindVariableDeclarationOrBindingElement(node);
- case 159:
- case 158:
- return bindPropertyWorker(node);
- case 281:
- case 282:
- return bindPropertyOrMethodOrAccessor(node, 4, 0);
- case 284:
- return bindPropertyOrMethodOrAccessor(node, 8, 900095);
- case 165:
- case 166:
- case 167:
- return declareSymbolAndAddToSymbolTable(node, 131072, 0);
- case 161:
- case 160:
- return bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 16777216 : 0), ts.isObjectLiteralMethod(node) ? 0 : 103359);
- case 244:
- return bindFunctionDeclaration(node);
- case 162:
- return declareSymbolAndAddToSymbolTable(node, 16384, 0);
- case 163:
- return bindPropertyOrMethodOrAccessor(node, 32768, 46015);
- case 164:
- return bindPropertyOrMethodOrAccessor(node, 65536, 78783);
- case 170:
- case 300:
- case 305:
- case 171:
- return bindFunctionOrConstructorType(node);
- case 173:
- case 304:
- case 186:
- return bindAnonymousTypeWorker(node);
- case 310:
- return bindJSDocClassTag(node);
- case 193:
- return bindObjectLiteralExpression(node);
- case 201:
- case 202:
- return bindFunctionExpression(node);
- case 196:
- var assignmentKind = ts.getAssignmentDeclarationKind(node);
- switch (assignmentKind) {
- case 7:
- return bindObjectDefinePropertyAssignment(node);
- case 8:
- return bindObjectDefinePropertyExport(node);
- case 9:
- return bindObjectDefinePrototypeProperty(node);
- case 0:
- break;
- default:
- return ts.Debug.fail("Unknown call expression assignment declaration kind");
- }
- if (ts.isInJSFile(node)) {
- bindCallExpression(node);
- }
- break;
+ reportInvalidOptionValue(option && option.type !== "number");
+ return Number(valueExpression.text);
case 214:
- case 245:
- inStrictMode = true;
- return bindClassLikeDeclaration(node);
- case 246:
- return bindBlockScopedDeclaration(node, 64, 788872);
- case 247:
- return bindBlockScopedDeclaration(node, 524288, 788968);
- case 248:
- return bindEnumDeclaration(node);
- case 249:
- return bindModuleDeclaration(node);
- case 274:
- return bindJsxAttributes(node);
- case 273:
- return bindJsxAttribute(node, 4, 0);
- case 253:
- case 256:
- case 258:
- case 263:
- return declareSymbolAndAddToSymbolTable(node, 2097152, 2097152);
- case 252:
- return bindNamespaceExportDeclaration(node);
- case 255:
- return bindImportClause(node);
- case 260:
- return bindExportDeclaration(node);
- case 259:
- return bindExportAssignment(node);
- case 290:
- updateStrictModeStatementList(node.statements);
- return bindSourceFileIfExternalModule();
- case 223:
- if (!ts.isFunctionLike(node.parent)) {
- return;
+ if (valueExpression.operator !== 40 || valueExpression.operand.kind !== 8) {
+ break;
}
- case 250:
- return updateStrictModeStatementList(node.statements);
- case 317:
- if (node.parent.kind === 305) {
- return bindParameter(node);
+ reportInvalidOptionValue(option && option.type !== "number");
+ return -Number(valueExpression.operand.text);
+ case 200:
+ reportInvalidOptionValue(option && option.type !== "object");
+ var objectLiteralExpression = valueExpression;
+ if (option) {
+ var _a = option, elementOptions = _a.elementOptions, extraKeyDiagnostics = _a.extraKeyDiagnostics, optionName = _a.name;
+ return convertObjectLiteralExpressionToJson(objectLiteralExpression, elementOptions, extraKeyDiagnostics, optionName);
}
- if (node.parent.kind !== 304) {
- break;
+ else {
+ return convertObjectLiteralExpressionToJson(objectLiteralExpression, undefined, undefined, undefined);
}
- case 323:
- var propTag = node;
- var flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === 299 ?
- 4 | 16777216 :
- 4;
- return declareSymbolAndAddToSymbolTable(propTag, flags, 0);
- case 322:
- case 315:
- case 316:
- return (delayedTypeAliases || (delayedTypeAliases = [])).push(node);
- }
- }
- function bindPropertyWorker(node) {
- return bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 16777216 : 0), 0);
- }
- function bindAnonymousTypeWorker(node) {
- return bindAnonymousDeclaration(node, 2048, "__type");
- }
- function bindSourceFileIfExternalModule() {
- setExportContextFlag(file);
- if (ts.isExternalModule(file)) {
- bindSourceFileAsExternalModule();
- }
- else if (ts.isJsonSourceFile(file)) {
- bindSourceFileAsExternalModule();
- var originalSymbol = file.symbol;
- declareSymbol(file.symbol.exports, file.symbol, file, 4, 67108863);
- file.symbol = originalSymbol;
+ case 199:
+ reportInvalidOptionValue(option && option.type !== "list");
+ return convertArrayLiteralExpressionToJson(valueExpression.elements, option && option.element);
}
- }
- function bindSourceFileAsExternalModule() {
- bindAnonymousDeclaration(file, 512, "\"" + ts.removeFileExtension(file.fileName) + "\"");
- }
- function bindExportAssignment(node) {
- if (!container.symbol || !container.symbol.exports) {
- bindAnonymousDeclaration(node, 2097152, getDeclarationName(node));
+ if (option) {
+ reportInvalidOptionValue(true);
}
else {
- var flags = ts.exportAssignmentIsAlias(node)
- ? 2097152
- : 4;
- var symbol = declareSymbol(container.symbol.exports, container.symbol, node, flags, 67108863);
- if (node.isExportEquals) {
- ts.setValueDeclaration(symbol, node);
+ errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal));
+ }
+ return undefined;
+ function reportInvalidOptionValue(isError) {
+ if (isError) {
+ errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option)));
}
}
}
- function bindNamespaceExportDeclaration(node) {
- if (node.modifiers && node.modifiers.length) {
- file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Modifiers_cannot_appear_here));
- }
- var diag = !ts.isSourceFile(node.parent) ? ts.Diagnostics.Global_module_exports_may_only_appear_at_top_level
- : !ts.isExternalModule(node.parent) ? ts.Diagnostics.Global_module_exports_may_only_appear_in_module_files
- : !node.parent.isDeclarationFile ? ts.Diagnostics.Global_module_exports_may_only_appear_in_declaration_files
- : undefined;
- if (diag) {
- file.bindDiagnostics.push(createDiagnosticForNode(node, diag));
+ function isDoubleQuotedString(node) {
+ return ts.isStringLiteral(node) && ts.isStringDoubleQuoted(node, sourceFile);
+ }
+ }
+ ts.convertToObjectWorker = convertToObjectWorker;
+ function getCompilerOptionValueTypeString(option) {
+ return option.type === "list" ?
+ "Array" :
+ ts.isString(option.type) ? option.type : "string";
+ }
+ function isCompilerOptionsValue(option, value) {
+ if (option) {
+ if (isNullOrUndefined(value))
+ return true;
+ if (option.type === "list") {
+ return ts.isArray(value);
}
- else {
- file.symbol.globalExports = file.symbol.globalExports || ts.createSymbolTable();
- declareSymbol(file.symbol.globalExports, file.symbol, node, 2097152, 2097152);
+ var expectedType = ts.isString(option.type) ? option.type : "string";
+ return typeof value === expectedType;
+ }
+ return false;
+ }
+ function convertToTSConfig(configParseResult, configFileName, host) {
+ var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames);
+ var files = ts.map(ts.filter(configParseResult.fileNames, (!configParseResult.configFileSpecs || !configParseResult.configFileSpecs.validatedIncludeSpecs) ? function (_) { return true; } : matchesSpecs(configFileName, configParseResult.configFileSpecs.validatedIncludeSpecs, configParseResult.configFileSpecs.validatedExcludeSpecs, host)), function (f) { return ts.getRelativePathFromFile(ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), ts.getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName); });
+ var optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames });
+ var watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
+ var config = __assign(__assign({ compilerOptions: __assign(__assign({}, optionMapToObject(optionMap)), { showConfig: undefined, configFile: undefined, configFilePath: undefined, help: undefined, init: undefined, listFiles: undefined, listEmittedFiles: undefined, project: undefined, build: undefined, version: undefined }), watchOptions: watchOptionMap && optionMapToObject(watchOptionMap), references: ts.map(configParseResult.projectReferences, function (r) { return (__assign(__assign({}, r), { path: r.originalPath ? r.originalPath : "", originalPath: undefined })); }), files: ts.length(files) ? files : undefined }, (configParseResult.configFileSpecs ? {
+ include: filterSameAsDefaultInclude(configParseResult.configFileSpecs.validatedIncludeSpecs),
+ exclude: configParseResult.configFileSpecs.validatedExcludeSpecs
+ } : {})), { compileOnSave: !!configParseResult.compileOnSave ? true : undefined });
+ return config;
+ }
+ ts.convertToTSConfig = convertToTSConfig;
+ function optionMapToObject(optionMap) {
+ return __assign({}, ts.arrayFrom(optionMap.entries()).reduce(function (prev, cur) {
+ var _a;
+ return (__assign(__assign({}, prev), (_a = {}, _a[cur[0]] = cur[1], _a)));
+ }, {}));
+ }
+ function filterSameAsDefaultInclude(specs) {
+ if (!ts.length(specs))
+ return undefined;
+ if (ts.length(specs) !== 1)
+ return specs;
+ if (specs[0] === "**/*")
+ return undefined;
+ return specs;
+ }
+ function matchesSpecs(path, includeSpecs, excludeSpecs, host) {
+ if (!includeSpecs)
+ return function (_) { return true; };
+ var patterns = ts.getFileMatcherPatterns(path, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
+ var excludeRe = patterns.excludePattern && ts.getRegexFromPattern(patterns.excludePattern, host.useCaseSensitiveFileNames);
+ var includeRe = patterns.includeFilePattern && ts.getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames);
+ if (includeRe) {
+ if (excludeRe) {
+ return function (path) { return !(includeRe.test(path) && !excludeRe.test(path)); };
}
+ return function (path) { return !includeRe.test(path); };
}
- function bindExportDeclaration(node) {
- if (!container.symbol || !container.symbol.exports) {
- bindAnonymousDeclaration(node, 8388608, getDeclarationName(node));
- }
- else if (!node.exportClause) {
- declareSymbol(container.symbol.exports, container.symbol, node, 8388608, 0);
- }
- else if (ts.isNamespaceExport(node.exportClause)) {
- node.exportClause.parent = node;
- declareSymbol(container.symbol.exports, container.symbol, node.exportClause, 2097152, 2097152);
- }
+ if (excludeRe) {
+ return function (path) { return excludeRe.test(path); };
}
- function bindImportClause(node) {
- if (node.name) {
- declareSymbolAndAddToSymbolTable(node, 2097152, 2097152);
- }
+ return function (_) { return true; };
+ }
+ function getCustomTypeMapOfCommandLineOption(optionDefinition) {
+ if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean" || optionDefinition.type === "object") {
+ return undefined;
}
- function setCommonJsModuleIndicator(node) {
- if (file.externalModuleIndicator) {
- return false;
- }
- if (!file.commonJsModuleIndicator) {
- file.commonJsModuleIndicator = node;
- bindSourceFileAsExternalModule();
- }
- return true;
+ else if (optionDefinition.type === "list") {
+ return getCustomTypeMapOfCommandLineOption(optionDefinition.element);
}
- function bindObjectDefinePropertyExport(node) {
- if (!setCommonJsModuleIndicator(node)) {
- return;
- }
- var symbol = forEachIdentifierInEntityName(node.arguments[0], undefined, function (id, symbol) {
- if (symbol) {
- addDeclarationToSymbol(symbol, id, 1536 | 67108864);
- }
- return symbol;
- });
- if (symbol) {
- var flags = 4 | 1048576;
- declareSymbol(symbol.exports, symbol, node, flags, 0);
- }
+ else {
+ return optionDefinition.type;
}
- function bindExportsPropertyAssignment(node) {
- if (!setCommonJsModuleIndicator(node)) {
- return;
+ }
+ function getNameOfCompilerOptionValue(value, customTypeMap) {
+ return ts.forEachEntry(customTypeMap, function (mapValue, key) {
+ if (mapValue === value) {
+ return key;
}
- var symbol = forEachIdentifierInEntityName(node.left.expression, undefined, function (id, symbol) {
- if (symbol) {
- addDeclarationToSymbol(symbol, id, 1536 | 67108864);
+ });
+ }
+ function serializeCompilerOptions(options, pathOptions) {
+ return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
+ }
+ function serializeWatchOptions(options) {
+ return serializeOptionBaseObject(options, getWatchOptionsNameMap());
+ }
+ function serializeOptionBaseObject(options, _a, pathOptions) {
+ var optionsNameMap = _a.optionsNameMap;
+ var result = new ts.Map();
+ var getCanonicalFileName = pathOptions && ts.createGetCanonicalFileName(pathOptions.useCaseSensitiveFileNames);
+ var _loop_5 = function (name) {
+ if (ts.hasProperty(options, name)) {
+ if (optionsNameMap.has(name) && optionsNameMap.get(name).category === ts.Diagnostics.Command_line_Options) {
+ return "continue";
}
- return symbol;
- });
- if (symbol) {
- var flags = ts.isClassExpression(node.right) ?
- 4 | 1048576 | 32 :
- 4 | 1048576;
- declareSymbol(symbol.exports, symbol, node.left, flags, 0);
- }
- }
- function bindModuleExportsAssignment(node) {
- if (!setCommonJsModuleIndicator(node)) {
- return;
- }
- var assignedExpression = ts.getRightMostAssignedExpression(node.right);
- if (ts.isEmptyObjectLiteral(assignedExpression) || container === file && isExportsOrModuleExportsOrAlias(file, assignedExpression)) {
- return;
- }
- var flags = ts.exportAssignmentIsAlias(node)
- ? 2097152
- : 4 | 1048576 | 512;
- var symbol = declareSymbol(file.symbol.exports, file.symbol, node, flags | 67108864, 0);
- ts.setValueDeclaration(symbol, node);
- }
- function bindThisPropertyAssignment(node) {
- ts.Debug.assert(ts.isInJSFile(node));
- var hasPrivateIdentifier = (ts.isBinaryExpression(node) && ts.isPropertyAccessExpression(node.left) && ts.isPrivateIdentifier(node.left.name))
- || (ts.isPropertyAccessExpression(node) && ts.isPrivateIdentifier(node.name));
- if (hasPrivateIdentifier) {
- return;
- }
- var thisContainer = ts.getThisContainer(node, false);
- switch (thisContainer.kind) {
- case 244:
- case 201:
- var constructorSymbol = thisContainer.symbol;
- if (ts.isBinaryExpression(thisContainer.parent) && thisContainer.parent.operatorToken.kind === 62) {
- var l = thisContainer.parent.left;
- if (ts.isBindableStaticAccessExpression(l) && ts.isPrototypeAccess(l.expression)) {
- constructorSymbol = lookupSymbolForPropertyAccess(l.expression.expression, thisParentContainer);
- }
- }
- if (constructorSymbol && constructorSymbol.valueDeclaration) {
- constructorSymbol.members = constructorSymbol.members || ts.createSymbolTable();
- if (ts.hasDynamicName(node)) {
- bindDynamicallyNamedThisPropertyAssignment(node, constructorSymbol);
+ var value = options[name];
+ var optionDefinition = optionsNameMap.get(name.toLowerCase());
+ if (optionDefinition) {
+ var customTypeMap_1 = getCustomTypeMapOfCommandLineOption(optionDefinition);
+ if (!customTypeMap_1) {
+ if (pathOptions && optionDefinition.isFilePath) {
+ result.set(name, ts.getRelativePathFromFile(pathOptions.configFilePath, ts.getNormalizedAbsolutePath(value, ts.getDirectoryPath(pathOptions.configFilePath)), getCanonicalFileName));
}
else {
- declareSymbol(constructorSymbol.members, constructorSymbol, node, 4 | 67108864, 0 & ~4);
+ result.set(name, value);
}
- addDeclarationToSymbol(constructorSymbol, constructorSymbol.valueDeclaration, 32);
- }
- break;
- case 162:
- case 159:
- case 161:
- case 163:
- case 164:
- var containingClass = thisContainer.parent;
- var symbolTable = ts.hasModifier(thisContainer, 32) ? containingClass.symbol.exports : containingClass.symbol.members;
- if (ts.hasDynamicName(node)) {
- bindDynamicallyNamedThisPropertyAssignment(node, containingClass.symbol);
- }
- else {
- declareSymbol(symbolTable, containingClass.symbol, node, 4 | 67108864, 0, true);
- }
- break;
- case 290:
- if (ts.hasDynamicName(node)) {
- break;
- }
- else if (thisContainer.commonJsModuleIndicator) {
- declareSymbol(thisContainer.symbol.exports, thisContainer.symbol, node, 4 | 1048576, 0);
}
else {
- declareSymbolAndAddToSymbolTable(node, 1, 111550);
+ if (optionDefinition.type === "list") {
+ result.set(name, value.map(function (element) { return getNameOfCompilerOptionValue(element, customTypeMap_1); }));
+ }
+ else {
+ result.set(name, getNameOfCompilerOptionValue(value, customTypeMap_1));
+ }
}
- break;
+ }
+ }
+ };
+ for (var name in options) {
+ _loop_5(name);
+ }
+ return result;
+ }
+ function generateTSConfig(options, fileNames, newLine) {
+ var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions);
+ var compilerOptionsMap = serializeCompilerOptions(compilerOptions);
+ return writeConfigurations();
+ function getDefaultValueForOption(option) {
+ switch (option.type) {
+ case "number":
+ return 1;
+ case "boolean":
+ return true;
+ case "string":
+ return option.isFilePath ? "./" : "";
+ case "list":
+ return [];
+ case "object":
+ return {};
default:
- ts.Debug.failBadSyntaxKind(thisContainer);
+ var iterResult = option.type.keys().next();
+ if (!iterResult.done)
+ return iterResult.value;
+ return ts.Debug.fail("Expected 'option.type' to have entries.");
}
}
- function bindDynamicallyNamedThisPropertyAssignment(node, symbol) {
- bindAnonymousDeclaration(node, 4, "__computed");
- addLateBoundAssignmentDeclarationToSymbol(node, symbol);
+ function makePadding(paddingLength) {
+ return Array(paddingLength + 1).join(" ");
}
- function addLateBoundAssignmentDeclarationToSymbol(node, symbol) {
- if (symbol) {
- var members = symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = ts.createMap());
- members.set("" + ts.getNodeId(node), node);
- }
+ function isAllowedOption(_a) {
+ var category = _a.category, name = _a.name;
+ return category !== undefined
+ && category !== ts.Diagnostics.Command_line_Options
+ && (category !== ts.Diagnostics.Advanced_Options || compilerOptionsMap.has(name));
}
- function bindSpecialPropertyDeclaration(node) {
- if (node.expression.kind === 104) {
- bindThisPropertyAssignment(node);
+ function writeConfigurations() {
+ var categorizedOptions = ts.createMultiMap();
+ for (var _i = 0, optionDeclarations_1 = ts.optionDeclarations; _i < optionDeclarations_1.length; _i++) {
+ var option = optionDeclarations_1[_i];
+ var category = option.category;
+ if (isAllowedOption(option)) {
+ categorizedOptions.add(ts.getLocaleSpecificMessage(category), option);
+ }
}
- else if (ts.isBindableStaticAccessExpression(node) && node.parent.parent.kind === 290) {
- if (ts.isPrototypeAccess(node.expression)) {
- bindPrototypePropertyAssignment(node, node.parent);
+ var marginLength = 0;
+ var seenKnownKeys = 0;
+ var entries = [];
+ categorizedOptions.forEach(function (options, category) {
+ if (entries.length !== 0) {
+ entries.push({ value: "" });
}
- else {
- bindStaticPropertyAssignment(node);
+ entries.push({ value: "/* " + category + " */" });
+ for (var _i = 0, options_1 = options; _i < options_1.length; _i++) {
+ var option = options_1[_i];
+ var optionName = void 0;
+ if (compilerOptionsMap.has(option.name)) {
+ optionName = "\"" + 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 && ts.getLocaleSpecificMessage(option.description) || option.name) + " */"
+ });
+ marginLength = Math.max(optionName.length, marginLength);
}
+ });
+ var tab = makePadding(2);
+ var result = [];
+ result.push("{");
+ result.push(tab + "\"compilerOptions\": {");
+ result.push("" + tab + tab + "/* " + ts.getLocaleSpecificMessage(ts.Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_json_to_read_more_about_this_file) + " */");
+ result.push("");
+ for (var _a = 0, entries_2 = entries; _a < entries_2.length; _a++) {
+ var entry = entries_2[_a];
+ var value = entry.value, _b = entry.description, description = _b === void 0 ? "" : _b;
+ result.push(value && "" + tab + tab + value + (description && (makePadding(marginLength - value.length + 2) + description)));
}
- }
- function bindPrototypeAssignment(node) {
- node.left.parent = node;
- node.right.parent = node;
- bindPropertyAssignment(node.left.expression, node.left, false, true);
- }
- function bindObjectDefinePrototypeProperty(node) {
- var namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0].expression);
- if (namespaceSymbol && namespaceSymbol.valueDeclaration) {
- addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32);
+ if (fileNames.length) {
+ result.push(tab + "},");
+ result.push(tab + "\"files\": [");
+ for (var i = 0; i < fileNames.length; i++) {
+ result.push("" + tab + tab + JSON.stringify(fileNames[i]) + (i === fileNames.length - 1 ? "" : ","));
+ }
+ result.push(tab + "]");
}
- bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, true);
+ else {
+ result.push(tab + "}");
+ }
+ result.push("}");
+ return result.join(newLine) + newLine;
}
- function bindPrototypePropertyAssignment(lhs, parent) {
- var classPrototype = lhs.expression;
- var constructorFunction = classPrototype.expression;
- lhs.parent = parent;
- constructorFunction.parent = classPrototype;
- classPrototype.parent = lhs;
- bindPropertyAssignment(constructorFunction, lhs, true, true);
+ }
+ ts.generateTSConfig = generateTSConfig;
+ function convertToOptionsWithAbsolutePaths(options, toAbsolutePath) {
+ var result = {};
+ var optionsNameMap = getOptionsNameMap().optionsNameMap;
+ for (var name in options) {
+ if (ts.hasProperty(options, name)) {
+ result[name] = convertToOptionValueWithAbsolutePaths(optionsNameMap.get(name.toLowerCase()), options[name], toAbsolutePath);
+ }
}
- function bindObjectDefinePropertyAssignment(node) {
- var namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0]);
- var isToplevel = node.parent.parent.kind === 290;
- namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, node.arguments[0], isToplevel, false, false);
- bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, false);
+ if (result.configFilePath) {
+ result.configFilePath = toAbsolutePath(result.configFilePath);
}
- function bindSpecialPropertyAssignment(node) {
- var parentSymbol = lookupSymbolForPropertyAccess(node.left.expression);
- if (!ts.isInJSFile(node) && !ts.isFunctionSymbol(parentSymbol)) {
- return;
- }
- node.left.parent = node;
- node.right.parent = node;
- if (ts.isIdentifier(node.left.expression) && container === file && isExportsOrModuleExportsOrAlias(file, node.left.expression)) {
- bindExportsPropertyAssignment(node);
- }
- else if (ts.hasDynamicName(node)) {
- bindAnonymousDeclaration(node, 4 | 67108864, "__computed");
- var sym = bindPotentiallyMissingNamespaces(parentSymbol, node.left.expression, isTopLevelNamespaceAssignment(node.left), false, false);
- addLateBoundAssignmentDeclarationToSymbol(node, sym);
+ return result;
+ }
+ ts.convertToOptionsWithAbsolutePaths = convertToOptionsWithAbsolutePaths;
+ function convertToOptionValueWithAbsolutePaths(option, value, toAbsolutePath) {
+ if (option && !isNullOrUndefined(value)) {
+ if (option.type === "list") {
+ var values = value;
+ if (option.element.isFilePath && values.length) {
+ return values.map(toAbsolutePath);
+ }
}
- else {
- bindStaticPropertyAssignment(ts.cast(node.left, ts.isBindableStaticNameExpression));
+ else if (option.isFilePath) {
+ return toAbsolutePath(value);
}
}
- function bindStaticPropertyAssignment(node) {
- ts.Debug.assert(!ts.isIdentifier(node));
- node.expression.parent = node;
- bindPropertyAssignment(node.expression, node, false, false);
+ return value;
+ }
+ function parseJsonConfigFileContent(json, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) {
+ return parseJsonConfigFileContentWorker(json, undefined, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
+ }
+ ts.parseJsonConfigFileContent = parseJsonConfigFileContent;
+ function parseJsonSourceFileConfigFileContent(sourceFile, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) {
+ return parseJsonConfigFileContentWorker(undefined, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
+ }
+ ts.parseJsonSourceFileConfigFileContent = parseJsonSourceFileConfigFileContent;
+ function setConfigFileInOptions(options, configFile) {
+ if (configFile) {
+ Object.defineProperty(options, "configFile", { enumerable: false, writable: false, value: configFile });
}
- function bindPotentiallyMissingNamespaces(namespaceSymbol, entityName, isToplevel, isPrototypeProperty, containerIsClass) {
- if (isToplevel && !isPrototypeProperty) {
- var flags_1 = 1536 | 67108864;
- var excludeFlags_1 = 110735 & ~67108864;
- namespaceSymbol = forEachIdentifierInEntityName(entityName, namespaceSymbol, function (id, symbol, parent) {
- if (symbol) {
- addDeclarationToSymbol(symbol, id, flags_1);
- return symbol;
+ }
+ ts.setConfigFileInOptions = setConfigFileInOptions;
+ function isNullOrUndefined(x) {
+ return x === undefined || x === null;
+ }
+ function directoryOfCombinedPath(fileName, basePath) {
+ return ts.getDirectoryPath(ts.getNormalizedAbsolutePath(fileName, basePath));
+ }
+ function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache) {
+ if (existingOptions === void 0) { existingOptions = {}; }
+ if (resolutionStack === void 0) { resolutionStack = []; }
+ if (extraFileExtensions === void 0) { extraFileExtensions = []; }
+ ts.Debug.assert((json === undefined && sourceFile !== undefined) || (json !== undefined && sourceFile === undefined));
+ var errors = [];
+ var parsedConfig = parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache);
+ var raw = parsedConfig.raw;
+ var options = ts.extend(existingOptions, parsedConfig.options || {});
+ var watchOptions = existingWatchOptions && parsedConfig.watchOptions ?
+ ts.extend(existingWatchOptions, parsedConfig.watchOptions) :
+ parsedConfig.watchOptions || existingWatchOptions;
+ options.configFilePath = configFileName && ts.normalizeSlashes(configFileName);
+ setConfigFileInOptions(options, sourceFile);
+ var projectReferences;
+ var _a = getFileNames(), fileNames = _a.fileNames, wildcardDirectories = _a.wildcardDirectories, spec = _a.spec;
+ return {
+ options: options,
+ watchOptions: watchOptions,
+ fileNames: fileNames,
+ projectReferences: projectReferences,
+ typeAcquisition: parsedConfig.typeAcquisition || getDefaultTypeAcquisition(),
+ raw: raw,
+ errors: errors,
+ wildcardDirectories: wildcardDirectories,
+ compileOnSave: !!raw.compileOnSave,
+ configFileSpecs: spec
+ };
+ function getFileNames() {
+ var referencesOfRaw = getPropFromRaw("references", function (element) { return typeof element === "object"; }, "object");
+ if (ts.isArray(referencesOfRaw)) {
+ for (var _i = 0, referencesOfRaw_1 = referencesOfRaw; _i < referencesOfRaw_1.length; _i++) {
+ var ref = referencesOfRaw_1[_i];
+ if (typeof ref.path !== "string") {
+ createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string");
}
else {
- var table = parent ? parent.exports :
- file.jsGlobalAugmentations || (file.jsGlobalAugmentations = ts.createSymbolTable());
- return declareSymbol(table, parent, id, flags_1, excludeFlags_1);
+ (projectReferences || (projectReferences = [])).push({
+ path: ts.getNormalizedAbsolutePath(ref.path, basePath),
+ originalPath: ref.path,
+ prepend: ref.prepend,
+ circular: ref.circular
+ });
}
- });
- }
- if (containerIsClass && namespaceSymbol && namespaceSymbol.valueDeclaration) {
- addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32);
- }
- return namespaceSymbol;
- }
- function bindPotentiallyNewExpandoMemberToNamespace(declaration, namespaceSymbol, isPrototypeProperty) {
- if (!namespaceSymbol || !isExpandoSymbol(namespaceSymbol)) {
- return;
- }
- var symbolTable = isPrototypeProperty ?
- (namespaceSymbol.members || (namespaceSymbol.members = ts.createSymbolTable())) :
- (namespaceSymbol.exports || (namespaceSymbol.exports = ts.createSymbolTable()));
- var includes = 0;
- var excludes = 0;
- if (ts.isFunctionLikeDeclaration(ts.getAssignedExpandoInitializer(declaration))) {
- includes = 8192;
- excludes = 103359;
+ }
}
- else if (ts.isCallExpression(declaration) && ts.isBindableObjectDefinePropertyCall(declaration)) {
- if (ts.some(declaration.arguments[2].properties, function (p) {
- var id = ts.getNameOfDeclaration(p);
- return !!id && ts.isIdentifier(id) && ts.idText(id) === "set";
- })) {
- includes |= 65536 | 4;
- excludes |= 78783;
+ var filesSpecs = toPropValue(getSpecsFromRaw("files"));
+ if (filesSpecs) {
+ var hasZeroOrNoReferences = referencesOfRaw === "no-prop" || ts.isArray(referencesOfRaw) && referencesOfRaw.length === 0;
+ var hasExtends = ts.hasProperty(raw, "extends");
+ if (filesSpecs.length === 0 && hasZeroOrNoReferences && !hasExtends) {
+ if (sourceFile) {
+ var fileName = configFileName || "tsconfig.json";
+ var diagnosticMessage = ts.Diagnostics.The_files_list_in_config_file_0_is_empty;
+ var nodeValue = ts.firstDefined(ts.getTsConfigPropArray(sourceFile, "files"), function (property) { return property.initializer; });
+ var error = nodeValue
+ ? ts.createDiagnosticForNodeInSourceFile(sourceFile, nodeValue, diagnosticMessage, fileName)
+ : ts.createCompilerDiagnostic(diagnosticMessage, fileName);
+ errors.push(error);
+ }
+ else {
+ createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.The_files_list_in_config_file_0_is_empty, configFileName || "tsconfig.json");
+ }
}
- if (ts.some(declaration.arguments[2].properties, function (p) {
- var id = ts.getNameOfDeclaration(p);
- return !!id && ts.isIdentifier(id) && ts.idText(id) === "get";
- })) {
- includes |= 32768 | 4;
- excludes |= 46015;
+ }
+ var includeSpecs = toPropValue(getSpecsFromRaw("include"));
+ var excludeOfRaw = getSpecsFromRaw("exclude");
+ var excludeSpecs = toPropValue(excludeOfRaw);
+ if (excludeOfRaw === "no-prop" && raw.compilerOptions) {
+ var outDir = raw.compilerOptions.outDir;
+ var declarationDir = raw.compilerOptions.declarationDir;
+ if (outDir || declarationDir) {
+ excludeSpecs = [outDir, declarationDir].filter(function (d) { return !!d; });
}
}
- if (includes === 0) {
- includes = 4;
- excludes = 0;
+ if (filesSpecs === undefined && includeSpecs === undefined) {
+ includeSpecs = ["**/*"];
}
- declareSymbol(symbolTable, namespaceSymbol, declaration, includes | 67108864, excludes & ~67108864);
+ var result = matchFileNames(filesSpecs, includeSpecs, excludeSpecs, configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath, options, host, errors, extraFileExtensions, sourceFile);
+ if (shouldReportNoInputFiles(result, canJsonReportNoInputFiles(raw), resolutionStack)) {
+ errors.push(getErrorForNoInputFiles(result.spec, configFileName));
+ }
+ return result;
}
- function isTopLevelNamespaceAssignment(propertyAccess) {
- return ts.isBinaryExpression(propertyAccess.parent)
- ? getParentOfBinaryExpression(propertyAccess.parent).parent.kind === 290
- : propertyAccess.parent.parent.kind === 290;
+ function toPropValue(specResult) {
+ return ts.isArray(specResult) ? specResult : undefined;
}
- function bindPropertyAssignment(name, propertyAccess, isPrototypeProperty, containerIsClass) {
- var namespaceSymbol = lookupSymbolForPropertyAccess(name);
- var isToplevel = isTopLevelNamespaceAssignment(propertyAccess);
- namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, propertyAccess.expression, isToplevel, isPrototypeProperty, containerIsClass);
- bindPotentiallyNewExpandoMemberToNamespace(propertyAccess, namespaceSymbol, isPrototypeProperty);
+ function getSpecsFromRaw(prop) {
+ return getPropFromRaw(prop, ts.isString, "string");
}
- function isExpandoSymbol(symbol) {
- if (symbol.flags & (16 | 32 | 1024)) {
- return true;
- }
- var node = symbol.valueDeclaration;
- if (node && ts.isCallExpression(node)) {
- return !!ts.getAssignedExpandoInitializer(node);
- }
- var init = !node ? undefined :
- ts.isVariableDeclaration(node) ? node.initializer :
- ts.isBinaryExpression(node) ? node.right :
- ts.isPropertyAccessExpression(node) && ts.isBinaryExpression(node.parent) ? node.parent.right :
- undefined;
- init = init && ts.getRightMostAssignedExpression(init);
- if (init) {
- var isPrototypeAssignment = ts.isPrototypeAccess(ts.isVariableDeclaration(node) ? node.name : ts.isBinaryExpression(node) ? node.left : node);
- return !!ts.getExpandoInitializer(ts.isBinaryExpression(init) && (init.operatorToken.kind === 56 || init.operatorToken.kind === 60) ? init.right : init, isPrototypeAssignment);
+ function getPropFromRaw(prop, validateElement, elementTypeName) {
+ if (ts.hasProperty(raw, prop) && !isNullOrUndefined(raw[prop])) {
+ if (ts.isArray(raw[prop])) {
+ var result = raw[prop];
+ if (!sourceFile && !ts.every(result, validateElement)) {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, prop, elementTypeName));
+ }
+ return result;
+ }
+ else {
+ createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, prop, "Array");
+ return "not-array";
+ }
}
- return false;
+ return "no-prop";
}
- function getParentOfBinaryExpression(expr) {
- while (ts.isBinaryExpression(expr.parent)) {
- expr = expr.parent;
+ function createCompilerDiagnosticOnlyIfJson(message, arg0, arg1) {
+ if (!sourceFile) {
+ errors.push(ts.createCompilerDiagnostic(message, arg0, arg1));
}
- return expr.parent;
}
- function lookupSymbolForPropertyAccess(node, lookupContainer) {
- if (lookupContainer === void 0) { lookupContainer = container; }
- if (ts.isIdentifier(node)) {
- return lookupSymbolForNameWorker(lookupContainer, node.escapedText);
- }
- else {
- var symbol = lookupSymbolForPropertyAccess(node.expression);
- return symbol && symbol.exports && symbol.exports.get(ts.getElementOrPropertyAccessName(node));
- }
+ }
+ function isErrorNoInputFiles(error) {
+ return error.code === ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2.code;
+ }
+ function getErrorForNoInputFiles(_a, configFileName) {
+ var includeSpecs = _a.includeSpecs, excludeSpecs = _a.excludeSpecs;
+ return ts.createCompilerDiagnostic(ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2, configFileName || "tsconfig.json", JSON.stringify(includeSpecs || []), JSON.stringify(excludeSpecs || []));
+ }
+ function shouldReportNoInputFiles(result, canJsonReportNoInutFiles, resolutionStack) {
+ return result.fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0);
+ }
+ function canJsonReportNoInputFiles(raw) {
+ return !ts.hasProperty(raw, "files") && !ts.hasProperty(raw, "references");
+ }
+ ts.canJsonReportNoInputFiles = canJsonReportNoInputFiles;
+ function updateErrorForNoInputFiles(result, configFileName, configFileSpecs, configParseDiagnostics, canJsonReportNoInutFiles) {
+ var existingErrors = configParseDiagnostics.length;
+ if (shouldReportNoInputFiles(result, canJsonReportNoInutFiles)) {
+ configParseDiagnostics.push(getErrorForNoInputFiles(configFileSpecs, configFileName));
+ }
+ else {
+ ts.filterMutate(configParseDiagnostics, function (error) { return !isErrorNoInputFiles(error); });
+ }
+ return existingErrors !== configParseDiagnostics.length;
+ }
+ ts.updateErrorForNoInputFiles = updateErrorForNoInputFiles;
+ function isSuccessfulParsedTsconfig(value) {
+ return !!value.options;
+ }
+ function parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache) {
+ var _a;
+ basePath = ts.normalizeSlashes(basePath);
+ var resolvedPath = ts.getNormalizedAbsolutePath(configFileName || "", basePath);
+ if (resolutionStack.indexOf(resolvedPath) >= 0) {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, __spreadArrays(resolutionStack, [resolvedPath]).join(" -> ")));
+ return { raw: json || convertToObject(sourceFile, errors) };
+ }
+ var ownConfig = json ?
+ parseOwnConfigOfJson(json, host, basePath, configFileName, errors) :
+ parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors);
+ if ((_a = ownConfig.options) === null || _a === void 0 ? void 0 : _a.paths) {
+ ownConfig.options.pathsBasePath = basePath;
}
- function forEachIdentifierInEntityName(e, parent, action) {
- if (isExportsOrModuleExportsOrAlias(file, e)) {
- return file.symbol;
- }
- else if (ts.isIdentifier(e)) {
- return action(e, lookupSymbolForPropertyAccess(e), parent);
- }
- else {
- var s = forEachIdentifierInEntityName(e.expression, parent, action);
- var name = ts.getNameOrArgument(e);
- if (ts.isPrivateIdentifier(name)) {
- ts.Debug.fail("unexpected PrivateIdentifier");
+ if (ownConfig.extendedConfigPath) {
+ resolutionStack = resolutionStack.concat([resolvedPath]);
+ var extendedConfig = getExtendedConfig(sourceFile, ownConfig.extendedConfigPath, host, basePath, resolutionStack, errors, extendedConfigCache);
+ if (extendedConfig && isSuccessfulParsedTsconfig(extendedConfig)) {
+ var baseRaw_1 = extendedConfig.raw;
+ var raw_1 = ownConfig.raw;
+ var setPropertyInRawIfNotUndefined = function (propertyName) {
+ var value = raw_1[propertyName] || baseRaw_1[propertyName];
+ if (value) {
+ raw_1[propertyName] = value;
+ }
+ };
+ setPropertyInRawIfNotUndefined("include");
+ setPropertyInRawIfNotUndefined("exclude");
+ setPropertyInRawIfNotUndefined("files");
+ if (raw_1.compileOnSave === undefined) {
+ raw_1.compileOnSave = baseRaw_1.compileOnSave;
}
- return action(name, s && s.exports && s.exports.get(ts.getElementOrPropertyAccessName(e)), s);
+ ownConfig.options = ts.assign({}, extendedConfig.options, ownConfig.options);
+ ownConfig.watchOptions = ownConfig.watchOptions && extendedConfig.watchOptions ?
+ ts.assign({}, extendedConfig.watchOptions, ownConfig.watchOptions) :
+ ownConfig.watchOptions || extendedConfig.watchOptions;
}
}
- function bindCallExpression(node) {
- if (!file.commonJsModuleIndicator && ts.isRequireCall(node, false)) {
- setCommonJsModuleIndicator(node);
- }
+ return ownConfig;
+ }
+ function parseOwnConfigOfJson(json, host, basePath, configFileName, errors) {
+ if (ts.hasProperty(json, "excludes")) {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
}
- function bindClassLikeDeclaration(node) {
- if (node.kind === 245) {
- bindBlockScopedDeclaration(node, 32, 899503);
+ var options = convertCompilerOptionsFromJsonWorker(json.compilerOptions, basePath, errors, configFileName);
+ var typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition || json.typingOptions, basePath, errors, configFileName);
+ var watchOptions = convertWatchOptionsFromJsonWorker(json.watchOptions, basePath, errors);
+ json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);
+ var extendedConfigPath;
+ if (json.extends) {
+ if (!ts.isString(json.extends)) {
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string"));
}
else {
- var bindingName = node.name ? node.name.escapedText : "__class";
- bindAnonymousDeclaration(node, 32, bindingName);
- if (node.name) {
- classifiableNames.set(node.name.escapedText, true);
- }
- }
- var symbol = node.symbol;
- var prototypeSymbol = createSymbol(4 | 4194304, "prototype");
- var symbolExport = symbol.exports.get(prototypeSymbol.escapedName);
- if (symbolExport) {
- if (node.name) {
- node.name.parent = node;
- }
- file.bindDiagnostics.push(createDiagnosticForNode(symbolExport.declarations[0], ts.Diagnostics.Duplicate_identifier_0, ts.symbolName(prototypeSymbol)));
+ var newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
+ extendedConfigPath = getExtendsConfigPath(json.extends, host, newBase, errors, ts.createCompilerDiagnostic);
}
- symbol.exports.set(prototypeSymbol.escapedName, prototypeSymbol);
- prototypeSymbol.parent = symbol;
- }
- function bindEnumDeclaration(node) {
- return ts.isEnumConst(node)
- ? bindBlockScopedDeclaration(node, 128, 899967)
- : bindBlockScopedDeclaration(node, 256, 899327);
}
- function bindVariableDeclarationOrBindingElement(node) {
- if (inStrictMode) {
- checkStrictModeEvalOrArguments(node, node.name);
- }
- if (!ts.isBindingPattern(node.name)) {
- if (ts.isBlockOrCatchScoped(node)) {
- bindBlockScopedDeclaration(node, 2, 111551);
+ return { raw: json, options: options, watchOptions: watchOptions, typeAcquisition: typeAcquisition, extendedConfigPath: extendedConfigPath };
+ }
+ function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors) {
+ var options = getDefaultCompilerOptions(configFileName);
+ var typeAcquisition, typingOptionstypeAcquisition;
+ var watchOptions;
+ var extendedConfigPath;
+ var optionsIterator = {
+ onSetValidOptionKeyValueInParent: function (parentOption, option, value) {
+ var currentOption;
+ switch (parentOption) {
+ case "compilerOptions":
+ currentOption = options;
+ break;
+ case "watchOptions":
+ currentOption = (watchOptions || (watchOptions = {}));
+ break;
+ case "typeAcquisition":
+ currentOption = (typeAcquisition || (typeAcquisition = getDefaultTypeAcquisition(configFileName)));
+ break;
+ case "typingOptions":
+ currentOption = (typingOptionstypeAcquisition || (typingOptionstypeAcquisition = getDefaultTypeAcquisition(configFileName)));
+ break;
+ default:
+ ts.Debug.fail("Unknown option");
}
- else if (ts.isParameterDeclaration(node)) {
- declareSymbolAndAddToSymbolTable(node, 1, 111551);
+ currentOption[option.name] = normalizeOptionValue(option, basePath, value);
+ },
+ onSetValidOptionKeyValueInRoot: function (key, _keyNode, value, valueNode) {
+ switch (key) {
+ case "extends":
+ var newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
+ extendedConfigPath = getExtendsConfigPath(value, host, newBase, errors, function (message, arg0) {
+ return ts.createDiagnosticForNodeInSourceFile(sourceFile, valueNode, message, arg0);
+ });
+ return;
}
- else {
- declareSymbolAndAddToSymbolTable(node, 1, 111550);
+ },
+ onSetUnknownOptionKeyValueInRoot: function (key, keyNode, _value, _valueNode) {
+ if (key === "excludes") {
+ errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, keyNode, ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
}
}
- }
- function bindParameter(node) {
- if (node.kind === 317 && container.kind !== 305) {
- return;
- }
- if (inStrictMode && !(node.flags & 8388608)) {
- checkStrictModeEvalOrArguments(node, node.name);
- }
- if (ts.isBindingPattern(node.name)) {
- bindAnonymousDeclaration(node, 1, "__" + node.parent.parameters.indexOf(node));
+ };
+ var json = convertToObjectWorker(sourceFile, errors, true, getTsconfigRootOptionsMap(), optionsIterator);
+ if (!typeAcquisition) {
+ if (typingOptionstypeAcquisition) {
+ typeAcquisition = (typingOptionstypeAcquisition.enableAutoDiscovery !== undefined) ?
+ {
+ enable: typingOptionstypeAcquisition.enableAutoDiscovery,
+ include: typingOptionstypeAcquisition.include,
+ exclude: typingOptionstypeAcquisition.exclude
+ } :
+ typingOptionstypeAcquisition;
}
else {
- declareSymbolAndAddToSymbolTable(node, 1, 111551);
- }
- if (ts.isParameterPropertyDeclaration(node, node.parent)) {
- var classDeclaration = node.parent.parent;
- declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 | (node.questionToken ? 16777216 : 0), 0);
+ typeAcquisition = getDefaultTypeAcquisition(configFileName);
}
}
- function bindFunctionDeclaration(node) {
- if (!file.isDeclarationFile && !(node.flags & 8388608)) {
- if (ts.isAsyncFunction(node)) {
- emitFlags |= 2048;
+ return { raw: json, options: options, watchOptions: watchOptions, typeAcquisition: typeAcquisition, extendedConfigPath: extendedConfigPath };
+ }
+ function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiagnostic) {
+ extendedConfig = ts.normalizeSlashes(extendedConfig);
+ if (ts.isRootedDiskPath(extendedConfig) || ts.startsWith(extendedConfig, "./") || ts.startsWith(extendedConfig, "../")) {
+ var extendedConfigPath = ts.getNormalizedAbsolutePath(extendedConfig, basePath);
+ if (!host.fileExists(extendedConfigPath) && !ts.endsWith(extendedConfigPath, ".json")) {
+ extendedConfigPath = extendedConfigPath + ".json";
+ if (!host.fileExists(extendedConfigPath)) {
+ errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig));
+ return undefined;
}
}
- checkStrictModeFunctionName(node);
- if (inStrictMode) {
- checkStrictModeFunctionDeclaration(node);
- bindBlockScopedDeclaration(node, 16, 110991);
- }
- else {
- declareSymbolAndAddToSymbolTable(node, 16, 110991);
- }
+ return extendedConfigPath;
}
- function bindFunctionExpression(node) {
- if (!file.isDeclarationFile && !(node.flags & 8388608)) {
- if (ts.isAsyncFunction(node)) {
- emitFlags |= 2048;
+ var resolved = ts.nodeModuleNameResolver(extendedConfig, ts.combinePaths(basePath, "tsconfig.json"), { moduleResolution: ts.ModuleResolutionKind.NodeJs }, host, undefined, undefined, true);
+ if (resolved.resolvedModule) {
+ return resolved.resolvedModule.resolvedFileName;
+ }
+ errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig));
+ return undefined;
+ }
+ function getExtendedConfig(sourceFile, extendedConfigPath, host, basePath, resolutionStack, errors, extendedConfigCache) {
+ var _a;
+ var path = host.useCaseSensitiveFileNames ? extendedConfigPath : ts.toFileNameLowerCase(extendedConfigPath);
+ var value;
+ var extendedResult;
+ var extendedConfig;
+ if (extendedConfigCache && (value = extendedConfigCache.get(path))) {
+ (extendedResult = value.extendedResult, extendedConfig = value.extendedConfig);
+ }
+ else {
+ extendedResult = readJsonConfigFile(extendedConfigPath, function (path) { return host.readFile(path); });
+ if (!extendedResult.parseDiagnostics.length) {
+ var extendedDirname = ts.getDirectoryPath(extendedConfigPath);
+ extendedConfig = parseConfig(undefined, extendedResult, host, extendedDirname, ts.getBaseFileName(extendedConfigPath), resolutionStack, errors, extendedConfigCache);
+ if (isSuccessfulParsedTsconfig(extendedConfig)) {
+ var relativeDifference_1 = ts.convertToRelativePath(extendedDirname, basePath, ts.identity);
+ var updatePath_1 = function (path) { return ts.isRootedDiskPath(path) ? path : ts.combinePaths(relativeDifference_1, path); };
+ var mapPropertiesInRawIfNotUndefined = function (propertyName) {
+ if (raw_2[propertyName]) {
+ raw_2[propertyName] = ts.map(raw_2[propertyName], updatePath_1);
+ }
+ };
+ var raw_2 = extendedConfig.raw;
+ mapPropertiesInRawIfNotUndefined("include");
+ mapPropertiesInRawIfNotUndefined("exclude");
+ mapPropertiesInRawIfNotUndefined("files");
}
}
- if (currentFlow) {
- node.flowNode = currentFlow;
+ if (extendedConfigCache) {
+ extendedConfigCache.set(path, { extendedResult: extendedResult, extendedConfig: extendedConfig });
}
- checkStrictModeFunctionName(node);
- var bindingName = node.name ? node.name.escapedText : "__function";
- return bindAnonymousDeclaration(node, 16, bindingName);
}
- function bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) {
- if (!file.isDeclarationFile && !(node.flags & 8388608) && ts.isAsyncFunction(node)) {
- emitFlags |= 2048;
- }
- if (currentFlow && ts.isObjectLiteralOrClassExpressionMethod(node)) {
- node.flowNode = currentFlow;
+ if (sourceFile) {
+ sourceFile.extendedSourceFiles = [extendedResult.fileName];
+ if (extendedResult.extendedSourceFiles) {
+ (_a = sourceFile.extendedSourceFiles).push.apply(_a, extendedResult.extendedSourceFiles);
}
- return ts.hasDynamicName(node)
- ? bindAnonymousDeclaration(node, symbolFlags, "__computed")
- : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
}
- function getInferTypeContainer(node) {
- var extendsType = ts.findAncestor(node, function (n) { return n.parent && ts.isConditionalTypeNode(n.parent) && n.parent.extendsType === n; });
- return extendsType && extendsType.parent;
+ if (extendedResult.parseDiagnostics.length) {
+ errors.push.apply(errors, extendedResult.parseDiagnostics);
+ return undefined;
}
- function bindTypeParameter(node) {
- if (ts.isJSDocTemplateTag(node.parent)) {
- var container_1 = ts.find(node.parent.parent.tags, ts.isJSDocTypeAlias) || ts.getHostSignatureFromJSDoc(node.parent);
- if (container_1) {
- if (!container_1.locals) {
- container_1.locals = ts.createSymbolTable();
- }
- declareSymbol(container_1.locals, undefined, node, 262144, 526824);
- }
- else {
- declareSymbolAndAddToSymbolTable(node, 262144, 526824);
- }
- }
- else if (node.parent.kind === 181) {
- var container_2 = getInferTypeContainer(node.parent);
- if (container_2) {
- if (!container_2.locals) {
- container_2.locals = ts.createSymbolTable();
- }
- declareSymbol(container_2.locals, undefined, node, 262144, 526824);
- }
- else {
- bindAnonymousDeclaration(node, 262144, getDeclarationName(node));
- }
- }
- else {
- declareSymbolAndAddToSymbolTable(node, 262144, 526824);
- }
+ return extendedConfig;
+ }
+ function convertCompileOnSaveOptionFromJson(jsonOption, basePath, errors) {
+ if (!ts.hasProperty(jsonOption, ts.compileOnSaveCommandLineOption.name)) {
+ return false;
}
- function shouldReportErrorOnModuleDeclaration(node) {
- var instanceState = getModuleInstanceState(node);
- return instanceState === 1 || (instanceState === 2 && !!options.preserveConstEnums);
+ var result = convertJsonOption(ts.compileOnSaveCommandLineOption, jsonOption.compileOnSave, basePath, errors);
+ return typeof result === "boolean" && result;
+ }
+ function convertCompilerOptionsFromJson(jsonOptions, basePath, configFileName) {
+ var errors = [];
+ var options = convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);
+ return { options: options, errors: errors };
+ }
+ ts.convertCompilerOptionsFromJson = convertCompilerOptionsFromJson;
+ function convertTypeAcquisitionFromJson(jsonOptions, basePath, configFileName) {
+ var errors = [];
+ var options = convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName);
+ return { options: options, errors: errors };
+ }
+ ts.convertTypeAcquisitionFromJson = convertTypeAcquisitionFromJson;
+ function getDefaultCompilerOptions(configFileName) {
+ var options = configFileName && ts.getBaseFileName(configFileName) === "jsconfig.json"
+ ? { allowJs: true, maxNodeModuleJsDepth: 2, allowSyntheticDefaultImports: true, skipLibCheck: true, noEmit: true }
+ : {};
+ return options;
+ }
+ function convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
+ var options = getDefaultCompilerOptions(configFileName);
+ convertOptionsFromJson(getCommandLineCompilerOptionsMap(), jsonOptions, basePath, options, ts.compilerOptionsDidYouMeanDiagnostics, errors);
+ if (configFileName) {
+ options.configFilePath = ts.normalizeSlashes(configFileName);
}
- function checkUnreachable(node) {
- if (!(currentFlow.flags & 1)) {
- return false;
+ return options;
+ }
+ function getDefaultTypeAcquisition(configFileName) {
+ return { enable: !!configFileName && ts.getBaseFileName(configFileName) === "jsconfig.json", include: [], exclude: [] };
+ }
+ function convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
+ var options = getDefaultTypeAcquisition(configFileName);
+ var typeAcquisition = convertEnableAutoDiscoveryToEnable(jsonOptions);
+ convertOptionsFromJson(getCommandLineTypeAcquisitionMap(), typeAcquisition, basePath, options, typeAcquisitionDidYouMeanDiagnostics, errors);
+ return options;
+ }
+ function convertWatchOptionsFromJsonWorker(jsonOptions, basePath, errors) {
+ return convertOptionsFromJson(getCommandLineWatchOptionsMap(), jsonOptions, basePath, undefined, watchOptionsDidYouMeanDiagnostics, errors);
+ }
+ function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOptions, diagnostics, errors) {
+ if (!jsonOptions) {
+ return;
+ }
+ for (var id in jsonOptions) {
+ var opt = optionsNameMap.get(id);
+ if (opt) {
+ (defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
}
- if (currentFlow === unreachableFlow) {
- var reportError = (ts.isStatementButNotDeclaration(node) && node.kind !== 224) ||
- node.kind === 245 ||
- (node.kind === 249 && shouldReportErrorOnModuleDeclaration(node));
- if (reportError) {
- currentFlow = reportedUnreachableFlow;
- if (!options.allowUnreachableCode) {
- var isError_1 = ts.unreachableCodeIsError(options) &&
- !(node.flags & 8388608) &&
- (!ts.isVariableStatement(node) ||
- !!(ts.getCombinedNodeFlags(node.declarationList) & 3) ||
- node.declarationList.declarations.some(function (d) { return !!d.initializer; }));
- eachUnreachableRange(node, function (start, end) { return errorOrSuggestionOnRange(isError_1, start, end, ts.Diagnostics.Unreachable_code_detected); });
- }
- }
+ else {
+ errors.push(createUnknownOptionError(id, diagnostics, ts.createCompilerDiagnostic));
}
- return true;
}
+ return defaultOptions;
}
- function eachUnreachableRange(node, cb) {
- if (ts.isStatement(node) && isExecutableStatement(node) && ts.isBlock(node.parent)) {
- var statements = node.parent.statements;
- var slice_1 = ts.sliceAfter(statements, node);
- ts.getRangesWhere(slice_1, isExecutableStatement, function (start, afterEnd) { return cb(slice_1[start], slice_1[afterEnd - 1]); });
+ function convertJsonOption(opt, value, basePath, errors) {
+ if (isCompilerOptionsValue(opt, value)) {
+ var optType = opt.type;
+ if (optType === "list" && ts.isArray(value)) {
+ return convertJsonOptionOfListType(opt, value, basePath, errors);
+ }
+ else if (!ts.isString(optType)) {
+ return convertJsonOptionOfCustomType(opt, value, errors);
+ }
+ return normalizeNonListOptionValue(opt, basePath, value);
}
else {
- cb(node, node);
+ errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
}
}
- function isExecutableStatement(s) {
- return !ts.isFunctionDeclaration(s) && !isPurelyTypeDeclaration(s) && !ts.isEnumDeclaration(s) &&
- !(ts.isVariableStatement(s) && !(ts.getCombinedNodeFlags(s) & (1 | 2)) && s.declarationList.declarations.some(function (d) { return !d.initializer; }));
- }
- function isPurelyTypeDeclaration(s) {
- switch (s.kind) {
- case 246:
- case 247:
- return true;
- case 249:
- return getModuleInstanceState(s) !== 1;
- case 248:
- return ts.hasModifier(s, 2048);
- default:
- return false;
+ function normalizeOptionValue(option, basePath, value) {
+ if (isNullOrUndefined(value))
+ return undefined;
+ if (option.type === "list") {
+ var listOption_1 = option;
+ if (listOption_1.element.isFilePath || !ts.isString(listOption_1.element.type)) {
+ return ts.filter(ts.map(value, function (v) { return normalizeOptionValue(listOption_1.element, basePath, v); }), function (v) { return !!v; });
+ }
+ return value;
+ }
+ else if (!ts.isString(option.type)) {
+ return option.type.get(ts.isString(value) ? value.toLowerCase() : value);
}
+ return normalizeNonListOptionValue(option, basePath, value);
}
- function isExportsOrModuleExportsOrAlias(sourceFile, node) {
- var i = 0;
- var q = [node];
- while (q.length && i < 100) {
- i++;
- node = q.shift();
- if (ts.isExportsIdentifier(node) || ts.isModuleExportsAccessExpression(node)) {
- return true;
- }
- else if (ts.isIdentifier(node)) {
- var symbol = lookupSymbolForNameWorker(sourceFile, node.escapedText);
- if (!!symbol && !!symbol.valueDeclaration && ts.isVariableDeclaration(symbol.valueDeclaration) && !!symbol.valueDeclaration.initializer) {
- var init = symbol.valueDeclaration.initializer;
- q.push(init);
- if (ts.isAssignmentExpression(init, true)) {
- q.push(init.left);
- q.push(init.right);
- }
- }
+ function normalizeNonListOptionValue(option, basePath, value) {
+ if (option.isFilePath) {
+ value = ts.getNormalizedAbsolutePath(value, basePath);
+ if (value === "") {
+ value = ".";
}
}
- return false;
+ return value;
}
- ts.isExportsOrModuleExportsOrAlias = isExportsOrModuleExportsOrAlias;
- function lookupSymbolForNameWorker(container, name) {
- var local = container.locals && container.locals.get(name);
- if (local) {
- return local.exportSymbol || local;
+ function convertJsonOptionOfCustomType(opt, value, errors) {
+ if (isNullOrUndefined(value))
+ return undefined;
+ var key = value.toLowerCase();
+ var val = opt.type.get(key);
+ if (val !== undefined) {
+ return val;
}
- if (ts.isSourceFile(container) && container.jsGlobalAugmentations && container.jsGlobalAugmentations.has(name)) {
- return container.jsGlobalAugmentations.get(name);
+ else {
+ errors.push(createCompilerDiagnosticForInvalidCustomType(opt));
}
- return container.symbol && container.symbol.exports && container.symbol.exports.get(name);
}
- function computeTransformFlagsForNode(node, subtreeFlags) {
- var kind = node.kind;
- switch (kind) {
- case 196:
- return computeCallExpression(node, subtreeFlags);
- case 197:
- return computeNewExpression(node, subtreeFlags);
- case 249:
- return computeModuleDeclaration(node, subtreeFlags);
- case 200:
- return computeParenthesizedExpression(node, subtreeFlags);
- case 209:
- return computeBinaryExpression(node, subtreeFlags);
- case 226:
- return computeExpressionStatement(node, subtreeFlags);
- case 156:
- return computeParameter(node, subtreeFlags);
- case 202:
- return computeArrowFunction(node, subtreeFlags);
- case 201:
- return computeFunctionExpression(node, subtreeFlags);
- case 244:
- return computeFunctionDeclaration(node, subtreeFlags);
- case 242:
- return computeVariableDeclaration(node, subtreeFlags);
- case 243:
- return computeVariableDeclarationList(node, subtreeFlags);
- case 225:
- return computeVariableStatement(node, subtreeFlags);
- case 238:
- return computeLabeledStatement(node, subtreeFlags);
- case 245:
- return computeClassDeclaration(node, subtreeFlags);
- case 214:
- return computeClassExpression(node, subtreeFlags);
- case 279:
- return computeHeritageClause(node, subtreeFlags);
- case 280:
- return computeCatchClause(node, subtreeFlags);
- case 216:
- return computeExpressionWithTypeArguments(node, subtreeFlags);
- case 162:
- return computeConstructor(node, subtreeFlags);
- case 159:
- return computePropertyDeclaration(node, subtreeFlags);
- case 161:
- return computeMethod(node, subtreeFlags);
- case 163:
- case 164:
- return computeAccessor(node, subtreeFlags);
- case 253:
- return computeImportEquals(node, subtreeFlags);
- case 194:
- return computePropertyAccess(node, subtreeFlags);
- case 195:
- return computeElementAccess(node, subtreeFlags);
- case 267:
- case 268:
- return computeJsxOpeningLikeElement(node, subtreeFlags);
- default:
- return computeOther(node, kind, subtreeFlags);
- }
+ function convertJsonOptionOfListType(option, values, basePath, errors) {
+ return ts.filter(ts.map(values, function (v) { return convertJsonOption(option.element, v, basePath, errors); }), function (v) { return !!v; });
}
- ts.computeTransformFlagsForNode = computeTransformFlagsForNode;
- function computeCallExpression(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- var callee = ts.skipOuterExpressions(node.expression);
- var expression = node.expression;
- if (node.flags & 32) {
- transformFlags |= 8;
+ function trimString(s) {
+ return typeof s.trim === "function" ? s.trim() : s.replace(/^[\s]+|[\s]+$/g, "");
+ }
+ var invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/;
+ var invalidDotDotAfterRecursiveWildcardPattern = /(^|\/)\*\*\/(.*\/)?\.\.($|\/)/;
+ var watchRecursivePattern = /\/[^/]*?[*?][^/]*\//;
+ var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/;
+ function matchFileNames(filesSpecs, includeSpecs, excludeSpecs, basePath, options, host, errors, extraFileExtensions, jsonSourceFile) {
+ basePath = ts.normalizePath(basePath);
+ var validatedIncludeSpecs, validatedExcludeSpecs;
+ if (includeSpecs) {
+ validatedIncludeSpecs = validateSpecs(includeSpecs, errors, false, jsonSourceFile, "include");
}
- if (node.typeArguments) {
- transformFlags |= 1;
+ if (excludeSpecs) {
+ validatedExcludeSpecs = validateSpecs(excludeSpecs, errors, true, jsonSourceFile, "exclude");
}
- if (subtreeFlags & 8192 || ts.isSuperOrSuperProperty(callee)) {
- transformFlags |= 256;
- if (ts.isSuperProperty(callee)) {
- transformFlags |= 4096;
+ var wildcardDirectories = getWildcardDirectories(validatedIncludeSpecs, validatedExcludeSpecs, basePath, host.useCaseSensitiveFileNames);
+ var spec = {
+ filesSpecs: filesSpecs,
+ includeSpecs: includeSpecs,
+ excludeSpecs: excludeSpecs,
+ validatedFilesSpec: ts.filter(filesSpecs, ts.isString),
+ validatedIncludeSpecs: validatedIncludeSpecs,
+ validatedExcludeSpecs: validatedExcludeSpecs,
+ wildcardDirectories: wildcardDirectories
+ };
+ return getFileNamesFromConfigSpecs(spec, basePath, options, host, extraFileExtensions);
+ }
+ function getFileNamesFromConfigSpecs(spec, basePath, options, host, extraFileExtensions) {
+ if (extraFileExtensions === void 0) { extraFileExtensions = ts.emptyArray; }
+ basePath = ts.normalizePath(basePath);
+ var keyMapper = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames);
+ var literalFileMap = new ts.Map();
+ var wildcardFileMap = new ts.Map();
+ var wildCardJsonFileMap = new ts.Map();
+ var validatedFilesSpec = spec.validatedFilesSpec, validatedIncludeSpecs = spec.validatedIncludeSpecs, validatedExcludeSpecs = spec.validatedExcludeSpecs, wildcardDirectories = spec.wildcardDirectories;
+ var supportedExtensions = ts.getSupportedExtensions(options, extraFileExtensions);
+ var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
+ if (validatedFilesSpec) {
+ for (var _i = 0, validatedFilesSpec_1 = validatedFilesSpec; _i < validatedFilesSpec_1.length; _i++) {
+ var fileName = validatedFilesSpec_1[_i];
+ var file = ts.getNormalizedAbsolutePath(fileName, basePath);
+ literalFileMap.set(keyMapper(file), file);
+ }
+ }
+ var jsonOnlyIncludeRegexes;
+ if (validatedIncludeSpecs && validatedIncludeSpecs.length > 0) {
+ var _loop_6 = function (file) {
+ if (ts.fileExtensionIs(file, ".json")) {
+ if (!jsonOnlyIncludeRegexes) {
+ var includes = validatedIncludeSpecs.filter(function (s) { return ts.endsWith(s, ".json"); });
+ var includeFilePatterns = ts.map(ts.getRegularExpressionsForWildcards(includes, basePath, "files"), function (pattern) { return "^" + pattern + "$"; });
+ jsonOnlyIncludeRegexes = includeFilePatterns ? includeFilePatterns.map(function (pattern) { return ts.getRegexFromPattern(pattern, host.useCaseSensitiveFileNames); }) : ts.emptyArray;
+ }
+ var includeIndex = ts.findIndex(jsonOnlyIncludeRegexes, function (re) { return re.test(file); });
+ if (includeIndex !== -1) {
+ var key_1 = keyMapper(file);
+ if (!literalFileMap.has(key_1) && !wildCardJsonFileMap.has(key_1)) {
+ wildCardJsonFileMap.set(key_1, file);
+ }
+ }
+ return "continue";
+ }
+ if (hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMapper)) {
+ return "continue";
+ }
+ removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);
+ var key = keyMapper(file);
+ if (!literalFileMap.has(key) && !wildcardFileMap.has(key)) {
+ wildcardFileMap.set(key, file);
+ }
+ };
+ for (var _a = 0, _b = host.readDirectory(basePath, supportedExtensionsWithJsonIfResolveJsonModule, validatedExcludeSpecs, validatedIncludeSpecs, undefined); _a < _b.length; _a++) {
+ var file = _b[_a];
+ _loop_6(file);
}
}
- if (expression.kind === 96) {
- transformFlags |= 2097152;
- }
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536879104;
- }
- function computeNewExpression(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- if (node.typeArguments) {
- transformFlags |= 1;
- }
- if (subtreeFlags & 8192) {
- transformFlags |= 256;
- }
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536879104;
+ var literalFiles = ts.arrayFrom(literalFileMap.values());
+ var wildcardFiles = ts.arrayFrom(wildcardFileMap.values());
+ return {
+ fileNames: literalFiles.concat(wildcardFiles, ts.arrayFrom(wildCardJsonFileMap.values())),
+ wildcardDirectories: wildcardDirectories,
+ spec: spec
+ };
}
- function computeJsxOpeningLikeElement(node, subtreeFlags) {
- var transformFlags = subtreeFlags | 2;
- if (node.typeArguments) {
- transformFlags |= 1;
+ ts.getFileNamesFromConfigSpecs = getFileNamesFromConfigSpecs;
+ function isExcludedFile(pathToCheck, spec, basePath, useCaseSensitiveFileNames, currentDirectory) {
+ var validatedFilesSpec = spec.validatedFilesSpec, validatedIncludeSpecs = spec.validatedIncludeSpecs, validatedExcludeSpecs = spec.validatedExcludeSpecs;
+ if (!ts.length(validatedIncludeSpecs) || !ts.length(validatedExcludeSpecs))
+ return false;
+ basePath = ts.normalizePath(basePath);
+ var keyMapper = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
+ if (validatedFilesSpec) {
+ for (var _i = 0, validatedFilesSpec_2 = validatedFilesSpec; _i < validatedFilesSpec_2.length; _i++) {
+ var fileName = validatedFilesSpec_2[_i];
+ if (keyMapper(ts.getNormalizedAbsolutePath(fileName, basePath)) === pathToCheck)
+ return false;
+ }
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
+ var excludePattern = ts.getRegularExpressionForWildcard(validatedExcludeSpecs, ts.combinePaths(ts.normalizePath(currentDirectory), basePath), "exclude");
+ var excludeRegex = excludePattern && ts.getRegexFromPattern(excludePattern, useCaseSensitiveFileNames);
+ if (!excludeRegex)
+ return false;
+ if (excludeRegex.test(pathToCheck))
+ return true;
+ return !ts.hasExtension(pathToCheck) && excludeRegex.test(ts.ensureTrailingDirectorySeparator(pathToCheck));
}
- function computeBinaryExpression(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- var operatorTokenKind = node.operatorToken.kind;
- var leftKind = node.left.kind;
- if (operatorTokenKind === 60) {
- transformFlags |= 8;
- }
- else if (operatorTokenKind === 62 && leftKind === 193) {
- transformFlags |= 32 | 256 | 1024;
- }
- else if (operatorTokenKind === 62 && leftKind === 192) {
- transformFlags |= 256 | 1024;
- }
- else if (operatorTokenKind === 42
- || operatorTokenKind === 66) {
- transformFlags |= 128;
+ ts.isExcludedFile = isExcludedFile;
+ function validateSpecs(specs, errors, allowTrailingRecursion, jsonSourceFile, specKey) {
+ return specs.filter(function (spec) {
+ if (!ts.isString(spec))
+ return false;
+ var diag = specToDiagnostic(spec, allowTrailingRecursion);
+ if (diag !== undefined) {
+ errors.push(createDiagnostic(diag, spec));
+ }
+ return diag === undefined;
+ });
+ function createDiagnostic(message, spec) {
+ var element = ts.getTsConfigPropArrayElementValue(jsonSourceFile, specKey, spec);
+ return element ?
+ ts.createDiagnosticForNodeInSourceFile(jsonSourceFile, element, message, spec) :
+ ts.createCompilerDiagnostic(message, spec);
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
}
- function computeParameter(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- var name = node.name;
- var initializer = node.initializer;
- var dotDotDotToken = node.dotDotDotToken;
- if (node.questionToken
- || node.type
- || (subtreeFlags & 2048 && ts.some(node.decorators))
- || ts.isThisIdentifier(name)) {
- transformFlags |= 1;
- }
- if (ts.hasModifier(node, 92)) {
- transformFlags |= 1 | 2048;
- }
- if (subtreeFlags & 16384) {
- transformFlags |= 32;
- }
- if (subtreeFlags & 131072 || initializer || dotDotDotToken) {
- transformFlags |= 256;
+ function specToDiagnostic(spec, allowTrailingRecursion) {
+ if (!allowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) {
+ return ts.Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0;
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
- }
- function computeParenthesizedExpression(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- var expression = node.expression;
- var expressionKind = expression.kind;
- if (expressionKind === 217
- || expressionKind === 199) {
- transformFlags |= 1;
+ else if (invalidDotDotAfterRecursiveWildcardPattern.test(spec)) {
+ return ts.Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0;
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
}
- function computeClassDeclaration(node, subtreeFlags) {
- var transformFlags;
- if (ts.hasModifier(node, 2)) {
- transformFlags = 1;
- }
- else {
- transformFlags = subtreeFlags | 256;
- if ((subtreeFlags & 2048)
- || node.typeParameters) {
- transformFlags |= 1;
+ function getWildcardDirectories(include, exclude, path, useCaseSensitiveFileNames) {
+ var rawExcludeRegex = ts.getRegularExpressionForWildcard(exclude, path, "exclude");
+ var excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
+ var wildcardDirectories = {};
+ if (include !== undefined) {
+ var recursiveKeys = [];
+ for (var _i = 0, include_1 = include; _i < include_1.length; _i++) {
+ var file = include_1[_i];
+ var spec = ts.normalizePath(ts.combinePaths(path, file));
+ if (excludeRegex && excludeRegex.test(spec)) {
+ continue;
+ }
+ var match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames);
+ if (match) {
+ var key = match.key, flags = match.flags;
+ var existingFlags = wildcardDirectories[key];
+ if (existingFlags === undefined || existingFlags < flags) {
+ wildcardDirectories[key] = flags;
+ if (flags === 1) {
+ recursiveKeys.push(key);
+ }
+ }
+ }
+ }
+ for (var key in wildcardDirectories) {
+ if (ts.hasProperty(wildcardDirectories, key)) {
+ for (var _a = 0, recursiveKeys_1 = recursiveKeys; _a < recursiveKeys_1.length; _a++) {
+ var recursiveKey = recursiveKeys_1[_a];
+ if (key !== recursiveKey && ts.containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
+ delete wildcardDirectories[key];
+ }
+ }
+ }
}
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536905728;
+ return wildcardDirectories;
}
- function computeClassExpression(node, subtreeFlags) {
- var transformFlags = subtreeFlags | 256;
- if (subtreeFlags & 2048
- || node.typeParameters) {
- transformFlags |= 1;
+ function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames) {
+ var match = wildcardDirectoryPattern.exec(spec);
+ if (match) {
+ return {
+ key: useCaseSensitiveFileNames ? match[0] : ts.toFileNameLowerCase(match[0]),
+ flags: watchRecursivePattern.test(spec) ? 1 : 0
+ };
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536905728;
- }
- function computeHeritageClause(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- switch (node.token) {
- case 90:
- transformFlags |= 256;
- break;
- case 113:
- transformFlags |= 1;
- break;
- default:
- ts.Debug.fail("Unexpected token for heritage clause");
- break;
+ if (ts.isImplicitGlob(spec)) {
+ return {
+ key: useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec),
+ flags: 1
+ };
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
+ return undefined;
}
- function computeCatchClause(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- if (!node.variableDeclaration) {
- transformFlags |= 16;
- }
- else if (ts.isBindingPattern(node.variableDeclaration.name)) {
- transformFlags |= 256;
+ function hasFileWithHigherPriorityExtension(file, literalFiles, wildcardFiles, extensions, keyMapper) {
+ var extensionPriority = ts.getExtensionPriority(file, extensions);
+ var adjustedExtensionPriority = ts.adjustExtensionPriority(extensionPriority, extensions);
+ for (var i = 0; i < adjustedExtensionPriority; i++) {
+ var higherPriorityExtension = extensions[i];
+ var higherPriorityPath = keyMapper(ts.changeExtension(file, higherPriorityExtension));
+ if (literalFiles.has(higherPriorityPath) || wildcardFiles.has(higherPriorityPath)) {
+ return true;
+ }
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536887296;
+ return false;
}
- function computeExpressionWithTypeArguments(node, subtreeFlags) {
- var transformFlags = subtreeFlags | 256;
- if (node.typeArguments) {
- transformFlags |= 1;
+ function removeWildcardFilesWithLowerPriorityExtension(file, wildcardFiles, extensions, keyMapper) {
+ var extensionPriority = ts.getExtensionPriority(file, extensions);
+ var nextExtensionPriority = ts.getNextLowestExtensionPriority(extensionPriority, extensions);
+ for (var i = nextExtensionPriority; i < extensions.length; i++) {
+ var lowerPriorityExtension = extensions[i];
+ var lowerPriorityPath = keyMapper(ts.changeExtension(file, lowerPriorityExtension));
+ wildcardFiles.delete(lowerPriorityPath);
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
}
- function computeConstructor(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- if (ts.hasModifier(node, 2270)
- || !node.body) {
- transformFlags |= 1;
- }
- if (subtreeFlags & 16384) {
- transformFlags |= 32;
+ function convertCompilerOptionsForTelemetry(opts) {
+ var out = {};
+ for (var key in opts) {
+ if (opts.hasOwnProperty(key)) {
+ var type = getOptionFromName(key);
+ if (type !== undefined) {
+ out[key] = getOptionValueWithEmptyStrings(opts[key], type);
+ }
+ }
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~538923008;
+ return out;
}
- function computeMethod(node, subtreeFlags) {
- var transformFlags = subtreeFlags | 256;
- if (node.decorators
- || ts.hasModifier(node, 2270)
- || node.typeParameters
- || node.type
- || !node.body
- || node.questionToken) {
- transformFlags |= 1;
- }
- if (subtreeFlags & 16384) {
- transformFlags |= 32;
- }
- if (ts.hasModifier(node, 256)) {
- transformFlags |= node.asteriskToken ? 32 : 64;
- }
- if (node.asteriskToken) {
- transformFlags |= 512;
+ ts.convertCompilerOptionsForTelemetry = convertCompilerOptionsForTelemetry;
+ function getOptionValueWithEmptyStrings(value, option) {
+ switch (option.type) {
+ case "object":
+ return "";
+ case "string":
+ return "";
+ case "number":
+ return typeof value === "number" ? value : "";
+ case "boolean":
+ return typeof value === "boolean" ? value : "";
+ case "list":
+ var elementType_1 = option.element;
+ return ts.isArray(value) ? value.map(function (v) { return getOptionValueWithEmptyStrings(v, elementType_1); }) : "";
+ default:
+ return ts.forEachEntry(option.type, function (optionEnumValue, optionStringValue) {
+ if (optionEnumValue === value) {
+ return optionStringValue;
+ }
+ });
}
- node.transformFlags = transformFlags | 536870912;
- return propagatePropertyNameFlags(node.name, transformFlags & ~538923008);
}
- function computeAccessor(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- if (node.decorators
- || ts.hasModifier(node, 2270)
- || node.type
- || !node.body) {
- transformFlags |= 1;
- }
- if (subtreeFlags & 16384) {
- transformFlags |= 32;
- }
- node.transformFlags = transformFlags | 536870912;
- return propagatePropertyNameFlags(node.name, transformFlags & ~538923008);
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function trace(host) {
+ host.trace(ts.formatMessage.apply(undefined, arguments));
}
- function computePropertyDeclaration(node, subtreeFlags) {
- var transformFlags = subtreeFlags | 4194304;
- if (ts.some(node.decorators) || ts.hasModifier(node, 2270) || node.type || node.questionToken || node.exclamationToken) {
- transformFlags |= 1;
- }
- if (ts.isComputedPropertyName(node.name) || (ts.hasStaticModifier(node) && node.initializer)) {
- transformFlags |= 2048;
- }
- node.transformFlags = transformFlags | 536870912;
- return propagatePropertyNameFlags(node.name, transformFlags & ~536875008);
+ ts.trace = trace;
+ function isTraceEnabled(compilerOptions, host) {
+ return !!compilerOptions.traceResolution && host.trace !== undefined;
}
- function computeFunctionDeclaration(node, subtreeFlags) {
- var transformFlags;
- var modifierFlags = ts.getModifierFlags(node);
- var body = node.body;
- if (!body || (modifierFlags & 2)) {
- transformFlags = 1;
- }
- else {
- transformFlags = subtreeFlags | 1048576;
- if (modifierFlags & 2270
- || node.typeParameters
- || node.type) {
- transformFlags |= 1;
- }
- if (modifierFlags & 256) {
- transformFlags |= node.asteriskToken ? 32 : 64;
- }
- if (subtreeFlags & 16384) {
- transformFlags |= 32;
- }
- if (node.asteriskToken) {
- transformFlags |= 512;
+ ts.isTraceEnabled = isTraceEnabled;
+ function withPackageId(packageInfo, r) {
+ var packageId;
+ if (r && packageInfo) {
+ var packageJsonContent = packageInfo.packageJsonContent;
+ if (typeof packageJsonContent.name === "string" && typeof packageJsonContent.version === "string") {
+ packageId = {
+ name: packageJsonContent.name,
+ subModuleName: r.path.slice(packageInfo.packageDirectory.length + ts.directorySeparator.length),
+ version: packageJsonContent.version
+ };
}
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~538925056;
- }
- function computeFunctionExpression(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- if (ts.hasModifier(node, 2270)
- || node.typeParameters
- || node.type) {
- transformFlags |= 1;
- }
- if (ts.hasModifier(node, 256)) {
- transformFlags |= node.asteriskToken ? 32 : 64;
- }
- if (subtreeFlags & 16384) {
- transformFlags |= 32;
- }
- if (node.asteriskToken) {
- transformFlags |= 512;
- }
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~538925056;
+ return r && { path: r.path, extension: r.ext, packageId: packageId };
}
- function computeArrowFunction(node, subtreeFlags) {
- var transformFlags = subtreeFlags | 256;
- if (ts.hasModifier(node, 2270)
- || node.typeParameters
- || node.type) {
- transformFlags |= 1;
- }
- if (ts.hasModifier(node, 256)) {
- transformFlags |= 64;
- }
- if (subtreeFlags & 16384) {
- transformFlags |= 32;
- }
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~538920960;
+ function noPackageId(r) {
+ return withPackageId(undefined, r);
}
- function computePropertyAccess(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- if (node.flags & 32) {
- transformFlags |= 8;
- }
- if (node.expression.kind === 102) {
- transformFlags |= 64 | 32;
+ function removeIgnoredPackageId(r) {
+ if (r) {
+ ts.Debug.assert(r.packageId === undefined);
+ return { path: r.path, ext: r.extension };
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
}
- function computeElementAccess(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- if (node.flags & 32) {
- transformFlags |= 8;
- }
- if (node.expression.kind === 102) {
- transformFlags |= 64 | 32;
+ var Extensions;
+ (function (Extensions) {
+ Extensions[Extensions["TypeScript"] = 0] = "TypeScript";
+ Extensions[Extensions["JavaScript"] = 1] = "JavaScript";
+ Extensions[Extensions["Json"] = 2] = "Json";
+ Extensions[Extensions["TSConfig"] = 3] = "TSConfig";
+ Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly";
+ })(Extensions || (Extensions = {}));
+ function resolvedTypeScriptOnly(resolved) {
+ if (!resolved) {
+ return undefined;
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
+ ts.Debug.assert(ts.extensionIsTS(resolved.extension));
+ return { fileName: resolved.path, packageId: resolved.packageId };
}
- function computeVariableDeclaration(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- transformFlags |= 256 | 131072;
- if (subtreeFlags & 16384) {
- transformFlags |= 32;
- }
- if (node.type || node.exclamationToken) {
- transformFlags |= 1;
+ function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, resultFromCache) {
+ var _a;
+ if (resultFromCache) {
+ (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations);
+ return resultFromCache;
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
+ return {
+ resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId },
+ failedLookupLocations: failedLookupLocations
+ };
}
- function computeVariableStatement(node, subtreeFlags) {
- var transformFlags;
- var declarationListTransformFlags = node.declarationList.transformFlags;
- if (ts.hasModifier(node, 2)) {
- transformFlags = 1;
+ function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
+ if (!ts.hasProperty(jsonContent, fieldName)) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.package_json_does_not_have_a_0_field, fieldName);
+ }
+ return;
}
- else {
- transformFlags = subtreeFlags;
- if (declarationListTransformFlags & 131072) {
- transformFlags |= 256;
+ var value = jsonContent[fieldName];
+ if (typeof value !== typeOfTag || value === null) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, fieldName, typeOfTag, value === null ? "null" : typeof value);
}
+ return;
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
+ return value;
}
- function computeLabeledStatement(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- if (subtreeFlags & 65536
- && ts.isIterationStatement(node, true)) {
- transformFlags |= 256;
+ function readPackageJsonPathField(jsonContent, fieldName, baseDirectory, state) {
+ var fileName = readPackageJsonField(jsonContent, fieldName, "string", state);
+ if (fileName === undefined) {
+ return;
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
- }
- function computeImportEquals(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- if (!ts.isExternalModuleImportEqualsDeclaration(node)) {
- transformFlags |= 1;
+ if (!fileName) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.package_json_had_a_falsy_0_field, fieldName);
+ }
+ return;
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
- }
- function computeExpressionStatement(node, subtreeFlags) {
- var transformFlags = subtreeFlags;
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~536870912;
- }
- function computeModuleDeclaration(node, subtreeFlags) {
- var transformFlags = 1;
- var modifierFlags = ts.getModifierFlags(node);
- if ((modifierFlags & 2) === 0) {
- transformFlags |= subtreeFlags;
+ var path = ts.normalizePath(ts.combinePaths(baseDirectory, fileName));
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path);
}
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~537991168;
+ return path;
}
- function computeVariableDeclarationList(node, subtreeFlags) {
- var transformFlags = subtreeFlags | 1048576;
- if (subtreeFlags & 131072) {
- transformFlags |= 256;
- }
- if (node.flags & 3) {
- transformFlags |= 256 | 65536;
- }
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~537018368;
+ function readPackageJsonTypesFields(jsonContent, baseDirectory, state) {
+ return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state)
+ || readPackageJsonPathField(jsonContent, "types", baseDirectory, state);
}
- function computeOther(node, kind, subtreeFlags) {
- var transformFlags = subtreeFlags;
- var excludeFlags = 536870912;
- switch (kind) {
- case 126:
- transformFlags |= 32 | 64;
- break;
- case 206:
- transformFlags |= 32 | 64 | 524288;
- break;
- case 199:
- case 217:
- case 326:
- transformFlags |= 1;
- excludeFlags = 536870912;
- break;
- case 119:
- case 117:
- case 118:
- case 122:
- case 130:
- case 81:
- case 248:
- case 284:
- case 218:
- case 138:
- transformFlags |= 1;
- break;
- case 266:
- case 11:
- case 269:
- case 270:
- case 271:
- case 272:
- case 273:
- case 274:
- case 275:
- case 276:
- transformFlags |= 2;
- break;
- case 14:
- case 15:
- case 16:
- case 17:
- if (node.templateFlags) {
- transformFlags |= 32;
- break;
- }
- case 198:
- if (ts.hasInvalidEscape(node.template)) {
- transformFlags |= 32;
- break;
- }
- case 211:
- case 282:
- case 120:
- case 219:
- transformFlags |= 256;
- break;
- case 10:
- if (node.hasExtendedUnicodeEscape) {
- transformFlags |= 256;
- }
- break;
- case 8:
- if (node.numericLiteralFlags & 384) {
- transformFlags |= 256;
- }
- break;
- case 9:
- transformFlags |= 4;
- break;
- case 232:
- if (node.awaitModifier) {
- transformFlags |= 32;
- }
- transformFlags |= 256;
- break;
- case 212:
- transformFlags |= 32 | 256 | 262144;
- break;
- case 125:
- case 140:
- case 151:
- case 137:
- case 141:
- case 143:
- case 128:
- case 144:
- case 110:
- case 155:
- case 158:
- case 160:
- case 165:
- case 166:
- case 167:
- case 168:
- case 169:
- case 170:
- case 171:
- case 172:
- case 173:
- case 174:
- case 175:
- case 176:
- case 177:
- case 178:
- case 179:
- case 180:
- case 181:
- case 182:
- case 246:
- case 247:
- case 183:
- case 184:
- case 185:
- case 186:
- case 187:
- case 252:
- transformFlags = 1;
- excludeFlags = -2;
- break;
- case 154:
- transformFlags |= 32768;
- break;
- case 213:
- transformFlags |= 256 | 8192;
- break;
- case 283:
- transformFlags |= 32 | 16384;
- break;
- case 102:
- transformFlags |= 256;
- excludeFlags = 536870912;
- break;
- case 104:
- transformFlags |= 4096;
- break;
- case 189:
- transformFlags |= 256 | 131072;
- if (subtreeFlags & 8192) {
- transformFlags |= 32 | 16384;
- }
- excludeFlags = 536879104;
- break;
- case 190:
- transformFlags |= 256 | 131072;
- excludeFlags = 536879104;
- break;
- case 191:
- transformFlags |= 256;
- if (node.dotDotDotToken) {
- transformFlags |= 8192;
- }
- break;
- case 157:
- transformFlags |= 1 | 2048;
- break;
- case 193:
- excludeFlags = 536922112;
- if (subtreeFlags & 32768) {
- transformFlags |= 256;
- }
- if (subtreeFlags & 16384) {
- transformFlags |= 32;
- }
- break;
- case 192:
- excludeFlags = 536879104;
- break;
- case 228:
- case 229:
- case 230:
- case 231:
- if (subtreeFlags & 65536) {
- transformFlags |= 256;
- }
- break;
- case 290:
- break;
- case 262:
- transformFlags |= 4;
- break;
- case 235:
- transformFlags |= 1048576 | 32;
- break;
- case 233:
- case 234:
- transformFlags |= 1048576;
- break;
- case 76:
- transformFlags |= 4194304;
- break;
- }
- node.transformFlags = transformFlags | 536870912;
- return transformFlags & ~excludeFlags;
+ function readPackageJsonTSConfigField(jsonContent, baseDirectory, state) {
+ return readPackageJsonPathField(jsonContent, "tsconfig", baseDirectory, state);
}
- function propagatePropertyNameFlags(node, transformFlags) {
- return transformFlags | (node.transformFlags & 4096);
+ function readPackageJsonMainField(jsonContent, baseDirectory, state) {
+ return readPackageJsonPathField(jsonContent, "main", baseDirectory, state);
}
- function getTransformFlagsSubtreeExclusions(kind) {
- if (kind >= 168 && kind <= 188) {
- return -2;
- }
- switch (kind) {
- case 196:
- case 197:
- case 192:
- return 536879104;
- case 249:
- return 537991168;
- case 156:
- return 536870912;
- case 202:
- return 538920960;
- case 201:
- case 244:
- return 538925056;
- case 243:
- return 537018368;
- case 245:
- case 214:
- return 536905728;
- case 162:
- return 538923008;
- case 161:
- case 163:
- case 164:
- return 538923008;
- case 125:
- case 140:
- case 151:
- case 137:
- case 143:
- case 141:
- case 128:
- case 144:
- case 110:
- case 155:
- case 158:
- case 160:
- case 165:
- case 166:
- case 167:
- case 246:
- case 247:
- return -2;
- case 193:
- return 536922112;
- case 280:
- return 536887296;
- case 189:
- case 190:
- return 536879104;
- case 199:
- case 217:
- case 326:
- case 200:
- case 102:
- return 536870912;
- case 194:
- case 195:
- return 536870912;
- default:
- return 536870912;
+ function readPackageJsonTypesVersionsField(jsonContent, state) {
+ var typesVersions = readPackageJsonField(jsonContent, "typesVersions", "object", state);
+ if (typesVersions === undefined)
+ return;
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_field_with_version_specific_path_mappings);
}
+ return typesVersions;
}
- ts.getTransformFlagsSubtreeExclusions = getTransformFlagsSubtreeExclusions;
- function setParentPointers(parent, child) {
- child.parent = parent;
- ts.forEachChild(child, function (grandchild) { return setParentPointers(child, grandchild); });
- }
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getIndexTypeOfStructuredType, getConstraintOfTypeParameter, getFirstIdentifier, getTypeArguments) {
- return getSymbolWalker;
- function getSymbolWalker(accept) {
- if (accept === void 0) { accept = function () { return true; }; }
- var visitedTypes = [];
- var visitedSymbols = [];
- return {
- walkType: function (type) {
- try {
- visitType(type);
- return { visitedTypes: ts.getOwnValues(visitedTypes), visitedSymbols: ts.getOwnValues(visitedSymbols) };
- }
- finally {
- ts.clear(visitedTypes);
- ts.clear(visitedSymbols);
- }
- },
- walkSymbol: function (symbol) {
- try {
- visitSymbol(symbol);
- return { visitedTypes: ts.getOwnValues(visitedTypes), visitedSymbols: ts.getOwnValues(visitedSymbols) };
- }
- finally {
- ts.clear(visitedTypes);
- ts.clear(visitedSymbols);
- }
- },
- };
- function visitType(type) {
- if (!type) {
- return;
- }
- if (visitedTypes[type.id]) {
- return;
- }
- visitedTypes[type.id] = type;
- var shouldBail = visitSymbol(type.symbol);
- if (shouldBail)
- return;
- if (type.flags & 524288) {
- var objectType = type;
- var objectFlags = objectType.objectFlags;
- if (objectFlags & 4) {
- visitTypeReference(type);
- }
- if (objectFlags & 32) {
- visitMappedType(type);
- }
- if (objectFlags & (1 | 2)) {
- visitInterfaceType(type);
- }
- if (objectFlags & (8 | 16)) {
- visitObjectType(objectType);
- }
- }
- if (type.flags & 262144) {
- visitTypeParameter(type);
- }
- if (type.flags & 3145728) {
- visitUnionOrIntersectionType(type);
- }
- if (type.flags & 4194304) {
- visitIndexType(type);
- }
- if (type.flags & 8388608) {
- visitIndexedAccessType(type);
+ function readPackageJsonTypesVersionPaths(jsonContent, state) {
+ var typesVersions = readPackageJsonTypesVersionsField(jsonContent, state);
+ if (typesVersions === undefined)
+ return;
+ if (state.traceEnabled) {
+ for (var key in typesVersions) {
+ if (ts.hasProperty(typesVersions, key) && !ts.VersionRange.tryParse(key)) {
+ trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range, key);
}
}
- function visitTypeReference(type) {
- visitType(type.target);
- ts.forEach(getTypeArguments(type), visitType);
+ }
+ var result = getPackageJsonTypesVersionsPaths(typesVersions);
+ if (!result) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, ts.versionMajorMinor);
}
- function visitTypeParameter(type) {
- visitType(getConstraintOfTypeParameter(type));
+ return;
+ }
+ var bestVersionKey = result.version, bestVersionPaths = result.paths;
+ if (typeof bestVersionPaths !== "object") {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, "typesVersions['" + bestVersionKey + "']", "object", typeof bestVersionPaths);
}
- function visitUnionOrIntersectionType(type) {
- ts.forEach(type.types, visitType);
+ return;
+ }
+ return result;
+ }
+ var typeScriptVersion;
+ function getPackageJsonTypesVersionsPaths(typesVersions) {
+ if (!typeScriptVersion)
+ typeScriptVersion = new ts.Version(ts.version);
+ for (var key in typesVersions) {
+ if (!ts.hasProperty(typesVersions, key))
+ continue;
+ var keyRange = ts.VersionRange.tryParse(key);
+ if (keyRange === undefined) {
+ continue;
}
- function visitIndexType(type) {
- visitType(type.type);
+ if (keyRange.test(typeScriptVersion)) {
+ return { version: key, paths: typesVersions[key] };
}
- function visitIndexedAccessType(type) {
- visitType(type.objectType);
- visitType(type.indexType);
- visitType(type.constraint);
+ }
+ }
+ ts.getPackageJsonTypesVersionsPaths = getPackageJsonTypesVersionsPaths;
+ function getEffectiveTypeRoots(options, host) {
+ if (options.typeRoots) {
+ return options.typeRoots;
+ }
+ var currentDirectory;
+ if (options.configFilePath) {
+ currentDirectory = ts.getDirectoryPath(options.configFilePath);
+ }
+ else if (host.getCurrentDirectory) {
+ currentDirectory = host.getCurrentDirectory();
+ }
+ if (currentDirectory !== undefined) {
+ return getDefaultTypeRoots(currentDirectory, host);
+ }
+ }
+ ts.getEffectiveTypeRoots = getEffectiveTypeRoots;
+ function getDefaultTypeRoots(currentDirectory, host) {
+ if (!host.directoryExists) {
+ return [ts.combinePaths(currentDirectory, nodeModulesAtTypes)];
+ }
+ var typeRoots;
+ ts.forEachAncestorDirectory(ts.normalizePath(currentDirectory), function (directory) {
+ var atTypes = ts.combinePaths(directory, nodeModulesAtTypes);
+ if (host.directoryExists(atTypes)) {
+ (typeRoots || (typeRoots = [])).push(atTypes);
}
- function visitMappedType(type) {
- visitType(type.typeParameter);
- visitType(type.constraintType);
- visitType(type.templateType);
- visitType(type.modifiersType);
+ return undefined;
+ });
+ return typeRoots;
+ }
+ var nodeModulesAtTypes = ts.combinePaths("node_modules", "@types");
+ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference) {
+ var traceEnabled = isTraceEnabled(options, host);
+ if (redirectedReference) {
+ options = redirectedReference.commandLine.options;
+ }
+ var failedLookupLocations = [];
+ var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations };
+ var typeRoots = getEffectiveTypeRoots(options, host);
+ if (traceEnabled) {
+ if (containingFile === undefined) {
+ if (typeRoots === undefined) {
+ trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);
+ }
+ else {
+ trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);
+ }
}
- function visitSignature(signature) {
- var typePredicate = getTypePredicateOfSignature(signature);
- if (typePredicate) {
- visitType(typePredicate.type);
+ else {
+ if (typeRoots === undefined) {
+ trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);
}
- ts.forEach(signature.typeParameters, visitType);
- for (var _i = 0, _a = signature.parameters; _i < _a.length; _i++) {
- var parameter = _a[_i];
- visitSymbol(parameter);
+ else {
+ trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);
}
- visitType(getRestTypeOfSignature(signature));
- visitType(getReturnTypeOfSignature(signature));
}
- function visitInterfaceType(interfaceT) {
- visitObjectType(interfaceT);
- ts.forEach(interfaceT.typeParameters, visitType);
- ts.forEach(getBaseTypes(interfaceT), visitType);
- visitType(interfaceT.thisType);
+ if (redirectedReference) {
+ trace(host, ts.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
}
- function visitObjectType(type) {
- var stringIndexType = getIndexTypeOfStructuredType(type, 0);
- visitType(stringIndexType);
- var numberIndexType = getIndexTypeOfStructuredType(type, 1);
- visitType(numberIndexType);
- var resolved = resolveStructuredTypeMembers(type);
- for (var _i = 0, _a = resolved.callSignatures; _i < _a.length; _i++) {
- var signature = _a[_i];
- visitSignature(signature);
+ }
+ var resolved = primaryLookup();
+ var primary = true;
+ if (!resolved) {
+ resolved = secondaryLookup();
+ primary = false;
+ }
+ var resolvedTypeReferenceDirective;
+ if (resolved) {
+ var fileName = resolved.fileName, packageId = resolved.packageId;
+ var resolvedFileName = options.preserveSymlinks ? fileName : realPath(fileName, host, traceEnabled);
+ if (traceEnabled) {
+ if (packageId) {
+ trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, resolvedFileName, ts.packageIdToString(packageId), primary);
}
- for (var _b = 0, _c = resolved.constructSignatures; _b < _c.length; _b++) {
- var signature = _c[_b];
- visitSignature(signature);
+ else {
+ trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFileName, primary);
}
- for (var _d = 0, _e = resolved.properties; _d < _e.length; _d++) {
- var p = _e[_d];
- visitSymbol(p);
+ }
+ resolvedTypeReferenceDirective = { primary: primary, resolvedFileName: resolvedFileName, packageId: packageId, isExternalLibraryImport: pathContainsNodeModules(fileName) };
+ }
+ return { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations };
+ function primaryLookup() {
+ if (typeRoots && typeRoots.length) {
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
}
+ return ts.firstDefined(typeRoots, function (typeRoot) {
+ var candidate = ts.combinePaths(typeRoot, typeReferenceDirectiveName);
+ var candidateDirectory = ts.getDirectoryPath(candidate);
+ var directoryExists = ts.directoryProbablyExists(candidateDirectory, host);
+ if (!directoryExists && traceEnabled) {
+ trace(host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);
+ }
+ return resolvedTypeScriptOnly(loadNodeModuleFromDirectory(Extensions.DtsOnly, candidate, !directoryExists, moduleResolutionState));
+ });
}
- function visitSymbol(symbol) {
- if (!symbol) {
- return false;
+ else {
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);
}
- var symbolId = ts.getSymbolId(symbol);
- if (visitedSymbols[symbolId]) {
- return false;
+ }
+ }
+ function secondaryLookup() {
+ var initialLocationForSecondaryLookup = containingFile && ts.getDirectoryPath(containingFile);
+ if (initialLocationForSecondaryLookup !== undefined) {
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
}
- visitedSymbols[symbolId] = symbol;
- if (!accept(symbol)) {
- return true;
+ var result = void 0;
+ if (!ts.isExternalModuleNameRelative(typeReferenceDirectiveName)) {
+ var searchResult = loadModuleFromNearestNodeModulesDirectory(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, undefined, undefined);
+ result = searchResult && searchResult.value;
}
- var t = getTypeOfSymbol(symbol);
- visitType(t);
- if (symbol.exports) {
- symbol.exports.forEach(visitSymbol);
+ else {
+ var candidate = ts.normalizePathAndParts(ts.combinePaths(initialLocationForSecondaryLookup, typeReferenceDirectiveName)).path;
+ result = nodeLoadModuleByRelativeName(Extensions.DtsOnly, candidate, false, moduleResolutionState, true);
+ }
+ var resolvedFile = resolvedTypeScriptOnly(result);
+ if (!resolvedFile && traceEnabled) {
+ trace(host, ts.Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);
+ }
+ return resolvedFile;
+ }
+ else {
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);
}
- ts.forEach(symbol.declarations, function (d) {
- if (d.type && d.type.kind === 172) {
- var query = d.type;
- var entity = getResolvedSymbol(getFirstIdentifier(query.exprName));
- visitSymbol(entity);
- }
- });
- return false;
}
}
}
- ts.createGetSymbolWalker = createGetSymbolWalker;
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- var ambientModuleSymbolRegex = /^".+"$/;
- var anon = "(anonymous)";
- var nextSymbolId = 1;
- var nextNodeId = 1;
- var nextMergeId = 1;
- var nextFlowId = 1;
- var typeofEQFacts = ts.createMapFromTemplate({
- string: 1,
- number: 2,
- bigint: 4,
- boolean: 8,
- symbol: 16,
- undefined: 65536,
- object: 32,
- function: 64
- });
- var typeofNEFacts = ts.createMapFromTemplate({
- string: 256,
- number: 512,
- bigint: 1024,
- boolean: 2048,
- symbol: 4096,
- undefined: 524288,
- object: 8192,
- function: 16384
- });
- var isNotOverloadAndNotAccessor = ts.and(isNotOverload, isNotAccessor);
- function SymbolLinks() {
+ ts.resolveTypeReferenceDirective = resolveTypeReferenceDirective;
+ function getAutomaticTypeDirectiveNames(options, host) {
+ if (options.types) {
+ return options.types;
+ }
+ var result = [];
+ if (host.directoryExists && host.getDirectories) {
+ var typeRoots = getEffectiveTypeRoots(options, host);
+ if (typeRoots) {
+ for (var _i = 0, typeRoots_1 = typeRoots; _i < typeRoots_1.length; _i++) {
+ var root = typeRoots_1[_i];
+ if (host.directoryExists(root)) {
+ for (var _a = 0, _b = host.getDirectories(root); _a < _b.length; _a++) {
+ var typeDirectivePath = _b[_a];
+ var normalized = ts.normalizePath(typeDirectivePath);
+ var packageJsonPath = ts.combinePaths(root, normalized, "package.json");
+ var isNotNeededPackage = host.fileExists(packageJsonPath) && ts.readJson(packageJsonPath, host).typings === null;
+ if (!isNotNeededPackage) {
+ var baseFileName = ts.getBaseFileName(normalized);
+ if (baseFileName.charCodeAt(0) !== 46) {
+ result.push(baseFileName);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return result;
}
- function NodeLinks() {
- this.flags = 0;
+ ts.getAutomaticTypeDirectiveNames = getAutomaticTypeDirectiveNames;
+ function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options) {
+ return createModuleResolutionCacheWithMaps(createCacheWithRedirects(options), createCacheWithRedirects(options), currentDirectory, getCanonicalFileName);
}
- function getNodeId(node) {
- if (!node.id) {
- node.id = nextNodeId;
- nextNodeId++;
+ ts.createModuleResolutionCache = createModuleResolutionCache;
+ function createCacheWithRedirects(options) {
+ var ownMap = new ts.Map();
+ var redirectsMap = new ts.Map();
+ return {
+ ownMap: ownMap,
+ redirectsMap: redirectsMap,
+ getOrCreateMapOfCacheRedirects: getOrCreateMapOfCacheRedirects,
+ clear: clear,
+ setOwnOptions: setOwnOptions,
+ setOwnMap: setOwnMap
+ };
+ function setOwnOptions(newOptions) {
+ options = newOptions;
}
- return node.id;
- }
- ts.getNodeId = getNodeId;
- function getSymbolId(symbol) {
- if (!symbol.id) {
- symbol.id = nextSymbolId;
- nextSymbolId++;
+ function setOwnMap(newOwnMap) {
+ ownMap = newOwnMap;
+ }
+ function getOrCreateMapOfCacheRedirects(redirectedReference) {
+ if (!redirectedReference) {
+ return ownMap;
+ }
+ var path = redirectedReference.sourceFile.path;
+ var redirects = redirectsMap.get(path);
+ if (!redirects) {
+ redirects = !options || ts.optionsHaveModuleResolutionChanges(options, redirectedReference.commandLine.options) ? new ts.Map() : ownMap;
+ redirectsMap.set(path, redirects);
+ }
+ return redirects;
+ }
+ function clear() {
+ ownMap.clear();
+ redirectsMap.clear();
}
- return symbol.id;
- }
- ts.getSymbolId = getSymbolId;
- function isInstantiatedModule(node, preserveConstEnums) {
- var moduleState = ts.getModuleInstanceState(node);
- return moduleState === 1 ||
- (preserveConstEnums && moduleState === 2);
}
- ts.isInstantiatedModule = isInstantiatedModule;
- function createTypeChecker(host, produceDiagnostics) {
- var getPackagesSet = ts.memoize(function () {
- var set = ts.createMap();
- host.getSourceFiles().forEach(function (sf) {
- if (!sf.resolvedModules)
- return;
- ts.forEachEntry(sf.resolvedModules, function (r) {
- if (r && r.packageId)
- set.set(r.packageId.name, true);
- });
- });
- return set;
- });
- var cancellationToken;
- var requestedExternalEmitHelpers;
- var externalHelpersModule;
- var Symbol = ts.objectAllocator.getSymbolConstructor();
- var Type = ts.objectAllocator.getTypeConstructor();
- var Signature = ts.objectAllocator.getSignatureConstructor();
- var typeCount = 0;
- var symbolCount = 0;
- var enumCount = 0;
- var totalInstantiationCount = 0;
- var instantiationCount = 0;
- var instantiationDepth = 0;
- var constraintDepth = 0;
- var currentNode;
- var emptySymbols = ts.createSymbolTable();
- var arrayVariances = [1];
- var compilerOptions = host.getCompilerOptions();
- var languageVersion = ts.getEmitScriptTarget(compilerOptions);
- var moduleKind = ts.getEmitModuleKind(compilerOptions);
- var allowSyntheticDefaultImports = ts.getAllowSyntheticDefaultImports(compilerOptions);
- var strictNullChecks = ts.getStrictOptionValue(compilerOptions, "strictNullChecks");
- var strictFunctionTypes = ts.getStrictOptionValue(compilerOptions, "strictFunctionTypes");
- var strictBindCallApply = ts.getStrictOptionValue(compilerOptions, "strictBindCallApply");
- var strictPropertyInitialization = ts.getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
- var noImplicitAny = ts.getStrictOptionValue(compilerOptions, "noImplicitAny");
- var noImplicitThis = ts.getStrictOptionValue(compilerOptions, "noImplicitThis");
- var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
- var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 32768;
- var emitResolver = createResolver();
- var nodeBuilder = createNodeBuilder();
- var globals = ts.createSymbolTable();
- var undefinedSymbol = createSymbol(4, "undefined");
- undefinedSymbol.declarations = [];
- var globalThisSymbol = createSymbol(1536, "globalThis", 8);
- globalThisSymbol.exports = globals;
- globalThisSymbol.declarations = [];
- globals.set(globalThisSymbol.escapedName, globalThisSymbol);
- var argumentsSymbol = createSymbol(4, "arguments");
- var requireSymbol = createSymbol(4, "require");
- var apparentArgumentCount;
- var checker = {
- getNodeCount: function () { return ts.sum(host.getSourceFiles(), "nodeCount"); },
- getIdentifierCount: function () { return ts.sum(host.getSourceFiles(), "identifierCount"); },
- getSymbolCount: function () { return ts.sum(host.getSourceFiles(), "symbolCount") + symbolCount; },
- getTypeCount: function () { return typeCount; },
- getInstantiationCount: function () { return totalInstantiationCount; },
- getRelationCacheSizes: function () { return ({
- assignable: assignableRelation.size,
- identity: identityRelation.size,
- subtype: subtypeRelation.size,
- strictSubtype: strictSubtypeRelation.size,
- }); },
- isUndefinedSymbol: function (symbol) { return symbol === undefinedSymbol; },
- isArgumentsSymbol: function (symbol) { return symbol === argumentsSymbol; },
- isUnknownSymbol: function (symbol) { return symbol === unknownSymbol; },
- getMergedSymbol: getMergedSymbol,
- getDiagnostics: getDiagnostics,
- getGlobalDiagnostics: getGlobalDiagnostics,
- getTypeOfSymbolAtLocation: function (symbol, location) {
- location = ts.getParseTreeNode(location);
- return location ? getTypeOfSymbolAtLocation(symbol, location) : errorType;
- },
- getSymbolsOfParameterPropertyDeclaration: function (parameterIn, parameterName) {
- var parameter = ts.getParseTreeNode(parameterIn, ts.isParameter);
- if (parameter === undefined)
- return ts.Debug.fail("Cannot get symbols of a synthetic parameter that cannot be resolved to a parse-tree node.");
- return getSymbolsOfParameterPropertyDeclaration(parameter, ts.escapeLeadingUnderscores(parameterName));
- },
- getDeclaredTypeOfSymbol: getDeclaredTypeOfSymbol,
- getPropertiesOfType: getPropertiesOfType,
- getPropertyOfType: function (type, name) { return getPropertyOfType(type, ts.escapeLeadingUnderscores(name)); },
- getPrivateIdentifierPropertyOfType: function (leftType, name, location) {
- var node = ts.getParseTreeNode(location);
- if (!node) {
- return undefined;
- }
- var propName = ts.escapeLeadingUnderscores(name);
- var lexicallyScopedIdentifier = lookupSymbolForPrivateIdentifierDeclaration(propName, node);
- return lexicallyScopedIdentifier ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) : undefined;
- },
- getTypeOfPropertyOfType: function (type, name) { return getTypeOfPropertyOfType(type, ts.escapeLeadingUnderscores(name)); },
- getIndexInfoOfType: getIndexInfoOfType,
- getSignaturesOfType: getSignaturesOfType,
- getIndexTypeOfType: getIndexTypeOfType,
- getBaseTypes: getBaseTypes,
- getBaseTypeOfLiteralType: getBaseTypeOfLiteralType,
- getWidenedType: getWidenedType,
- getTypeFromTypeNode: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode);
- return node ? getTypeFromTypeNode(node) : errorType;
- },
- getParameterType: getTypeAtPosition,
- getPromisedTypeOfPromise: getPromisedTypeOfPromise,
- getReturnTypeOfSignature: getReturnTypeOfSignature,
- isNullableType: isNullableType,
- getNullableType: getNullableType,
- getNonNullableType: getNonNullableType,
- getNonOptionalType: removeOptionalTypeMarker,
- getTypeArguments: getTypeArguments,
- typeToTypeNode: nodeBuilder.typeToTypeNode,
- indexInfoToIndexSignatureDeclaration: nodeBuilder.indexInfoToIndexSignatureDeclaration,
- signatureToSignatureDeclaration: nodeBuilder.signatureToSignatureDeclaration,
- symbolToEntityName: nodeBuilder.symbolToEntityName,
- symbolToExpression: nodeBuilder.symbolToExpression,
- symbolToTypeParameterDeclarations: nodeBuilder.symbolToTypeParameterDeclarations,
- symbolToParameterDeclaration: nodeBuilder.symbolToParameterDeclaration,
- typeParameterToDeclaration: nodeBuilder.typeParameterToDeclaration,
- getSymbolsInScope: function (location, meaning) {
- location = ts.getParseTreeNode(location);
- return location ? getSymbolsInScope(location, meaning) : [];
- },
- getSymbolAtLocation: function (node) {
- node = ts.getParseTreeNode(node);
- return node ? getSymbolAtLocation(node, true) : undefined;
- },
- getShorthandAssignmentValueSymbol: function (node) {
- node = ts.getParseTreeNode(node);
- return node ? getShorthandAssignmentValueSymbol(node) : undefined;
- },
- getExportSpecifierLocalTargetSymbol: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isExportSpecifier);
- return node ? getExportSpecifierLocalTargetSymbol(node) : undefined;
- },
- getExportSymbolOfSymbol: function (symbol) {
- return getMergedSymbol(symbol.exportSymbol || symbol);
- },
- getTypeAtLocation: function (node) {
- node = ts.getParseTreeNode(node);
- return node ? getTypeOfNode(node) : errorType;
- },
- getTypeOfAssignmentPattern: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isAssignmentPattern);
- return node && getTypeOfAssignmentPattern(node) || errorType;
- },
- getPropertySymbolOfDestructuringAssignment: function (locationIn) {
- var location = ts.getParseTreeNode(locationIn, ts.isIdentifier);
- return location ? getPropertySymbolOfDestructuringAssignment(location) : undefined;
- },
- signatureToString: function (signature, enclosingDeclaration, flags, kind) {
- return signatureToString(signature, ts.getParseTreeNode(enclosingDeclaration), flags, kind);
- },
- typeToString: function (type, enclosingDeclaration, flags) {
- return typeToString(type, ts.getParseTreeNode(enclosingDeclaration), flags);
- },
- symbolToString: function (symbol, enclosingDeclaration, meaning, flags) {
- return symbolToString(symbol, ts.getParseTreeNode(enclosingDeclaration), meaning, flags);
- },
- typePredicateToString: function (predicate, enclosingDeclaration, flags) {
- return typePredicateToString(predicate, ts.getParseTreeNode(enclosingDeclaration), flags);
- },
- writeSignature: function (signature, enclosingDeclaration, flags, kind, writer) {
- return signatureToString(signature, ts.getParseTreeNode(enclosingDeclaration), flags, kind, writer);
- },
- writeType: function (type, enclosingDeclaration, flags, writer) {
- return typeToString(type, ts.getParseTreeNode(enclosingDeclaration), flags, writer);
- },
- writeSymbol: function (symbol, enclosingDeclaration, meaning, flags, writer) {
- return symbolToString(symbol, ts.getParseTreeNode(enclosingDeclaration), meaning, flags, writer);
- },
- writeTypePredicate: function (predicate, enclosingDeclaration, flags, writer) {
- return typePredicateToString(predicate, ts.getParseTreeNode(enclosingDeclaration), flags, writer);
- },
- getAugmentedPropertiesOfType: getAugmentedPropertiesOfType,
- getRootSymbols: getRootSymbols,
- getContextualType: function (nodeIn, contextFlags) {
- var node = ts.getParseTreeNode(nodeIn, ts.isExpression);
- if (!node) {
- return undefined;
+ ts.createCacheWithRedirects = createCacheWithRedirects;
+ function createModuleResolutionCacheWithMaps(directoryToModuleNameMap, moduleNameToDirectoryMap, currentDirectory, getCanonicalFileName) {
+ return { getOrCreateCacheForDirectory: getOrCreateCacheForDirectory, getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, directoryToModuleNameMap: directoryToModuleNameMap, moduleNameToDirectoryMap: moduleNameToDirectoryMap };
+ function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
+ var path = ts.toPath(directoryName, currentDirectory, getCanonicalFileName);
+ return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, function () { return new ts.Map(); });
+ }
+ function getOrCreateCacheForModuleName(nonRelativeModuleName, redirectedReference) {
+ ts.Debug.assert(!ts.isExternalModuleNameRelative(nonRelativeModuleName));
+ return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, nonRelativeModuleName, createPerModuleNameCache);
+ }
+ function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {
+ var cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
+ var result = cache.get(key);
+ if (!result) {
+ result = create();
+ cache.set(key, result);
+ }
+ return result;
+ }
+ function createPerModuleNameCache() {
+ var directoryPathMap = new ts.Map();
+ return { get: get, set: set };
+ function get(directory) {
+ return directoryPathMap.get(ts.toPath(directory, currentDirectory, getCanonicalFileName));
+ }
+ function set(directory, result) {
+ var path = ts.toPath(directory, currentDirectory, getCanonicalFileName);
+ if (directoryPathMap.has(path)) {
+ return;
}
- var containingCall = ts.findAncestor(node, ts.isCallLikeExpression);
- var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
- if (contextFlags & 4 && containingCall) {
- var toMarkSkip = node;
- do {
- getNodeLinks(toMarkSkip).skipDirectInference = true;
- toMarkSkip = toMarkSkip.parent;
- } while (toMarkSkip && toMarkSkip !== containingCall);
- getNodeLinks(containingCall).resolvedSignature = undefined;
+ directoryPathMap.set(path, result);
+ var resolvedFileName = result.resolvedModule &&
+ (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);
+ var commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName);
+ var current = path;
+ while (current !== commonPrefix) {
+ var parent = ts.getDirectoryPath(current);
+ if (parent === current || directoryPathMap.has(parent)) {
+ break;
+ }
+ directoryPathMap.set(parent, result);
+ current = parent;
}
- var result = getContextualType(node, contextFlags);
- if (contextFlags & 4 && containingCall) {
- var toMarkSkip = node;
- do {
- getNodeLinks(toMarkSkip).skipDirectInference = undefined;
- toMarkSkip = toMarkSkip.parent;
- } while (toMarkSkip && toMarkSkip !== containingCall);
- getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
+ }
+ function getCommonPrefix(directory, resolution) {
+ var resolutionDirectory = ts.toPath(ts.getDirectoryPath(resolution), currentDirectory, getCanonicalFileName);
+ var i = 0;
+ var limit = Math.min(directory.length, resolutionDirectory.length);
+ while (i < limit && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) {
+ i++;
}
- return result;
- },
- getContextualTypeForObjectLiteralElement: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike);
- return node ? getContextualTypeForObjectLiteralElement(node) : undefined;
- },
- getContextualTypeForArgumentAtIndex: function (nodeIn, argIndex) {
- var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
- return node && getContextualTypeForArgumentAtIndex(node, argIndex);
- },
- getContextualTypeForJsxAttribute: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isJsxAttributeLike);
- return node && getContextualTypeForJsxAttribute(node);
- },
- isContextSensitive: isContextSensitive,
- getFullyQualifiedName: getFullyQualifiedName,
- getResolvedSignature: function (node, candidatesOutArray, argumentCount) {
- return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0);
- },
- getResolvedSignatureForSignatureHelp: function (node, candidatesOutArray, argumentCount) {
- return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16);
- },
- getExpandedParameters: getExpandedParameters,
- hasEffectiveRestParameter: hasEffectiveRestParameter,
- getConstantValue: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, canHaveConstantValue);
- return node ? getConstantValue(node) : undefined;
- },
- isValidPropertyAccess: function (nodeIn, propertyName) {
- var node = ts.getParseTreeNode(nodeIn, ts.isPropertyAccessOrQualifiedNameOrImportTypeNode);
- return !!node && isValidPropertyAccess(node, ts.escapeLeadingUnderscores(propertyName));
- },
- isValidPropertyAccessForCompletions: function (nodeIn, type, property) {
- var node = ts.getParseTreeNode(nodeIn, ts.isPropertyAccessExpression);
- return !!node && isValidPropertyAccessForCompletions(node, type, property);
- },
- getSignatureFromDeclaration: function (declarationIn) {
- var declaration = ts.getParseTreeNode(declarationIn, ts.isFunctionLike);
- return declaration ? getSignatureFromDeclaration(declaration) : undefined;
- },
- isImplementationOfOverload: function (node) {
- var parsed = ts.getParseTreeNode(node, ts.isFunctionLike);
- return parsed ? isImplementationOfOverload(parsed) : undefined;
- },
- getImmediateAliasedSymbol: getImmediateAliasedSymbol,
- getAliasedSymbol: resolveAlias,
- getEmitResolver: getEmitResolver,
- getExportsOfModule: getExportsOfModuleAsArray,
- getExportsAndPropertiesOfModule: getExportsAndPropertiesOfModule,
- getSymbolWalker: ts.createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getIndexTypeOfStructuredType, getConstraintOfTypeParameter, ts.getFirstIdentifier, getTypeArguments),
- getAmbientModules: getAmbientModules,
- getJsxIntrinsicTagNamesAt: getJsxIntrinsicTagNamesAt,
- isOptionalParameter: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isParameter);
- return node ? isOptionalParameter(node) : false;
- },
- tryGetMemberInModuleExports: function (name, symbol) { return tryGetMemberInModuleExports(ts.escapeLeadingUnderscores(name), symbol); },
- tryGetMemberInModuleExportsAndProperties: function (name, symbol) { return tryGetMemberInModuleExportsAndProperties(ts.escapeLeadingUnderscores(name), symbol); },
- tryFindAmbientModuleWithoutAugmentations: function (moduleName) {
- return tryFindAmbientModule(moduleName, false);
- },
- getApparentType: getApparentType,
- getUnionType: getUnionType,
- isTypeAssignableTo: isTypeAssignableTo,
- createAnonymousType: createAnonymousType,
- createSignature: createSignature,
- createSymbol: createSymbol,
- createIndexInfo: createIndexInfo,
- getAnyType: function () { return anyType; },
- getStringType: function () { return stringType; },
- getNumberType: function () { return numberType; },
- createPromiseType: createPromiseType,
- createArrayType: createArrayType,
- getElementTypeOfArrayType: getElementTypeOfArrayType,
- getBooleanType: function () { return booleanType; },
- getFalseType: function (fresh) { return fresh ? falseType : regularFalseType; },
- getTrueType: function (fresh) { return fresh ? trueType : regularTrueType; },
- getVoidType: function () { return voidType; },
- getUndefinedType: function () { return undefinedType; },
- getNullType: function () { return nullType; },
- getESSymbolType: function () { return esSymbolType; },
- getNeverType: function () { return neverType; },
- getOptionalType: function () { return optionalType; },
- isSymbolAccessible: isSymbolAccessible,
- isArrayType: isArrayType,
- isTupleType: isTupleType,
- isArrayLikeType: isArrayLikeType,
- isTypeInvalidDueToUnionDiscriminant: isTypeInvalidDueToUnionDiscriminant,
- getAllPossiblePropertiesOfTypes: getAllPossiblePropertiesOfTypes,
- getSuggestedSymbolForNonexistentProperty: getSuggestedSymbolForNonexistentProperty,
- getSuggestionForNonexistentProperty: getSuggestionForNonexistentProperty,
- getSuggestedSymbolForNonexistentSymbol: function (location, name, meaning) { return getSuggestedSymbolForNonexistentSymbol(location, ts.escapeLeadingUnderscores(name), meaning); },
- getSuggestionForNonexistentSymbol: function (location, name, meaning) { return getSuggestionForNonexistentSymbol(location, ts.escapeLeadingUnderscores(name), meaning); },
- getSuggestedSymbolForNonexistentModule: getSuggestedSymbolForNonexistentModule,
- getSuggestionForNonexistentExport: getSuggestionForNonexistentExport,
- getBaseConstraintOfType: getBaseConstraintOfType,
- getDefaultFromTypeParameter: function (type) { return type && type.flags & 262144 ? getDefaultFromTypeParameter(type) : undefined; },
- resolveName: function (name, location, meaning, excludeGlobals) {
- return resolveName(location, ts.escapeLeadingUnderscores(name), meaning, undefined, undefined, false, excludeGlobals);
- },
- getJsxNamespace: function (n) { return ts.unescapeLeadingUnderscores(getJsxNamespace(n)); },
- getAccessibleSymbolChain: getAccessibleSymbolChain,
- getTypePredicateOfSignature: getTypePredicateOfSignature,
- resolveExternalModuleName: function (moduleSpecifier) {
- return resolveExternalModuleName(moduleSpecifier, moduleSpecifier, true);
- },
- resolveExternalModuleSymbol: resolveExternalModuleSymbol,
- tryGetThisTypeAt: function (node, includeGlobalThis) {
- node = ts.getParseTreeNode(node);
- return node && tryGetThisTypeAt(node, includeGlobalThis);
- },
- getTypeArgumentConstraint: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode);
- return node && getTypeArgumentConstraint(node);
- },
- getSuggestionDiagnostics: function (file, ct) {
- if (ts.skipTypeChecking(file, compilerOptions, host)) {
- return ts.emptyArray;
+ if (i === directory.length && (resolutionDirectory.length === i || resolutionDirectory[i] === ts.directorySeparator)) {
+ return directory;
}
- var diagnostics;
- try {
- cancellationToken = ct;
- checkSourceFile(file);
- ts.Debug.assert(!!(getNodeLinks(file).flags & 1));
- diagnostics = ts.addRange(diagnostics, suggestionDiagnostics.getDiagnostics(file.fileName));
- checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(file), function (containingNode, kind, diag) {
- if (!ts.containsParseError(containingNode) && !unusedIsError(kind, !!(containingNode.flags & 8388608))) {
- (diagnostics || (diagnostics = [])).push(__assign(__assign({}, diag), { category: ts.DiagnosticCategory.Suggestion }));
- }
- });
- return diagnostics || ts.emptyArray;
+ var rootLength = ts.getRootLength(directory);
+ if (i < rootLength) {
+ return undefined;
}
- finally {
- cancellationToken = undefined;
+ var sep = directory.lastIndexOf(ts.directorySeparator, i - 1);
+ if (sep === -1) {
+ return undefined;
}
- },
- runWithCancellationToken: function (token, callback) {
- try {
- cancellationToken = token;
- return callback(checker);
+ return directory.substr(0, Math.max(sep, rootLength));
+ }
+ }
+ }
+ ts.createModuleResolutionCacheWithMaps = createModuleResolutionCacheWithMaps;
+ function resolveModuleNameFromCache(moduleName, containingFile, cache) {
+ var containingDirectory = ts.getDirectoryPath(containingFile);
+ var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
+ return perFolderCache && perFolderCache.get(moduleName);
+ }
+ ts.resolveModuleNameFromCache = resolveModuleNameFromCache;
+ function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
+ var traceEnabled = isTraceEnabled(compilerOptions, host);
+ if (redirectedReference) {
+ compilerOptions = redirectedReference.commandLine.options;
+ }
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
+ if (redirectedReference) {
+ trace(host, ts.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
+ }
+ }
+ var containingDirectory = ts.getDirectoryPath(containingFile);
+ var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference);
+ var result = perFolderCache && perFolderCache.get(moduleName);
+ if (result) {
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
+ }
+ }
+ else {
+ var moduleResolution = compilerOptions.moduleResolution;
+ if (moduleResolution === undefined) {
+ moduleResolution = ts.getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS ? ts.ModuleResolutionKind.NodeJs : ts.ModuleResolutionKind.Classic;
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Module_resolution_kind_is_not_specified_using_0, ts.ModuleResolutionKind[moduleResolution]);
}
- finally {
- cancellationToken = undefined;
+ }
+ else {
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ts.ModuleResolutionKind[moduleResolution]);
}
- },
- getLocalTypeParametersOfClassOrInterfaceOrTypeAlias: getLocalTypeParametersOfClassOrInterfaceOrTypeAlias,
- isDeclarationVisible: isDeclarationVisible,
- };
- function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
- var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
- apparentArgumentCount = argumentCount;
- var res = node ? getResolvedSignature(node, candidatesOutArray, checkMode) : undefined;
- apparentArgumentCount = undefined;
- return res;
+ }
+ ts.perfLogger.logStartResolveModule(moduleName);
+ switch (moduleResolution) {
+ case ts.ModuleResolutionKind.NodeJs:
+ result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
+ break;
+ case ts.ModuleResolutionKind.Classic:
+ result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
+ break;
+ default:
+ return ts.Debug.fail("Unexpected moduleResolution: " + moduleResolution);
+ }
+ if (result && result.resolvedModule)
+ ts.perfLogger.logInfoEvent("Module \"" + moduleName + "\" resolved to \"" + result.resolvedModule.resolvedFileName + "\"");
+ ts.perfLogger.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null");
+ if (perFolderCache) {
+ perFolderCache.set(moduleName, result);
+ if (!ts.isExternalModuleNameRelative(moduleName)) {
+ cache.getOrCreateCacheForModuleName(moduleName, redirectedReference).set(containingDirectory, result);
+ }
+ }
}
- var tupleTypes = ts.createMap();
- var unionTypes = ts.createMap();
- var intersectionTypes = ts.createMap();
- var literalTypes = ts.createMap();
- var indexedAccessTypes = ts.createMap();
- var substitutionTypes = ts.createMap();
- var evolvingArrayTypes = [];
- var undefinedProperties = ts.createMap();
- var unknownSymbol = createSymbol(4, "unknown");
- var resolvingSymbol = createSymbol(0, "__resolving__");
- var anyType = createIntrinsicType(1, "any");
- var autoType = createIntrinsicType(1, "any");
- var wildcardType = createIntrinsicType(1, "any");
- var errorType = createIntrinsicType(1, "error");
- var nonInferrableAnyType = createIntrinsicType(1, "any", 524288);
- var unknownType = createIntrinsicType(2, "unknown");
- var undefinedType = createIntrinsicType(32768, "undefined");
- var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768, "undefined", 524288);
- var optionalType = createIntrinsicType(32768, "undefined");
- var nullType = createIntrinsicType(65536, "null");
- var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536, "null", 524288);
- var stringType = createIntrinsicType(4, "string");
- var numberType = createIntrinsicType(8, "number");
- var bigintType = createIntrinsicType(64, "bigint");
- var falseType = createIntrinsicType(512, "false");
- var regularFalseType = createIntrinsicType(512, "false");
- var trueType = createIntrinsicType(512, "true");
- var regularTrueType = createIntrinsicType(512, "true");
- trueType.regularType = regularTrueType;
- trueType.freshType = trueType;
- regularTrueType.regularType = regularTrueType;
- regularTrueType.freshType = trueType;
- falseType.regularType = regularFalseType;
- falseType.freshType = falseType;
- regularFalseType.regularType = regularFalseType;
- regularFalseType.freshType = falseType;
- var booleanType = createBooleanType([regularFalseType, regularTrueType]);
- createBooleanType([regularFalseType, trueType]);
- createBooleanType([falseType, regularTrueType]);
- createBooleanType([falseType, trueType]);
- var esSymbolType = createIntrinsicType(4096, "symbol");
- var voidType = createIntrinsicType(16384, "void");
- var neverType = createIntrinsicType(131072, "never");
- var silentNeverType = createIntrinsicType(131072, "never");
- var nonInferrableType = createIntrinsicType(131072, "never", 2097152);
- var implicitNeverType = createIntrinsicType(131072, "never");
- var unreachableNeverType = createIntrinsicType(131072, "never");
- var nonPrimitiveType = createIntrinsicType(67108864, "object");
- var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
- var keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
- var numberOrBigIntType = getUnionType([numberType, bigintType]);
- var restrictiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 ? getRestrictiveTypeParameter(t) : t; });
- var permissiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 ? wildcardType : t; });
- var emptyObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- var emptyJsxObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- emptyJsxObjectType.objectFlags |= 4096;
- var emptyTypeLiteralSymbol = createSymbol(2048, "__type");
- emptyTypeLiteralSymbol.members = ts.createSymbolTable();
- var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- var emptyGenericType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- emptyGenericType.instantiations = ts.createMap();
- var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- anyFunctionType.objectFlags |= 2097152;
- var noConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- var circularConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- var markerSuperType = createTypeParameter();
- var markerSubType = createTypeParameter();
- markerSubType.constraint = markerSuperType;
- var markerOtherType = createTypeParameter();
- var noTypePredicate = createTypePredicate(1, "<<unresolved>>", 0, anyType);
- var anySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, anyType, undefined, 0, 0);
- var unknownSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, errorType, undefined, 0, 0);
- var resolvingSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, anyType, undefined, 0, 0);
- var silentNeverSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, silentNeverType, undefined, 0, 0);
- var enumNumberIndexInfo = createIndexInfo(stringType, true);
- var iterationTypesCache = ts.createMap();
- var noIterationTypes = {
- get yieldType() { return ts.Debug.fail("Not supported"); },
- get returnType() { return ts.Debug.fail("Not supported"); },
- get nextType() { return ts.Debug.fail("Not supported"); },
- };
- var anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
- var anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
- var defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType);
- var asyncIterationTypesResolver = {
- iterableCacheKey: "iterationTypesOfAsyncIterable",
- iteratorCacheKey: "iterationTypesOfAsyncIterator",
- iteratorSymbolName: "asyncIterator",
- getGlobalIteratorType: getGlobalAsyncIteratorType,
- getGlobalIterableType: getGlobalAsyncIterableType,
- getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
- getGlobalGeneratorType: getGlobalAsyncGeneratorType,
- resolveIterationType: getAwaitedType,
- mustHaveANextMethodDiagnostic: ts.Diagnostics.An_async_iterator_must_have_a_next_method,
- mustBeAMethodDiagnostic: ts.Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
- mustHaveAValueDiagnostic: ts.Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property,
- };
- var syncIterationTypesResolver = {
- iterableCacheKey: "iterationTypesOfIterable",
- iteratorCacheKey: "iterationTypesOfIterator",
- iteratorSymbolName: "iterator",
- getGlobalIteratorType: getGlobalIteratorType,
- getGlobalIterableType: getGlobalIterableType,
- getGlobalIterableIteratorType: getGlobalIterableIteratorType,
- getGlobalGeneratorType: getGlobalGeneratorType,
- resolveIterationType: function (type, _errorNode) { return type; },
- mustHaveANextMethodDiagnostic: ts.Diagnostics.An_iterator_must_have_a_next_method,
- mustBeAMethodDiagnostic: ts.Diagnostics.The_0_property_of_an_iterator_must_be_a_method,
- mustHaveAValueDiagnostic: ts.Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property,
- };
- var amalgamatedDuplicates;
- var reverseMappedCache = ts.createMap();
- var ambientModulesCache;
- var patternAmbientModules;
- var patternAmbientModuleAugmentations;
- var globalObjectType;
- var globalFunctionType;
- var globalCallableFunctionType;
- var globalNewableFunctionType;
- var globalArrayType;
- var globalReadonlyArrayType;
- var globalStringType;
- var globalNumberType;
- var globalBooleanType;
- var globalRegExpType;
- var globalThisType;
- var anyArrayType;
- var autoArrayType;
- var anyReadonlyArrayType;
- var deferredGlobalNonNullableTypeAlias;
- var deferredGlobalESSymbolConstructorSymbol;
- var deferredGlobalESSymbolType;
- var deferredGlobalTypedPropertyDescriptorType;
- var deferredGlobalPromiseType;
- var deferredGlobalPromiseLikeType;
- var deferredGlobalPromiseConstructorSymbol;
- var deferredGlobalPromiseConstructorLikeType;
- var deferredGlobalIterableType;
- var deferredGlobalIteratorType;
- var deferredGlobalIterableIteratorType;
- var deferredGlobalGeneratorType;
- var deferredGlobalIteratorYieldResultType;
- var deferredGlobalIteratorReturnResultType;
- var deferredGlobalAsyncIterableType;
- var deferredGlobalAsyncIteratorType;
- var deferredGlobalAsyncIterableIteratorType;
- var deferredGlobalAsyncGeneratorType;
- var deferredGlobalTemplateStringsArrayType;
- var deferredGlobalImportMetaType;
- var deferredGlobalExtractSymbol;
- var deferredGlobalOmitSymbol;
- var deferredGlobalBigIntType;
- var allPotentiallyUnusedIdentifiers = ts.createMap();
- var flowLoopStart = 0;
- var flowLoopCount = 0;
- var sharedFlowCount = 0;
- var flowAnalysisDisabled = false;
- var flowInvocationCount = 0;
- var lastFlowNode;
- var lastFlowNodeReachable;
- var flowTypeCache;
- var emptyStringType = getLiteralType("");
- var zeroType = getLiteralType(0);
- var zeroBigIntType = getLiteralType({ negative: false, base10Value: "0" });
- var resolutionTargets = [];
- var resolutionResults = [];
- var resolutionPropertyNames = [];
- var suggestionCount = 0;
- var maximumSuggestionCount = 10;
- var mergedSymbols = [];
- var symbolLinks = [];
- var nodeLinks = [];
- var flowLoopCaches = [];
- var flowLoopNodes = [];
- var flowLoopKeys = [];
- var flowLoopTypes = [];
- var sharedFlowNodes = [];
- var sharedFlowTypes = [];
- var flowNodeReachable = [];
- var potentialThisCollisions = [];
- var potentialNewTargetCollisions = [];
- var potentialWeakMapCollisions = [];
- var awaitedTypeStack = [];
- var diagnostics = ts.createDiagnosticCollection();
- var suggestionDiagnostics = ts.createDiagnosticCollection();
- var typeofTypesByName = ts.createMapFromTemplate({
- string: stringType,
- number: numberType,
- bigint: bigintType,
- boolean: booleanType,
- symbol: esSymbolType,
- undefined: undefinedType
- });
- var typeofType = createTypeofType();
- var _jsxNamespace;
- var _jsxFactoryEntity;
- var outofbandVarianceMarkerHandler;
- var subtypeRelation = ts.createMap();
- var strictSubtypeRelation = ts.createMap();
- var assignableRelation = ts.createMap();
- var comparableRelation = ts.createMap();
- var identityRelation = ts.createMap();
- var enumRelation = ts.createMap();
- var builtinGlobals = ts.createSymbolTable();
- builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
- initializeTypeChecker();
- return checker;
- function getJsxNamespace(location) {
- if (location) {
- var file = ts.getSourceFileOfNode(location);
- if (file) {
- if (file.localJsxNamespace) {
- return file.localJsxNamespace;
- }
- var jsxPragma = file.pragmas.get("jsx");
- if (jsxPragma) {
- var chosenpragma = ts.isArray(jsxPragma) ? jsxPragma[0] : jsxPragma;
- file.localJsxFactory = ts.parseIsolatedEntityName(chosenpragma.arguments.factory, languageVersion);
- ts.visitNode(file.localJsxFactory, markAsSynthetic);
- if (file.localJsxFactory) {
- return file.localJsxNamespace = ts.getFirstIdentifier(file.localJsxFactory).escapedText;
- }
- }
+ if (traceEnabled) {
+ if (result.resolvedModule) {
+ if (result.resolvedModule.packageId) {
+ trace(host, ts.Diagnostics.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2, moduleName, result.resolvedModule.resolvedFileName, ts.packageIdToString(result.resolvedModule.packageId));
+ }
+ else {
+ trace(host, ts.Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);
+ }
+ }
+ else {
+ trace(host, ts.Diagnostics.Module_name_0_was_not_resolved, moduleName);
+ }
+ }
+ return result;
+ }
+ ts.resolveModuleName = resolveModuleName;
+ function tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state) {
+ var resolved = tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state);
+ if (resolved)
+ return resolved.value;
+ if (!ts.isExternalModuleNameRelative(moduleName)) {
+ return tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state);
+ }
+ else {
+ return tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state);
+ }
+ }
+ function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state) {
+ var _a = state.compilerOptions, baseUrl = _a.baseUrl, paths = _a.paths;
+ if (paths && !ts.pathIsRelative(moduleName)) {
+ if (state.traceEnabled) {
+ if (baseUrl) {
+ trace(state.host, ts.Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName);
}
+ trace(state.host, ts.Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
+ }
+ var baseDirectory = ts.getPathsBasePath(state.compilerOptions, state.host);
+ return tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, loader, false, state);
+ }
+ }
+ function tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state) {
+ if (!state.compilerOptions.rootDirs) {
+ return undefined;
+ }
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName);
+ }
+ var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName));
+ var matchedRootDir;
+ var matchedNormalizedPrefix;
+ for (var _i = 0, _a = state.compilerOptions.rootDirs; _i < _a.length; _i++) {
+ var rootDir = _a[_i];
+ var normalizedRoot = ts.normalizePath(rootDir);
+ if (!ts.endsWith(normalizedRoot, ts.directorySeparator)) {
+ normalizedRoot += ts.directorySeparator;
+ }
+ var isLongestMatchingPrefix = ts.startsWith(candidate, normalizedRoot) &&
+ (matchedNormalizedPrefix === undefined || matchedNormalizedPrefix.length < normalizedRoot.length);
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2, normalizedRoot, candidate, isLongestMatchingPrefix);
}
- if (!_jsxNamespace) {
- _jsxNamespace = "React";
- if (compilerOptions.jsxFactory) {
- _jsxFactoryEntity = ts.parseIsolatedEntityName(compilerOptions.jsxFactory, languageVersion);
- ts.visitNode(_jsxFactoryEntity, markAsSynthetic);
- if (_jsxFactoryEntity) {
- _jsxNamespace = ts.getFirstIdentifier(_jsxFactoryEntity).escapedText;
- }
+ if (isLongestMatchingPrefix) {
+ matchedNormalizedPrefix = normalizedRoot;
+ matchedRootDir = rootDir;
+ }
+ }
+ if (matchedNormalizedPrefix) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix);
+ }
+ var suffix = candidate.substr(matchedNormalizedPrefix.length);
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate);
+ }
+ var resolvedFileName = loader(extensions, candidate, !ts.directoryProbablyExists(containingDirectory, state.host), state);
+ if (resolvedFileName) {
+ return resolvedFileName;
+ }
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Trying_other_entries_in_rootDirs);
+ }
+ for (var _b = 0, _c = state.compilerOptions.rootDirs; _b < _c.length; _b++) {
+ var rootDir = _c[_b];
+ if (rootDir === matchedRootDir) {
+ continue;
}
- else if (compilerOptions.reactNamespace) {
- _jsxNamespace = ts.escapeLeadingUnderscores(compilerOptions.reactNamespace);
+ var candidate_1 = ts.combinePaths(ts.normalizePath(rootDir), suffix);
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate_1);
+ }
+ var baseDirectory = ts.getDirectoryPath(candidate_1);
+ var resolvedFileName_1 = loader(extensions, candidate_1, !ts.directoryProbablyExists(baseDirectory, state.host), state);
+ if (resolvedFileName_1) {
+ return resolvedFileName_1;
}
}
- if (!_jsxFactoryEntity) {
- _jsxFactoryEntity = ts.createQualifiedName(ts.createIdentifier(ts.unescapeLeadingUnderscores(_jsxNamespace)), "createElement");
- }
- return _jsxNamespace;
- function markAsSynthetic(node) {
- node.pos = -1;
- node.end = -1;
- return ts.visitEachChild(node, markAsSynthetic, ts.nullTransformationContext);
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Module_resolution_using_rootDirs_has_failed);
}
}
- function getEmitResolver(sourceFile, cancellationToken) {
- getDiagnostics(sourceFile, cancellationToken);
- return emitResolver;
+ return undefined;
+ }
+ function tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state) {
+ var baseUrl = state.compilerOptions.baseUrl;
+ if (!baseUrl) {
+ return undefined;
}
- function lookupOrIssueError(location, message, arg0, arg1, arg2, arg3) {
- var diagnostic = location
- ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3)
- : ts.createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
- var existing = diagnostics.lookup(diagnostic);
- if (existing) {
- return existing;
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName);
+ }
+ var candidate = ts.normalizePath(ts.combinePaths(baseUrl, moduleName));
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, baseUrl, candidate);
+ }
+ return loader(extensions, candidate, !ts.directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state);
+ }
+ function resolveJSModule(moduleName, initialDir, host) {
+ var _a = tryResolveJSModuleWorker(moduleName, initialDir, host), resolvedModule = _a.resolvedModule, failedLookupLocations = _a.failedLookupLocations;
+ if (!resolvedModule) {
+ throw new Error("Could not resolve JS module '" + moduleName + "' starting at '" + initialDir + "'. Looked in: " + failedLookupLocations.join(", "));
+ }
+ return resolvedModule.resolvedFileName;
+ }
+ ts.resolveJSModule = resolveJSModule;
+ function tryResolveJSModule(moduleName, initialDir, host) {
+ var resolvedModule = tryResolveJSModuleWorker(moduleName, initialDir, host).resolvedModule;
+ return resolvedModule && resolvedModule.resolvedFileName;
+ }
+ ts.tryResolveJSModule = tryResolveJSModule;
+ var jsOnlyExtensions = [Extensions.JavaScript];
+ var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript];
+ var tsPlusJsonExtensions = __spreadArrays(tsExtensions, [Extensions.Json]);
+ var tsconfigExtensions = [Extensions.TSConfig];
+ function tryResolveJSModuleWorker(moduleName, initialDir, host) {
+ return nodeModuleNameResolverWorker(moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, undefined, jsOnlyExtensions, undefined);
+ }
+ function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, lookupConfig) {
+ return nodeModuleNameResolverWorker(moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, lookupConfig ? tsconfigExtensions : (compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions), redirectedReference);
+ }
+ ts.nodeModuleNameResolver = nodeModuleNameResolver;
+ function nodeModuleNameResolverWorker(moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) {
+ var _a, _b;
+ var traceEnabled = isTraceEnabled(compilerOptions, host);
+ var failedLookupLocations = [];
+ var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations };
+ var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
+ return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, state.resultFromCache);
+ function tryResolve(extensions) {
+ var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, true); };
+ var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state);
+ if (resolved) {
+ return toSearchResult({ resolved: resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) });
+ }
+ if (!ts.isExternalModuleNameRelative(moduleName)) {
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions]);
+ }
+ var resolved_1 = loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, containingDirectory, state, cache, redirectedReference);
+ if (!resolved_1)
+ return undefined;
+ var resolvedValue = resolved_1.value;
+ if (!compilerOptions.preserveSymlinks && resolvedValue && !resolvedValue.originalPath) {
+ var path = realPath(resolvedValue.path, host, traceEnabled);
+ var originalPath = path === resolvedValue.path ? undefined : resolvedValue.path;
+ resolvedValue = __assign(__assign({}, resolvedValue), { path: path, originalPath: originalPath });
+ }
+ return { value: resolvedValue && { resolved: resolvedValue, isExternalLibraryImport: true } };
}
else {
- diagnostics.add(diagnostic);
- return diagnostic;
+ var _a = ts.normalizePathAndParts(ts.combinePaths(containingDirectory, moduleName)), candidate = _a.path, parts = _a.parts;
+ var resolved_2 = nodeLoadModuleByRelativeName(extensions, candidate, false, state, true);
+ return resolved_2 && toSearchResult({ resolved: resolved_2, isExternalLibraryImport: ts.contains(parts, "node_modules") });
}
}
- function error(location, message, arg0, arg1, arg2, arg3) {
- var diagnostic = location
- ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3)
- : ts.createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
- diagnostics.add(diagnostic);
- return diagnostic;
+ }
+ function realPath(path, host, traceEnabled) {
+ if (!host.realpath) {
+ return path;
}
- function addErrorOrSuggestion(isError, diagnostic) {
- if (isError) {
- diagnostics.add(diagnostic);
+ var real = ts.normalizePath(host.realpath(path));
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Resolving_real_path_for_0_result_1, path, real);
+ }
+ ts.Debug.assert(host.fileExists(real), path + " linked to nonexistent file " + real);
+ return real;
+ }
+ function nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, considerPackageJson) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1, candidate, Extensions[extensions]);
+ }
+ if (!ts.hasTrailingDirectorySeparator(candidate)) {
+ if (!onlyRecordFailures) {
+ var parentOfCandidate = ts.getDirectoryPath(candidate);
+ if (!ts.directoryProbablyExists(parentOfCandidate, state.host)) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, parentOfCandidate);
+ }
+ onlyRecordFailures = true;
+ }
}
- else {
- suggestionDiagnostics.add(__assign(__assign({}, diagnostic), { category: ts.DiagnosticCategory.Suggestion }));
+ var resolvedFromFile = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state);
+ if (resolvedFromFile) {
+ var packageDirectory = considerPackageJson ? parseNodeModuleFromPath(resolvedFromFile) : undefined;
+ var packageInfo = packageDirectory ? getPackageJsonInfo(packageDirectory, false, state) : undefined;
+ return withPackageId(packageInfo, resolvedFromFile);
}
}
- function errorOrSuggestion(isError, location, message, arg0, arg1, arg2, arg3) {
- addErrorOrSuggestion(isError, "message" in message ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : ts.createDiagnosticForNodeFromMessageChain(location, message));
- }
- function errorAndMaybeSuggestAwait(location, maybeMissingAwait, message, arg0, arg1, arg2, arg3) {
- var diagnostic = error(location, message, arg0, arg1, arg2, arg3);
- if (maybeMissingAwait) {
- var related = ts.createDiagnosticForNode(location, ts.Diagnostics.Did_you_forget_to_use_await);
- ts.addRelatedInfo(diagnostic, related);
+ if (!onlyRecordFailures) {
+ var candidateExists = ts.directoryProbablyExists(candidate, state.host);
+ if (!candidateExists) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidate);
+ }
+ onlyRecordFailures = true;
}
- return diagnostic;
}
- function createSymbol(flags, name, checkFlags) {
- symbolCount++;
- var symbol = (new Symbol(flags | 33554432, name));
- symbol.checkFlags = checkFlags || 0;
- return symbol;
+ return loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson);
+ }
+ ts.nodeModulesPathPart = "/node_modules/";
+ function pathContainsNodeModules(path) {
+ return ts.stringContains(path, ts.nodeModulesPathPart);
+ }
+ ts.pathContainsNodeModules = pathContainsNodeModules;
+ function parseNodeModuleFromPath(resolved) {
+ var path = ts.normalizePath(resolved.path);
+ var idx = path.lastIndexOf(ts.nodeModulesPathPart);
+ if (idx === -1) {
+ return undefined;
}
- function getExcludedSymbolFlags(flags) {
- var result = 0;
- if (flags & 2)
- result |= 111551;
- if (flags & 1)
- result |= 111550;
- if (flags & 4)
- result |= 0;
- if (flags & 8)
- result |= 900095;
- if (flags & 16)
- result |= 110991;
- if (flags & 32)
- result |= 899503;
- if (flags & 64)
- result |= 788872;
- if (flags & 256)
- result |= 899327;
- if (flags & 128)
- result |= 899967;
- if (flags & 512)
- result |= 110735;
- if (flags & 8192)
- result |= 103359;
- if (flags & 32768)
- result |= 46015;
- if (flags & 65536)
- result |= 78783;
- if (flags & 262144)
- result |= 526824;
- if (flags & 524288)
- result |= 788968;
- if (flags & 2097152)
- result |= 2097152;
- return result;
+ var indexAfterNodeModules = idx + ts.nodeModulesPathPart.length;
+ var indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterNodeModules);
+ if (path.charCodeAt(indexAfterNodeModules) === 64) {
+ indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterPackageName);
}
- function recordMergedSymbol(target, source) {
- if (!source.mergeId) {
- source.mergeId = nextMergeId;
- nextMergeId++;
+ return path.slice(0, indexAfterPackageName);
+ }
+ function moveToNextDirectorySeparatorIfAvailable(path, prevSeparatorIndex) {
+ var nextSeparatorIndex = path.indexOf(ts.directorySeparator, prevSeparatorIndex + 1);
+ return nextSeparatorIndex === -1 ? prevSeparatorIndex : nextSeparatorIndex;
+ }
+ function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) {
+ return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state));
+ }
+ function loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) {
+ if (extensions === Extensions.Json || extensions === Extensions.TSConfig) {
+ var extensionLess = ts.tryRemoveExtension(candidate, ".json");
+ return (extensionLess === undefined && extensions === Extensions.Json) ? undefined : tryAddingExtensions(extensionLess || candidate, extensions, onlyRecordFailures, state);
+ }
+ var resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, onlyRecordFailures, state);
+ if (resolvedByAddingExtension) {
+ return resolvedByAddingExtension;
+ }
+ if (ts.hasJSFileExtension(candidate)) {
+ var extensionless = ts.removeFileExtension(candidate);
+ if (state.traceEnabled) {
+ var extension = candidate.substring(extensionless.length);
+ trace(state.host, ts.Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
}
- mergedSymbols[source.mergeId] = target;
+ return tryAddingExtensions(extensionless, extensions, onlyRecordFailures, state);
}
- function cloneSymbol(symbol) {
- var result = createSymbol(symbol.flags, symbol.escapedName);
- result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
- result.parent = symbol.parent;
- if (symbol.valueDeclaration)
- result.valueDeclaration = symbol.valueDeclaration;
- if (symbol.constEnumOnlyModule)
- result.constEnumOnlyModule = true;
- if (symbol.members)
- result.members = ts.cloneMap(symbol.members);
- if (symbol.exports)
- result.exports = ts.cloneMap(symbol.exports);
- recordMergedSymbol(result, symbol);
- return result;
+ }
+ function tryAddingExtensions(candidate, extensions, onlyRecordFailures, state) {
+ if (!onlyRecordFailures) {
+ var directory = ts.getDirectoryPath(candidate);
+ if (directory) {
+ onlyRecordFailures = !ts.directoryProbablyExists(directory, state.host);
+ }
}
- function mergeSymbol(target, source, unidirectional) {
- if (unidirectional === void 0) { unidirectional = false; }
- if (!(target.flags & getExcludedSymbolFlags(source.flags)) ||
- (source.flags | target.flags) & 67108864) {
- if (source === target) {
- return target;
- }
- if (!(target.flags & 33554432)) {
- var resolvedTarget = resolveSymbol(target);
- if (resolvedTarget === unknownSymbol) {
- return source;
- }
- target = cloneSymbol(resolvedTarget);
- }
- if (source.flags & 512 && target.flags & 512 && target.constEnumOnlyModule && !source.constEnumOnlyModule) {
- target.constEnumOnlyModule = false;
- }
- target.flags |= source.flags;
- if (source.valueDeclaration) {
- ts.setValueDeclaration(target, source.valueDeclaration);
+ switch (extensions) {
+ case Extensions.DtsOnly:
+ return tryExtension(".d.ts");
+ case Extensions.TypeScript:
+ return tryExtension(".ts") || tryExtension(".tsx") || tryExtension(".d.ts");
+ case Extensions.JavaScript:
+ return tryExtension(".js") || tryExtension(".jsx");
+ case Extensions.TSConfig:
+ case Extensions.Json:
+ return tryExtension(".json");
+ }
+ function tryExtension(ext) {
+ var path = tryFile(candidate + ext, onlyRecordFailures, state);
+ return path === undefined ? undefined : { path: path, ext: ext };
+ }
+ }
+ function tryFile(fileName, onlyRecordFailures, state) {
+ if (!onlyRecordFailures) {
+ if (state.host.fileExists(fileName)) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
}
- ts.addRange(target.declarations, source.declarations);
- if (source.members) {
- if (!target.members)
- target.members = ts.createSymbolTable();
- mergeSymbolTable(target.members, source.members, unidirectional);
+ return fileName;
+ }
+ else {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.File_0_does_not_exist, fileName);
}
- if (source.exports) {
- if (!target.exports)
- target.exports = ts.createSymbolTable();
- mergeSymbolTable(target.exports, source.exports, unidirectional);
+ }
+ }
+ state.failedLookupLocations.push(fileName);
+ return undefined;
+ }
+ function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson) {
+ if (considerPackageJson === void 0) { considerPackageJson = true; }
+ var packageInfo = considerPackageJson ? getPackageJsonInfo(candidate, onlyRecordFailures, state) : undefined;
+ var packageJsonContent = packageInfo && packageInfo.packageJsonContent;
+ var versionPaths = packageInfo && packageInfo.versionPaths;
+ return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths));
+ }
+ function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
+ var host = state.host, traceEnabled = state.traceEnabled;
+ var directoryExists = !onlyRecordFailures && ts.directoryProbablyExists(packageDirectory, host);
+ var packageJsonPath = ts.combinePaths(packageDirectory, "package.json");
+ if (directoryExists && host.fileExists(packageJsonPath)) {
+ var packageJsonContent = ts.readJson(packageJsonPath, host);
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath);
+ }
+ var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
+ return { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths };
+ }
+ else {
+ if (directoryExists && traceEnabled) {
+ trace(host, ts.Diagnostics.File_0_does_not_exist, packageJsonPath);
+ }
+ state.failedLookupLocations.push(packageJsonPath);
+ }
+ }
+ function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
+ var packageFile;
+ if (jsonContent) {
+ switch (extensions) {
+ case Extensions.JavaScript:
+ case Extensions.Json:
+ packageFile = readPackageJsonMainField(jsonContent, candidate, state);
+ break;
+ case Extensions.TypeScript:
+ packageFile = readPackageJsonTypesFields(jsonContent, candidate, state) || readPackageJsonMainField(jsonContent, candidate, state);
+ break;
+ case Extensions.DtsOnly:
+ packageFile = readPackageJsonTypesFields(jsonContent, candidate, state);
+ break;
+ case Extensions.TSConfig:
+ packageFile = readPackageJsonTSConfigField(jsonContent, candidate, state);
+ break;
+ default:
+ return ts.Debug.assertNever(extensions);
+ }
+ }
+ var loader = function (extensions, candidate, onlyRecordFailures, state) {
+ var fromFile = tryFile(candidate, onlyRecordFailures, state);
+ if (fromFile) {
+ var resolved = resolvedIfExtensionMatches(extensions, fromFile);
+ if (resolved) {
+ return noPackageId(resolved);
}
- if (!unidirectional) {
- recordMergedSymbol(target, source);
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.File_0_has_an_unsupported_extension_so_skipping_it, fromFile);
}
}
- else if (target.flags & 1024) {
- if (target !== globalThisSymbol) {
- error(ts.getNameOfDeclaration(source.declarations[0]), ts.Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity, symbolToString(target));
- }
+ var nextExtensions = extensions === Extensions.DtsOnly ? Extensions.TypeScript : extensions;
+ return nodeLoadModuleByRelativeName(nextExtensions, candidate, onlyRecordFailures, state, false);
+ };
+ var onlyRecordFailuresForPackageFile = packageFile ? !ts.directoryProbablyExists(ts.getDirectoryPath(packageFile), state.host) : undefined;
+ var onlyRecordFailuresForIndex = onlyRecordFailures || !ts.directoryProbablyExists(candidate, state.host);
+ var indexPath = ts.combinePaths(candidate, extensions === Extensions.TSConfig ? "tsconfig" : "index");
+ if (versionPaths && (!packageFile || ts.containsPath(candidate, packageFile))) {
+ var moduleName = ts.getRelativePathFromDirectory(candidate, packageFile || indexPath, false);
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, ts.version, moduleName);
}
- else {
- var isEitherEnum = !!(target.flags & 384 || source.flags & 384);
- var isEitherBlockScoped_1 = !!(target.flags & 2 || source.flags & 2);
- var message = isEitherEnum
- ? ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations
- : isEitherBlockScoped_1
- ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
- : ts.Diagnostics.Duplicate_identifier_0;
- var sourceSymbolFile = source.declarations && ts.getSourceFileOfNode(source.declarations[0]);
- var targetSymbolFile = target.declarations && ts.getSourceFileOfNode(target.declarations[0]);
- var symbolName_1 = symbolToString(source);
- if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) {
- var firstFile_1 = ts.comparePaths(sourceSymbolFile.path, targetSymbolFile.path) === -1 ? sourceSymbolFile : targetSymbolFile;
- var secondFile_1 = firstFile_1 === sourceSymbolFile ? targetSymbolFile : sourceSymbolFile;
- var filesDuplicates = ts.getOrUpdate(amalgamatedDuplicates, firstFile_1.path + "|" + secondFile_1.path, function () {
- return ({ firstFile: firstFile_1, secondFile: secondFile_1, conflictingSymbols: ts.createMap() });
- });
- var conflictingSymbolInfo = ts.getOrUpdate(filesDuplicates.conflictingSymbols, symbolName_1, function () {
- return ({ isBlockScoped: isEitherBlockScoped_1, firstFileLocations: [], secondFileLocations: [] });
- });
- addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
- addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
+ var result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
+ if (result) {
+ return removeIgnoredPackageId(result.value);
+ }
+ }
+ var packageFileResult = packageFile && removeIgnoredPackageId(loader(extensions, packageFile, onlyRecordFailuresForPackageFile, state));
+ if (packageFileResult)
+ return packageFileResult;
+ return loadModuleFromFile(extensions, indexPath, onlyRecordFailuresForIndex, state);
+ }
+ function resolvedIfExtensionMatches(extensions, path) {
+ var ext = ts.tryGetExtensionFromPath(path);
+ return ext !== undefined && extensionIsOk(extensions, ext) ? { path: path, ext: ext } : undefined;
+ }
+ function extensionIsOk(extensions, extension) {
+ switch (extensions) {
+ case Extensions.JavaScript:
+ return extension === ".js" || extension === ".jsx";
+ case Extensions.TSConfig:
+ case Extensions.Json:
+ return extension === ".json";
+ case Extensions.TypeScript:
+ return extension === ".ts" || extension === ".tsx" || extension === ".d.ts";
+ case Extensions.DtsOnly:
+ return extension === ".d.ts";
+ }
+ }
+ function parsePackageName(moduleName) {
+ var idx = moduleName.indexOf(ts.directorySeparator);
+ if (moduleName[0] === "@") {
+ idx = moduleName.indexOf(ts.directorySeparator, idx + 1);
+ }
+ return idx === -1 ? { packageName: moduleName, rest: "" } : { packageName: moduleName.slice(0, idx), rest: moduleName.slice(idx + 1) };
+ }
+ ts.parsePackageName = parsePackageName;
+ function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) {
+ return loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, false, cache, redirectedReference);
+ }
+ function loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, directory, state) {
+ return loadModuleFromNearestNodeModulesDirectoryWorker(Extensions.DtsOnly, moduleName, directory, state, true, undefined, undefined);
+ }
+ function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
+ var perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, redirectedReference);
+ return ts.forEachAncestorDirectory(ts.normalizeSlashes(directory), function (ancestorDirectory) {
+ if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
+ var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
+ if (resolutionFromCache) {
+ return resolutionFromCache;
}
- else {
- addDuplicateDeclarationErrorsForSymbols(source, message, symbolName_1, target);
- addDuplicateDeclarationErrorsForSymbols(target, message, symbolName_1, source);
+ return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, ancestorDirectory, state, typesScopeOnly));
+ }
+ });
+ }
+ function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly) {
+ var nodeModulesFolder = ts.combinePaths(directory, "node_modules");
+ var nodeModulesFolderExists = ts.directoryProbablyExists(nodeModulesFolder, state.host);
+ if (!nodeModulesFolderExists && state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder);
+ }
+ var packageResult = typesScopeOnly ? undefined : loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state);
+ if (packageResult) {
+ return packageResult;
+ }
+ if (extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) {
+ var nodeModulesAtTypes_1 = ts.combinePaths(nodeModulesFolder, "@types");
+ var nodeModulesAtTypesExists = nodeModulesFolderExists;
+ if (nodeModulesFolderExists && !ts.directoryProbablyExists(nodeModulesAtTypes_1, state.host)) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesAtTypes_1);
}
+ nodeModulesAtTypesExists = false;
}
- return target;
- function addDuplicateLocations(locs, symbol) {
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var decl = _a[_i];
- ts.pushIfUnique(locs, decl);
+ return loadModuleFromSpecificNodeModulesDirectory(Extensions.DtsOnly, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes_1, nodeModulesAtTypesExists, state);
+ }
+ }
+ function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state) {
+ var candidate = ts.normalizePath(ts.combinePaths(nodeModulesDirectory, moduleName));
+ var packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state);
+ if (packageInfo) {
+ var fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
+ if (fromFile) {
+ return noPackageId(fromFile);
+ }
+ var fromDirectory = loadNodeModuleFromDirectoryWorker(extensions, candidate, !nodeModulesDirectoryExists, state, packageInfo.packageJsonContent, packageInfo.versionPaths);
+ return withPackageId(packageInfo, fromDirectory);
+ }
+ var loader = function (extensions, candidate, onlyRecordFailures, state) {
+ var pathAndExtension = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) ||
+ loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo && packageInfo.packageJsonContent, packageInfo && packageInfo.versionPaths);
+ return withPackageId(packageInfo, pathAndExtension);
+ };
+ var _a = parsePackageName(moduleName), packageName = _a.packageName, rest = _a.rest;
+ if (rest !== "") {
+ var packageDirectory = ts.combinePaths(nodeModulesDirectory, packageName);
+ packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
+ if (packageInfo && packageInfo.versionPaths) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, packageInfo.versionPaths.version, ts.version, rest);
+ }
+ var packageDirectoryExists = nodeModulesDirectoryExists && ts.directoryProbablyExists(packageDirectory, state.host);
+ var fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.versionPaths.paths, loader, !packageDirectoryExists, state);
+ if (fromPaths) {
+ return fromPaths.value;
}
}
}
- function addDuplicateDeclarationErrorsForSymbols(target, message, symbolName, source) {
- ts.forEach(target.declarations, function (node) {
- addDuplicateDeclarationError(node, message, symbolName, source.declarations);
+ return loader(extensions, candidate, !nodeModulesDirectoryExists, state);
+ }
+ function tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, loader, onlyRecordFailures, state) {
+ var matchedPattern = ts.matchPatternOrExact(ts.getOwnKeys(paths), moduleName);
+ if (matchedPattern) {
+ var matchedStar_1 = ts.isString(matchedPattern) ? undefined : ts.matchedText(matchedPattern, moduleName);
+ var matchedPatternText = ts.isString(matchedPattern) ? matchedPattern : ts.patternText(matchedPattern);
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
+ }
+ var resolved = ts.forEach(paths[matchedPatternText], function (subst) {
+ var path = matchedStar_1 ? subst.replace("*", matchedStar_1) : subst;
+ var candidate = ts.normalizePath(ts.combinePaths(baseDirectory, path));
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path);
+ }
+ var extension = ts.tryGetExtensionFromPath(candidate);
+ if (extension !== undefined) {
+ var path_1 = tryFile(candidate, onlyRecordFailures, state);
+ if (path_1 !== undefined) {
+ return noPackageId({ path: path_1, ext: extension });
+ }
+ }
+ return loader(extensions, candidate, onlyRecordFailures || !ts.directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state);
});
+ return { value: resolved };
}
- function addDuplicateDeclarationError(node, message, symbolName, relatedNodes) {
- var errorNode = (ts.getExpandoInitializer(node, false) ? ts.getNameOfExpando(node) : ts.getNameOfDeclaration(node)) || node;
- var err = lookupOrIssueError(errorNode, message, symbolName);
- var _loop_6 = function (relatedNode) {
- var adjustedNode = (ts.getExpandoInitializer(relatedNode, false) ? ts.getNameOfExpando(relatedNode) : ts.getNameOfDeclaration(relatedNode)) || relatedNode;
- if (adjustedNode === errorNode)
- return "continue";
- err.relatedInformation = err.relatedInformation || [];
- var leadingMessage = ts.createDiagnosticForNode(adjustedNode, ts.Diagnostics._0_was_also_declared_here, symbolName);
- var followOnMessage = ts.createDiagnosticForNode(adjustedNode, ts.Diagnostics.and_here);
- if (ts.length(err.relatedInformation) >= 5 || ts.some(err.relatedInformation, function (r) { return ts.compareDiagnostics(r, followOnMessage) === 0 || ts.compareDiagnostics(r, leadingMessage) === 0; }))
- return "continue";
- ts.addRelatedInfo(err, !ts.length(err.relatedInformation) ? leadingMessage : followOnMessage);
- };
- for (var _i = 0, _a = relatedNodes || ts.emptyArray; _i < _a.length; _i++) {
- var relatedNode = _a[_i];
- _loop_6(relatedNode);
- }
+ }
+ var mangledScopedPackageSeparator = "__";
+ function mangleScopedPackageNameWithTrace(packageName, state) {
+ var mangled = mangleScopedPackageName(packageName);
+ if (state.traceEnabled && mangled !== packageName) {
+ trace(state.host, ts.Diagnostics.Scoped_package_detected_looking_in_0, mangled);
}
- function combineSymbolTables(first, second) {
- if (!ts.hasEntries(first))
- return second;
- if (!ts.hasEntries(second))
- return first;
- var combined = ts.createSymbolTable();
- mergeSymbolTable(combined, first);
- mergeSymbolTable(combined, second);
- return combined;
+ return mangled;
+ }
+ function getTypesPackageName(packageName) {
+ return "@types/" + mangleScopedPackageName(packageName);
+ }
+ ts.getTypesPackageName = getTypesPackageName;
+ function mangleScopedPackageName(packageName) {
+ if (ts.startsWith(packageName, "@")) {
+ var replaceSlash = packageName.replace(ts.directorySeparator, mangledScopedPackageSeparator);
+ if (replaceSlash !== packageName) {
+ return replaceSlash.slice(1);
+ }
}
- function mergeSymbolTable(target, source, unidirectional) {
- if (unidirectional === void 0) { unidirectional = false; }
- source.forEach(function (sourceSymbol, id) {
- var targetSymbol = target.get(id);
- target.set(id, targetSymbol ? mergeSymbol(targetSymbol, sourceSymbol, unidirectional) : sourceSymbol);
- });
+ return packageName;
+ }
+ ts.mangleScopedPackageName = mangleScopedPackageName;
+ function getPackageNameFromTypesPackageName(mangledName) {
+ var withoutAtTypePrefix = ts.removePrefix(mangledName, "@types/");
+ if (withoutAtTypePrefix !== mangledName) {
+ return unmangleScopedPackageName(withoutAtTypePrefix);
}
- function mergeModuleAugmentation(moduleName) {
- var _a, _b;
- var moduleAugmentation = moduleName.parent;
- if (moduleAugmentation.symbol.declarations[0] !== moduleAugmentation) {
- ts.Debug.assert(moduleAugmentation.symbol.declarations.length > 1);
- return;
+ return mangledName;
+ }
+ ts.getPackageNameFromTypesPackageName = getPackageNameFromTypesPackageName;
+ function unmangleScopedPackageName(typesPackageName) {
+ return ts.stringContains(typesPackageName, mangledScopedPackageSeparator) ?
+ "@" + typesPackageName.replace(mangledScopedPackageSeparator, ts.directorySeparator) :
+ typesPackageName;
+ }
+ ts.unmangleScopedPackageName = unmangleScopedPackageName;
+ function tryFindNonRelativeModuleNameInCache(cache, moduleName, containingDirectory, state) {
+ var result = cache && cache.get(containingDirectory);
+ if (result) {
+ if (state.traceEnabled) {
+ trace(state.host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
}
- if (ts.isGlobalScopeAugmentation(moduleAugmentation)) {
- mergeSymbolTable(globals, moduleAugmentation.symbol.exports);
+ state.resultFromCache = result;
+ return { value: result.resolvedModule && { path: result.resolvedModule.resolvedFileName, originalPath: result.resolvedModule.originalPath || true, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId } };
+ }
+ }
+ function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
+ var traceEnabled = isTraceEnabled(compilerOptions, host);
+ var failedLookupLocations = [];
+ var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations };
+ var containingDirectory = ts.getDirectoryPath(containingFile);
+ var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
+ return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, false, failedLookupLocations, state.resultFromCache);
+ function tryResolve(extensions) {
+ var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
+ if (resolvedUsingSettings) {
+ return { value: resolvedUsingSettings };
}
- else {
- var moduleNotFoundError = !(moduleName.parent.parent.flags & 8388608)
- ? ts.Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found
- : undefined;
- var mainModule_1 = resolveExternalModuleNameWorker(moduleName, moduleName, moduleNotFoundError, true);
- if (!mainModule_1) {
- return;
- }
- mainModule_1 = resolveExternalModuleSymbol(mainModule_1);
- if (mainModule_1.flags & 1920) {
- if (ts.some(patternAmbientModules, function (module) { return mainModule_1 === module.symbol; })) {
- var merged = mergeSymbol(moduleAugmentation.symbol, mainModule_1, true);
- if (!patternAmbientModuleAugmentations) {
- patternAmbientModuleAugmentations = ts.createMap();
- }
- patternAmbientModuleAugmentations.set(moduleName.text, merged);
- }
- else {
- if (((_a = mainModule_1.exports) === null || _a === void 0 ? void 0 : _a.get("__export")) && ((_b = moduleAugmentation.symbol.exports) === null || _b === void 0 ? void 0 : _b.size)) {
- var resolvedExports = getResolvedMembersOrExportsOfSymbol(mainModule_1, "resolvedExports");
- for (var _i = 0, _c = ts.arrayFrom(moduleAugmentation.symbol.exports.entries()); _i < _c.length; _i++) {
- var _d = _c[_i], key = _d[0], value = _d[1];
- if (resolvedExports.has(key) && !mainModule_1.exports.has(key)) {
- mergeSymbol(resolvedExports.get(key), value);
- }
- }
- }
- mergeSymbol(mainModule_1, moduleAugmentation.symbol);
+ if (!ts.isExternalModuleNameRelative(moduleName)) {
+ var perModuleNameCache_1 = cache && cache.getOrCreateCacheForModuleName(moduleName, redirectedReference);
+ var resolved_3 = ts.forEachAncestorDirectory(containingDirectory, function (directory) {
+ var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache_1, moduleName, directory, state);
+ if (resolutionFromCache) {
+ return resolutionFromCache;
}
+ var searchName = ts.normalizePath(ts.combinePaths(directory, moduleName));
+ return toSearchResult(loadModuleFromFileNoPackageId(extensions, searchName, false, state));
+ });
+ if (resolved_3) {
+ return resolved_3;
}
- else {
- error(moduleName, ts.Diagnostics.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity, moduleName.text);
+ if (extensions === Extensions.TypeScript) {
+ return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
}
}
- }
- function addToSymbolTable(target, source, message) {
- source.forEach(function (sourceSymbol, id) {
- var targetSymbol = target.get(id);
- if (targetSymbol) {
- ts.forEach(targetSymbol.declarations, addDeclarationDiagnostic(ts.unescapeLeadingUnderscores(id), message));
- }
- else {
- target.set(id, sourceSymbol);
- }
- });
- function addDeclarationDiagnostic(id, message) {
- return function (declaration) { return diagnostics.add(ts.createDiagnosticForNode(declaration, message, id)); };
+ else {
+ var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName));
+ return toSearchResult(loadModuleFromFileNoPackageId(extensions, candidate, false, state));
}
}
- function getSymbolLinks(symbol) {
- if (symbol.flags & 33554432)
- return symbol;
- var id = getSymbolId(symbol);
- return symbolLinks[id] || (symbolLinks[id] = new SymbolLinks());
+ }
+ ts.classicNameResolver = classicNameResolver;
+ function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, host, globalCache) {
+ var traceEnabled = isTraceEnabled(compilerOptions, host);
+ if (traceEnabled) {
+ trace(host, ts.Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache);
}
- function getNodeLinks(node) {
- var nodeId = getNodeId(node);
- return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
+ var failedLookupLocations = [];
+ var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations };
+ var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, false);
+ return createResolvedModuleWithFailedLookupLocations(resolved, true, failedLookupLocations, state.resultFromCache);
+ }
+ ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache;
+ function toSearchResult(value) {
+ return value !== undefined ? { value: value } : undefined;
+ }
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function getModuleInstanceState(node, visited) {
+ if (node.body && !node.body.parent) {
+ ts.setParent(node.body, node);
+ ts.setParentRecursive(node.body, false);
}
- function isGlobalSourceFile(node) {
- return node.kind === 290 && !ts.isExternalOrCommonJsModule(node);
+ return node.body ? getModuleInstanceStateCached(node.body, visited) : 1;
+ }
+ ts.getModuleInstanceState = getModuleInstanceState;
+ function getModuleInstanceStateCached(node, visited) {
+ if (visited === void 0) { visited = new ts.Map(); }
+ var nodeId = ts.getNodeId(node);
+ if (visited.has(nodeId)) {
+ return visited.get(nodeId) || 0;
}
- function getSymbol(symbols, name, meaning) {
- if (meaning) {
- var symbol = getMergedSymbol(symbols.get(name));
- if (symbol) {
- ts.Debug.assert((ts.getCheckFlags(symbol) & 1) === 0, "Should never get an instantiated symbol here.");
- if (symbol.flags & meaning) {
- return symbol;
- }
- if (symbol.flags & 2097152) {
- var target = resolveAlias(symbol);
- if (target === unknownSymbol || target.flags & meaning) {
- return symbol;
+ visited.set(nodeId, undefined);
+ var result = getModuleInstanceStateWorker(node, visited);
+ visited.set(nodeId, result);
+ return result;
+ }
+ function getModuleInstanceStateWorker(node, visited) {
+ switch (node.kind) {
+ case 253:
+ case 254:
+ return 0;
+ case 255:
+ if (ts.isEnumConst(node)) {
+ return 2;
+ }
+ break;
+ case 261:
+ case 260:
+ if (!(ts.hasSyntacticModifier(node, 1))) {
+ return 0;
+ }
+ break;
+ case 267:
+ var exportDeclaration = node;
+ if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === 268) {
+ var state = 0;
+ for (var _i = 0, _a = exportDeclaration.exportClause.elements; _i < _a.length; _i++) {
+ var specifier = _a[_i];
+ var specifierState = getModuleInstanceStateForAliasTarget(specifier, visited);
+ if (specifierState > state) {
+ state = specifierState;
+ }
+ if (state === 1) {
+ return state;
}
}
+ return state;
}
+ break;
+ case 257: {
+ var state_1 = 0;
+ ts.forEachChild(node, function (n) {
+ var childState = getModuleInstanceStateCached(n, visited);
+ switch (childState) {
+ case 0:
+ return;
+ case 2:
+ state_1 = 2;
+ return;
+ case 1:
+ state_1 = 1;
+ return true;
+ default:
+ ts.Debug.assertNever(childState);
+ }
+ });
+ return state_1;
}
- }
- function getSymbolsOfParameterPropertyDeclaration(parameter, parameterName) {
- var constructorDeclaration = parameter.parent;
- var classDeclaration = parameter.parent.parent;
- var parameterSymbol = getSymbol(constructorDeclaration.locals, parameterName, 111551);
- var propertySymbol = getSymbol(getMembersOfSymbol(classDeclaration.symbol), parameterName, 111551);
- if (parameterSymbol && propertySymbol) {
- return [parameterSymbol, propertySymbol];
- }
- return ts.Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration");
- }
- function isBlockScopedNameDeclaredBeforeUse(declaration, usage) {
- var declarationFile = ts.getSourceFileOfNode(declaration);
- var useFile = ts.getSourceFileOfNode(usage);
- var declContainer = ts.getEnclosingBlockScopeContainer(declaration);
- if (declarationFile !== useFile) {
- if ((moduleKind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator)) ||
- (!compilerOptions.outFile && !compilerOptions.out) ||
- isInTypeQuery(usage) ||
- declaration.flags & 8388608) {
- return true;
- }
- if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
- return true;
+ case 256:
+ return getModuleInstanceState(node, visited);
+ case 78:
+ if (node.isInJSDocNamespace) {
+ return 0;
}
- var sourceFiles = host.getSourceFiles();
- return sourceFiles.indexOf(declarationFile) <= sourceFiles.indexOf(useFile);
- }
- if (declaration.pos <= usage.pos) {
- if (declaration.kind === 191) {
- var errorBindingElement = ts.getAncestor(usage, 191);
- if (errorBindingElement) {
- return ts.findAncestor(errorBindingElement, ts.isBindingElement) !== ts.findAncestor(declaration, ts.isBindingElement) ||
- declaration.pos < errorBindingElement.pos;
+ }
+ return 1;
+ }
+ function getModuleInstanceStateForAliasTarget(specifier, visited) {
+ var name = specifier.propertyName || specifier.name;
+ var p = specifier.parent;
+ while (p) {
+ if (ts.isBlock(p) || ts.isModuleBlock(p) || ts.isSourceFile(p)) {
+ var statements = p.statements;
+ var found = void 0;
+ for (var _i = 0, statements_2 = statements; _i < statements_2.length; _i++) {
+ var statement = statements_2[_i];
+ if (ts.nodeHasName(statement, name)) {
+ if (!statement.parent) {
+ ts.setParent(statement, p);
+ ts.setParentRecursive(statement, false);
+ }
+ var state = getModuleInstanceStateCached(statement, visited);
+ if (found === undefined || state > found) {
+ found = state;
+ }
+ if (found === 1) {
+ return found;
+ }
}
- return isBlockScopedNameDeclaredBeforeUse(ts.getAncestor(declaration, 242), usage);
- }
- else if (declaration.kind === 242) {
- return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage);
- }
- else if (ts.isClassDeclaration(declaration)) {
- return !ts.findAncestor(usage, function (n) { return ts.isComputedPropertyName(n) && n.parent.parent === declaration; });
- }
- else if (ts.isPropertyDeclaration(declaration)) {
- return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, false);
}
- else if (ts.isParameterPropertyDeclaration(declaration, declaration.parent)) {
- return !(compilerOptions.target === 99 && !!compilerOptions.useDefineForClassFields
- && ts.getContainingClass(declaration) === ts.getContainingClass(usage)
- && isUsedInFunctionOrInstanceProperty(usage, declaration));
+ if (found !== undefined) {
+ return found;
}
- return true;
}
- if (usage.parent.kind === 263 || (usage.parent.kind === 259 && usage.parent.isExportEquals)) {
- return true;
- }
- if (usage.kind === 259 && usage.isExportEquals) {
- return true;
+ p = p.parent;
+ }
+ return 1;
+ }
+ function initFlowNode(node) {
+ ts.Debug.attachFlowNodeDebugInfo(node);
+ return node;
+ }
+ var binder = createBinder();
+ function bindSourceFile(file, options) {
+ var tracingData = ["bind", "bindSourceFile", { path: file.path }];
+ ts.tracing.begin.apply(ts.tracing, tracingData);
+ ts.performance.mark("beforeBind");
+ ts.perfLogger.logStartBindFile("" + file.fileName);
+ binder(file, options);
+ ts.perfLogger.logStopBindFile();
+ ts.performance.mark("afterBind");
+ ts.performance.measure("Bind", "beforeBind", "afterBind");
+ ts.tracing.end.apply(ts.tracing, tracingData);
+ }
+ ts.bindSourceFile = bindSourceFile;
+ function createBinder() {
+ var file;
+ var options;
+ var languageVersion;
+ var parent;
+ var container;
+ var thisParentContainer;
+ var blockScopeContainer;
+ var lastContainer;
+ var delayedTypeAliases;
+ var seenThisKeyword;
+ var currentFlow;
+ var currentBreakTarget;
+ var currentContinueTarget;
+ var currentReturnTarget;
+ var currentTrueTarget;
+ var currentFalseTarget;
+ var currentExceptionTarget;
+ var preSwitchCaseFlow;
+ var activeLabelList;
+ var hasExplicitReturn;
+ var emitFlags;
+ var inStrictMode;
+ var inAssignmentPattern = false;
+ var symbolCount = 0;
+ var Symbol;
+ var classifiableNames;
+ var unreachableFlow = { flags: 1 };
+ var reportedUnreachableFlow = { flags: 1 };
+ function createDiagnosticForNode(node, message, arg0, arg1, arg2) {
+ return ts.createDiagnosticForNodeInSourceFile(ts.getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);
+ }
+ function bindSourceFile(f, opts) {
+ file = f;
+ options = opts;
+ languageVersion = ts.getEmitScriptTarget(options);
+ inStrictMode = bindInStrictMode(file, opts);
+ classifiableNames = new ts.Set();
+ symbolCount = 0;
+ Symbol = ts.objectAllocator.getSymbolConstructor();
+ ts.Debug.attachFlowNodeDebugInfo(unreachableFlow);
+ ts.Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);
+ if (!file.locals) {
+ bind(file);
+ file.symbolCount = symbolCount;
+ file.classifiableNames = classifiableNames;
+ delayedBindJSDocTypedefTag();
}
- if (!!(usage.flags & 4194304) || isInTypeQuery(usage) || usageInTypeDeclaration()) {
+ file = undefined;
+ options = undefined;
+ languageVersion = undefined;
+ parent = undefined;
+ container = undefined;
+ thisParentContainer = undefined;
+ blockScopeContainer = undefined;
+ lastContainer = undefined;
+ delayedTypeAliases = undefined;
+ seenThisKeyword = false;
+ currentFlow = undefined;
+ currentBreakTarget = undefined;
+ currentContinueTarget = undefined;
+ currentReturnTarget = undefined;
+ currentTrueTarget = undefined;
+ currentFalseTarget = undefined;
+ currentExceptionTarget = undefined;
+ activeLabelList = undefined;
+ hasExplicitReturn = false;
+ inAssignmentPattern = false;
+ emitFlags = 0;
+ }
+ return bindSourceFile;
+ function bindInStrictMode(file, opts) {
+ if (ts.getStrictOptionValue(opts, "alwaysStrict") && !file.isDeclarationFile) {
return true;
}
- if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
- if (compilerOptions.target === 99 && !!compilerOptions.useDefineForClassFields
- && ts.getContainingClass(declaration)
- && (ts.isPropertyDeclaration(declaration) || ts.isParameterPropertyDeclaration(declaration, declaration.parent))) {
- return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, true);
- }
- else {
- return true;
- }
- }
- return false;
- function usageInTypeDeclaration() {
- return !!ts.findAncestor(usage, function (node) { return ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node); });
+ else {
+ return !!file.externalModuleIndicator;
}
- function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage) {
- switch (declaration.parent.parent.kind) {
- case 225:
- case 230:
- case 232:
- if (isSameScopeDescendentOf(usage, declaration, declContainer)) {
- return true;
- }
- break;
- }
- var grandparent = declaration.parent.parent;
- return ts.isForInOrOfStatement(grandparent) && isSameScopeDescendentOf(usage, grandparent.expression, declContainer);
+ }
+ function createSymbol(flags, name) {
+ symbolCount++;
+ return new Symbol(flags, name);
+ }
+ function addDeclarationToSymbol(symbol, node, symbolFlags) {
+ symbol.flags |= symbolFlags;
+ node.symbol = symbol;
+ symbol.declarations = ts.appendIfUnique(symbol.declarations, node);
+ if (symbolFlags & (32 | 384 | 1536 | 3) && !symbol.exports) {
+ symbol.exports = ts.createSymbolTable();
}
- function isUsedInFunctionOrInstanceProperty(usage, declaration) {
- return !!ts.findAncestor(usage, function (current) {
- if (current === declContainer) {
- return "quit";
- }
- if (ts.isFunctionLike(current)) {
- return true;
- }
- var initializerOfProperty = current.parent &&
- current.parent.kind === 159 &&
- current.parent.initializer === current;
- if (initializerOfProperty) {
- if (ts.hasModifier(current.parent, 32)) {
- if (declaration.kind === 161) {
- return true;
- }
- }
- else {
- var isDeclarationInstanceProperty = declaration.kind === 159 && !ts.hasModifier(declaration, 32);
- if (!isDeclarationInstanceProperty || ts.getContainingClass(usage) !== ts.getContainingClass(declaration)) {
- return true;
- }
- }
- }
- return false;
- });
+ if (symbolFlags & (32 | 64 | 2048 | 4096) && !symbol.members) {
+ symbol.members = ts.createSymbolTable();
}
- function isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, stopAtAnyPropertyDeclaration) {
- if (usage.end > declaration.end) {
- return false;
+ if (symbol.constEnumOnlyModule && (symbol.flags & (16 | 32 | 256))) {
+ symbol.constEnumOnlyModule = false;
+ }
+ if (symbolFlags & 111551) {
+ ts.setValueDeclaration(symbol, node);
+ }
+ }
+ function getDeclarationName(node) {
+ if (node.kind === 266) {
+ return node.isExportEquals ? "export=" : "default";
+ }
+ var name = ts.getNameOfDeclaration(node);
+ if (name) {
+ if (ts.isAmbientModule(node)) {
+ var moduleName = ts.getTextOfIdentifierOrLiteral(name);
+ return (ts.isGlobalScopeAugmentation(node) ? "__global" : "\"" + moduleName + "\"");
}
- var ancestorChangingReferenceScope = ts.findAncestor(usage, function (node) {
- if (node === declaration) {
- return "quit";
+ if (name.kind === 158) {
+ var nameExpression = name.expression;
+ if (ts.isStringOrNumericLiteralLike(nameExpression)) {
+ return ts.escapeLeadingUnderscores(nameExpression.text);
}
- switch (node.kind) {
- case 202:
- return true;
- case 159:
- return stopAtAnyPropertyDeclaration &&
- (ts.isPropertyDeclaration(declaration) && node.parent === declaration.parent
- || ts.isParameterPropertyDeclaration(declaration, declaration.parent) && node.parent === declaration.parent.parent)
- ? "quit" : true;
- case 223:
- switch (node.parent.kind) {
- case 163:
- case 161:
- case 164:
- return true;
- default:
- return false;
- }
- default:
- return false;
+ if (ts.isSignedNumericLiteral(nameExpression)) {
+ return ts.tokenToString(nameExpression.operator) + nameExpression.operand.text;
}
- });
- return ancestorChangingReferenceScope === undefined;
- }
- }
- function useOuterVariableScopeInParameter(result, location, lastLocation) {
- var target = ts.getEmitScriptTarget(compilerOptions);
- var functionLocation = location;
- if (ts.isParameter(lastLocation) && functionLocation.body && result.valueDeclaration.pos >= functionLocation.body.pos && result.valueDeclaration.end <= functionLocation.body.end) {
- if (target >= 2) {
- var links = getNodeLinks(functionLocation);
- if (links.declarationRequiresScopeChange === undefined) {
- links.declarationRequiresScopeChange = ts.forEach(functionLocation.parameters, requiresScopeChange) || false;
+ ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression));
+ return ts.getPropertyNameForKnownSymbolName(ts.idText(nameExpression.name));
+ }
+ if (ts.isWellKnownSymbolSyntactically(name)) {
+ return ts.getPropertyNameForKnownSymbolName(ts.idText(name.name));
+ }
+ if (ts.isPrivateIdentifier(name)) {
+ var containingClass = ts.getContainingClass(node);
+ if (!containingClass) {
+ return undefined;
}
- return !links.declarationRequiresScopeChange;
+ var containingClassSymbol = containingClass.symbol;
+ return ts.getSymbolNameForPrivateIdentifier(containingClassSymbol, name.escapedText);
}
+ return ts.isPropertyNameLiteral(name) ? ts.getEscapedTextOfIdentifierOrLiteral(name) : undefined;
}
- return false;
- function requiresScopeChange(node) {
- return requiresScopeChangeWorker(node.name)
- || !!node.initializer && requiresScopeChangeWorker(node.initializer);
- }
- function requiresScopeChangeWorker(node) {
- switch (node.kind) {
- case 202:
- case 201:
- case 244:
- case 162:
- return false;
- case 161:
- case 163:
- case 164:
- case 281:
- return requiresScopeChangeWorker(node.name);
- case 159:
- if (ts.hasStaticModifier(node)) {
- return target < 99 || !compilerOptions.useDefineForClassFields;
- }
- return requiresScopeChangeWorker(node.name);
- default:
- if (ts.isNullishCoalesce(node) || ts.isOptionalChain(node)) {
- return target < 7;
- }
- if (ts.isBindingElement(node) && node.dotDotDotToken && ts.isObjectBindingPattern(node.parent)) {
- return target < 4;
- }
- if (ts.isTypeNode(node))
- return false;
- return ts.forEachChild(node, requiresScopeChangeWorker) || false;
- }
+ switch (node.kind) {
+ case 166:
+ return "__constructor";
+ case 174:
+ case 169:
+ case 313:
+ return "__call";
+ case 175:
+ case 170:
+ return "__new";
+ case 171:
+ return "__index";
+ case 267:
+ return "__export";
+ case 297:
+ return "export=";
+ case 216:
+ if (ts.getAssignmentDeclarationKind(node) === 2) {
+ return "export=";
+ }
+ ts.Debug.fail("Unknown binary declaration kind");
+ break;
+ case 308:
+ return (ts.isJSDocConstructSignature(node) ? "__new" : "__call");
+ case 160:
+ ts.Debug.assert(node.parent.kind === 308, "Impossible parameter parent kind", function () { return "parent is: " + (ts.SyntaxKind ? ts.SyntaxKind[node.parent.kind] : node.parent.kind) + ", expected JSDocFunctionType"; });
+ var functionType = node.parent;
+ var index = functionType.parameters.indexOf(node);
+ return "arg" + index;
}
}
- function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, suggestedNameNotFoundMessage) {
- if (excludeGlobals === void 0) { excludeGlobals = false; }
- return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSymbol, suggestedNameNotFoundMessage);
+ function getDisplayName(node) {
+ return ts.isNamedDeclaration(node) ? ts.declarationNameToString(node.name) : ts.unescapeLeadingUnderscores(ts.Debug.checkDefined(getDeclarationName(node)));
}
- function resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, lookup, suggestedNameNotFoundMessage) {
- var originalLocation = location;
- var result;
- var lastLocation;
- var lastSelfReferenceLocation;
- var propertyWithInvalidInitializer;
- var associatedDeclarationForContainingInitializerOrBindingName;
- var withinDeferredContext = false;
- var errorLocation = location;
- var grandparent;
- var isInExternalModule = false;
- loop: while (location) {
- if (location.locals && !isGlobalSourceFile(location)) {
- if (result = lookup(location.locals, name, meaning)) {
- var useResult = true;
- if (ts.isFunctionLike(location) && lastLocation && lastLocation !== location.body) {
- if (meaning & result.flags & 788968 && lastLocation.kind !== 303) {
- useResult = result.flags & 262144
- ? lastLocation === location.type ||
- lastLocation.kind === 156 ||
- lastLocation.kind === 155
- : false;
- }
- if (meaning & result.flags & 3) {
- if (useOuterVariableScopeInParameter(result, location, lastLocation)) {
- useResult = false;
- }
- else if (result.flags & 1) {
- useResult =
- lastLocation.kind === 156 ||
- (lastLocation === location.type &&
- !!ts.findAncestor(result.valueDeclaration, ts.isParameter));
- }
- }
- }
- else if (location.kind === 180) {
- useResult = lastLocation === location.trueType;
- }
- if (useResult) {
- break loop;
- }
- else {
- result = undefined;
- }
- }
+ function declareSymbol(symbolTable, parent, node, includes, excludes, isReplaceableByMethod) {
+ ts.Debug.assert(!ts.hasDynamicName(node));
+ var isDefaultExport = ts.hasSyntacticModifier(node, 512) || ts.isExportSpecifier(node) && node.name.escapedText === "default";
+ var name = isDefaultExport && parent ? "default" : getDeclarationName(node);
+ var symbol;
+ if (name === undefined) {
+ symbol = createSymbol(0, "__missing");
+ }
+ else {
+ symbol = symbolTable.get(name);
+ if (includes & 2885600) {
+ classifiableNames.add(name);
}
- withinDeferredContext = withinDeferredContext || getIsDeferredContext(location, lastLocation);
- switch (location.kind) {
- case 290:
- if (!ts.isExternalOrCommonJsModule(location))
- break;
- isInExternalModule = true;
- case 249:
- var moduleExports = getSymbolOfNode(location).exports || emptySymbols;
- if (location.kind === 290 || (ts.isModuleDeclaration(location) && location.flags & 8388608 && !ts.isGlobalScopeAugmentation(location))) {
- if (result = moduleExports.get("default")) {
- var localSymbol = ts.getLocalSymbolForExportDefault(result);
- if (localSymbol && (result.flags & meaning) && localSymbol.escapedName === name) {
- break loop;
- }
- result = undefined;
- }
- var moduleExport = moduleExports.get(name);
- if (moduleExport &&
- moduleExport.flags === 2097152 &&
- (ts.getDeclarationOfKind(moduleExport, 263) || ts.getDeclarationOfKind(moduleExport, 262))) {
- break;
- }
- }
- if (name !== "default" && (result = lookup(moduleExports, name, meaning & 2623475))) {
- if (ts.isSourceFile(location) && location.commonJsModuleIndicator && !result.declarations.some(ts.isJSDocTypeAlias)) {
- result = undefined;
- }
- else {
- break loop;
- }
- }
- break;
- case 248:
- if (result = lookup(getSymbolOfNode(location).exports, name, meaning & 8)) {
- break loop;
- }
- break;
- case 159:
- if (!ts.hasModifier(location, 32)) {
- var ctor = findConstructorDeclaration(location.parent);
- if (ctor && ctor.locals) {
- if (lookup(ctor.locals, name, meaning & 111551)) {
- propertyWithInvalidInitializer = location;
- }
- }
+ if (!symbol) {
+ symbolTable.set(name, symbol = createSymbol(0, 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, name));
+ }
+ else if (!(includes & 3 && symbol.flags & 67108864)) {
+ if (ts.isNamedDeclaration(node)) {
+ ts.setParent(node.name, node);
}
- break;
- case 245:
- case 214:
- case 246:
- if (result = lookup(getSymbolOfNode(location).members || emptySymbols, name, meaning & 788968)) {
- if (!isTypeParameterSymbolDeclaredInContainer(result, location)) {
- result = undefined;
- break;
- }
- if (lastLocation && ts.hasModifier(lastLocation, 32)) {
- error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters);
- return undefined;
- }
- break loop;
+ var message_1 = symbol.flags & 2
+ ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
+ : ts.Diagnostics.Duplicate_identifier_0;
+ var messageNeedsName_1 = true;
+ if (symbol.flags & 384 || includes & 384) {
+ message_1 = ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations;
+ messageNeedsName_1 = false;
}
- if (location.kind === 214 && meaning & 32) {
- var className = location.name;
- if (className && name === className.escapedText) {
- result = location.symbol;
- break loop;
+ var multipleDefaultExports_1 = false;
+ if (ts.length(symbol.declarations)) {
+ if (isDefaultExport) {
+ message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
+ messageNeedsName_1 = false;
+ multipleDefaultExports_1 = true;
}
- }
- break;
- case 216:
- if (lastLocation === location.expression && location.parent.token === 90) {
- var container = location.parent.parent;
- if (ts.isClassLike(container) && (result = lookup(getSymbolOfNode(container).members, name, meaning & 788968))) {
- if (nameNotFoundMessage) {
- error(errorLocation, ts.Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters);
+ else {
+ if (symbol.declarations && symbol.declarations.length &&
+ (node.kind === 266 && !node.isExportEquals)) {
+ message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
+ messageNeedsName_1 = false;
+ multipleDefaultExports_1 = true;
}
- return undefined;
- }
- }
- break;
- case 154:
- grandparent = location.parent.parent;
- if (ts.isClassLike(grandparent) || grandparent.kind === 246) {
- if (result = lookup(getSymbolOfNode(grandparent).members, name, meaning & 788968)) {
- error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
- return undefined;
- }
- }
- break;
- case 202:
- if (compilerOptions.target >= 2) {
- break;
- }
- case 161:
- case 162:
- case 163:
- case 164:
- case 244:
- if (meaning & 3 && name === "arguments") {
- result = argumentsSymbol;
- break loop;
- }
- break;
- case 201:
- if (meaning & 3 && name === "arguments") {
- result = argumentsSymbol;
- break loop;
- }
- if (meaning & 16) {
- var functionName = location.name;
- if (functionName && name === functionName.escapedText) {
- result = location.symbol;
- break loop;
}
}
- break;
- case 157:
- if (location.parent && location.parent.kind === 156) {
- location = location.parent;
- }
- if (location.parent && (ts.isClassElement(location.parent) || location.parent.kind === 245)) {
- location = location.parent;
- }
- break;
- case 322:
- case 315:
- case 316:
- location = ts.getJSDocHost(location);
- break;
- case 156:
- if (lastLocation && (lastLocation === location.initializer ||
- lastLocation === location.name && ts.isBindingPattern(lastLocation))) {
- if (!associatedDeclarationForContainingInitializerOrBindingName) {
- associatedDeclarationForContainingInitializerOrBindingName = location;
- }
+ var relatedInformation_1 = [];
+ if (ts.isTypeAliasDeclaration(node) && ts.nodeIsMissing(node.type) && ts.hasSyntacticModifier(node, 1) && symbol.flags & (2097152 | 788968 | 1920)) {
+ relatedInformation_1.push(createDiagnosticForNode(node, ts.Diagnostics.Did_you_mean_0, "export type { " + ts.unescapeLeadingUnderscores(node.name.escapedText) + " }"));
}
- break;
- case 191:
- if (lastLocation && (lastLocation === location.initializer ||
- lastLocation === location.name && ts.isBindingPattern(lastLocation))) {
- var root = ts.getRootDeclaration(location);
- if (root.kind === 156) {
- if (!associatedDeclarationForContainingInitializerOrBindingName) {
- associatedDeclarationForContainingInitializerOrBindingName = location;
- }
+ var declarationName_1 = ts.getNameOfDeclaration(node) || node;
+ ts.forEach(symbol.declarations, function (declaration, index) {
+ var decl = ts.getNameOfDeclaration(declaration) || declaration;
+ var diag = createDiagnosticForNode(decl, message_1, messageNeedsName_1 ? getDisplayName(declaration) : undefined);
+ file.bindDiagnostics.push(multipleDefaultExports_1 ? ts.addRelatedInfo(diag, createDiagnosticForNode(declarationName_1, index === 0 ? ts.Diagnostics.Another_export_default_is_here : ts.Diagnostics.and_here)) : diag);
+ if (multipleDefaultExports_1) {
+ relatedInformation_1.push(createDiagnosticForNode(decl, ts.Diagnostics.The_first_export_default_is_here));
}
- }
- break;
- }
- if (isSelfReferenceLocation(location)) {
- lastSelfReferenceLocation = location;
+ });
+ var diag = createDiagnosticForNode(declarationName_1, message_1, messageNeedsName_1 ? getDisplayName(node) : undefined);
+ file.bindDiagnostics.push(ts.addRelatedInfo.apply(void 0, __spreadArrays([diag], relatedInformation_1)));
+ symbol = createSymbol(0, name);
+ }
}
- lastLocation = location;
- location = location.parent;
}
- if (isUse && result && (!lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) {
- result.isReferenced |= meaning;
+ addDeclarationToSymbol(symbol, node, includes);
+ if (symbol.parent) {
+ ts.Debug.assert(symbol.parent === parent, "Existing symbol parent should match new one");
}
- if (!result) {
- if (lastLocation) {
- ts.Debug.assert(lastLocation.kind === 290);
- if (lastLocation.commonJsModuleIndicator && name === "exports" && meaning & lastLocation.symbol.flags) {
- return lastLocation.symbol;
- }
+ else {
+ symbol.parent = parent;
+ }
+ return symbol;
+ }
+ function declareModuleMember(node, symbolFlags, symbolExcludes) {
+ var hasExportModifier = !!(ts.getCombinedModifierFlags(node) & 1) || jsdocTreatAsExported(node);
+ if (symbolFlags & 2097152) {
+ if (node.kind === 270 || (node.kind === 260 && hasExportModifier)) {
+ return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
}
- if (!excludeGlobals) {
- result = lookup(globals, name, meaning);
+ else {
+ return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
}
}
- if (!result) {
- if (originalLocation && ts.isInJSFile(originalLocation) && originalLocation.parent) {
- if (ts.isRequireCall(originalLocation.parent, false)) {
- return requireSymbol;
+ else {
+ if (ts.isJSDocTypeAlias(node))
+ ts.Debug.assert(ts.isInJSFile(node));
+ if (!ts.isAmbientModule(node) && (hasExportModifier || container.flags & 64)) {
+ if (!container.locals || (ts.hasSyntacticModifier(node, 512) && !getDeclarationName(node))) {
+ return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
}
+ var exportKind = symbolFlags & 111551 ? 1048576 : 0;
+ var local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes);
+ local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
+ node.localSymbol = local;
+ return local;
}
- }
- if (!result) {
- if (nameNotFoundMessage) {
- if (!errorLocation ||
- !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
- !checkAndReportErrorForExtendingInterface(errorLocation) &&
- !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
- !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) &&
- !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) &&
- !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
- !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
- var suggestion = void 0;
- if (suggestedNameNotFoundMessage && suggestionCount < maximumSuggestionCount) {
- suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
- if (suggestion) {
- var suggestionName = symbolToString(suggestion);
- var diagnostic = error(errorLocation, suggestedNameNotFoundMessage, diagnosticName(nameArg), suggestionName);
- if (suggestion.valueDeclaration) {
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName));
- }
- }
- }
- if (!suggestion) {
- error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
- }
- suggestionCount++;
- }
+ else {
+ return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
}
- return undefined;
}
- if (nameNotFoundMessage) {
- if (propertyWithInvalidInitializer && !(compilerOptions.target === 99 && compilerOptions.useDefineForClassFields)) {
- var propertyName = propertyWithInvalidInitializer.name;
- error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), diagnosticName(nameArg));
- return undefined;
+ }
+ function jsdocTreatAsExported(node) {
+ if (node.parent && ts.isModuleDeclaration(node)) {
+ node = node.parent;
+ }
+ if (!ts.isJSDocTypeAlias(node))
+ return false;
+ if (!ts.isJSDocEnumTag(node) && !!node.fullName)
+ return true;
+ var declName = ts.getNameOfDeclaration(node);
+ if (!declName)
+ return false;
+ if (ts.isPropertyAccessEntityNameExpression(declName.parent) && isTopLevelNamespaceAssignment(declName.parent))
+ return true;
+ if (ts.isDeclaration(declName.parent) && ts.getCombinedModifierFlags(declName.parent) & 1)
+ return true;
+ return false;
+ }
+ function bindContainer(node, containerFlags) {
+ var saveContainer = container;
+ var saveThisParentContainer = thisParentContainer;
+ var savedBlockScopeContainer = blockScopeContainer;
+ if (containerFlags & 1) {
+ if (node.kind !== 209) {
+ thisParentContainer = container;
}
- if (errorLocation &&
- (meaning & 2 ||
- ((meaning & 32 || meaning & 384) && (meaning & 111551) === 111551))) {
- var exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
- if (exportOrLocalSymbol.flags & 2 || exportOrLocalSymbol.flags & 32 || exportOrLocalSymbol.flags & 384) {
- checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
- }
+ container = blockScopeContainer = node;
+ if (containerFlags & 32) {
+ container.locals = ts.createSymbolTable();
}
- if (result && isInExternalModule && (meaning & 111551) === 111551 && !(originalLocation.flags & 4194304)) {
- var merged = getMergedSymbol(result);
- if (ts.length(merged.declarations) && ts.every(merged.declarations, function (d) { return ts.isNamespaceExportDeclaration(d) || ts.isSourceFile(d) && !!d.symbol.globalExports; })) {
- errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, ts.unescapeLeadingUnderscores(name));
+ addToContainerChain(container);
+ }
+ else if (containerFlags & 2) {
+ blockScopeContainer = node;
+ blockScopeContainer.locals = undefined;
+ }
+ if (containerFlags & 4) {
+ var saveCurrentFlow = currentFlow;
+ var saveBreakTarget = currentBreakTarget;
+ var saveContinueTarget = currentContinueTarget;
+ var saveReturnTarget = currentReturnTarget;
+ var saveExceptionTarget = currentExceptionTarget;
+ var saveActiveLabelList = activeLabelList;
+ var saveHasExplicitReturn = hasExplicitReturn;
+ var isIIFE = containerFlags & 16 && !ts.hasSyntacticModifier(node, 256) &&
+ !node.asteriskToken && !!ts.getImmediatelyInvokedFunctionExpression(node);
+ if (!isIIFE) {
+ currentFlow = initFlowNode({ flags: 2 });
+ if (containerFlags & (16 | 128)) {
+ currentFlow.node = node;
}
}
- if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551) === 111551) {
- var candidate = getMergedSymbol(getLateBoundSymbol(result));
- var root = ts.getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
- if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializerOrBindingName)) {
- error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_itself, ts.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, ts.Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), ts.declarationNameToString(errorLocation));
+ currentReturnTarget = isIIFE || node.kind === 166 || (ts.isInJSFile && (node.kind === 251 || node.kind === 208)) ? createBranchLabel() : undefined;
+ currentExceptionTarget = undefined;
+ currentBreakTarget = undefined;
+ currentContinueTarget = undefined;
+ activeLabelList = undefined;
+ hasExplicitReturn = false;
+ bindChildren(node);
+ node.flags &= ~2816;
+ if (!(currentFlow.flags & 1) && containerFlags & 8 && ts.nodeIsPresent(node.body)) {
+ node.flags |= 256;
+ if (hasExplicitReturn)
+ node.flags |= 512;
+ node.endFlowNode = currentFlow;
+ }
+ if (node.kind === 297) {
+ node.flags |= emitFlags;
+ }
+ if (currentReturnTarget) {
+ addAntecedent(currentReturnTarget, currentFlow);
+ currentFlow = finishFlowLabel(currentReturnTarget);
+ if (node.kind === 166 || (ts.isInJSFile && (node.kind === 251 || node.kind === 208))) {
+ node.returnFlowNode = currentFlow;
}
}
- if (result && errorLocation && meaning & 111551 && result.flags & 2097152) {
- checkSymbolUsageInExpressionContext(result, name, errorLocation);
+ if (!isIIFE) {
+ currentFlow = saveCurrentFlow;
}
+ currentBreakTarget = saveBreakTarget;
+ currentContinueTarget = saveContinueTarget;
+ currentReturnTarget = saveReturnTarget;
+ currentExceptionTarget = saveExceptionTarget;
+ activeLabelList = saveActiveLabelList;
+ hasExplicitReturn = saveHasExplicitReturn;
}
- return result;
- }
- function checkSymbolUsageInExpressionContext(symbol, name, useSite) {
- if (!ts.isValidTypeOnlyAliasUseSite(useSite)) {
- var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(symbol);
- if (typeOnlyDeclaration) {
- var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration);
- var message = isExport
- ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type
- : ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
- var relatedMessage = isExport
- ? ts.Diagnostics._0_was_exported_here
- : ts.Diagnostics._0_was_imported_here;
- var unescapedName = ts.unescapeLeadingUnderscores(name);
- ts.addRelatedInfo(error(useSite, message, unescapedName), ts.createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, unescapedName));
- }
+ else if (containerFlags & 64) {
+ seenThisKeyword = false;
+ bindChildren(node);
+ node.flags = seenThisKeyword ? node.flags | 128 : node.flags & ~128;
+ }
+ else {
+ bindChildren(node);
}
+ container = saveContainer;
+ thisParentContainer = saveThisParentContainer;
+ blockScopeContainer = savedBlockScopeContainer;
}
- function getIsDeferredContext(location, lastLocation) {
- if (location.kind !== 202 && location.kind !== 201) {
- return ts.isTypeQueryNode(location) || ((ts.isFunctionLikeDeclaration(location) ||
- (location.kind === 159 && !ts.hasModifier(location, 32))) && (!lastLocation || lastLocation !== location.name));
+ function bindEachFunctionsFirst(nodes) {
+ bindEach(nodes, function (n) { return n.kind === 251 ? bind(n) : undefined; });
+ bindEach(nodes, function (n) { return n.kind !== 251 ? bind(n) : undefined; });
+ }
+ function bindEach(nodes, bindFunction) {
+ if (bindFunction === void 0) { bindFunction = bind; }
+ if (nodes === undefined) {
+ return;
}
- if (lastLocation && lastLocation === location.name) {
- return false;
+ ts.forEach(nodes, bindFunction);
+ }
+ function bindEachChild(node) {
+ ts.forEachChild(node, bind, bindEach);
+ }
+ function bindChildren(node) {
+ var saveInAssignmentPattern = inAssignmentPattern;
+ inAssignmentPattern = false;
+ if (checkUnreachable(node)) {
+ bindEachChild(node);
+ bindJSDoc(node);
+ inAssignmentPattern = saveInAssignmentPattern;
+ return;
}
- if (location.asteriskToken || ts.hasModifier(location, 256)) {
- return true;
+ if (node.kind >= 232 && node.kind <= 248 && !options.allowUnreachableCode) {
+ node.flowNode = currentFlow;
}
- return !ts.getImmediatelyInvokedFunctionExpression(location);
- }
- function isSelfReferenceLocation(node) {
switch (node.kind) {
- case 244:
- case 245:
+ case 236:
+ bindWhileStatement(node);
+ break;
+ case 235:
+ bindDoStatement(node);
+ break;
+ case 237:
+ bindForStatement(node);
+ break;
+ case 238:
+ case 239:
+ bindForInOrForOfStatement(node);
+ break;
+ case 234:
+ bindIfStatement(node);
+ break;
+ case 242:
case 246:
- case 248:
+ bindReturnOrThrow(node);
+ break;
+ case 241:
+ case 240:
+ bindBreakOrContinueStatement(node);
+ break;
case 247:
+ bindTryStatement(node);
+ break;
+ case 244:
+ bindSwitchStatement(node);
+ break;
+ case 258:
+ bindCaseBlock(node);
+ break;
+ case 284:
+ bindCaseClause(node);
+ break;
+ case 233:
+ bindExpressionStatement(node);
+ break;
+ case 245:
+ bindLabeledStatement(node);
+ break;
+ case 214:
+ bindPrefixUnaryExpressionFlow(node);
+ break;
+ case 215:
+ bindPostfixUnaryExpressionFlow(node);
+ break;
+ case 216:
+ if (ts.isDestructuringAssignment(node)) {
+ inAssignmentPattern = saveInAssignmentPattern;
+ bindDestructuringAssignmentFlow(node);
+ return;
+ }
+ bindBinaryExpressionFlow(node);
+ break;
+ case 210:
+ bindDeleteExpressionFlow(node);
+ break;
+ case 217:
+ bindConditionalExpressionFlow(node);
+ break;
case 249:
- return true;
+ bindVariableDeclarationFlow(node);
+ break;
+ case 201:
+ case 202:
+ bindAccessExpressionFlow(node);
+ break;
+ case 203:
+ bindCallExpressionFlow(node);
+ break;
+ case 225:
+ bindNonNullExpressionFlow(node);
+ break;
+ case 331:
+ case 324:
+ case 325:
+ bindJSDocTypeAlias(node);
+ break;
+ case 297: {
+ bindEachFunctionsFirst(node.statements);
+ bind(node.endOfFileToken);
+ break;
+ }
+ case 230:
+ case 257:
+ bindEachFunctionsFirst(node.statements);
+ break;
+ case 198:
+ bindBindingElementFlow(node);
+ break;
+ case 200:
+ case 199:
+ case 288:
+ case 220:
+ inAssignmentPattern = saveInAssignmentPattern;
default:
- return false;
+ bindEachChild(node);
+ break;
}
+ bindJSDoc(node);
+ inAssignmentPattern = saveInAssignmentPattern;
}
- function diagnosticName(nameArg) {
- return ts.isString(nameArg) ? ts.unescapeLeadingUnderscores(nameArg) : ts.declarationNameToString(nameArg);
- }
- function isTypeParameterSymbolDeclaredInContainer(symbol, container) {
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var decl = _a[_i];
- if (decl.kind === 155) {
- var parent = ts.isJSDocTemplateTag(decl.parent) ? ts.getJSDocHost(decl.parent) : decl.parent;
- if (parent === container) {
- return !(ts.isJSDocTemplateTag(decl.parent) && ts.find(decl.parent.parent.tags, ts.isJSDocTypeAlias));
- }
- }
+ function isNarrowingExpression(expr) {
+ switch (expr.kind) {
+ case 78:
+ case 79:
+ case 107:
+ case 201:
+ case 202:
+ return containsNarrowableReference(expr);
+ case 203:
+ return hasNarrowableArgument(expr);
+ case 207:
+ case 225:
+ return isNarrowingExpression(expr.expression);
+ case 216:
+ return isNarrowingBinaryExpression(expr);
+ case 214:
+ return expr.operator === 53 && isNarrowingExpression(expr.operand);
+ case 211:
+ return isNarrowingExpression(expr.expression);
}
return false;
}
- function checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) {
- if (!ts.isIdentifier(errorLocation) || errorLocation.escapedText !== name || isTypeReferenceIdentifier(errorLocation) || isInTypeQuery(errorLocation)) {
- return false;
- }
- var container = ts.getThisContainer(errorLocation, false);
- var location = container;
- while (location) {
- if (ts.isClassLike(location.parent)) {
- var classSymbol = getSymbolOfNode(location.parent);
- if (!classSymbol) {
- break;
- }
- var constructorType = getTypeOfSymbol(classSymbol);
- if (getPropertyOfType(constructorType, name)) {
- error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0, diagnosticName(nameArg), symbolToString(classSymbol));
+ function isNarrowableReference(expr) {
+ return expr.kind === 78 || expr.kind === 79 || expr.kind === 107 || expr.kind === 105 ||
+ (ts.isPropertyAccessExpression(expr) || ts.isNonNullExpression(expr) || ts.isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) ||
+ ts.isBinaryExpression(expr) && expr.operatorToken.kind === 27 && isNarrowableReference(expr.right) ||
+ ts.isElementAccessExpression(expr) && ts.isStringOrNumericLiteralLike(expr.argumentExpression) && isNarrowableReference(expr.expression) ||
+ ts.isAssignmentExpression(expr) && isNarrowableReference(expr.left);
+ }
+ function containsNarrowableReference(expr) {
+ return isNarrowableReference(expr) || ts.isOptionalChain(expr) && containsNarrowableReference(expr.expression);
+ }
+ function hasNarrowableArgument(expr) {
+ if (expr.arguments) {
+ for (var _i = 0, _a = expr.arguments; _i < _a.length; _i++) {
+ var argument = _a[_i];
+ if (containsNarrowableReference(argument)) {
return true;
}
- if (location === container && !ts.hasModifier(location, 32)) {
- var instanceType = getDeclaredTypeOfSymbol(classSymbol).thisType;
- if (getPropertyOfType(instanceType, name)) {
- error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0, diagnosticName(nameArg));
- return true;
- }
- }
}
- location = location.parent;
}
- return false;
- }
- function checkAndReportErrorForExtendingInterface(errorLocation) {
- var expression = getEntityNameForExtendingInterface(errorLocation);
- if (expression && resolveEntityName(expression, 64, true)) {
- error(errorLocation, ts.Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, ts.getTextOfNode(expression));
+ if (expr.expression.kind === 201 &&
+ containsNarrowableReference(expr.expression.expression)) {
return true;
}
return false;
}
- function getEntityNameForExtendingInterface(node) {
- switch (node.kind) {
+ function isNarrowingTypeofOperands(expr1, expr2) {
+ return ts.isTypeOfExpression(expr1) && isNarrowableOperand(expr1.expression) && ts.isStringLiteralLike(expr2);
+ }
+ function isNarrowableInOperands(left, right) {
+ return ts.isStringLiteralLike(left) && isNarrowingExpression(right);
+ }
+ function isNarrowingBinaryExpression(expr) {
+ switch (expr.operatorToken.kind) {
+ case 62:
+ case 74:
case 75:
- case 194:
- return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined;
+ case 76:
+ return containsNarrowableReference(expr.left);
+ case 34:
+ case 35:
+ case 36:
+ case 37:
+ return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) ||
+ isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right);
+ case 101:
+ return isNarrowableOperand(expr.left);
+ case 100:
+ return isNarrowableInOperands(expr.left, expr.right);
+ case 27:
+ return isNarrowingExpression(expr.right);
+ }
+ return false;
+ }
+ function isNarrowableOperand(expr) {
+ switch (expr.kind) {
+ case 207:
+ return isNarrowableOperand(expr.expression);
case 216:
- if (ts.isEntityNameExpression(node.expression)) {
- return node.expression;
+ switch (expr.operatorToken.kind) {
+ case 62:
+ return isNarrowableOperand(expr.left);
+ case 27:
+ return isNarrowableOperand(expr.right);
}
- default:
- return undefined;
}
+ return containsNarrowableReference(expr);
}
- function checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) {
- var namespaceMeaning = 1920 | (ts.isInJSFile(errorLocation) ? 111551 : 0);
- if (meaning === namespaceMeaning) {
- var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 & ~namespaceMeaning, undefined, undefined, false));
- var parent = errorLocation.parent;
- if (symbol) {
- if (ts.isQualifiedName(parent)) {
- ts.Debug.assert(parent.left === errorLocation, "Should only be resolving left side of qualified name as a namespace");
- var propName = parent.right.escapedText;
- var propType = getPropertyOfType(getDeclaredTypeOfSymbol(symbol), propName);
- if (propType) {
- error(parent, ts.Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1, ts.unescapeLeadingUnderscores(name), ts.unescapeLeadingUnderscores(propName));
- return true;
- }
- }
- error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here, ts.unescapeLeadingUnderscores(name));
- return true;
- }
+ function createBranchLabel() {
+ return initFlowNode({ flags: 4, antecedents: undefined });
+ }
+ function createLoopLabel() {
+ return initFlowNode({ flags: 8, antecedents: undefined });
+ }
+ function createReduceLabel(target, antecedents, antecedent) {
+ return initFlowNode({ flags: 1024, target: target, antecedents: antecedents, antecedent: antecedent });
+ }
+ function setFlowNodeReferenced(flow) {
+ flow.flags |= flow.flags & 2048 ? 4096 : 2048;
+ }
+ function addAntecedent(label, antecedent) {
+ if (!(antecedent.flags & 1) && !ts.contains(label.antecedents, antecedent)) {
+ (label.antecedents || (label.antecedents = [])).push(antecedent);
+ setFlowNodeReferenced(antecedent);
+ }
+ }
+ function createFlowCondition(flags, antecedent, expression) {
+ if (antecedent.flags & 1) {
+ return antecedent;
+ }
+ if (!expression) {
+ return flags & 32 ? antecedent : unreachableFlow;
+ }
+ if ((expression.kind === 109 && flags & 64 ||
+ expression.kind === 94 && flags & 32) &&
+ !ts.isExpressionOfOptionalChainRoot(expression) && !ts.isNullishCoalesce(expression.parent)) {
+ return unreachableFlow;
+ }
+ if (!isNarrowingExpression(expression)) {
+ return antecedent;
+ }
+ setFlowNodeReferenced(antecedent);
+ return initFlowNode({ flags: flags, antecedent: antecedent, node: expression });
+ }
+ function createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) {
+ setFlowNodeReferenced(antecedent);
+ return initFlowNode({ flags: 128, antecedent: antecedent, switchStatement: switchStatement, clauseStart: clauseStart, clauseEnd: clauseEnd });
+ }
+ function createFlowMutation(flags, antecedent, node) {
+ setFlowNodeReferenced(antecedent);
+ var result = initFlowNode({ flags: flags, antecedent: antecedent, node: node });
+ if (currentExceptionTarget) {
+ addAntecedent(currentExceptionTarget, result);
+ }
+ return result;
+ }
+ function createFlowCall(antecedent, node) {
+ setFlowNodeReferenced(antecedent);
+ return initFlowNode({ flags: 512, antecedent: antecedent, node: node });
+ }
+ function finishFlowLabel(flow) {
+ var antecedents = flow.antecedents;
+ if (!antecedents) {
+ return unreachableFlow;
+ }
+ if (antecedents.length === 1) {
+ return antecedents[0];
+ }
+ return flow;
+ }
+ function isStatementCondition(node) {
+ var parent = node.parent;
+ switch (parent.kind) {
+ case 234:
+ case 236:
+ case 235:
+ return parent.expression === node;
+ case 237:
+ case 217:
+ return parent.condition === node;
}
return false;
}
- function checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning) {
- if (meaning & (788968 & ~1920)) {
- var symbol = resolveSymbol(resolveName(errorLocation, name, ~788968 & 111551, undefined, undefined, false));
- if (symbol && !(symbol.flags & 1920)) {
- error(errorLocation, ts.Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0, ts.unescapeLeadingUnderscores(name));
- return true;
+ function isLogicalExpression(node) {
+ while (true) {
+ if (node.kind === 207) {
+ node = node.expression;
+ }
+ else if (node.kind === 214 && node.operator === 53) {
+ node = node.operand;
+ }
+ else {
+ return node.kind === 216 && (node.operatorToken.kind === 55 ||
+ node.operatorToken.kind === 56 ||
+ node.operatorToken.kind === 60);
}
}
- return false;
}
- function isPrimitiveTypeName(name) {
- return name === "any" || name === "string" || name === "number" || name === "boolean" || name === "never" || name === "unknown";
+ function isLogicalAssignmentExpression(node) {
+ node = ts.skipParentheses(node);
+ return ts.isBinaryExpression(node) && ts.isLogicalOrCoalescingAssignmentOperator(node.operatorToken.kind);
}
- function checkAndReportErrorForExportingPrimitiveType(errorLocation, name) {
- if (isPrimitiveTypeName(name) && errorLocation.parent.kind === 263) {
- error(errorLocation, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, name);
- return true;
+ function isTopLevelLogicalExpression(node) {
+ while (ts.isParenthesizedExpression(node.parent) ||
+ ts.isPrefixUnaryExpression(node.parent) && node.parent.operator === 53) {
+ node = node.parent;
}
- return false;
+ return !isStatementCondition(node) &&
+ !isLogicalAssignmentExpression(node.parent) &&
+ !isLogicalExpression(node.parent) &&
+ !(ts.isOptionalChain(node.parent) && node.parent.expression === node);
}
- function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) {
- if (meaning & (111551 & ~1024)) {
- if (isPrimitiveTypeName(name)) {
- error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, ts.unescapeLeadingUnderscores(name));
- return true;
+ function doWithConditionalBranches(action, value, trueTarget, falseTarget) {
+ var savedTrueTarget = currentTrueTarget;
+ var savedFalseTarget = currentFalseTarget;
+ currentTrueTarget = trueTarget;
+ currentFalseTarget = falseTarget;
+ action(value);
+ currentTrueTarget = savedTrueTarget;
+ currentFalseTarget = savedFalseTarget;
+ }
+ function bindCondition(node, trueTarget, falseTarget) {
+ doWithConditionalBranches(bind, node, trueTarget, falseTarget);
+ if (!node || !isLogicalAssignmentExpression(node) && !isLogicalExpression(node) && !(ts.isOptionalChain(node) && ts.isOutermostOptionalChain(node))) {
+ addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node));
+ addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node));
+ }
+ }
+ function bindIterativeStatement(node, breakTarget, continueTarget) {
+ var saveBreakTarget = currentBreakTarget;
+ var saveContinueTarget = currentContinueTarget;
+ currentBreakTarget = breakTarget;
+ currentContinueTarget = continueTarget;
+ bind(node);
+ currentBreakTarget = saveBreakTarget;
+ currentContinueTarget = saveContinueTarget;
+ }
+ function setContinueTarget(node, target) {
+ var label = activeLabelList;
+ while (label && node.parent.kind === 245) {
+ label.continueTarget = target;
+ label = label.next;
+ node = node.parent;
+ }
+ return target;
+ }
+ function bindWhileStatement(node) {
+ var preWhileLabel = setContinueTarget(node, createLoopLabel());
+ var preBodyLabel = createBranchLabel();
+ var postWhileLabel = createBranchLabel();
+ addAntecedent(preWhileLabel, currentFlow);
+ currentFlow = preWhileLabel;
+ bindCondition(node.expression, preBodyLabel, postWhileLabel);
+ currentFlow = finishFlowLabel(preBodyLabel);
+ bindIterativeStatement(node.statement, postWhileLabel, preWhileLabel);
+ addAntecedent(preWhileLabel, currentFlow);
+ currentFlow = finishFlowLabel(postWhileLabel);
+ }
+ function bindDoStatement(node) {
+ var preDoLabel = createLoopLabel();
+ var preConditionLabel = setContinueTarget(node, createBranchLabel());
+ var postDoLabel = createBranchLabel();
+ addAntecedent(preDoLabel, currentFlow);
+ currentFlow = preDoLabel;
+ bindIterativeStatement(node.statement, postDoLabel, preConditionLabel);
+ addAntecedent(preConditionLabel, currentFlow);
+ currentFlow = finishFlowLabel(preConditionLabel);
+ bindCondition(node.expression, preDoLabel, postDoLabel);
+ currentFlow = finishFlowLabel(postDoLabel);
+ }
+ function bindForStatement(node) {
+ var preLoopLabel = setContinueTarget(node, createLoopLabel());
+ var preBodyLabel = createBranchLabel();
+ var postLoopLabel = createBranchLabel();
+ bind(node.initializer);
+ addAntecedent(preLoopLabel, currentFlow);
+ currentFlow = preLoopLabel;
+ bindCondition(node.condition, preBodyLabel, postLoopLabel);
+ currentFlow = finishFlowLabel(preBodyLabel);
+ bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
+ bind(node.incrementor);
+ addAntecedent(preLoopLabel, currentFlow);
+ currentFlow = finishFlowLabel(postLoopLabel);
+ }
+ function bindForInOrForOfStatement(node) {
+ var preLoopLabel = setContinueTarget(node, createLoopLabel());
+ var postLoopLabel = createBranchLabel();
+ bind(node.expression);
+ addAntecedent(preLoopLabel, currentFlow);
+ currentFlow = preLoopLabel;
+ if (node.kind === 239) {
+ bind(node.awaitModifier);
+ }
+ addAntecedent(postLoopLabel, currentFlow);
+ bind(node.initializer);
+ if (node.initializer.kind !== 250) {
+ bindAssignmentTargetFlow(node.initializer);
+ }
+ bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
+ addAntecedent(preLoopLabel, currentFlow);
+ currentFlow = finishFlowLabel(postLoopLabel);
+ }
+ function bindIfStatement(node) {
+ var thenLabel = createBranchLabel();
+ var elseLabel = createBranchLabel();
+ var postIfLabel = createBranchLabel();
+ bindCondition(node.expression, thenLabel, elseLabel);
+ currentFlow = finishFlowLabel(thenLabel);
+ bind(node.thenStatement);
+ addAntecedent(postIfLabel, currentFlow);
+ currentFlow = finishFlowLabel(elseLabel);
+ bind(node.elseStatement);
+ addAntecedent(postIfLabel, currentFlow);
+ currentFlow = finishFlowLabel(postIfLabel);
+ }
+ function bindReturnOrThrow(node) {
+ bind(node.expression);
+ if (node.kind === 242) {
+ hasExplicitReturn = true;
+ if (currentReturnTarget) {
+ addAntecedent(currentReturnTarget, currentFlow);
}
- var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 & ~111551, undefined, undefined, false));
- if (symbol && !(symbol.flags & 1024)) {
- var message = isES2015OrLaterConstructorName(name)
- ? ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later
- : ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here;
- error(errorLocation, message, ts.unescapeLeadingUnderscores(name));
- return true;
+ }
+ currentFlow = unreachableFlow;
+ }
+ function findActiveLabel(name) {
+ for (var label = activeLabelList; label; label = label.next) {
+ if (label.name === name) {
+ return label;
}
}
- return false;
+ return undefined;
}
- function isES2015OrLaterConstructorName(n) {
- switch (n) {
- case "Promise":
- case "Symbol":
- case "Map":
- case "WeakMap":
- case "Set":
- case "WeakSet":
- return true;
+ function bindBreakOrContinueFlow(node, breakTarget, continueTarget) {
+ var flowLabel = node.kind === 241 ? breakTarget : continueTarget;
+ if (flowLabel) {
+ addAntecedent(flowLabel, currentFlow);
+ currentFlow = unreachableFlow;
}
- return false;
}
- function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) {
- if (meaning & (111551 & ~1024 & ~788968)) {
- var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 & ~111551, undefined, undefined, false));
- if (symbol) {
- error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_value, ts.unescapeLeadingUnderscores(name));
- return true;
+ function bindBreakOrContinueStatement(node) {
+ bind(node.label);
+ if (node.label) {
+ var activeLabel = findActiveLabel(node.label.escapedText);
+ if (activeLabel) {
+ activeLabel.referenced = true;
+ bindBreakOrContinueFlow(node, activeLabel.breakTarget, activeLabel.continueTarget);
}
}
- else if (meaning & (788968 & ~1024 & ~111551)) {
- var symbol = resolveSymbol(resolveName(errorLocation, name, (512 | 1024) & ~788968, undefined, undefined, false));
- if (symbol) {
- error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_type, ts.unescapeLeadingUnderscores(name));
- return true;
- }
+ else {
+ bindBreakOrContinueFlow(node, currentBreakTarget, currentContinueTarget);
}
- return false;
}
- function checkResolvedBlockScopedVariable(result, errorLocation) {
- ts.Debug.assert(!!(result.flags & 2 || result.flags & 32 || result.flags & 384));
- if (result.flags & (16 | 1 | 67108864) && result.flags & 32) {
- return;
+ function bindTryStatement(node) {
+ var saveReturnTarget = currentReturnTarget;
+ var saveExceptionTarget = currentExceptionTarget;
+ var normalExitLabel = createBranchLabel();
+ var returnLabel = createBranchLabel();
+ var exceptionLabel = createBranchLabel();
+ if (node.finallyBlock) {
+ currentReturnTarget = returnLabel;
}
- var declaration = ts.find(result.declarations, function (d) { return ts.isBlockOrCatchScoped(d) || ts.isClassLike(d) || (d.kind === 248); });
- if (declaration === undefined)
- return ts.Debug.fail("checkResolvedBlockScopedVariable could not find block-scoped declaration");
- if (!(declaration.flags & 8388608) && !isBlockScopedNameDeclaredBeforeUse(declaration, errorLocation)) {
- var diagnosticMessage = void 0;
- var declarationName = ts.declarationNameToString(ts.getNameOfDeclaration(declaration));
- if (result.flags & 2) {
- diagnosticMessage = error(errorLocation, ts.Diagnostics.Block_scoped_variable_0_used_before_its_declaration, declarationName);
- }
- else if (result.flags & 32) {
- diagnosticMessage = error(errorLocation, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName);
- }
- else if (result.flags & 256) {
- diagnosticMessage = error(errorLocation, ts.Diagnostics.Enum_0_used_before_its_declaration, declarationName);
+ 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) {
+ var finallyLabel = createBranchLabel();
+ finallyLabel.antecedents = ts.concatenate(ts.concatenate(normalExitLabel.antecedents, exceptionLabel.antecedents), returnLabel.antecedents);
+ currentFlow = finallyLabel;
+ bind(node.finallyBlock);
+ if (currentFlow.flags & 1) {
+ currentFlow = unreachableFlow;
}
else {
- ts.Debug.assert(!!(result.flags & 128));
- if (compilerOptions.preserveConstEnums) {
- diagnosticMessage = error(errorLocation, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName);
+ if (currentReturnTarget && returnLabel.antecedents) {
+ addAntecedent(currentReturnTarget, createReduceLabel(finallyLabel, returnLabel.antecedents, currentFlow));
}
- }
- if (diagnosticMessage) {
- ts.addRelatedInfo(diagnosticMessage, ts.createDiagnosticForNode(declaration, ts.Diagnostics._0_is_declared_here, declarationName));
+ if (currentExceptionTarget && exceptionLabel.antecedents) {
+ addAntecedent(currentExceptionTarget, createReduceLabel(finallyLabel, exceptionLabel.antecedents, currentFlow));
+ }
+ currentFlow = normalExitLabel.antecedents ? createReduceLabel(finallyLabel, normalExitLabel.antecedents, currentFlow) : unreachableFlow;
}
}
- }
- function isSameScopeDescendentOf(initial, parent, stopAt) {
- return !!parent && !!ts.findAncestor(initial, function (n) { return n === stopAt || ts.isFunctionLike(n) ? "quit" : n === parent; });
- }
- function getAnyImportSyntax(node) {
- switch (node.kind) {
- case 253:
- return node;
- case 255:
- return node.parent;
- case 256:
- return node.parent.parent;
- case 258:
- return node.parent.parent.parent;
- default:
- return undefined;
+ else {
+ currentFlow = finishFlowLabel(normalExitLabel);
}
}
- function getDeclarationOfAliasSymbol(symbol) {
- return ts.find(symbol.declarations, isAliasSymbolDeclaration);
+ function bindSwitchStatement(node) {
+ var postSwitchLabel = createBranchLabel();
+ bind(node.expression);
+ var saveBreakTarget = currentBreakTarget;
+ var savePreSwitchCaseFlow = preSwitchCaseFlow;
+ currentBreakTarget = postSwitchLabel;
+ preSwitchCaseFlow = currentFlow;
+ bind(node.caseBlock);
+ addAntecedent(postSwitchLabel, currentFlow);
+ var hasDefault = ts.forEach(node.caseBlock.clauses, function (c) { return c.kind === 285; });
+ node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents;
+ if (!hasDefault) {
+ addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0));
+ }
+ currentBreakTarget = saveBreakTarget;
+ preSwitchCaseFlow = savePreSwitchCaseFlow;
+ currentFlow = finishFlowLabel(postSwitchLabel);
}
- function isAliasSymbolDeclaration(node) {
- return node.kind === 253 ||
- node.kind === 252 ||
- node.kind === 255 && !!node.name ||
- node.kind === 256 ||
- node.kind === 262 ||
- node.kind === 258 ||
- node.kind === 263 ||
- node.kind === 259 && ts.exportAssignmentIsAlias(node) ||
- ts.isBinaryExpression(node) && ts.getAssignmentDeclarationKind(node) === 2 && ts.exportAssignmentIsAlias(node) ||
- ts.isPropertyAccessExpression(node)
- && ts.isBinaryExpression(node.parent)
- && node.parent.left === node
- && node.parent.operatorToken.kind === 62
- && isAliasableOrJsExpression(node.parent.right) ||
- node.kind === 282 ||
- node.kind === 281 && isAliasableOrJsExpression(node.initializer);
+ function bindCaseBlock(node) {
+ var clauses = node.clauses;
+ var isNarrowingSwitch = isNarrowingExpression(node.parent.expression);
+ var fallthroughFlow = unreachableFlow;
+ for (var i = 0; i < clauses.length; i++) {
+ var clauseStart = i;
+ while (!clauses[i].statements.length && i + 1 < clauses.length) {
+ bind(clauses[i]);
+ i++;
+ }
+ var preCaseLabel = createBranchLabel();
+ addAntecedent(preCaseLabel, isNarrowingSwitch ? createFlowSwitchClause(preSwitchCaseFlow, node.parent, clauseStart, i + 1) : preSwitchCaseFlow);
+ addAntecedent(preCaseLabel, fallthroughFlow);
+ currentFlow = finishFlowLabel(preCaseLabel);
+ var clause = clauses[i];
+ bind(clause);
+ fallthroughFlow = currentFlow;
+ if (!(currentFlow.flags & 1) && i !== clauses.length - 1 && options.noFallthroughCasesInSwitch) {
+ clause.fallthroughFlowNode = currentFlow;
+ }
+ }
}
- function isAliasableOrJsExpression(e) {
- return ts.isAliasableExpression(e) || ts.isFunctionExpression(e) && isJSConstructor(e);
+ function bindCaseClause(node) {
+ var saveCurrentFlow = currentFlow;
+ currentFlow = preSwitchCaseFlow;
+ bind(node.expression);
+ currentFlow = saveCurrentFlow;
+ bindEach(node.statements);
}
- function getTargetOfImportEqualsDeclaration(node, dontResolveAlias) {
- if (node.moduleReference.kind === 265) {
- var immediate = resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node));
- var resolved_4 = resolveExternalModuleSymbol(immediate);
- markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved_4, false);
- return resolved_4;
- }
- var resolved = getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, dontResolveAlias);
- checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved);
- return resolved;
+ function bindExpressionStatement(node) {
+ bind(node.expression);
+ maybeBindExpressionFlowIfCall(node.expression);
}
- function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved) {
- if (markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false)) {
- var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(getSymbolOfNode(node));
- var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration);
- var message = isExport
- ? ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type
- : ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type;
- var relatedMessage = isExport
- ? ts.Diagnostics._0_was_exported_here
- : ts.Diagnostics._0_was_imported_here;
- var name = ts.unescapeLeadingUnderscores(typeOnlyDeclaration.name.escapedText);
- ts.addRelatedInfo(error(node.moduleReference, message), ts.createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, name));
+ function maybeBindExpressionFlowIfCall(node) {
+ if (node.kind === 203) {
+ var call = node;
+ if (ts.isDottedName(call.expression) && call.expression.kind !== 105) {
+ currentFlow = createFlowCall(currentFlow, call);
+ }
}
}
- function resolveExportByName(moduleSymbol, name, sourceNode, dontResolveAlias) {
- var exportValue = moduleSymbol.exports.get("export=");
- if (exportValue) {
- return getPropertyOfType(getTypeOfSymbol(exportValue), name);
+ function bindLabeledStatement(node) {
+ var postStatementLabel = createBranchLabel();
+ activeLabelList = {
+ next: activeLabelList,
+ name: node.label.escapedText,
+ breakTarget: postStatementLabel,
+ continueTarget: undefined,
+ referenced: false
+ };
+ bind(node.label);
+ bind(node.statement);
+ if (!activeLabelList.referenced && !options.allowUnusedLabels) {
+ errorOrSuggestionOnNode(ts.unusedLabelIsError(options), node.label, ts.Diagnostics.Unused_label);
}
- var exportSymbol = moduleSymbol.exports.get(name);
- var resolved = resolveSymbol(exportSymbol, dontResolveAlias);
- markSymbolOfAliasDeclarationIfTypeOnly(sourceNode, exportSymbol, resolved, false);
- return resolved;
- }
- function isSyntacticDefault(node) {
- return ((ts.isExportAssignment(node) && !node.isExportEquals) || ts.hasModifier(node, 512) || ts.isExportSpecifier(node));
+ activeLabelList = activeLabelList.next;
+ addAntecedent(postStatementLabel, currentFlow);
+ currentFlow = finishFlowLabel(postStatementLabel);
}
- function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias) {
- if (!allowSyntheticDefaultImports) {
- return false;
- }
- if (!file || file.isDeclarationFile) {
- var defaultExportSymbol = resolveExportByName(moduleSymbol, "default", undefined, true);
- if (defaultExportSymbol && ts.some(defaultExportSymbol.declarations, isSyntacticDefault)) {
- return false;
- }
- if (resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), undefined, dontResolveAlias)) {
- return false;
- }
- return true;
+ function bindDestructuringTargetFlow(node) {
+ if (node.kind === 216 && node.operatorToken.kind === 62) {
+ bindAssignmentTargetFlow(node.left);
}
- if (!ts.isSourceFileJS(file)) {
- return hasExportAssignmentSymbol(moduleSymbol);
+ else {
+ bindAssignmentTargetFlow(node);
}
- return !file.externalModuleIndicator && !resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), undefined, dontResolveAlias);
}
- function getTargetOfImportClause(node, dontResolveAlias) {
- var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier);
- if (moduleSymbol) {
- var exportDefaultSymbol = void 0;
- if (ts.isShorthandAmbientModuleSymbol(moduleSymbol)) {
- exportDefaultSymbol = moduleSymbol;
- }
- else {
- exportDefaultSymbol = resolveExportByName(moduleSymbol, "default", node, dontResolveAlias);
- }
- var file = ts.find(moduleSymbol.declarations, ts.isSourceFile);
- var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias);
- if (!exportDefaultSymbol && !hasSyntheticDefault) {
- if (hasExportAssignmentSymbol(moduleSymbol)) {
- var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop";
- var exportEqualsSymbol = moduleSymbol.exports.get("export=");
- var exportAssignment = exportEqualsSymbol.valueDeclaration;
- var err = error(node.name, ts.Diagnostics.Module_0_can_only_be_default_imported_using_the_1_flag, symbolToString(moduleSymbol), compilerOptionName);
- ts.addRelatedInfo(err, ts.createDiagnosticForNode(exportAssignment, ts.Diagnostics.This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag, compilerOptionName));
+ function bindAssignmentTargetFlow(node) {
+ if (isNarrowableReference(node)) {
+ currentFlow = createFlowMutation(16, currentFlow, node);
+ }
+ else if (node.kind === 199) {
+ for (var _i = 0, _a = node.elements; _i < _a.length; _i++) {
+ var e = _a[_i];
+ if (e.kind === 220) {
+ bindAssignmentTargetFlow(e.expression);
}
else {
- reportNonDefaultExport(moduleSymbol, node);
+ bindDestructuringTargetFlow(e);
}
}
- else if (hasSyntheticDefault) {
- var resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
- markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, false);
- return resolved;
+ }
+ else if (node.kind === 200) {
+ for (var _b = 0, _c = node.properties; _b < _c.length; _b++) {
+ var p = _c[_b];
+ if (p.kind === 288) {
+ bindDestructuringTargetFlow(p.initializer);
+ }
+ else if (p.kind === 289) {
+ bindAssignmentTargetFlow(p.name);
+ }
+ else if (p.kind === 290) {
+ bindAssignmentTargetFlow(p.expression);
+ }
}
- markSymbolOfAliasDeclarationIfTypeOnly(node, exportDefaultSymbol, undefined, false);
- return exportDefaultSymbol;
}
}
- function reportNonDefaultExport(moduleSymbol, node) {
- var _a, _b;
- if ((_a = moduleSymbol.exports) === null || _a === void 0 ? void 0 : _a.has(node.symbol.escapedName)) {
- error(node.name, ts.Diagnostics.Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead, symbolToString(moduleSymbol), symbolToString(node.symbol));
+ function bindLogicalLikeExpression(node, trueTarget, falseTarget) {
+ var preRightLabel = createBranchLabel();
+ if (node.operatorToken.kind === 55 || node.operatorToken.kind === 75) {
+ bindCondition(node.left, preRightLabel, falseTarget);
}
else {
- var diagnostic = error(node.name, ts.Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol));
- var exportStar = (_b = moduleSymbol.exports) === null || _b === void 0 ? void 0 : _b.get("__export");
- if (exportStar) {
- var defaultExport = ts.find(exportStar.declarations, function (decl) {
- var _a, _b;
- return !!(ts.isExportDeclaration(decl) && decl.moduleSpecifier && ((_b = (_a = resolveExternalModuleName(decl, decl.moduleSpecifier)) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.has("default")));
- });
- if (defaultExport) {
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(defaultExport, ts.Diagnostics.export_Asterisk_does_not_re_export_a_default));
- }
- }
+ bindCondition(node.left, trueTarget, preRightLabel);
+ }
+ currentFlow = finishFlowLabel(preRightLabel);
+ bind(node.operatorToken);
+ if (ts.isLogicalOrCoalescingAssignmentOperator(node.operatorToken.kind)) {
+ doWithConditionalBranches(bind, node.right, trueTarget, falseTarget);
+ bindAssignmentTargetFlow(node.left);
+ addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node));
+ addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node));
+ }
+ else {
+ bindCondition(node.right, trueTarget, falseTarget);
}
}
- function getTargetOfNamespaceImport(node, dontResolveAlias) {
- var moduleSpecifier = node.parent.parent.moduleSpecifier;
- var immediate = resolveExternalModuleName(node, moduleSpecifier);
- var resolved = resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false);
- markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false);
- return resolved;
- }
- function getTargetOfNamespaceExport(node, dontResolveAlias) {
- var moduleSpecifier = node.parent.moduleSpecifier;
- var immediate = moduleSpecifier && resolveExternalModuleName(node, moduleSpecifier);
- var resolved = moduleSpecifier && resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false);
- markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false);
- return resolved;
- }
- function combineValueAndTypeSymbols(valueSymbol, typeSymbol) {
- if (valueSymbol === unknownSymbol && typeSymbol === unknownSymbol) {
- return unknownSymbol;
+ function bindPrefixUnaryExpressionFlow(node) {
+ if (node.operator === 53) {
+ var saveTrueTarget = currentTrueTarget;
+ currentTrueTarget = currentFalseTarget;
+ currentFalseTarget = saveTrueTarget;
+ bindEachChild(node);
+ currentFalseTarget = currentTrueTarget;
+ currentTrueTarget = saveTrueTarget;
}
- if (valueSymbol.flags & (788968 | 1920)) {
- return valueSymbol;
+ else {
+ bindEachChild(node);
+ if (node.operator === 45 || node.operator === 46) {
+ bindAssignmentTargetFlow(node.operand);
+ }
}
- var result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.escapedName);
- result.declarations = ts.deduplicate(ts.concatenate(valueSymbol.declarations, typeSymbol.declarations), ts.equateValues);
- result.parent = valueSymbol.parent || typeSymbol.parent;
- if (valueSymbol.valueDeclaration)
- result.valueDeclaration = valueSymbol.valueDeclaration;
- if (typeSymbol.members)
- result.members = ts.cloneMap(typeSymbol.members);
- if (valueSymbol.exports)
- result.exports = ts.cloneMap(valueSymbol.exports);
- return result;
}
- function getExportOfModule(symbol, specifier, dontResolveAlias) {
- var _a;
- if (symbol.flags & 1536) {
- var name = ((_a = specifier.propertyName) !== null && _a !== void 0 ? _a : specifier.name).escapedText;
- var exportSymbol = getExportsOfSymbol(symbol).get(name);
- var resolved = resolveSymbol(exportSymbol, dontResolveAlias);
- markSymbolOfAliasDeclarationIfTypeOnly(specifier, exportSymbol, resolved, false);
- return resolved;
+ function bindPostfixUnaryExpressionFlow(node) {
+ bindEachChild(node);
+ if (node.operator === 45 || node.operator === 46) {
+ bindAssignmentTargetFlow(node.operand);
}
}
- function getPropertyOfVariable(symbol, name) {
- if (symbol.flags & 3) {
- var typeAnnotation = symbol.valueDeclaration.type;
- if (typeAnnotation) {
- return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name));
- }
+ 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 getExternalModuleMember(node, specifier, dontResolveAlias) {
- var _a;
- if (dontResolveAlias === void 0) { dontResolveAlias = false; }
- var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
- var name = specifier.propertyName || specifier.name;
- var suppressInteropError = name.escapedText === "default" && !!(compilerOptions.allowSyntheticDefaultImports || compilerOptions.esModuleInterop);
- var targetSymbol = resolveESModuleSymbol(moduleSymbol, node.moduleSpecifier, dontResolveAlias, suppressInteropError);
- if (targetSymbol) {
- if (name.escapedText) {
- if (ts.isShorthandAmbientModuleSymbol(moduleSymbol)) {
- return moduleSymbol;
- }
- var symbolFromVariable = void 0;
- if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports.get("export=")) {
- symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name.escapedText);
- }
- else {
- symbolFromVariable = getPropertyOfVariable(targetSymbol, name.escapedText);
- }
- symbolFromVariable = resolveSymbol(symbolFromVariable, dontResolveAlias);
- var symbolFromModule = getExportOfModule(targetSymbol, specifier, dontResolveAlias);
- if (symbolFromModule === undefined && name.escapedText === "default") {
- var file = ts.find(moduleSymbol.declarations, ts.isSourceFile);
- if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias)) {
- symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
- }
+ function bindBinaryExpressionFlow(node) {
+ var workStacks = {
+ expr: [node],
+ state: [1],
+ inStrictMode: [undefined],
+ parent: [undefined],
+ };
+ var stackIndex = 0;
+ while (stackIndex >= 0) {
+ node = workStacks.expr[stackIndex];
+ switch (workStacks.state[stackIndex]) {
+ case 0: {
+ ts.setParent(node, parent);
+ var saveInStrictMode = inStrictMode;
+ bindWorker(node);
+ var saveParent = parent;
+ parent = node;
+ advanceState(1, saveInStrictMode, saveParent);
+ break;
}
- var symbol = symbolFromModule && symbolFromVariable && symbolFromModule !== symbolFromVariable ?
- combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
- symbolFromModule || symbolFromVariable;
- if (!symbol) {
- var moduleName = getFullyQualifiedName(moduleSymbol, node);
- var declarationName = ts.declarationNameToString(name);
- var suggestion = getSuggestedSymbolForNonexistentModule(name, targetSymbol);
- if (suggestion !== undefined) {
- var suggestionName = symbolToString(suggestion);
- var diagnostic = error(name, ts.Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_2, moduleName, declarationName, suggestionName);
- if (suggestion.valueDeclaration) {
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName));
+ case 1: {
+ var operator = node.operatorToken.kind;
+ if (operator === 55 || operator === 56 || operator === 60 ||
+ ts.isLogicalOrCoalescingAssignmentOperator(operator)) {
+ if (isTopLevelLogicalExpression(node)) {
+ var postExpressionLabel = createBranchLabel();
+ bindLogicalLikeExpression(node, postExpressionLabel, postExpressionLabel);
+ currentFlow = finishFlowLabel(postExpressionLabel);
+ }
+ else {
+ bindLogicalLikeExpression(node, currentTrueTarget, currentFalseTarget);
}
+ completeNode();
}
else {
- if ((_a = moduleSymbol.exports) === null || _a === void 0 ? void 0 : _a.has("default")) {
- error(name, ts.Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead, moduleName, declarationName);
- }
- else {
- reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName);
+ advanceState(2);
+ maybeBind(node.left);
+ }
+ break;
+ }
+ case 2: {
+ if (node.operatorToken.kind === 27) {
+ maybeBindExpressionFlowIfCall(node.left);
+ }
+ advanceState(3);
+ maybeBind(node.operatorToken);
+ break;
+ }
+ case 3: {
+ advanceState(4);
+ maybeBind(node.right);
+ break;
+ }
+ case 4: {
+ var operator = node.operatorToken.kind;
+ if (ts.isAssignmentOperator(operator) && !ts.isAssignmentTarget(node)) {
+ bindAssignmentTargetFlow(node.left);
+ if (operator === 62 && node.left.kind === 202) {
+ var elementAccess = node.left;
+ if (isNarrowableOperand(elementAccess.expression)) {
+ currentFlow = createFlowMutation(256, currentFlow, node);
+ }
}
}
+ completeNode();
+ break;
}
- return symbol;
+ default: return ts.Debug.fail("Invalid state " + workStacks.state[stackIndex] + " for bindBinaryExpressionFlow");
}
}
- }
- function reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName) {
- var _a;
- var localSymbol = (_a = moduleSymbol.valueDeclaration.locals) === null || _a === void 0 ? void 0 : _a.get(name.escapedText);
- var exports = moduleSymbol.exports;
- if (localSymbol) {
- var exportedEqualsSymbol = exports === null || exports === void 0 ? void 0 : exports.get("export=");
- if (exportedEqualsSymbol) {
- getSymbolIfSameReference(exportedEqualsSymbol, localSymbol) ? reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) :
- error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName);
+ function advanceState(state, isInStrictMode, parent) {
+ workStacks.state[stackIndex] = state;
+ if (isInStrictMode !== undefined) {
+ workStacks.inStrictMode[stackIndex] = isInStrictMode;
+ }
+ if (parent !== undefined) {
+ workStacks.parent[stackIndex] = parent;
+ }
+ }
+ function completeNode() {
+ if (workStacks.inStrictMode[stackIndex] !== undefined) {
+ inStrictMode = workStacks.inStrictMode[stackIndex];
+ parent = workStacks.parent[stackIndex];
+ }
+ stackIndex--;
+ }
+ function maybeBind(node) {
+ if (node && ts.isBinaryExpression(node) && !ts.isDestructuringAssignment(node)) {
+ stackIndex++;
+ workStacks.expr[stackIndex] = node;
+ workStacks.state[stackIndex] = 0;
+ workStacks.inStrictMode[stackIndex] = undefined;
+ workStacks.parent[stackIndex] = undefined;
}
else {
- var exportedSymbol = exports ? ts.find(symbolsToArray(exports), function (symbol) { return !!getSymbolIfSameReference(symbol, localSymbol); }) : undefined;
- var diagnostic = exportedSymbol ? error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2, moduleName, declarationName, symbolToString(exportedSymbol)) :
- error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName);
- ts.addRelatedInfo.apply(void 0, __spreadArrays([diagnostic], ts.map(localSymbol.declarations, function (decl, index) {
- return ts.createDiagnosticForNode(decl, index === 0 ? ts.Diagnostics._0_is_declared_here : ts.Diagnostics.and_here, declarationName);
- })));
+ bind(node);
+ }
+ }
+ }
+ function bindDeleteExpressionFlow(node) {
+ bindEachChild(node);
+ if (node.expression.kind === 201) {
+ bindAssignmentTargetFlow(node.expression);
+ }
+ }
+ function bindConditionalExpressionFlow(node) {
+ var trueLabel = createBranchLabel();
+ var falseLabel = createBranchLabel();
+ var postExpressionLabel = createBranchLabel();
+ bindCondition(node.condition, trueLabel, falseLabel);
+ currentFlow = finishFlowLabel(trueLabel);
+ bind(node.questionToken);
+ bind(node.whenTrue);
+ addAntecedent(postExpressionLabel, currentFlow);
+ currentFlow = finishFlowLabel(falseLabel);
+ bind(node.colonToken);
+ bind(node.whenFalse);
+ addAntecedent(postExpressionLabel, currentFlow);
+ currentFlow = finishFlowLabel(postExpressionLabel);
+ }
+ function bindInitializedVariableFlow(node) {
+ var name = !ts.isOmittedExpression(node) ? node.name : undefined;
+ if (ts.isBindingPattern(name)) {
+ for (var _i = 0, _a = name.elements; _i < _a.length; _i++) {
+ var child = _a[_i];
+ bindInitializedVariableFlow(child);
}
}
else {
- error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName);
+ currentFlow = createFlowMutation(16, currentFlow, node);
}
}
- function reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) {
- if (moduleKind >= ts.ModuleKind.ES2015) {
- var message = compilerOptions.esModuleInterop ? ts.Diagnostics._0_can_only_be_imported_by_using_a_default_import :
- ts.Diagnostics._0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
- error(name, message, declarationName);
+ function bindVariableDeclarationFlow(node) {
+ bindEachChild(node);
+ if (node.initializer || ts.isForInOrOfStatement(node.parent.parent)) {
+ bindInitializedVariableFlow(node);
+ }
+ }
+ function bindBindingElementFlow(node) {
+ if (ts.isBindingPattern(node.name)) {
+ bindEach(node.decorators);
+ bindEach(node.modifiers);
+ bind(node.dotDotDotToken);
+ bind(node.propertyName);
+ bind(node.initializer);
+ bind(node.name);
}
else {
- if (ts.isInJSFile(node)) {
- var message = compilerOptions.esModuleInterop ? ts.Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import :
- ts.Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
- error(name, message, declarationName);
- }
- else {
- var message = compilerOptions.esModuleInterop ? ts.Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import :
- ts.Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
- error(name, message, declarationName, declarationName, moduleName);
- }
+ bindEachChild(node);
}
}
- function getTargetOfImportSpecifier(node, dontResolveAlias) {
- var resolved = getExternalModuleMember(node.parent.parent.parent, node, dontResolveAlias);
- markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false);
- return resolved;
+ function bindJSDocTypeAlias(node) {
+ ts.setParent(node.tagName, node);
+ if (node.kind !== 325 && node.fullName) {
+ ts.setParent(node.fullName, node);
+ ts.setParentRecursive(node.fullName, false);
+ }
}
- function getTargetOfNamespaceExportDeclaration(node, dontResolveAlias) {
- var resolved = resolveExternalModuleSymbol(node.parent.symbol, dontResolveAlias);
- markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false);
- return resolved;
+ function bindJSDocClassTag(node) {
+ bindEachChild(node);
+ var host = ts.getHostSignatureFromJSDoc(node);
+ if (host && host.kind !== 165) {
+ addDeclarationToSymbol(host.symbol, host, 32);
+ }
}
- function getTargetOfExportSpecifier(node, meaning, dontResolveAlias) {
- var resolved = node.parent.parent.moduleSpecifier ?
- getExternalModuleMember(node.parent.parent, node, dontResolveAlias) :
- resolveEntityName(node.propertyName || node.name, meaning, false, dontResolveAlias);
- markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false);
- return resolved;
+ function bindOptionalExpression(node, trueTarget, falseTarget) {
+ doWithConditionalBranches(bind, node, trueTarget, falseTarget);
+ if (!ts.isOptionalChain(node) || ts.isOutermostOptionalChain(node)) {
+ addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node));
+ addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node));
+ }
}
- function getTargetOfExportAssignment(node, dontResolveAlias) {
- var expression = ts.isExportAssignment(node) ? node.expression : node.right;
- var resolved = getTargetOfAliasLikeExpression(expression, dontResolveAlias);
- markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false);
- return resolved;
+ function bindOptionalChainRest(node) {
+ switch (node.kind) {
+ case 201:
+ bind(node.questionDotToken);
+ bind(node.name);
+ break;
+ case 202:
+ bind(node.questionDotToken);
+ bind(node.argumentExpression);
+ break;
+ case 203:
+ bind(node.questionDotToken);
+ bindEach(node.typeArguments);
+ bindEach(node.arguments);
+ break;
+ }
}
- function getTargetOfAliasLikeExpression(expression, dontResolveAlias) {
- if (ts.isClassExpression(expression)) {
- return checkExpressionCached(expression).symbol;
+ function bindOptionalChain(node, trueTarget, falseTarget) {
+ var preChainLabel = ts.isOptionalChainRoot(node) ? createBranchLabel() : undefined;
+ bindOptionalExpression(node.expression, preChainLabel || trueTarget, falseTarget);
+ if (preChainLabel) {
+ currentFlow = finishFlowLabel(preChainLabel);
}
- if (!ts.isEntityName(expression) && !ts.isEntityNameExpression(expression)) {
- return undefined;
+ doWithConditionalBranches(bindOptionalChainRest, node, trueTarget, falseTarget);
+ if (ts.isOutermostOptionalChain(node)) {
+ addAntecedent(trueTarget, createFlowCondition(32, currentFlow, node));
+ addAntecedent(falseTarget, createFlowCondition(64, currentFlow, node));
}
- var aliasLike = resolveEntityName(expression, 111551 | 788968 | 1920, true, dontResolveAlias);
- if (aliasLike) {
- return aliasLike;
+ }
+ function bindOptionalChainFlow(node) {
+ if (isTopLevelLogicalExpression(node)) {
+ var postExpressionLabel = createBranchLabel();
+ bindOptionalChain(node, postExpressionLabel, postExpressionLabel);
+ currentFlow = finishFlowLabel(postExpressionLabel);
+ }
+ else {
+ bindOptionalChain(node, currentTrueTarget, currentFalseTarget);
}
- checkExpressionCached(expression);
- return getNodeLinks(expression).resolvedSymbol;
}
- function getTargetOfPropertyAssignment(node, dontRecursivelyResolve) {
- var expression = node.initializer;
- return getTargetOfAliasLikeExpression(expression, dontRecursivelyResolve);
+ function bindNonNullExpressionFlow(node) {
+ if (ts.isOptionalChain(node)) {
+ bindOptionalChainFlow(node);
+ }
+ else {
+ bindEachChild(node);
+ }
}
- function getTargetOfPropertyAccessExpression(node, dontRecursivelyResolve) {
- if (!(ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 62)) {
- return undefined;
+ function bindAccessExpressionFlow(node) {
+ if (ts.isOptionalChain(node)) {
+ bindOptionalChainFlow(node);
+ }
+ else {
+ bindEachChild(node);
}
- return getTargetOfAliasLikeExpression(node.parent.right, dontRecursivelyResolve);
}
- function getTargetOfAliasDeclaration(node, dontRecursivelyResolve) {
- if (dontRecursivelyResolve === void 0) { dontRecursivelyResolve = false; }
+ function bindCallExpressionFlow(node) {
+ if (ts.isOptionalChain(node)) {
+ bindOptionalChainFlow(node);
+ }
+ else {
+ var expr = ts.skipParentheses(node.expression);
+ if (expr.kind === 208 || expr.kind === 209) {
+ bindEach(node.typeArguments);
+ bindEach(node.arguments);
+ bind(node.expression);
+ }
+ else {
+ bindEachChild(node);
+ if (node.expression.kind === 105) {
+ currentFlow = createFlowCall(currentFlow, node);
+ }
+ }
+ }
+ if (node.expression.kind === 201) {
+ var propertyAccess = node.expression;
+ if (ts.isIdentifier(propertyAccess.name) && isNarrowableOperand(propertyAccess.expression) && ts.isPushOrUnshiftIdentifier(propertyAccess.name)) {
+ currentFlow = createFlowMutation(256, currentFlow, node);
+ }
+ }
+ }
+ function getContainerFlags(node) {
switch (node.kind) {
- case 253:
- return getTargetOfImportEqualsDeclaration(node, dontRecursivelyResolve);
+ case 221:
+ case 252:
case 255:
- return getTargetOfImportClause(node, dontRecursivelyResolve);
+ case 200:
+ case 177:
+ case 312:
+ case 281:
+ return 1;
+ case 253:
+ return 1 | 64;
case 256:
- return getTargetOfNamespaceImport(node, dontRecursivelyResolve);
- case 262:
- return getTargetOfNamespaceExport(node, dontRecursivelyResolve);
- case 258:
- return getTargetOfImportSpecifier(node, dontRecursivelyResolve);
- case 263:
- return getTargetOfExportSpecifier(node, 111551 | 788968 | 1920, dontRecursivelyResolve);
- case 259:
+ case 254:
+ case 190:
+ return 1 | 32;
+ case 297:
+ return 1 | 4 | 32;
+ case 165:
+ if (ts.isObjectLiteralOrClassExpressionMethod(node)) {
+ return 1 | 4 | 32 | 8 | 128;
+ }
+ case 166:
+ case 251:
+ case 164:
+ case 167:
+ case 168:
+ case 169:
+ case 313:
+ case 308:
+ case 174:
+ case 170:
+ case 171:
+ case 175:
+ return 1 | 4 | 32 | 8;
+ case 208:
case 209:
- return getTargetOfExportAssignment(node, dontRecursivelyResolve);
+ return 1 | 4 | 32 | 8 | 16;
+ case 257:
+ return 4;
+ case 163:
+ return node.initializer ? 4 : 0;
+ case 287:
+ case 237:
+ case 238:
+ case 239:
+ case 258:
+ return 2;
+ case 230:
+ return ts.isFunctionLike(node.parent) ? 0 : 2;
+ }
+ return 0;
+ }
+ function addToContainerChain(next) {
+ if (lastContainer) {
+ lastContainer.nextContainer = next;
+ }
+ lastContainer = next;
+ }
+ function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
+ switch (container.kind) {
+ case 256:
+ return declareModuleMember(node, symbolFlags, symbolExcludes);
+ case 297:
+ return declareSourceFileMember(node, symbolFlags, symbolExcludes);
+ case 221:
case 252:
- return getTargetOfNamespaceExportDeclaration(node, dontRecursivelyResolve);
- case 282:
- return resolveEntityName(node.name, 111551 | 788968 | 1920, true, dontRecursivelyResolve);
+ return declareClassMember(node, symbolFlags, symbolExcludes);
+ case 255:
+ return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
+ case 177:
+ case 312:
+ case 200:
+ case 253:
case 281:
- return getTargetOfPropertyAssignment(node, dontRecursivelyResolve);
- case 194:
- return getTargetOfPropertyAccessExpression(node, dontRecursivelyResolve);
- default:
- return ts.Debug.fail();
+ return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
+ case 174:
+ case 175:
+ case 169:
+ case 170:
+ case 313:
+ case 171:
+ case 165:
+ case 164:
+ case 166:
+ case 167:
+ case 168:
+ case 251:
+ case 208:
+ case 209:
+ case 308:
+ case 331:
+ case 324:
+ case 254:
+ case 190:
+ return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
}
}
- function isNonLocalAlias(symbol, excludes) {
- if (excludes === void 0) { excludes = 111551 | 788968 | 1920; }
- if (!symbol)
- return false;
- return (symbol.flags & (2097152 | excludes)) === 2097152 || !!(symbol.flags & 2097152 && symbol.flags & 67108864);
+ function declareClassMember(node, symbolFlags, symbolExcludes) {
+ return ts.hasSyntacticModifier(node, 32)
+ ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes)
+ : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
}
- function resolveSymbol(symbol, dontResolveAlias) {
- return !dontResolveAlias && isNonLocalAlias(symbol) ? resolveAlias(symbol) : symbol;
+ function declareSourceFileMember(node, symbolFlags, symbolExcludes) {
+ return ts.isExternalModule(file)
+ ? declareModuleMember(node, symbolFlags, symbolExcludes)
+ : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
}
- function resolveAlias(symbol) {
- ts.Debug.assert((symbol.flags & 2097152) !== 0, "Should only get Alias here.");
- var links = getSymbolLinks(symbol);
- if (!links.target) {
- links.target = resolvingSymbol;
- var node = getDeclarationOfAliasSymbol(symbol);
- if (!node)
- return ts.Debug.fail();
- var target = getTargetOfAliasDeclaration(node);
- if (links.target === resolvingSymbol) {
- links.target = target || unknownSymbol;
+ function hasExportDeclarations(node) {
+ var body = ts.isSourceFile(node) ? node : ts.tryCast(node.body, ts.isModuleBlock);
+ return !!body && body.statements.some(function (s) { return ts.isExportDeclaration(s) || ts.isExportAssignment(s); });
+ }
+ function setExportContextFlag(node) {
+ if (node.flags & 8388608 && !hasExportDeclarations(node)) {
+ node.flags |= 64;
+ }
+ else {
+ node.flags &= ~64;
+ }
+ }
+ function bindModuleDeclaration(node) {
+ setExportContextFlag(node);
+ if (ts.isAmbientModule(node)) {
+ if (ts.hasSyntacticModifier(node, 1)) {
+ errorOnFirstToken(node, ts.Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible);
+ }
+ if (ts.isModuleAugmentationExternal(node)) {
+ declareModuleSymbol(node);
}
else {
- error(node, ts.Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol));
+ var pattern = void 0;
+ if (node.name.kind === 10) {
+ var text = node.name.text;
+ if (ts.hasZeroOrOneAsteriskCharacter(text)) {
+ pattern = ts.tryParsePattern(text);
+ }
+ else {
+ errorOnFirstToken(node.name, ts.Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, text);
+ }
+ }
+ var symbol = declareSymbolAndAddToSymbolTable(node, 512, 110735);
+ file.patternAmbientModules = ts.append(file.patternAmbientModules, pattern && { pattern: pattern, symbol: symbol });
}
}
- else if (links.target === resolvingSymbol) {
- links.target = unknownSymbol;
+ else {
+ var state = declareModuleSymbol(node);
+ if (state !== 0) {
+ var symbol = node.symbol;
+ symbol.constEnumOnlyModule = (!(symbol.flags & (16 | 32 | 256)))
+ && state === 2
+ && symbol.constEnumOnlyModule !== false;
+ }
}
- return links.target;
}
- function tryResolveAlias(symbol) {
- var links = getSymbolLinks(symbol);
- if (links.target !== resolvingSymbol) {
- return resolveAlias(symbol);
- }
- return undefined;
+ function declareModuleSymbol(node) {
+ var state = getModuleInstanceState(node);
+ var instantiated = state !== 0;
+ declareSymbolAndAddToSymbolTable(node, instantiated ? 512 : 1024, instantiated ? 110735 : 0);
+ return state;
}
- function markSymbolOfAliasDeclarationIfTypeOnly(aliasDeclaration, immediateTarget, finalTarget, overwriteEmpty) {
- if (!aliasDeclaration)
- return false;
- var sourceSymbol = getSymbolOfNode(aliasDeclaration);
- if (ts.isTypeOnlyImportOrExportDeclaration(aliasDeclaration)) {
- var links_1 = getSymbolLinks(sourceSymbol);
- links_1.typeOnlyDeclaration = aliasDeclaration;
- return true;
+ function bindFunctionOrConstructorType(node) {
+ var symbol = createSymbol(131072, getDeclarationName(node));
+ addDeclarationToSymbol(symbol, node, 131072);
+ var typeLiteralSymbol = createSymbol(2048, "__type");
+ addDeclarationToSymbol(typeLiteralSymbol, node, 2048);
+ typeLiteralSymbol.members = ts.createSymbolTable();
+ typeLiteralSymbol.members.set(symbol.escapedName, symbol);
+ }
+ function bindObjectLiteralExpression(node) {
+ if (inStrictMode && !ts.isAssignmentTarget(node)) {
+ var seen = new ts.Map();
+ for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
+ var prop = _a[_i];
+ if (prop.kind === 290 || prop.name.kind !== 78) {
+ continue;
+ }
+ var identifier = prop.name;
+ var currentKind = prop.kind === 288 || prop.kind === 289 || prop.kind === 165
+ ? 1
+ : 2;
+ var existingKind = seen.get(identifier.escapedText);
+ if (!existingKind) {
+ seen.set(identifier.escapedText, currentKind);
+ continue;
+ }
+ if (currentKind === 1 && existingKind === 1) {
+ var span = ts.getErrorSpanForNode(file, identifier);
+ file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode));
+ }
+ }
}
- var links = getSymbolLinks(sourceSymbol);
- return markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, immediateTarget, overwriteEmpty)
- || markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, finalTarget, overwriteEmpty);
+ return bindAnonymousDeclaration(node, 4096, "__object");
}
- function markSymbolOfAliasDeclarationIfTypeOnlyWorker(aliasDeclarationLinks, target, overwriteEmpty) {
- var _a, _b, _c;
- if (target && (aliasDeclarationLinks.typeOnlyDeclaration === undefined || overwriteEmpty && aliasDeclarationLinks.typeOnlyDeclaration === false)) {
- var exportSymbol = (_b = (_a = target.exports) === null || _a === void 0 ? void 0 : _a.get("export=")) !== null && _b !== void 0 ? _b : target;
- var typeOnly = exportSymbol.declarations && ts.find(exportSymbol.declarations, ts.isTypeOnlyImportOrExportDeclaration);
- aliasDeclarationLinks.typeOnlyDeclaration = (_c = typeOnly !== null && typeOnly !== void 0 ? typeOnly : getSymbolLinks(exportSymbol).typeOnlyDeclaration) !== null && _c !== void 0 ? _c : false;
+ function bindJsxAttributes(node) {
+ return bindAnonymousDeclaration(node, 4096, "__jsxAttributes");
+ }
+ function bindJsxAttribute(node, symbolFlags, symbolExcludes) {
+ return declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
+ }
+ function bindAnonymousDeclaration(node, symbolFlags, name) {
+ var symbol = createSymbol(symbolFlags, name);
+ if (symbolFlags & (8 | 106500)) {
+ symbol.parent = container.symbol;
}
- return !!aliasDeclarationLinks.typeOnlyDeclaration;
+ addDeclarationToSymbol(symbol, node, symbolFlags);
+ return symbol;
}
- function getTypeOnlyAliasDeclaration(symbol) {
- if (!(symbol.flags & 2097152)) {
- return undefined;
+ function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) {
+ switch (blockScopeContainer.kind) {
+ case 256:
+ declareModuleMember(node, symbolFlags, symbolExcludes);
+ break;
+ case 297:
+ if (ts.isExternalOrCommonJsModule(container)) {
+ declareModuleMember(node, symbolFlags, symbolExcludes);
+ break;
+ }
+ default:
+ if (!blockScopeContainer.locals) {
+ blockScopeContainer.locals = ts.createSymbolTable();
+ addToContainerChain(blockScopeContainer);
+ }
+ declareSymbol(blockScopeContainer.locals, undefined, node, symbolFlags, symbolExcludes);
}
- var links = getSymbolLinks(symbol);
- return links.typeOnlyDeclaration || undefined;
}
- function markExportAsReferenced(node) {
- var symbol = getSymbolOfNode(node);
- var target = resolveAlias(symbol);
- if (target) {
- var markAlias = target === unknownSymbol ||
- ((target.flags & 111551) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol));
- if (markAlias) {
- markAliasSymbolAsReferenced(symbol);
+ function delayedBindJSDocTypedefTag() {
+ if (!delayedTypeAliases) {
+ return;
+ }
+ var saveContainer = container;
+ var saveLastContainer = lastContainer;
+ var saveBlockScopeContainer = blockScopeContainer;
+ var saveParent = parent;
+ var saveCurrentFlow = currentFlow;
+ for (var _i = 0, delayedTypeAliases_1 = delayedTypeAliases; _i < delayedTypeAliases_1.length; _i++) {
+ var typeAlias = delayedTypeAliases_1[_i];
+ var host = ts.getJSDocHost(typeAlias);
+ container = ts.findAncestor(host.parent, function (n) { return !!(getContainerFlags(n) & 1); }) || file;
+ blockScopeContainer = ts.getEnclosingBlockScopeContainer(host) || file;
+ currentFlow = initFlowNode({ flags: 2 });
+ parent = typeAlias;
+ bind(typeAlias.typeExpression);
+ var declName = ts.getNameOfDeclaration(typeAlias);
+ if ((ts.isJSDocEnumTag(typeAlias) || !typeAlias.fullName) && declName && ts.isPropertyAccessEntityNameExpression(declName.parent)) {
+ var isTopLevel = isTopLevelNamespaceAssignment(declName.parent);
+ if (isTopLevel) {
+ bindPotentiallyMissingNamespaces(file.symbol, declName.parent, isTopLevel, !!ts.findAncestor(declName, function (d) { return ts.isPropertyAccessExpression(d) && d.name.escapedText === "prototype"; }), false);
+ var oldContainer = container;
+ switch (ts.getAssignmentDeclarationPropertyAccessKind(declName.parent)) {
+ case 1:
+ case 2:
+ if (!ts.isExternalOrCommonJsModule(file)) {
+ container = undefined;
+ }
+ else {
+ container = file;
+ }
+ break;
+ case 4:
+ container = declName.parent.expression;
+ break;
+ case 3:
+ container = declName.parent.expression.name;
+ break;
+ case 5:
+ container = isExportsOrModuleExportsOrAlias(file, declName.parent.expression) ? file
+ : ts.isPropertyAccessExpression(declName.parent.expression) ? declName.parent.expression.name
+ : declName.parent.expression;
+ break;
+ case 0:
+ return ts.Debug.fail("Shouldn't have detected typedef or enum on non-assignment declaration");
+ }
+ if (container) {
+ declareModuleMember(typeAlias, 524288, 788968);
+ }
+ container = oldContainer;
+ }
+ }
+ else if (ts.isJSDocEnumTag(typeAlias) || !typeAlias.fullName || typeAlias.fullName.kind === 78) {
+ parent = typeAlias.parent;
+ bindBlockScopedDeclaration(typeAlias, 524288, 788968);
+ }
+ else {
+ bind(typeAlias.fullName);
}
}
+ container = saveContainer;
+ lastContainer = saveLastContainer;
+ blockScopeContainer = saveBlockScopeContainer;
+ parent = saveParent;
+ currentFlow = saveCurrentFlow;
}
- function markAliasSymbolAsReferenced(symbol) {
- var links = getSymbolLinks(symbol);
- if (!links.referenced) {
- links.referenced = true;
- var node = getDeclarationOfAliasSymbol(symbol);
- if (!node)
- return ts.Debug.fail();
- if (ts.isInternalModuleImportEqualsDeclaration(node)) {
- var target = resolveSymbol(symbol);
- if (target === unknownSymbol || target.flags & 111551) {
- checkExpressionCached(node.moduleReference);
+ function checkContextualIdentifier(node) {
+ if (!file.parseDiagnostics.length &&
+ !(node.flags & 8388608) &&
+ !(node.flags & 4194304) &&
+ !ts.isIdentifierName(node)) {
+ if (inStrictMode &&
+ node.originalKeywordKind >= 116 &&
+ node.originalKeywordKind <= 124) {
+ file.bindDiagnostics.push(createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(node)));
+ }
+ else if (node.originalKeywordKind === 130) {
+ if (ts.isExternalModule(file) && ts.isInTopLevelContext(node)) {
+ file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module, ts.declarationNameToString(node)));
}
+ else if (node.flags & 32768) {
+ file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here, ts.declarationNameToString(node)));
+ }
+ }
+ else if (node.originalKeywordKind === 124 && node.flags & 8192) {
+ file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here, ts.declarationNameToString(node)));
+ }
+ }
+ }
+ function getStrictModeIdentifierMessage(node) {
+ if (ts.getContainingClass(node)) {
+ return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode;
+ }
+ if (file.externalModuleIndicator) {
+ return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode;
+ }
+ return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode;
+ }
+ function checkPrivateIdentifier(node) {
+ if (node.escapedText === "#constructor") {
+ if (!file.parseDiagnostics.length) {
+ file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.constructor_is_a_reserved_word, ts.declarationNameToString(node)));
}
}
}
- function markConstEnumAliasAsReferenced(symbol) {
- var links = getSymbolLinks(symbol);
- if (!links.constEnumReferenced) {
- links.constEnumReferenced = true;
+ function checkStrictModeBinaryExpression(node) {
+ if (inStrictMode && ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) {
+ checkStrictModeEvalOrArguments(node, node.left);
}
}
- function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) {
- if (entityName.kind === 75 && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
- entityName = entityName.parent;
- }
- if (entityName.kind === 75 || entityName.parent.kind === 153) {
- return resolveEntityName(entityName, 1920, false, dontResolveAlias);
+ function checkStrictModeCatchClause(node) {
+ if (inStrictMode && node.variableDeclaration) {
+ checkStrictModeEvalOrArguments(node, node.variableDeclaration.name);
}
- else {
- ts.Debug.assert(entityName.parent.kind === 253);
- return resolveEntityName(entityName, 111551 | 788968 | 1920, false, dontResolveAlias);
+ }
+ function checkStrictModeDeleteExpression(node) {
+ if (inStrictMode && node.expression.kind === 78) {
+ var span = ts.getErrorSpanForNode(file, node.expression);
+ file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode));
}
}
- function getFullyQualifiedName(symbol, containingLocation) {
- return symbol.parent ? getFullyQualifiedName(symbol.parent, containingLocation) + "." + symbolToString(symbol) : symbolToString(symbol, containingLocation, undefined, 16 | 4);
+ function isEvalOrArgumentsIdentifier(node) {
+ return ts.isIdentifier(node) && (node.escapedText === "eval" || node.escapedText === "arguments");
}
- function resolveEntityName(name, meaning, ignoreErrors, dontResolveAlias, location) {
- if (ts.nodeIsMissing(name)) {
- return undefined;
- }
- var namespaceMeaning = 1920 | (ts.isInJSFile(name) ? meaning & 111551 : 0);
- var symbol;
- if (name.kind === 75) {
- var message = meaning === namespaceMeaning || ts.nodeIsSynthesized(name) ? ts.Diagnostics.Cannot_find_namespace_0 : getCannotFindNameDiagnosticForName(ts.getFirstIdentifier(name));
- var symbolFromJSPrototype = ts.isInJSFile(name) && !ts.nodeIsSynthesized(name) ? resolveEntityNameFromAssignmentDeclaration(name, meaning) : undefined;
- symbol = getMergedSymbol(resolveName(location || name, name.escapedText, meaning, ignoreErrors || symbolFromJSPrototype ? undefined : message, name, true));
- if (!symbol) {
- return getMergedSymbol(symbolFromJSPrototype);
- }
- }
- else if (name.kind === 153 || name.kind === 194) {
- var left = name.kind === 153 ? name.left : name.expression;
- var right = name.kind === 153 ? name.right : name.name;
- var namespace = resolveEntityName(left, namespaceMeaning, ignoreErrors, false, location);
- if (!namespace || ts.nodeIsMissing(right)) {
- return undefined;
- }
- else if (namespace === unknownSymbol) {
- return namespace;
- }
- if (ts.isInJSFile(name)) {
- if (namespace.valueDeclaration &&
- ts.isVariableDeclaration(namespace.valueDeclaration) &&
- namespace.valueDeclaration.initializer &&
- isCommonJsRequire(namespace.valueDeclaration.initializer)) {
- var moduleName = namespace.valueDeclaration.initializer.arguments[0];
- var moduleSym = resolveExternalModuleName(moduleName, moduleName);
- if (moduleSym) {
- var resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym);
- if (resolvedModuleSymbol) {
- namespace = resolvedModuleSymbol;
- }
- }
- }
- }
- symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(namespace), right.escapedText, meaning));
- if (!symbol) {
- if (!ignoreErrors) {
- error(right, ts.Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(namespace), ts.declarationNameToString(right));
- }
- return undefined;
+ function checkStrictModeEvalOrArguments(contextNode, name) {
+ if (name && name.kind === 78) {
+ var identifier = name;
+ if (isEvalOrArgumentsIdentifier(identifier)) {
+ var span = ts.getErrorSpanForNode(file, name);
+ file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, getStrictModeEvalOrArgumentsMessage(contextNode), ts.idText(identifier)));
}
}
- else {
- throw ts.Debug.assertNever(name, "Unknown entity name kind.");
+ }
+ function getStrictModeEvalOrArgumentsMessage(node) {
+ if (ts.getContainingClass(node)) {
+ return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode;
}
- ts.Debug.assert((ts.getCheckFlags(symbol) & 1) === 0, "Should never get an instantiated symbol here.");
- if (!ts.nodeIsSynthesized(name) && ts.isEntityName(name) && (symbol.flags & 2097152 || name.parent.kind === 259)) {
- markSymbolOfAliasDeclarationIfTypeOnly(ts.getAliasDeclarationFromName(name), symbol, undefined, true);
+ if (file.externalModuleIndicator) {
+ return ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode;
}
- return (symbol.flags & meaning) || dontResolveAlias ? symbol : resolveAlias(symbol);
+ return ts.Diagnostics.Invalid_use_of_0_in_strict_mode;
}
- function resolveEntityNameFromAssignmentDeclaration(name, meaning) {
- if (isJSDocTypeReference(name.parent)) {
- var secondaryLocation = getAssignmentDeclarationLocation(name.parent);
- if (secondaryLocation) {
- return resolveName(secondaryLocation, name.escapedText, meaning, undefined, name, true);
- }
+ function checkStrictModeFunctionName(node) {
+ if (inStrictMode) {
+ checkStrictModeEvalOrArguments(node, node.name);
}
}
- function getAssignmentDeclarationLocation(node) {
- var typeAlias = ts.findAncestor(node, function (node) { return !(ts.isJSDocNode(node) || node.flags & 4194304) ? "quit" : ts.isJSDocTypeAlias(node); });
- if (typeAlias) {
- return;
+ function getStrictModeBlockScopeFunctionDeclarationMessage(node) {
+ if (ts.getContainingClass(node)) {
+ return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode;
}
- var host = ts.getJSDocHost(node);
- if (ts.isExpressionStatement(host) &&
- ts.isBinaryExpression(host.expression) &&
- ts.getAssignmentDeclarationKind(host.expression) === 3) {
- var symbol = getSymbolOfNode(host.expression.left);
- if (symbol) {
- return getDeclarationOfJSPrototypeContainer(symbol);
- }
+ if (file.externalModuleIndicator) {
+ return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode;
}
- if ((ts.isObjectLiteralMethod(host) || ts.isPropertyAssignment(host)) &&
- ts.isBinaryExpression(host.parent.parent) &&
- ts.getAssignmentDeclarationKind(host.parent.parent) === 6) {
- var symbol = getSymbolOfNode(host.parent.parent.left);
- if (symbol) {
- return getDeclarationOfJSPrototypeContainer(symbol);
+ return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5;
+ }
+ function checkStrictModeFunctionDeclaration(node) {
+ if (languageVersion < 2) {
+ if (blockScopeContainer.kind !== 297 &&
+ blockScopeContainer.kind !== 256 &&
+ !ts.isFunctionLike(blockScopeContainer)) {
+ var errorSpan = ts.getErrorSpanForNode(file, node);
+ file.bindDiagnostics.push(ts.createFileDiagnostic(file, errorSpan.start, errorSpan.length, getStrictModeBlockScopeFunctionDeclarationMessage(node)));
}
}
- var sig = ts.getEffectiveJSDocHost(node);
- if (sig && ts.isFunctionLike(sig)) {
- var symbol = getSymbolOfNode(sig);
- return symbol && symbol.valueDeclaration;
+ }
+ function checkStrictModeNumericLiteral(node) {
+ if (inStrictMode && node.numericLiteralFlags & 32) {
+ file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
}
}
- function getDeclarationOfJSPrototypeContainer(symbol) {
- var decl = symbol.parent.valueDeclaration;
- if (!decl) {
- return undefined;
+ function checkStrictModePostfixUnaryExpression(node) {
+ if (inStrictMode) {
+ checkStrictModeEvalOrArguments(node, node.operand);
}
- var initializer = ts.isAssignmentDeclaration(decl) ? ts.getAssignedExpandoInitializer(decl) :
- ts.hasOnlyExpressionInitializer(decl) ? ts.getDeclaredExpandoInitializer(decl) :
- undefined;
- return initializer || decl;
}
- function getExpandoSymbol(symbol) {
- var decl = symbol.valueDeclaration;
- if (!decl || !ts.isInJSFile(decl) || symbol.flags & 524288 || ts.getExpandoInitializer(decl, false)) {
- return undefined;
+ function checkStrictModePrefixUnaryExpression(node) {
+ if (inStrictMode) {
+ if (node.operator === 45 || node.operator === 46) {
+ checkStrictModeEvalOrArguments(node, node.operand);
+ }
}
- var init = ts.isVariableDeclaration(decl) ? ts.getDeclaredExpandoInitializer(decl) : ts.getAssignedExpandoInitializer(decl);
- if (init) {
- var initSymbol = getSymbolOfNode(init);
- if (initSymbol) {
- return mergeJSSymbols(initSymbol, symbol);
+ }
+ function checkStrictModeWithStatement(node) {
+ if (inStrictMode) {
+ errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
+ }
+ }
+ function checkStrictModeLabeledStatement(node) {
+ if (inStrictMode && options.target >= 2) {
+ if (ts.isDeclarationStatement(node.statement) || ts.isVariableStatement(node.statement)) {
+ errorOnFirstToken(node.label, ts.Diagnostics.A_label_is_not_allowed_here);
}
}
}
- function resolveExternalModuleName(location, moduleReferenceExpression, ignoreErrors) {
- return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? undefined : ts.Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations);
+ function errorOnFirstToken(node, message, arg0, arg1, arg2) {
+ var span = ts.getSpanOfTokenAtPosition(file, node.pos);
+ file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
}
- function resolveExternalModuleNameWorker(location, moduleReferenceExpression, moduleNotFoundError, isForAugmentation) {
- if (isForAugmentation === void 0) { isForAugmentation = false; }
- return ts.isStringLiteralLike(moduleReferenceExpression)
- ? resolveExternalModule(location, moduleReferenceExpression.text, moduleNotFoundError, moduleReferenceExpression, isForAugmentation)
- : undefined;
+ function errorOrSuggestionOnNode(isError, node, message) {
+ errorOrSuggestionOnRange(isError, node, node, message);
}
- function resolveExternalModule(location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
- if (isForAugmentation === void 0) { isForAugmentation = false; }
- if (ts.startsWith(moduleReference, "@types/")) {
- var diag = ts.Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1;
- var withoutAtTypePrefix = ts.removePrefix(moduleReference, "@types/");
- error(errorNode, diag, withoutAtTypePrefix, moduleReference);
- }
- var ambientModule = tryFindAmbientModule(moduleReference, true);
- if (ambientModule) {
- return ambientModule;
+ function errorOrSuggestionOnRange(isError, startNode, endNode, message) {
+ addErrorOrSuggestionDiagnostic(isError, { pos: ts.getTokenPosOfNode(startNode, file), end: endNode.end }, message);
+ }
+ function addErrorOrSuggestionDiagnostic(isError, range, message) {
+ var diag = ts.createFileDiagnostic(file, range.pos, range.end - range.pos, message);
+ if (isError) {
+ file.bindDiagnostics.push(diag);
}
- var currentSourceFile = ts.getSourceFileOfNode(location);
- var resolvedModule = ts.getResolvedModule(currentSourceFile, moduleReference);
- var resolutionDiagnostic = resolvedModule && ts.getResolutionDiagnostic(compilerOptions, resolvedModule);
- var sourceFile = resolvedModule && !resolutionDiagnostic && host.getSourceFile(resolvedModule.resolvedFileName);
- if (sourceFile) {
- if (sourceFile.symbol) {
- if (resolvedModule.isExternalLibraryImport && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
- errorOnImplicitAnyModule(false, errorNode, resolvedModule, moduleReference);
- }
- return getMergedSymbol(sourceFile.symbol);
- }
- if (moduleNotFoundError) {
- error(errorNode, ts.Diagnostics.File_0_is_not_a_module, sourceFile.fileName);
- }
- return undefined;
+ else {
+ file.bindSuggestionDiagnostics = ts.append(file.bindSuggestionDiagnostics, __assign(__assign({}, diag), { category: ts.DiagnosticCategory.Suggestion }));
}
- if (patternAmbientModules) {
- var pattern = ts.findBestPatternMatch(patternAmbientModules, function (_) { return _.pattern; }, moduleReference);
- if (pattern) {
- var augmentation = patternAmbientModuleAugmentations && patternAmbientModuleAugmentations.get(moduleReference);
- if (augmentation) {
- return getMergedSymbol(augmentation);
- }
- return getMergedSymbol(pattern.symbol);
- }
+ }
+ function bind(node) {
+ if (!node) {
+ return;
}
- if (resolvedModule && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension) && resolutionDiagnostic === undefined || resolutionDiagnostic === ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type) {
- if (isForAugmentation) {
- var diag = ts.Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented;
- error(errorNode, diag, moduleReference, resolvedModule.resolvedFileName);
+ ts.setParent(node, parent);
+ var saveInStrictMode = inStrictMode;
+ bindWorker(node);
+ if (node.kind > 156) {
+ var saveParent = parent;
+ parent = node;
+ var containerFlags = getContainerFlags(node);
+ if (containerFlags === 0) {
+ bindChildren(node);
}
else {
- errorOnImplicitAnyModule(noImplicitAny && !!moduleNotFoundError, errorNode, resolvedModule, moduleReference);
+ bindContainer(node, containerFlags);
}
- return undefined;
+ parent = saveParent;
}
- if (moduleNotFoundError) {
- if (resolvedModule) {
- var redirect = host.getProjectReferenceRedirect(resolvedModule.resolvedFileName);
- if (redirect) {
- error(errorNode, ts.Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, resolvedModule.resolvedFileName);
- return undefined;
+ else {
+ var saveParent = parent;
+ if (node.kind === 1)
+ parent = node;
+ bindJSDoc(node);
+ parent = saveParent;
+ }
+ inStrictMode = saveInStrictMode;
+ }
+ function bindJSDoc(node) {
+ if (ts.hasJSDocNodes(node)) {
+ if (ts.isInJSFile(node)) {
+ for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) {
+ var j = _a[_i];
+ bind(j);
}
}
- if (resolutionDiagnostic) {
- error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName);
- }
else {
- var tsExtension = ts.tryExtractTSExtension(moduleReference);
- if (tsExtension) {
- var diag = ts.Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
- error(errorNode, diag, tsExtension, ts.removeExtension(moduleReference, tsExtension));
- }
- else if (!compilerOptions.resolveJsonModule &&
- ts.fileExtensionIs(moduleReference, ".json") &&
- ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs &&
- ts.hasJsonModuleEmitEnabled(compilerOptions)) {
- error(errorNode, ts.Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
- }
- else {
- error(errorNode, moduleNotFoundError, moduleReference);
+ for (var _b = 0, _c = node.jsDoc; _b < _c.length; _b++) {
+ var j = _c[_b];
+ ts.setParent(j, node);
+ ts.setParentRecursive(j, false);
}
}
}
- return undefined;
- }
- function errorOnImplicitAnyModule(isError, errorNode, _a, moduleReference) {
- var packageId = _a.packageId, resolvedFileName = _a.resolvedFileName;
- var errorInfo = !ts.isExternalModuleNameRelative(moduleReference) && packageId
- ? typesPackageExists(packageId.name)
- ? ts.chainDiagnosticMessages(undefined, ts.Diagnostics.If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1, packageId.name, ts.mangleScopedPackageName(packageId.name))
- : ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0, moduleReference, ts.mangleScopedPackageName(packageId.name))
- : undefined;
- errorOrSuggestion(isError, errorNode, ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type, moduleReference, resolvedFileName));
}
- function typesPackageExists(packageName) {
- return getPackagesSet().has(ts.getTypesPackageName(packageName));
- }
- function resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) {
- if (moduleSymbol === null || moduleSymbol === void 0 ? void 0 : moduleSymbol.exports) {
- var exportEquals = resolveSymbol(moduleSymbol.exports.get("export="), dontResolveAlias);
- var exported = getCommonJsExportEquals(getMergedSymbol(exportEquals), getMergedSymbol(moduleSymbol));
- return getMergedSymbol(exported) || moduleSymbol;
+ function updateStrictModeStatementList(statements) {
+ if (!inStrictMode) {
+ for (var _i = 0, statements_3 = statements; _i < statements_3.length; _i++) {
+ var statement = statements_3[_i];
+ if (!ts.isPrologueDirective(statement)) {
+ return;
+ }
+ if (isUseStrictPrologueDirective(statement)) {
+ inStrictMode = true;
+ return;
+ }
+ }
}
- return undefined;
}
- function getCommonJsExportEquals(exported, moduleSymbol) {
- if (!exported || exported === unknownSymbol || exported === moduleSymbol || moduleSymbol.exports.size === 1 || exported.flags & 2097152) {
- return exported;
- }
- var links = getSymbolLinks(exported);
- if (links.cjsExportMerged) {
- return links.cjsExportMerged;
- }
- var merged = exported.flags & 33554432 ? exported : cloneSymbol(exported);
- merged.flags = merged.flags | 512;
- if (merged.exports === undefined) {
- merged.exports = ts.createSymbolTable();
- }
- moduleSymbol.exports.forEach(function (s, name) {
- if (name === "export=")
- 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 isUseStrictPrologueDirective(node) {
+ var nodeText = ts.getSourceTextOfNodeFromSourceFile(file, node.expression);
+ return nodeText === '"use strict"' || nodeText === "'use strict'";
}
- function resolveESModuleSymbol(moduleSymbol, referencingLocation, dontResolveAlias, suppressInteropError) {
- var symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias);
- if (!dontResolveAlias && symbol) {
- if (!suppressInteropError && !(symbol.flags & (1536 | 3)) && !ts.getDeclarationOfKind(symbol, 290)) {
- var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015
- ? "allowSyntheticDefaultImports"
- : "esModuleInterop";
- error(referencingLocation, ts.Diagnostics.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, compilerOptionName);
- return symbol;
- }
- if (compilerOptions.esModuleInterop) {
- var referenceParent = referencingLocation.parent;
- if ((ts.isImportDeclaration(referenceParent) && ts.getNamespaceDeclarationNode(referenceParent)) ||
- ts.isImportCall(referenceParent)) {
- var type = getTypeOfSymbol(symbol);
- var sigs = getSignaturesOfStructuredType(type, 0);
- if (!sigs || !sigs.length) {
- sigs = getSignaturesOfStructuredType(type, 1);
- }
- if (sigs && sigs.length) {
- var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol);
- var result = createSymbol(symbol.flags, symbol.escapedName);
- result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
- result.parent = symbol.parent;
- result.target = symbol;
- result.originatingImport = referenceParent;
- if (symbol.valueDeclaration)
- result.valueDeclaration = symbol.valueDeclaration;
- if (symbol.constEnumOnlyModule)
- result.constEnumOnlyModule = true;
- if (symbol.members)
- result.members = ts.cloneMap(symbol.members);
- if (symbol.exports)
- result.exports = ts.cloneMap(symbol.exports);
- var resolvedModuleType = resolveStructuredTypeMembers(moduleType);
- result.type = createAnonymousType(result, resolvedModuleType.members, ts.emptyArray, ts.emptyArray, resolvedModuleType.stringIndexInfo, resolvedModuleType.numberIndexInfo);
- return result;
+ function bindWorker(node) {
+ switch (node.kind) {
+ case 78:
+ if (node.isInJSDocNamespace) {
+ var parentNode = node.parent;
+ while (parentNode && !ts.isJSDocTypeAlias(parentNode)) {
+ parentNode = parentNode.parent;
}
+ bindBlockScopedDeclaration(parentNode, 524288, 788968);
+ break;
+ }
+ case 107:
+ if (currentFlow && (ts.isExpression(node) || parent.kind === 289)) {
+ node.flowNode = currentFlow;
+ }
+ return checkContextualIdentifier(node);
+ case 105:
+ node.flowNode = currentFlow;
+ break;
+ case 79:
+ return checkPrivateIdentifier(node);
+ case 201:
+ case 202:
+ var expr = node;
+ if (currentFlow && isNarrowableReference(expr)) {
+ expr.flowNode = currentFlow;
+ }
+ if (ts.isSpecialPropertyDeclaration(expr)) {
+ bindSpecialPropertyDeclaration(expr);
+ }
+ if (ts.isInJSFile(expr) &&
+ file.commonJsModuleIndicator &&
+ ts.isModuleExportsAccessExpression(expr) &&
+ !lookupSymbolForName(blockScopeContainer, "module")) {
+ declareSymbol(file.locals, undefined, expr.expression, 1 | 134217728, 111550);
+ }
+ break;
+ case 216:
+ var specialKind = ts.getAssignmentDeclarationKind(node);
+ switch (specialKind) {
+ case 1:
+ bindExportsPropertyAssignment(node);
+ break;
+ case 2:
+ bindModuleExportsAssignment(node);
+ break;
+ case 3:
+ bindPrototypePropertyAssignment(node.left, node);
+ break;
+ case 6:
+ bindPrototypeAssignment(node);
+ break;
+ case 4:
+ bindThisPropertyAssignment(node);
+ break;
+ case 5:
+ var expression = node.left.expression;
+ if (ts.isInJSFile(node) && ts.isIdentifier(expression)) {
+ var symbol = lookupSymbolForName(blockScopeContainer, expression.escapedText);
+ if (ts.isThisInitializedDeclaration(symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration)) {
+ bindThisPropertyAssignment(node);
+ break;
+ }
+ }
+ bindSpecialPropertyAssignment(node);
+ break;
+ case 0:
+ break;
+ default:
+ ts.Debug.fail("Unknown binary expression special property assignment kind");
+ }
+ return checkStrictModeBinaryExpression(node);
+ case 287:
+ return checkStrictModeCatchClause(node);
+ case 210:
+ return checkStrictModeDeleteExpression(node);
+ case 8:
+ return checkStrictModeNumericLiteral(node);
+ case 215:
+ return checkStrictModePostfixUnaryExpression(node);
+ case 214:
+ return checkStrictModePrefixUnaryExpression(node);
+ case 243:
+ return checkStrictModeWithStatement(node);
+ case 245:
+ return checkStrictModeLabeledStatement(node);
+ case 187:
+ seenThisKeyword = true;
+ return;
+ case 172:
+ break;
+ case 159:
+ return bindTypeParameter(node);
+ case 160:
+ return bindParameter(node);
+ case 249:
+ return bindVariableDeclarationOrBindingElement(node);
+ case 198:
+ node.flowNode = currentFlow;
+ return bindVariableDeclarationOrBindingElement(node);
+ case 163:
+ case 162:
+ return bindPropertyWorker(node);
+ case 288:
+ case 289:
+ return bindPropertyOrMethodOrAccessor(node, 4, 0);
+ case 291:
+ return bindPropertyOrMethodOrAccessor(node, 8, 900095);
+ case 169:
+ case 170:
+ case 171:
+ return declareSymbolAndAddToSymbolTable(node, 131072, 0);
+ case 165:
+ case 164:
+ return bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 16777216 : 0), ts.isObjectLiteralMethod(node) ? 0 : 103359);
+ case 251:
+ return bindFunctionDeclaration(node);
+ case 166:
+ return declareSymbolAndAddToSymbolTable(node, 16384, 0);
+ case 167:
+ return bindPropertyOrMethodOrAccessor(node, 32768, 46015);
+ case 168:
+ return bindPropertyOrMethodOrAccessor(node, 65536, 78783);
+ case 174:
+ case 308:
+ case 313:
+ case 175:
+ return bindFunctionOrConstructorType(node);
+ case 177:
+ case 312:
+ case 190:
+ return bindAnonymousTypeWorker(node);
+ case 319:
+ return bindJSDocClassTag(node);
+ case 200:
+ return bindObjectLiteralExpression(node);
+ case 208:
+ case 209:
+ return bindFunctionExpression(node);
+ case 203:
+ var assignmentKind = ts.getAssignmentDeclarationKind(node);
+ switch (assignmentKind) {
+ case 7:
+ return bindObjectDefinePropertyAssignment(node);
+ case 8:
+ return bindObjectDefinePropertyExport(node);
+ case 9:
+ return bindObjectDefinePrototypeProperty(node);
+ case 0:
+ break;
+ default:
+ return ts.Debug.fail("Unknown call expression assignment declaration kind");
+ }
+ if (ts.isInJSFile(node)) {
+ bindCallExpression(node);
+ }
+ break;
+ case 221:
+ case 252:
+ inStrictMode = true;
+ return bindClassLikeDeclaration(node);
+ case 253:
+ return bindBlockScopedDeclaration(node, 64, 788872);
+ case 254:
+ return bindBlockScopedDeclaration(node, 524288, 788968);
+ case 255:
+ return bindEnumDeclaration(node);
+ case 256:
+ return bindModuleDeclaration(node);
+ case 281:
+ return bindJsxAttributes(node);
+ case 280:
+ return bindJsxAttribute(node, 4, 0);
+ case 260:
+ case 263:
+ case 265:
+ case 270:
+ return declareSymbolAndAddToSymbolTable(node, 2097152, 2097152);
+ case 259:
+ return bindNamespaceExportDeclaration(node);
+ case 262:
+ return bindImportClause(node);
+ case 267:
+ return bindExportDeclaration(node);
+ case 266:
+ return bindExportAssignment(node);
+ case 297:
+ updateStrictModeStatementList(node.statements);
+ return bindSourceFileIfExternalModule();
+ case 230:
+ if (!ts.isFunctionLike(node.parent)) {
+ return;
}
- }
+ case 257:
+ return updateStrictModeStatementList(node.statements);
+ case 326:
+ if (node.parent.kind === 313) {
+ return bindParameter(node);
+ }
+ if (node.parent.kind !== 312) {
+ break;
+ }
+ case 333:
+ var propTag = node;
+ var flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === 307 ?
+ 4 | 16777216 :
+ 4;
+ return declareSymbolAndAddToSymbolTable(propTag, flags, 0);
+ case 331:
+ case 324:
+ case 325:
+ return (delayedTypeAliases || (delayedTypeAliases = [])).push(node);
}
- return symbol;
- }
- function hasExportAssignmentSymbol(moduleSymbol) {
- return moduleSymbol.exports.get("export=") !== undefined;
- }
- function getExportsOfModuleAsArray(moduleSymbol) {
- return symbolsToArray(getExportsOfModule(moduleSymbol));
}
- function getExportsAndPropertiesOfModule(moduleSymbol) {
- var exports = getExportsOfModuleAsArray(moduleSymbol);
- var exportEquals = resolveExternalModuleSymbol(moduleSymbol);
- if (exportEquals !== moduleSymbol) {
- ts.addRange(exports, getPropertiesOfType(getTypeOfSymbol(exportEquals)));
- }
- return exports;
+ function bindPropertyWorker(node) {
+ return bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 16777216 : 0), 0);
}
- function tryGetMemberInModuleExports(memberName, moduleSymbol) {
- var symbolTable = getExportsOfModule(moduleSymbol);
- if (symbolTable) {
- return symbolTable.get(memberName);
- }
+ function bindAnonymousTypeWorker(node) {
+ return bindAnonymousDeclaration(node, 2048, "__type");
}
- function tryGetMemberInModuleExportsAndProperties(memberName, moduleSymbol) {
- var symbol = tryGetMemberInModuleExports(memberName, moduleSymbol);
- if (symbol) {
- return symbol;
+ function bindSourceFileIfExternalModule() {
+ setExportContextFlag(file);
+ if (ts.isExternalModule(file)) {
+ bindSourceFileAsExternalModule();
}
- var exportEquals = resolveExternalModuleSymbol(moduleSymbol);
- if (exportEquals === moduleSymbol) {
- return undefined;
+ else if (ts.isJsonSourceFile(file)) {
+ bindSourceFileAsExternalModule();
+ var originalSymbol = file.symbol;
+ declareSymbol(file.symbol.exports, file.symbol, file, 4, 67108863);
+ file.symbol = originalSymbol;
}
- var type = getTypeOfSymbol(exportEquals);
- return type.flags & 131068 ||
- ts.getObjectFlags(type) & 1 ||
- isArrayOrTupleLikeType(type)
- ? undefined
- : getPropertyOfType(type, memberName);
}
- function getExportsOfSymbol(symbol) {
- return symbol.flags & 6256 ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedExports") :
- symbol.flags & 1536 ? getExportsOfModule(symbol) :
- symbol.exports || emptySymbols;
- }
- function getExportsOfModule(moduleSymbol) {
- var links = getSymbolLinks(moduleSymbol);
- return links.resolvedExports || (links.resolvedExports = getExportsOfModuleWorker(moduleSymbol));
- }
- function extendExportSymbols(target, source, lookupTable, exportNode) {
- if (!source)
- return;
- source.forEach(function (sourceSymbol, id) {
- if (id === "default")
- return;
- var targetSymbol = target.get(id);
- if (!targetSymbol) {
- target.set(id, sourceSymbol);
- if (lookupTable && exportNode) {
- lookupTable.set(id, {
- specifierText: ts.getTextOfNode(exportNode.moduleSpecifier)
- });
- }
- }
- else if (lookupTable && exportNode && targetSymbol && resolveSymbol(targetSymbol) !== resolveSymbol(sourceSymbol)) {
- var collisionTracker = lookupTable.get(id);
- if (!collisionTracker.exportsWithDuplicate) {
- collisionTracker.exportsWithDuplicate = [exportNode];
- }
- else {
- collisionTracker.exportsWithDuplicate.push(exportNode);
- }
- }
- });
+ function bindSourceFileAsExternalModule() {
+ bindAnonymousDeclaration(file, 512, "\"" + ts.removeFileExtension(file.fileName) + "\"");
}
- function getExportsOfModuleWorker(moduleSymbol) {
- var visitedSymbols = [];
- moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
- return visit(moduleSymbol) || emptySymbols;
- function visit(symbol) {
- if (!(symbol && symbol.exports && ts.pushIfUnique(visitedSymbols, symbol))) {
- return;
- }
- var symbols = ts.cloneMap(symbol.exports);
- var exportStars = symbol.exports.get("__export");
- if (exportStars) {
- var nestedSymbols = ts.createSymbolTable();
- var lookupTable_1 = ts.createMap();
- for (var _i = 0, _a = exportStars.declarations; _i < _a.length; _i++) {
- var node = _a[_i];
- var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
- var exportedSymbols = visit(resolvedModule);
- extendExportSymbols(nestedSymbols, exportedSymbols, lookupTable_1, node);
- }
- lookupTable_1.forEach(function (_a, id) {
- var exportsWithDuplicate = _a.exportsWithDuplicate;
- if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || symbols.has(id)) {
- return;
- }
- for (var _i = 0, exportsWithDuplicate_1 = exportsWithDuplicate; _i < exportsWithDuplicate_1.length; _i++) {
- var node = exportsWithDuplicate_1[_i];
- diagnostics.add(ts.createDiagnosticForNode(node, ts.Diagnostics.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity, lookupTable_1.get(id).specifierText, ts.unescapeLeadingUnderscores(id)));
- }
- });
- extendExportSymbols(symbols, nestedSymbols);
+ function bindExportAssignment(node) {
+ if (!container.symbol || !container.symbol.exports) {
+ bindAnonymousDeclaration(node, 2097152, getDeclarationName(node));
+ }
+ else {
+ var flags = ts.exportAssignmentIsAlias(node)
+ ? 2097152
+ : 4;
+ var symbol = declareSymbol(container.symbol.exports, container.symbol, node, flags, 67108863);
+ if (node.isExportEquals) {
+ ts.setValueDeclaration(symbol, node);
}
- return symbols;
}
}
- function getMergedSymbol(symbol) {
- var merged;
- return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol;
- }
- function getSymbolOfNode(node) {
- return getMergedSymbol(node.symbol && getLateBoundSymbol(node.symbol));
- }
- function getParentOfSymbol(symbol) {
- return getMergedSymbol(symbol.parent && getLateBoundSymbol(symbol.parent));
- }
- function getAlternativeContainingModules(symbol, enclosingDeclaration) {
- var containingFile = ts.getSourceFileOfNode(enclosingDeclaration);
- var id = "" + getNodeId(containingFile);
- var links = getSymbolLinks(symbol);
- var results;
- if (links.extendedContainersByFile && (results = links.extendedContainersByFile.get(id))) {
- return results;
- }
- if (containingFile && containingFile.imports) {
- for (var _i = 0, _a = containingFile.imports; _i < _a.length; _i++) {
- var importRef = _a[_i];
- if (ts.nodeIsSynthesized(importRef))
- continue;
- var resolvedModule = resolveExternalModuleName(enclosingDeclaration, importRef, true);
- if (!resolvedModule)
- continue;
- var ref = getAliasForSymbolInContainer(resolvedModule, symbol);
- if (!ref)
- continue;
- results = ts.append(results, resolvedModule);
- }
- if (ts.length(results)) {
- (links.extendedContainersByFile || (links.extendedContainersByFile = ts.createMap())).set(id, results);
- return results;
- }
+ function bindNamespaceExportDeclaration(node) {
+ if (node.modifiers && node.modifiers.length) {
+ file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Modifiers_cannot_appear_here));
}
- if (links.extendedContainers) {
- return links.extendedContainers;
+ var diag = !ts.isSourceFile(node.parent) ? ts.Diagnostics.Global_module_exports_may_only_appear_at_top_level
+ : !ts.isExternalModule(node.parent) ? ts.Diagnostics.Global_module_exports_may_only_appear_in_module_files
+ : !node.parent.isDeclarationFile ? ts.Diagnostics.Global_module_exports_may_only_appear_in_declaration_files
+ : undefined;
+ if (diag) {
+ file.bindDiagnostics.push(createDiagnosticForNode(node, diag));
}
- var otherFiles = host.getSourceFiles();
- for (var _b = 0, otherFiles_1 = otherFiles; _b < otherFiles_1.length; _b++) {
- var file = otherFiles_1[_b];
- if (!ts.isExternalModule(file))
- continue;
- var sym = getSymbolOfNode(file);
- var ref = getAliasForSymbolInContainer(sym, symbol);
- if (!ref)
- continue;
- results = ts.append(results, sym);
+ else {
+ file.symbol.globalExports = file.symbol.globalExports || ts.createSymbolTable();
+ declareSymbol(file.symbol.globalExports, file.symbol, node, 2097152, 2097152);
}
- return links.extendedContainers = results || ts.emptyArray;
}
- function getContainersOfSymbol(symbol, enclosingDeclaration) {
- var container = getParentOfSymbol(symbol);
- if (container && !(symbol.flags & 262144)) {
- var additionalContainers = ts.mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
- var reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
- if (enclosingDeclaration && getAccessibleSymbolChain(container, enclosingDeclaration, 1920, false)) {
- return ts.concatenate(ts.concatenate([container], additionalContainers), reexportContainers);
- }
- var res = ts.append(additionalContainers, container);
- return ts.concatenate(res, reexportContainers);
+ function bindExportDeclaration(node) {
+ if (!container.symbol || !container.symbol.exports) {
+ bindAnonymousDeclaration(node, 8388608, getDeclarationName(node));
}
- var candidates = ts.mapDefined(symbol.declarations, function (d) {
- if (!ts.isAmbientModule(d) && d.parent && hasNonGlobalAugmentationExternalModuleSymbol(d.parent)) {
- return getSymbolOfNode(d.parent);
- }
- if (ts.isClassExpression(d) && ts.isBinaryExpression(d.parent) && d.parent.operatorToken.kind === 62 && ts.isAccessExpression(d.parent.left) && ts.isEntityNameExpression(d.parent.left.expression)) {
- if (ts.isModuleExportsAccessExpression(d.parent.left) || ts.isExportsIdentifier(d.parent.left.expression)) {
- return getSymbolOfNode(ts.getSourceFileOfNode(d));
- }
- checkExpressionCached(d.parent.left.expression);
- return getNodeLinks(d.parent.left.expression).resolvedSymbol;
- }
- });
- if (!ts.length(candidates)) {
- return undefined;
+ else if (!node.exportClause) {
+ declareSymbol(container.symbol.exports, container.symbol, node, 8388608, 0);
}
- return ts.mapDefined(candidates, function (candidate) { return getAliasForSymbolInContainer(candidate, symbol) ? candidate : undefined; });
- function fileSymbolIfFileSymbolExportEqualsContainer(d) {
- return container && getFileSymbolIfFileSymbolExportEqualsContainer(d, container);
+ else if (ts.isNamespaceExport(node.exportClause)) {
+ ts.setParent(node.exportClause, node);
+ declareSymbol(container.symbol.exports, container.symbol, node.exportClause, 2097152, 2097152);
}
}
- function getFileSymbolIfFileSymbolExportEqualsContainer(d, container) {
- var fileSymbol = getExternalModuleContainer(d);
- var exported = fileSymbol && fileSymbol.exports && fileSymbol.exports.get("export=");
- return exported && getSymbolIfSameReference(exported, container) ? fileSymbol : undefined;
+ function bindImportClause(node) {
+ if (node.name) {
+ declareSymbolAndAddToSymbolTable(node, 2097152, 2097152);
+ }
}
- function getAliasForSymbolInContainer(container, symbol) {
- if (container === getParentOfSymbol(symbol)) {
- return symbol;
+ function setCommonJsModuleIndicator(node) {
+ if (file.externalModuleIndicator) {
+ return false;
}
- var exportEquals = container.exports && container.exports.get("export=");
- if (exportEquals && getSymbolIfSameReference(exportEquals, symbol)) {
- return container;
+ if (!file.commonJsModuleIndicator) {
+ file.commonJsModuleIndicator = node;
+ bindSourceFileAsExternalModule();
}
- var exports = getExportsOfSymbol(container);
- var quick = exports.get(symbol.escapedName);
- if (quick && getSymbolIfSameReference(quick, symbol)) {
- return quick;
+ return true;
+ }
+ function bindObjectDefinePropertyExport(node) {
+ if (!setCommonJsModuleIndicator(node)) {
+ return;
}
- return ts.forEachEntry(exports, function (exported) {
- if (getSymbolIfSameReference(exported, symbol)) {
- return exported;
+ var symbol = forEachIdentifierInEntityName(node.arguments[0], undefined, function (id, symbol) {
+ if (symbol) {
+ addDeclarationToSymbol(symbol, id, 1536 | 67108864);
}
+ return symbol;
});
- }
- function getSymbolIfSameReference(s1, s2) {
- if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
- return s1;
+ if (symbol) {
+ var flags = 4 | 1048576;
+ declareSymbol(symbol.exports, symbol, node, flags, 0);
}
}
- function getExportSymbolOfValueSymbolIfExported(symbol) {
- return getMergedSymbol(symbol && (symbol.flags & 1048576) !== 0 ? symbol.exportSymbol : symbol);
- }
- function symbolIsValue(symbol) {
- return !!(symbol.flags & 111551 || symbol.flags & 2097152 && resolveAlias(symbol).flags & 111551 && !getTypeOnlyAliasDeclaration(symbol));
- }
- function findConstructorDeclaration(node) {
- var members = node.members;
- for (var _i = 0, members_3 = members; _i < members_3.length; _i++) {
- var member = members_3[_i];
- if (member.kind === 162 && ts.nodeIsPresent(member.body)) {
- return member;
- }
+ function bindExportsPropertyAssignment(node) {
+ if (!setCommonJsModuleIndicator(node)) {
+ return;
}
- }
- function createType(flags) {
- var result = new Type(checker, flags);
- typeCount++;
- result.id = typeCount;
- return result;
- }
- function createIntrinsicType(kind, intrinsicName, objectFlags) {
- if (objectFlags === void 0) { objectFlags = 0; }
- var type = createType(kind);
- type.intrinsicName = intrinsicName;
- type.objectFlags = objectFlags;
- return type;
- }
- function createBooleanType(trueFalseTypes) {
- var type = getUnionType(trueFalseTypes);
- type.flags |= 16;
- type.intrinsicName = "boolean";
- return type;
- }
- function createObjectType(objectFlags, symbol) {
- var type = createType(524288);
- type.objectFlags = objectFlags;
- type.symbol = symbol;
- type.members = undefined;
- type.properties = undefined;
- type.callSignatures = undefined;
- type.constructSignatures = undefined;
- type.stringIndexInfo = undefined;
- type.numberIndexInfo = undefined;
- return type;
- }
- function createTypeofType() {
- return getUnionType(ts.arrayFrom(typeofEQFacts.keys(), getLiteralType));
- }
- function createTypeParameter(symbol) {
- var type = createType(262144);
- if (symbol)
- type.symbol = symbol;
- return type;
- }
- function isReservedMemberName(name) {
- return name.charCodeAt(0) === 95 &&
- name.charCodeAt(1) === 95 &&
- name.charCodeAt(2) !== 95 &&
- name.charCodeAt(2) !== 64 &&
- name.charCodeAt(2) !== 35;
- }
- function getNamedMembers(members) {
- var result;
- members.forEach(function (symbol, id) {
- if (!isReservedMemberName(id) && symbolIsValue(symbol)) {
- (result || (result = [])).push(symbol);
+ var symbol = forEachIdentifierInEntityName(node.left.expression, undefined, function (id, symbol) {
+ if (symbol) {
+ addDeclarationToSymbol(symbol, id, 1536 | 67108864);
}
+ return symbol;
});
- return result || ts.emptyArray;
- }
- function setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) {
- type.members = members;
- type.properties = members === emptySymbols ? ts.emptyArray : getNamedMembers(members);
- type.callSignatures = callSignatures;
- type.constructSignatures = constructSignatures;
- type.stringIndexInfo = stringIndexInfo;
- type.numberIndexInfo = numberIndexInfo;
- return type;
- }
- function createAnonymousType(symbol, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) {
- return setStructuredTypeMembers(createObjectType(16, symbol), members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
- }
- function forEachSymbolTableInScope(enclosingDeclaration, callback) {
- var result;
- var _loop_7 = function (location) {
- if (location.locals && !isGlobalSourceFile(location)) {
- if (result = callback(location.locals)) {
- return { value: result };
- }
- }
- switch (location.kind) {
- case 290:
- if (!ts.isExternalOrCommonJsModule(location)) {
- break;
- }
- case 249:
- var sym = getSymbolOfNode(location);
- if (result = callback((sym === null || sym === void 0 ? void 0 : sym.exports) || emptySymbols)) {
- return { value: result };
- }
- break;
- case 245:
- case 214:
- case 246:
- var table_1;
- (getSymbolOfNode(location).members || emptySymbols).forEach(function (memberSymbol, key) {
- if (memberSymbol.flags & (788968 & ~67108864)) {
- (table_1 || (table_1 = ts.createSymbolTable())).set(key, memberSymbol);
- }
- });
- if (table_1 && (result = callback(table_1))) {
- return { value: result };
- }
- break;
- }
- };
- for (var location = enclosingDeclaration; location; location = location.parent) {
- var state_2 = _loop_7(location);
- if (typeof state_2 === "object")
- return state_2.value;
+ if (symbol) {
+ var isAlias = ts.isAliasableExpression(node.right) && (ts.isExportsIdentifier(node.left.expression) || ts.isModuleExportsAccessExpression(node.left.expression));
+ var flags = isAlias ? 2097152 : 4 | 1048576;
+ ts.setParent(node.left, node);
+ declareSymbol(symbol.exports, symbol, node.left, flags, 0);
}
- return callback(globals);
- }
- function getQualifiedLeftMeaning(rightMeaning) {
- return rightMeaning === 111551 ? 111551 : 1920;
}
- function getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, useOnlyExternalAliasing, visitedSymbolTablesMap) {
- if (visitedSymbolTablesMap === void 0) { visitedSymbolTablesMap = ts.createMap(); }
- if (!(symbol && !isPropertyOrMethodDeclarationSymbol(symbol))) {
- return undefined;
- }
- var id = "" + getSymbolId(symbol);
- var visitedSymbolTables = visitedSymbolTablesMap.get(id);
- if (!visitedSymbolTables) {
- visitedSymbolTablesMap.set(id, visitedSymbolTables = []);
- }
- return forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable);
- function getAccessibleSymbolChainFromSymbolTable(symbols, ignoreQualification) {
- if (!ts.pushIfUnique(visitedSymbolTables, symbols)) {
- return undefined;
- }
- var result = trySymbolTable(symbols, ignoreQualification);
- visitedSymbolTables.pop();
- return result;
- }
- function canQualifySymbol(symbolFromSymbolTable, meaning) {
- return !needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning) ||
- !!getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing, visitedSymbolTablesMap);
- }
- function isAccessible(symbolFromSymbolTable, resolvedAliasSymbol, ignoreQualification) {
- return (symbol === (resolvedAliasSymbol || symbolFromSymbolTable) || getMergedSymbol(symbol) === getMergedSymbol(resolvedAliasSymbol || symbolFromSymbolTable)) &&
- !ts.some(symbolFromSymbolTable.declarations, hasNonGlobalAugmentationExternalModuleSymbol) &&
- (ignoreQualification || canQualifySymbol(getMergedSymbol(symbolFromSymbolTable), meaning));
- }
- function trySymbolTable(symbols, ignoreQualification) {
- if (isAccessible(symbols.get(symbol.escapedName), undefined, ignoreQualification)) {
- return [symbol];
- }
- var result = ts.forEachEntry(symbols, function (symbolFromSymbolTable) {
- if (symbolFromSymbolTable.flags & 2097152
- && symbolFromSymbolTable.escapedName !== "export="
- && symbolFromSymbolTable.escapedName !== "default"
- && !(ts.isUMDExportSymbol(symbolFromSymbolTable) && enclosingDeclaration && ts.isExternalModule(ts.getSourceFileOfNode(enclosingDeclaration)))
- && (!useOnlyExternalAliasing || ts.some(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration))
- && (ignoreQualification || !ts.getDeclarationOfKind(symbolFromSymbolTable, 263))) {
- var resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
- var candidate = getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification);
- if (candidate) {
- return candidate;
- }
- }
- if (symbolFromSymbolTable.escapedName === symbol.escapedName && symbolFromSymbolTable.exportSymbol) {
- if (isAccessible(getMergedSymbol(symbolFromSymbolTable.exportSymbol), undefined, ignoreQualification)) {
- return [symbol];
- }
- }
- });
- return result || (symbols === globals ? getCandidateListForSymbol(globalThisSymbol, globalThisSymbol, ignoreQualification) : undefined);
+ function bindModuleExportsAssignment(node) {
+ if (!setCommonJsModuleIndicator(node)) {
+ return;
}
- function getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification) {
- if (isAccessible(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification)) {
- return [symbolFromSymbolTable];
- }
- var candidateTable = getExportsOfSymbol(resolvedImportedSymbol);
- var accessibleSymbolsFromExports = candidateTable && getAccessibleSymbolChainFromSymbolTable(candidateTable, true);
- if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
- return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
- }
+ var assignedExpression = ts.getRightMostAssignedExpression(node.right);
+ if (ts.isEmptyObjectLiteral(assignedExpression) || container === file && isExportsOrModuleExportsOrAlias(file, assignedExpression)) {
+ return;
}
- }
- function needsQualification(symbol, enclosingDeclaration, meaning) {
- var qualify = false;
- forEachSymbolTableInScope(enclosingDeclaration, function (symbolTable) {
- var symbolFromSymbolTable = getMergedSymbol(symbolTable.get(symbol.escapedName));
- if (!symbolFromSymbolTable) {
- return false;
- }
- if (symbolFromSymbolTable === symbol) {
- return true;
- }
- symbolFromSymbolTable = (symbolFromSymbolTable.flags & 2097152 && !ts.getDeclarationOfKind(symbolFromSymbolTable, 263)) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
- if (symbolFromSymbolTable.flags & meaning) {
- qualify = true;
- return true;
- }
- return false;
- });
- return qualify;
- }
- function isPropertyOrMethodDeclarationSymbol(symbol) {
- if (symbol.declarations && symbol.declarations.length) {
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var declaration = _a[_i];
- switch (declaration.kind) {
- case 159:
- case 161:
- case 163:
- case 164:
- continue;
- default:
- return false;
- }
- }
- return true;
+ if (ts.isObjectLiteralExpression(assignedExpression) && ts.every(assignedExpression.properties, ts.isShorthandPropertyAssignment)) {
+ ts.forEach(assignedExpression.properties, bindExportAssignedObjectMemberAlias);
+ return;
}
- return false;
- }
- function isTypeSymbolAccessible(typeSymbol, enclosingDeclaration) {
- var access = isSymbolAccessible(typeSymbol, enclosingDeclaration, 788968, false);
- return access.accessibility === 0;
+ var flags = ts.exportAssignmentIsAlias(node)
+ ? 2097152
+ : 4 | 1048576 | 512;
+ var symbol = declareSymbol(file.symbol.exports, file.symbol, node, flags | 67108864, 0);
+ ts.setValueDeclaration(symbol, node);
}
- function isValueSymbolAccessible(typeSymbol, enclosingDeclaration) {
- var access = isSymbolAccessible(typeSymbol, enclosingDeclaration, 111551, false);
- return access.accessibility === 0;
+ function bindExportAssignedObjectMemberAlias(node) {
+ declareSymbol(file.symbol.exports, file.symbol, node, 2097152 | 67108864, 0);
}
- function isAnySymbolAccessible(symbols, enclosingDeclaration, initialSymbol, meaning, shouldComputeAliasesToMakeVisible) {
- if (!ts.length(symbols))
+ function bindThisPropertyAssignment(node) {
+ ts.Debug.assert(ts.isInJSFile(node));
+ var hasPrivateIdentifier = (ts.isBinaryExpression(node) && ts.isPropertyAccessExpression(node.left) && ts.isPrivateIdentifier(node.left.name))
+ || (ts.isPropertyAccessExpression(node) && ts.isPrivateIdentifier(node.name));
+ if (hasPrivateIdentifier) {
return;
- var hadAccessibleChain;
- var earlyModuleBail = false;
- for (var _i = 0, _a = symbols; _i < _a.length; _i++) {
- var symbol = _a[_i];
- var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, false);
- if (accessibleSymbolChain) {
- hadAccessibleChain = symbol;
- var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0], shouldComputeAliasesToMakeVisible);
- if (hasAccessibleDeclarations) {
- return hasAccessibleDeclarations;
+ }
+ var thisContainer = ts.getThisContainer(node, false);
+ switch (thisContainer.kind) {
+ case 251:
+ case 208:
+ var constructorSymbol = thisContainer.symbol;
+ if (ts.isBinaryExpression(thisContainer.parent) && thisContainer.parent.operatorToken.kind === 62) {
+ var l = thisContainer.parent.left;
+ if (ts.isBindableStaticAccessExpression(l) && ts.isPrototypeAccess(l.expression)) {
+ constructorSymbol = lookupSymbolForPropertyAccess(l.expression.expression, thisParentContainer);
+ }
}
- }
- else {
- if (ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
- if (shouldComputeAliasesToMakeVisible) {
- earlyModuleBail = true;
- continue;
+ if (constructorSymbol && constructorSymbol.valueDeclaration) {
+ constructorSymbol.members = constructorSymbol.members || ts.createSymbolTable();
+ if (ts.hasDynamicName(node)) {
+ bindDynamicallyNamedThisPropertyAssignment(node, constructorSymbol);
}
- return {
- accessibility: 0
- };
+ else {
+ declareSymbol(constructorSymbol.members, constructorSymbol, node, 4 | 67108864, 0 & ~4);
+ }
+ addDeclarationToSymbol(constructorSymbol, constructorSymbol.valueDeclaration, 32);
}
- }
- var containers = getContainersOfSymbol(symbol, enclosingDeclaration);
- var firstDecl = !!ts.length(symbol.declarations) && ts.first(symbol.declarations);
- if (!ts.length(containers) && meaning & 111551 && firstDecl && ts.isObjectLiteralExpression(firstDecl)) {
- if (firstDecl.parent && ts.isVariableDeclaration(firstDecl.parent) && firstDecl === firstDecl.parent.initializer) {
- containers = [getSymbolOfNode(firstDecl.parent)];
+ break;
+ case 166:
+ case 163:
+ case 165:
+ case 167:
+ case 168:
+ var containingClass = thisContainer.parent;
+ var symbolTable = ts.hasSyntacticModifier(thisContainer, 32) ? containingClass.symbol.exports : containingClass.symbol.members;
+ if (ts.hasDynamicName(node)) {
+ bindDynamicallyNamedThisPropertyAssignment(node, containingClass.symbol);
}
- }
- var parentResult = isAnySymbolAccessible(containers, enclosingDeclaration, initialSymbol, initialSymbol === symbol ? getQualifiedLeftMeaning(meaning) : meaning, shouldComputeAliasesToMakeVisible);
- if (parentResult) {
- return parentResult;
- }
- }
- if (earlyModuleBail) {
- return {
- accessibility: 0
- };
+ else {
+ declareSymbol(symbolTable, containingClass.symbol, node, 4 | 67108864, 0, true);
+ }
+ break;
+ case 297:
+ if (ts.hasDynamicName(node)) {
+ break;
+ }
+ else if (thisContainer.commonJsModuleIndicator) {
+ declareSymbol(thisContainer.symbol.exports, thisContainer.symbol, node, 4 | 1048576, 0);
+ }
+ else {
+ declareSymbolAndAddToSymbolTable(node, 1, 111550);
+ }
+ break;
+ default:
+ ts.Debug.failBadSyntaxKind(thisContainer);
}
- if (hadAccessibleChain) {
- return {
- accessibility: 1,
- errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
- errorModuleName: hadAccessibleChain !== initialSymbol ? symbolToString(hadAccessibleChain, enclosingDeclaration, 1920) : undefined,
- };
+ }
+ function bindDynamicallyNamedThisPropertyAssignment(node, symbol) {
+ bindAnonymousDeclaration(node, 4, "__computed");
+ addLateBoundAssignmentDeclarationToSymbol(node, symbol);
+ }
+ function addLateBoundAssignmentDeclarationToSymbol(node, symbol) {
+ if (symbol) {
+ (symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = new ts.Map())).set(ts.getNodeId(node), node);
}
}
- function isSymbolAccessible(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible) {
- if (symbol && enclosingDeclaration) {
- var result = isAnySymbolAccessible([symbol], enclosingDeclaration, symbol, meaning, shouldComputeAliasesToMakeVisible);
- if (result) {
- return result;
+ function bindSpecialPropertyDeclaration(node) {
+ if (node.expression.kind === 107) {
+ bindThisPropertyAssignment(node);
+ }
+ else if (ts.isBindableStaticAccessExpression(node) && node.parent.parent.kind === 297) {
+ if (ts.isPrototypeAccess(node.expression)) {
+ bindPrototypePropertyAssignment(node, node.parent);
}
- var symbolExternalModule = ts.forEach(symbol.declarations, getExternalModuleContainer);
- if (symbolExternalModule) {
- var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
- if (symbolExternalModule !== enclosingExternalModule) {
- return {
- accessibility: 2,
- errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning),
- errorModuleName: symbolToString(symbolExternalModule)
- };
- }
+ else {
+ bindStaticPropertyAssignment(node);
}
- return {
- accessibility: 1,
- errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning),
- };
}
- return { accessibility: 0 };
}
- function getExternalModuleContainer(declaration) {
- var node = ts.findAncestor(declaration, hasExternalModuleSymbol);
- return node && getSymbolOfNode(node);
+ function bindPrototypeAssignment(node) {
+ ts.setParent(node.left, node);
+ ts.setParent(node.right, node);
+ bindPropertyAssignment(node.left.expression, node.left, false, true);
}
- function hasExternalModuleSymbol(declaration) {
- return ts.isAmbientModule(declaration) || (declaration.kind === 290 && ts.isExternalOrCommonJsModule(declaration));
+ function bindObjectDefinePrototypeProperty(node) {
+ var namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0].expression);
+ if (namespaceSymbol && namespaceSymbol.valueDeclaration) {
+ addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32);
+ }
+ bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, true);
}
- function hasNonGlobalAugmentationExternalModuleSymbol(declaration) {
- return ts.isModuleWithStringLiteralName(declaration) || (declaration.kind === 290 && ts.isExternalOrCommonJsModule(declaration));
+ function bindPrototypePropertyAssignment(lhs, parent) {
+ var classPrototype = lhs.expression;
+ var constructorFunction = classPrototype.expression;
+ ts.setParent(constructorFunction, classPrototype);
+ ts.setParent(classPrototype, lhs);
+ ts.setParent(lhs, parent);
+ bindPropertyAssignment(constructorFunction, lhs, true, true);
}
- function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) {
- var aliasesToMakeVisible;
- if (!ts.every(ts.filter(symbol.declarations, function (d) { return d.kind !== 75; }), getIsDeclarationVisible)) {
- return undefined;
- }
- return { accessibility: 0, aliasesToMakeVisible: aliasesToMakeVisible };
- function getIsDeclarationVisible(declaration) {
- if (!isDeclarationVisible(declaration)) {
- var anyImportSyntax = getAnyImportSyntax(declaration);
- if (anyImportSyntax &&
- !ts.hasModifier(anyImportSyntax, 1) &&
- isDeclarationVisible(anyImportSyntax.parent)) {
- return addVisibleAlias(declaration, anyImportSyntax);
- }
- else if (ts.isVariableDeclaration(declaration) && ts.isVariableStatement(declaration.parent.parent) &&
- !ts.hasModifier(declaration.parent.parent, 1) &&
- isDeclarationVisible(declaration.parent.parent.parent)) {
- return addVisibleAlias(declaration, declaration.parent.parent);
- }
- else if (ts.isLateVisibilityPaintedStatement(declaration)
- && !ts.hasModifier(declaration, 1)
- && isDeclarationVisible(declaration.parent)) {
- return addVisibleAlias(declaration, declaration);
- }
- return false;
- }
- return true;
+ function bindObjectDefinePropertyAssignment(node) {
+ var namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0]);
+ var isToplevel = node.parent.parent.kind === 297;
+ namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, node.arguments[0], isToplevel, false, false);
+ bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, false);
+ }
+ function bindSpecialPropertyAssignment(node) {
+ var _a;
+ var parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, container) || lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer);
+ if (!ts.isInJSFile(node) && !ts.isFunctionSymbol(parentSymbol)) {
+ return;
}
- function addVisibleAlias(declaration, aliasingStatement) {
- if (shouldComputeAliasToMakeVisible) {
- getNodeLinks(declaration).isVisible = true;
- aliasesToMakeVisible = ts.appendIfUnique(aliasesToMakeVisible, aliasingStatement);
- }
- return true;
+ var rootExpr = ts.getLeftmostAccessExpression(node.left);
+ if (ts.isIdentifier(rootExpr) && ((_a = lookupSymbolForName(container, rootExpr.escapedText)) === null || _a === void 0 ? void 0 : _a.flags) & 2097152) {
+ return;
}
- }
- function isEntityNameVisible(entityName, enclosingDeclaration) {
- var meaning;
- if (entityName.parent.kind === 172 ||
- ts.isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent) ||
- entityName.parent.kind === 154) {
- meaning = 111551 | 1048576;
+ ts.setParent(node.left, node);
+ ts.setParent(node.right, node);
+ if (ts.isIdentifier(node.left.expression) && container === file && isExportsOrModuleExportsOrAlias(file, node.left.expression)) {
+ bindExportsPropertyAssignment(node);
}
- else if (entityName.kind === 153 || entityName.kind === 194 ||
- entityName.parent.kind === 253) {
- meaning = 1920;
+ else if (ts.hasDynamicName(node)) {
+ bindAnonymousDeclaration(node, 4 | 67108864, "__computed");
+ var sym = bindPotentiallyMissingNamespaces(parentSymbol, node.left.expression, isTopLevelNamespaceAssignment(node.left), false, false);
+ addLateBoundAssignmentDeclarationToSymbol(node, sym);
}
else {
- meaning = 788968;
+ bindStaticPropertyAssignment(ts.cast(node.left, ts.isBindableStaticNameExpression));
}
- var firstIdentifier = ts.getFirstIdentifier(entityName);
- var symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, undefined, undefined, false);
- return (symbol && hasVisibleDeclarations(symbol, true)) || {
- accessibility: 1,
- errorSymbolName: ts.getTextOfNode(firstIdentifier),
- errorNode: firstIdentifier
- };
}
- function symbolToString(symbol, enclosingDeclaration, meaning, flags, writer) {
- if (flags === void 0) { flags = 4; }
- var nodeFlags = 70221824;
- if (flags & 2) {
- nodeFlags |= 128;
+ function bindStaticPropertyAssignment(node) {
+ ts.Debug.assert(!ts.isIdentifier(node));
+ ts.setParent(node.expression, node);
+ bindPropertyAssignment(node.expression, node, false, false);
+ }
+ function bindPotentiallyMissingNamespaces(namespaceSymbol, entityName, isToplevel, isPrototypeProperty, containerIsClass) {
+ if ((namespaceSymbol === null || namespaceSymbol === void 0 ? void 0 : namespaceSymbol.flags) & 2097152) {
+ return namespaceSymbol;
}
- if (flags & 1) {
- nodeFlags |= 512;
+ if (isToplevel && !isPrototypeProperty) {
+ var flags_2 = 1536 | 67108864;
+ var excludeFlags_1 = 110735 & ~67108864;
+ namespaceSymbol = forEachIdentifierInEntityName(entityName, namespaceSymbol, function (id, symbol, parent) {
+ if (symbol) {
+ addDeclarationToSymbol(symbol, id, flags_2);
+ return symbol;
+ }
+ else {
+ var table = parent ? parent.exports :
+ file.jsGlobalAugmentations || (file.jsGlobalAugmentations = ts.createSymbolTable());
+ return declareSymbol(table, parent, id, flags_2, excludeFlags_1);
+ }
+ });
}
- if (flags & 8) {
- nodeFlags |= 16384;
+ if (containerIsClass && namespaceSymbol && namespaceSymbol.valueDeclaration) {
+ addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32);
}
- if (flags & 16) {
- nodeFlags |= 134217728;
+ return namespaceSymbol;
+ }
+ function bindPotentiallyNewExpandoMemberToNamespace(declaration, namespaceSymbol, isPrototypeProperty) {
+ if (!namespaceSymbol || !isExpandoSymbol(namespaceSymbol)) {
+ return;
}
- var builder = flags & 4 ? nodeBuilder.symbolToExpression : nodeBuilder.symbolToEntityName;
- return writer ? symbolToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(symbolToStringWorker);
- function symbolToStringWorker(writer) {
- var entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags);
- var printer = ts.createPrinter({ removeComments: true });
- var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
- printer.writeNode(4, entity, sourceFile, writer);
- return writer;
+ var symbolTable = isPrototypeProperty ?
+ (namespaceSymbol.members || (namespaceSymbol.members = ts.createSymbolTable())) :
+ (namespaceSymbol.exports || (namespaceSymbol.exports = ts.createSymbolTable()));
+ var includes = 0;
+ var excludes = 0;
+ if (ts.isFunctionLikeDeclaration(ts.getAssignedExpandoInitializer(declaration))) {
+ includes = 8192;
+ excludes = 103359;
}
- }
- function signatureToString(signature, enclosingDeclaration, flags, kind, writer) {
- if (flags === void 0) { flags = 0; }
- return writer ? signatureToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(signatureToStringWorker);
- function signatureToStringWorker(writer) {
- var sigOutput;
- if (flags & 262144) {
- sigOutput = kind === 1 ? 171 : 170;
+ else if (ts.isCallExpression(declaration) && ts.isBindableObjectDefinePropertyCall(declaration)) {
+ if (ts.some(declaration.arguments[2].properties, function (p) {
+ var id = ts.getNameOfDeclaration(p);
+ return !!id && ts.isIdentifier(id) && ts.idText(id) === "set";
+ })) {
+ includes |= 65536 | 4;
+ excludes |= 78783;
}
- else {
- sigOutput = kind === 1 ? 166 : 165;
+ if (ts.some(declaration.arguments[2].properties, function (p) {
+ var id = ts.getNameOfDeclaration(p);
+ return !!id && ts.isIdentifier(id) && ts.idText(id) === "get";
+ })) {
+ includes |= 32768 | 4;
+ excludes |= 46015;
}
- var sig = nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | 512);
- var printer = ts.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
- var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
- printer.writeNode(4, sig, sourceFile, ts.getTrailingSemicolonDeferringWriter(writer));
- return writer;
- }
- }
- function typeToString(type, enclosingDeclaration, flags, writer) {
- if (flags === void 0) { flags = 1048576 | 16384; }
- if (writer === void 0) { writer = ts.createTextWriter(""); }
- var noTruncation = compilerOptions.noErrorTruncation || flags & 1;
- var typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | (noTruncation ? 1 : 0), writer);
- if (typeNode === undefined)
- return ts.Debug.fail("should always get typenode");
- var options = { removeComments: true };
- var printer = ts.createPrinter(options);
- var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
- printer.writeNode(4, typeNode, sourceFile, writer);
- var result = writer.getText();
- var maxLength = noTruncation ? ts.noTruncationMaximumTruncationLength * 2 : ts.defaultMaximumTruncationLength * 2;
- if (maxLength && result && result.length >= maxLength) {
- return result.substr(0, maxLength - "...".length) + "...";
}
- return result;
- }
- function getTypeNamesForErrorDisplay(left, right) {
- var leftStr = symbolValueDeclarationIsContextSensitive(left.symbol) ? typeToString(left, left.symbol.valueDeclaration) : typeToString(left);
- var rightStr = symbolValueDeclarationIsContextSensitive(right.symbol) ? typeToString(right, right.symbol.valueDeclaration) : typeToString(right);
- if (leftStr === rightStr) {
- leftStr = typeToString(left, undefined, 64);
- rightStr = typeToString(right, undefined, 64);
+ if (includes === 0) {
+ includes = 4;
+ excludes = 0;
}
- return [leftStr, rightStr];
- }
- function symbolValueDeclarationIsContextSensitive(symbol) {
- return symbol && symbol.valueDeclaration && ts.isExpression(symbol.valueDeclaration) && !isContextSensitive(symbol.valueDeclaration);
+ declareSymbol(symbolTable, namespaceSymbol, declaration, includes | 67108864, excludes & ~67108864);
}
- function toNodeBuilderFlags(flags) {
- if (flags === void 0) { flags = 0; }
- return flags & 814775659;
+ function isTopLevelNamespaceAssignment(propertyAccess) {
+ return ts.isBinaryExpression(propertyAccess.parent)
+ ? getParentOfBinaryExpression(propertyAccess.parent).parent.kind === 297
+ : propertyAccess.parent.parent.kind === 297;
}
- function createNodeBuilder() {
- return {
- typeToTypeNode: function (type, enclosingDeclaration, flags, tracker) {
- return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeToTypeNodeHelper(type, context); });
- },
- indexInfoToIndexSignatureDeclaration: function (indexInfo, kind, enclosingDeclaration, flags, tracker) {
- return withContext(enclosingDeclaration, flags, tracker, function (context) { return indexInfoToIndexSignatureDeclarationHelper(indexInfo, kind, context); });
- },
- signatureToSignatureDeclaration: function (signature, kind, enclosingDeclaration, flags, tracker) {
- return withContext(enclosingDeclaration, flags, tracker, function (context) { return signatureToSignatureDeclarationHelper(signature, kind, context); });
- },
- symbolToEntityName: function (symbol, meaning, enclosingDeclaration, flags, tracker) {
- return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToName(symbol, context, meaning, false); });
- },
- symbolToExpression: function (symbol, meaning, enclosingDeclaration, flags, tracker) {
- return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToExpression(symbol, context, meaning); });
- },
- symbolToTypeParameterDeclarations: function (symbol, enclosingDeclaration, flags, tracker) {
- return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeParametersToTypeParameterDeclarations(symbol, context); });
- },
- symbolToParameterDeclaration: function (symbol, enclosingDeclaration, flags, tracker) {
- return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToParameterDeclaration(symbol, context); });
- },
- typeParameterToDeclaration: function (parameter, enclosingDeclaration, flags, tracker) {
- return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeParameterToDeclaration(parameter, context); });
- },
- symbolTableToDeclarationStatements: function (symbolTable, enclosingDeclaration, flags, tracker, bundled) {
- return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolTableToDeclarationStatements(symbolTable, context, bundled); });
- },
- };
- function withContext(enclosingDeclaration, flags, tracker, cb) {
- ts.Debug.assert(enclosingDeclaration === undefined || (enclosingDeclaration.flags & 8) === 0);
- var context = {
- enclosingDeclaration: enclosingDeclaration,
- flags: flags || 0,
- tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: ts.noop, moduleResolverHost: flags & 134217728 ? {
- getCommonSourceDirectory: !!host.getCommonSourceDirectory ? function () { return host.getCommonSourceDirectory(); } : function () { return ""; },
- getSourceFiles: function () { return host.getSourceFiles(); },
- getCurrentDirectory: function () { return host.getCurrentDirectory(); },
- getProbableSymlinks: ts.maybeBind(host, host.getProbableSymlinks),
- useCaseSensitiveFileNames: ts.maybeBind(host, host.useCaseSensitiveFileNames),
- redirectTargetsMap: host.redirectTargetsMap,
- getProjectReferenceRedirect: function (fileName) { return host.getProjectReferenceRedirect(fileName); },
- isSourceOfProjectReferenceRedirect: function (fileName) { return host.isSourceOfProjectReferenceRedirect(fileName); },
- fileExists: function (fileName) { return host.fileExists(fileName); },
- } : undefined },
- encounteredError: false,
- visitedTypes: undefined,
- symbolDepth: undefined,
- inferTypeParameters: undefined,
- approximateLength: 0
- };
- var resultingNode = cb(context);
- return context.encounteredError ? undefined : resultingNode;
- }
- function checkTruncationLength(context) {
- if (context.truncating)
- return context.truncating;
- return context.truncating = context.approximateLength > ((context.flags & 1) ? ts.noTruncationMaximumTruncationLength : ts.defaultMaximumTruncationLength);
- }
- function typeToTypeNodeHelper(type, context) {
- if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
- cancellationToken.throwIfCancellationRequested();
- }
- var inTypeAlias = context.flags & 8388608;
- context.flags &= ~8388608;
- if (!type) {
- if (!(context.flags & 262144)) {
- context.encounteredError = true;
- return undefined;
- }
- context.approximateLength += 3;
- return ts.createKeywordTypeNode(125);
- }
- if (!(context.flags & 536870912)) {
- type = getReducedType(type);
- }
- if (type.flags & 1) {
- context.approximateLength += 3;
- return ts.createKeywordTypeNode(125);
- }
- if (type.flags & 2) {
- return ts.createKeywordTypeNode(148);
- }
- if (type.flags & 4) {
- context.approximateLength += 6;
- return ts.createKeywordTypeNode(143);
- }
- if (type.flags & 8) {
- context.approximateLength += 6;
- return ts.createKeywordTypeNode(140);
- }
- if (type.flags & 64) {
- context.approximateLength += 6;
- return ts.createKeywordTypeNode(151);
- }
- if (type.flags & 16) {
- context.approximateLength += 7;
- return ts.createKeywordTypeNode(128);
- }
- if (type.flags & 1024 && !(type.flags & 1048576)) {
- var parentSymbol = getParentOfSymbol(type.symbol);
- var parentName = symbolToTypeNode(parentSymbol, context, 788968);
- var enumLiteralName = getDeclaredTypeOfSymbol(parentSymbol) === type
- ? parentName
- : appendReferenceToType(parentName, ts.createTypeReferenceNode(ts.symbolName(type.symbol), undefined));
- return enumLiteralName;
- }
- if (type.flags & 1056) {
- return symbolToTypeNode(type.symbol, context, 788968);
- }
- if (type.flags & 128) {
- context.approximateLength += (type.value.length + 2);
- return ts.createLiteralTypeNode(ts.setEmitFlags(ts.createLiteral(type.value, !!(context.flags & 268435456)), 16777216));
- }
- if (type.flags & 256) {
- var value = type.value;
- context.approximateLength += ("" + value).length;
- return ts.createLiteralTypeNode(value < 0 ? ts.createPrefix(40, ts.createLiteral(-value)) : ts.createLiteral(value));
- }
- if (type.flags & 2048) {
- context.approximateLength += (ts.pseudoBigIntToString(type.value).length) + 1;
- return ts.createLiteralTypeNode((ts.createLiteral(type.value)));
- }
- if (type.flags & 512) {
- context.approximateLength += type.intrinsicName.length;
- return type.intrinsicName === "true" ? ts.createTrue() : ts.createFalse();
- }
- if (type.flags & 8192) {
- if (!(context.flags & 1048576)) {
- if (isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
- context.approximateLength += 6;
- return symbolToTypeNode(type.symbol, context, 111551);
- }
- if (context.tracker.reportInaccessibleUniqueSymbolError) {
- context.tracker.reportInaccessibleUniqueSymbolError();
- }
- }
- context.approximateLength += 13;
- return ts.createTypeOperatorNode(147, ts.createKeywordTypeNode(144));
- }
- if (type.flags & 16384) {
- context.approximateLength += 4;
- return ts.createKeywordTypeNode(110);
- }
- if (type.flags & 32768) {
- context.approximateLength += 9;
- return ts.createKeywordTypeNode(146);
- }
- if (type.flags & 65536) {
- context.approximateLength += 4;
- return ts.createKeywordTypeNode(100);
- }
- if (type.flags & 131072) {
- context.approximateLength += 5;
- return ts.createKeywordTypeNode(137);
- }
- if (type.flags & 4096) {
- context.approximateLength += 6;
- return ts.createKeywordTypeNode(144);
- }
- if (type.flags & 67108864) {
- context.approximateLength += 6;
- return ts.createKeywordTypeNode(141);
- }
- if (isThisTypeParameter(type)) {
- if (context.flags & 4194304) {
- if (!context.encounteredError && !(context.flags & 32768)) {
- context.encounteredError = true;
- }
- if (context.tracker.reportInaccessibleThisError) {
- context.tracker.reportInaccessibleThisError();
- }
- }
- context.approximateLength += 4;
- return ts.createThis();
- }
- if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) {
- var typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
- if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32))
- return ts.createTypeReferenceNode(ts.createIdentifier(""), typeArgumentNodes);
- return symbolToTypeNode(type.aliasSymbol, context, 788968, typeArgumentNodes);
- }
- var objectFlags = ts.getObjectFlags(type);
- if (objectFlags & 4) {
- ts.Debug.assert(!!(type.flags & 524288));
- return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type);
- }
- if (type.flags & 262144 || objectFlags & 3) {
- if (type.flags & 262144 && ts.contains(context.inferTypeParameters, type)) {
- context.approximateLength += (ts.symbolName(type.symbol).length + 6);
- return ts.createInferTypeNode(typeParameterToDeclarationWithConstraint(type, context, undefined));
- }
- if (context.flags & 4 &&
- type.flags & 262144 &&
- !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
- var name = typeParameterToName(type, context);
- context.approximateLength += ts.idText(name).length;
- return ts.createTypeReferenceNode(ts.createIdentifier(ts.idText(name)), undefined);
- }
- return type.symbol
- ? symbolToTypeNode(type.symbol, context, 788968)
- : ts.createTypeReferenceNode(ts.createIdentifier("?"), undefined);
- }
- if (type.flags & (1048576 | 2097152)) {
- var types = type.flags & 1048576 ? formatUnionTypes(type.types) : type.types;
- if (ts.length(types) === 1) {
- return typeToTypeNodeHelper(types[0], context);
- }
- var typeNodes = mapToTypeNodes(types, context, true);
- if (typeNodes && typeNodes.length > 0) {
- var unionOrIntersectionTypeNode = ts.createUnionOrIntersectionTypeNode(type.flags & 1048576 ? 178 : 179, typeNodes);
- return unionOrIntersectionTypeNode;
- }
- else {
- if (!context.encounteredError && !(context.flags & 262144)) {
- context.encounteredError = true;
- }
- return undefined;
- }
+ function bindPropertyAssignment(name, propertyAccess, isPrototypeProperty, containerIsClass) {
+ var namespaceSymbol = lookupSymbolForPropertyAccess(name, container) || lookupSymbolForPropertyAccess(name, blockScopeContainer);
+ var isToplevel = isTopLevelNamespaceAssignment(propertyAccess);
+ namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, propertyAccess.expression, isToplevel, isPrototypeProperty, containerIsClass);
+ bindPotentiallyNewExpandoMemberToNamespace(propertyAccess, namespaceSymbol, isPrototypeProperty);
+ }
+ function isExpandoSymbol(symbol) {
+ if (symbol.flags & (16 | 32 | 1024)) {
+ return true;
+ }
+ var node = symbol.valueDeclaration;
+ if (node && ts.isCallExpression(node)) {
+ return !!ts.getAssignedExpandoInitializer(node);
+ }
+ var init = !node ? undefined :
+ ts.isVariableDeclaration(node) ? node.initializer :
+ ts.isBinaryExpression(node) ? node.right :
+ ts.isPropertyAccessExpression(node) && ts.isBinaryExpression(node.parent) ? node.parent.right :
+ undefined;
+ init = init && ts.getRightMostAssignedExpression(init);
+ if (init) {
+ var isPrototypeAssignment = ts.isPrototypeAccess(ts.isVariableDeclaration(node) ? node.name : ts.isBinaryExpression(node) ? node.left : node);
+ return !!ts.getExpandoInitializer(ts.isBinaryExpression(init) && (init.operatorToken.kind === 56 || init.operatorToken.kind === 60) ? init.right : init, isPrototypeAssignment);
+ }
+ return false;
+ }
+ function getParentOfBinaryExpression(expr) {
+ while (ts.isBinaryExpression(expr.parent)) {
+ expr = expr.parent;
+ }
+ return expr.parent;
+ }
+ function lookupSymbolForPropertyAccess(node, lookupContainer) {
+ if (lookupContainer === void 0) { lookupContainer = container; }
+ if (ts.isIdentifier(node)) {
+ return lookupSymbolForName(lookupContainer, node.escapedText);
+ }
+ else {
+ var symbol = lookupSymbolForPropertyAccess(node.expression);
+ return symbol && symbol.exports && symbol.exports.get(ts.getElementOrPropertyAccessName(node));
+ }
+ }
+ function forEachIdentifierInEntityName(e, parent, action) {
+ if (isExportsOrModuleExportsOrAlias(file, e)) {
+ return file.symbol;
+ }
+ else if (ts.isIdentifier(e)) {
+ return action(e, lookupSymbolForPropertyAccess(e), parent);
+ }
+ else {
+ var s = forEachIdentifierInEntityName(e.expression, parent, action);
+ var name = ts.getNameOrArgument(e);
+ if (ts.isPrivateIdentifier(name)) {
+ ts.Debug.fail("unexpected PrivateIdentifier");
}
- if (objectFlags & (16 | 32)) {
- ts.Debug.assert(!!(type.flags & 524288));
- return createAnonymousTypeNode(type);
+ return action(name, s && s.exports && s.exports.get(ts.getElementOrPropertyAccessName(e)), s);
+ }
+ }
+ function bindCallExpression(node) {
+ if (!file.commonJsModuleIndicator && ts.isRequireCall(node, false)) {
+ setCommonJsModuleIndicator(node);
+ }
+ }
+ function bindClassLikeDeclaration(node) {
+ if (node.kind === 252) {
+ bindBlockScopedDeclaration(node, 32, 899503);
+ }
+ else {
+ var bindingName = node.name ? node.name.escapedText : "__class";
+ bindAnonymousDeclaration(node, 32, bindingName);
+ if (node.name) {
+ classifiableNames.add(node.name.escapedText);
}
- if (type.flags & 4194304) {
- var indexedType = type.type;
- context.approximateLength += 6;
- var indexTypeNode = typeToTypeNodeHelper(indexedType, context);
- return ts.createTypeOperatorNode(indexTypeNode);
+ }
+ var symbol = node.symbol;
+ var prototypeSymbol = createSymbol(4 | 4194304, "prototype");
+ var symbolExport = symbol.exports.get(prototypeSymbol.escapedName);
+ if (symbolExport) {
+ if (node.name) {
+ ts.setParent(node.name, node);
}
- if (type.flags & 8388608) {
- var objectTypeNode = typeToTypeNodeHelper(type.objectType, context);
- var indexTypeNode = typeToTypeNodeHelper(type.indexType, context);
- context.approximateLength += 2;
- return ts.createIndexedAccessTypeNode(objectTypeNode, indexTypeNode);
+ file.bindDiagnostics.push(createDiagnosticForNode(symbolExport.declarations[0], ts.Diagnostics.Duplicate_identifier_0, ts.symbolName(prototypeSymbol)));
+ }
+ symbol.exports.set(prototypeSymbol.escapedName, prototypeSymbol);
+ prototypeSymbol.parent = symbol;
+ }
+ function bindEnumDeclaration(node) {
+ return ts.isEnumConst(node)
+ ? bindBlockScopedDeclaration(node, 128, 899967)
+ : bindBlockScopedDeclaration(node, 256, 899327);
+ }
+ function bindVariableDeclarationOrBindingElement(node) {
+ if (inStrictMode) {
+ checkStrictModeEvalOrArguments(node, node.name);
+ }
+ if (!ts.isBindingPattern(node.name)) {
+ if (ts.isInJSFile(node) && ts.isRequireVariableDeclaration(node, true) && !ts.getJSDocTypeTag(node)) {
+ declareSymbolAndAddToSymbolTable(node, 2097152, 2097152);
}
- if (type.flags & 16777216) {
- var checkTypeNode = typeToTypeNodeHelper(type.checkType, context);
- var saveInferTypeParameters = context.inferTypeParameters;
- context.inferTypeParameters = type.root.inferTypeParameters;
- var extendsTypeNode = typeToTypeNodeHelper(type.extendsType, context);
- context.inferTypeParameters = saveInferTypeParameters;
- var trueTypeNode = typeToTypeNodeHelper(getTrueTypeFromConditionalType(type), context);
- var falseTypeNode = typeToTypeNodeHelper(getFalseTypeFromConditionalType(type), context);
- context.approximateLength += 15;
- return ts.createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode);
+ else if (ts.isBlockOrCatchScoped(node)) {
+ bindBlockScopedDeclaration(node, 2, 111551);
}
- if (type.flags & 33554432) {
- return typeToTypeNodeHelper(type.baseType, context);
+ else if (ts.isParameterDeclaration(node)) {
+ declareSymbolAndAddToSymbolTable(node, 1, 111551);
}
- return ts.Debug.fail("Should be unreachable.");
- function createMappedTypeNodeFromType(type) {
- ts.Debug.assert(!!(type.flags & 524288));
- var readonlyToken = type.declaration.readonlyToken ? ts.createToken(type.declaration.readonlyToken.kind) : undefined;
- var questionToken = type.declaration.questionToken ? ts.createToken(type.declaration.questionToken.kind) : undefined;
- var appropriateConstraintTypeNode;
- if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
- appropriateConstraintTypeNode = ts.createTypeOperatorNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context));
- }
- else {
- appropriateConstraintTypeNode = typeToTypeNodeHelper(getConstraintTypeFromMappedType(type), context);
- }
- var typeParameterNode = typeParameterToDeclarationWithConstraint(getTypeParameterFromMappedType(type), context, appropriateConstraintTypeNode);
- var templateTypeNode = typeToTypeNodeHelper(getTemplateTypeFromMappedType(type), context);
- var mappedTypeNode = ts.createMappedTypeNode(readonlyToken, typeParameterNode, questionToken, templateTypeNode);
- context.approximateLength += 10;
- return ts.setEmitFlags(mappedTypeNode, 1);
+ else {
+ declareSymbolAndAddToSymbolTable(node, 1, 111550);
}
- function createAnonymousTypeNode(type) {
- var typeId = "" + type.id;
- var symbol = type.symbol;
- if (symbol) {
- if (isJSConstructor(symbol.valueDeclaration)) {
- var isInstanceType = type === getDeclaredTypeOfClassOrInterface(symbol) ? 788968 : 111551;
- return symbolToTypeNode(symbol, context, isInstanceType);
- }
- else if (symbol.flags & 32 && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration.kind === 214 && context.flags & 2048) ||
- symbol.flags & (384 | 512) ||
- shouldWriteTypeOfFunctionSymbol()) {
- return symbolToTypeNode(symbol, context, 111551);
- }
- else if (context.visitedTypes && context.visitedTypes.has(typeId)) {
- var typeAlias = getTypeAliasForTypeLiteral(type);
- if (typeAlias) {
- return symbolToTypeNode(typeAlias, context, 788968);
- }
- else {
- return createElidedInformationPlaceholder(context);
- }
- }
- else {
- return visitAndTransformType(type, createTypeNodeFromObjectType);
- }
- }
- else {
- return createTypeNodeFromObjectType(type);
- }
- function shouldWriteTypeOfFunctionSymbol() {
- var isStaticMethodSymbol = !!(symbol.flags & 8192) &&
- ts.some(symbol.declarations, function (declaration) { return ts.hasModifier(declaration, 32); });
- var isNonLocalFunctionSymbol = !!(symbol.flags & 16) &&
- (symbol.parent ||
- ts.forEach(symbol.declarations, function (declaration) {
- return declaration.parent.kind === 290 || declaration.parent.kind === 250;
- }));
- if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
- return (!!(context.flags & 4096) || (context.visitedTypes && context.visitedTypes.has(typeId))) &&
- (!(context.flags & 8) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
- }
- }
+ }
+ }
+ function bindParameter(node) {
+ if (node.kind === 326 && container.kind !== 313) {
+ return;
+ }
+ if (inStrictMode && !(node.flags & 8388608)) {
+ checkStrictModeEvalOrArguments(node, node.name);
+ }
+ if (ts.isBindingPattern(node.name)) {
+ bindAnonymousDeclaration(node, 1, "__" + node.parent.parameters.indexOf(node));
+ }
+ else {
+ declareSymbolAndAddToSymbolTable(node, 1, 111551);
+ }
+ if (ts.isParameterPropertyDeclaration(node, node.parent)) {
+ var classDeclaration = node.parent.parent;
+ declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 | (node.questionToken ? 16777216 : 0), 0);
+ }
+ }
+ function bindFunctionDeclaration(node) {
+ if (!file.isDeclarationFile && !(node.flags & 8388608)) {
+ if (ts.isAsyncFunction(node)) {
+ emitFlags |= 2048;
}
- function visitAndTransformType(type, transform) {
- var typeId = "" + type.id;
- var isConstructorObject = ts.getObjectFlags(type) & 16 && type.symbol && type.symbol.flags & 32;
- var id = ts.getObjectFlags(type) & 4 && type.node ? "N" + getNodeId(type.node) :
- type.symbol ? (isConstructorObject ? "+" : "") + getSymbolId(type.symbol) :
- undefined;
- if (!context.visitedTypes) {
- context.visitedTypes = ts.createMap();
- }
- if (id && !context.symbolDepth) {
- context.symbolDepth = ts.createMap();
- }
- var depth;
- if (id) {
- depth = context.symbolDepth.get(id) || 0;
- if (depth > 10) {
- return createElidedInformationPlaceholder(context);
- }
- context.symbolDepth.set(id, depth + 1);
- }
- context.visitedTypes.set(typeId, true);
- var result = transform(type);
- context.visitedTypes.delete(typeId);
- if (id) {
- context.symbolDepth.set(id, depth);
- }
- return result;
+ }
+ checkStrictModeFunctionName(node);
+ if (inStrictMode) {
+ checkStrictModeFunctionDeclaration(node);
+ bindBlockScopedDeclaration(node, 16, 110991);
+ }
+ else {
+ declareSymbolAndAddToSymbolTable(node, 16, 110991);
+ }
+ }
+ function bindFunctionExpression(node) {
+ if (!file.isDeclarationFile && !(node.flags & 8388608)) {
+ if (ts.isAsyncFunction(node)) {
+ emitFlags |= 2048;
}
- function createTypeNodeFromObjectType(type) {
- if (isGenericMappedType(type)) {
- return createMappedTypeNodeFromType(type);
- }
- var resolved = resolveStructuredTypeMembers(type);
- if (!resolved.properties.length && !resolved.stringIndexInfo && !resolved.numberIndexInfo) {
- if (!resolved.callSignatures.length && !resolved.constructSignatures.length) {
- context.approximateLength += 2;
- return ts.setEmitFlags(ts.createTypeLiteralNode(undefined), 1);
- }
- if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
- var signature = resolved.callSignatures[0];
- var signatureNode = signatureToSignatureDeclarationHelper(signature, 170, context);
- return signatureNode;
- }
- if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
- var signature = resolved.constructSignatures[0];
- var signatureNode = signatureToSignatureDeclarationHelper(signature, 171, context);
- return signatureNode;
- }
+ }
+ if (currentFlow) {
+ node.flowNode = currentFlow;
+ }
+ checkStrictModeFunctionName(node);
+ var bindingName = node.name ? node.name.escapedText : "__function";
+ return bindAnonymousDeclaration(node, 16, bindingName);
+ }
+ function bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) {
+ if (!file.isDeclarationFile && !(node.flags & 8388608) && ts.isAsyncFunction(node)) {
+ emitFlags |= 2048;
+ }
+ if (currentFlow && ts.isObjectLiteralOrClassExpressionMethod(node)) {
+ node.flowNode = currentFlow;
+ }
+ return ts.hasDynamicName(node)
+ ? bindAnonymousDeclaration(node, symbolFlags, "__computed")
+ : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
+ }
+ function getInferTypeContainer(node) {
+ var extendsType = ts.findAncestor(node, function (n) { return n.parent && ts.isConditionalTypeNode(n.parent) && n.parent.extendsType === n; });
+ return extendsType && extendsType.parent;
+ }
+ function bindTypeParameter(node) {
+ if (ts.isJSDocTemplateTag(node.parent)) {
+ var container_1 = ts.find(node.parent.parent.tags, ts.isJSDocTypeAlias) || ts.getHostSignatureFromJSDoc(node.parent);
+ if (container_1) {
+ if (!container_1.locals) {
+ container_1.locals = ts.createSymbolTable();
}
- var savedFlags = context.flags;
- context.flags |= 4194304;
- var members = createTypeNodesFromResolvedType(resolved);
- context.flags = savedFlags;
- var typeLiteralNode = ts.createTypeLiteralNode(members);
- context.approximateLength += 2;
- return ts.setEmitFlags(typeLiteralNode, (context.flags & 1024) ? 0 : 1);
+ declareSymbol(container_1.locals, undefined, node, 262144, 526824);
}
- function typeReferenceToTypeNode(type) {
- var typeArguments = getTypeArguments(type);
- if (type.target === globalArrayType || type.target === globalReadonlyArrayType) {
- if (context.flags & 2) {
- var typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context);
- return ts.createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]);
- }
- var elementType = typeToTypeNodeHelper(typeArguments[0], context);
- var arrayType = ts.createArrayTypeNode(elementType);
- return type.target === globalArrayType ? arrayType : ts.createTypeOperatorNode(138, arrayType);
- }
- else if (type.target.objectFlags & 8) {
- if (typeArguments.length > 0) {
- var arity = getTypeReferenceArity(type);
- var tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context);
- var hasRestElement = type.target.hasRestElement;
- if (tupleConstituentNodes) {
- for (var i = type.target.minLength; i < Math.min(arity, tupleConstituentNodes.length); i++) {
- tupleConstituentNodes[i] = hasRestElement && i === arity - 1 ?
- ts.createRestTypeNode(ts.createArrayTypeNode(tupleConstituentNodes[i])) :
- ts.createOptionalTypeNode(tupleConstituentNodes[i]);
- }
- var tupleTypeNode = ts.createTupleTypeNode(tupleConstituentNodes);
- return type.target.readonly ? ts.createTypeOperatorNode(138, tupleTypeNode) : tupleTypeNode;
- }
- }
- if (context.encounteredError || (context.flags & 524288)) {
- var tupleTypeNode = ts.createTupleTypeNode([]);
- return type.target.readonly ? ts.createTypeOperatorNode(138, tupleTypeNode) : tupleTypeNode;
- }
- context.encounteredError = true;
- return undefined;
- }
- else if (context.flags & 2048 &&
- type.symbol.valueDeclaration &&
- ts.isClassLike(type.symbol.valueDeclaration) &&
- !isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
- return createAnonymousTypeNode(type);
- }
- else {
- var outerTypeParameters = type.target.outerTypeParameters;
- var i = 0;
- var resultType = void 0;
- if (outerTypeParameters) {
- var length_2 = outerTypeParameters.length;
- while (i < length_2) {
- var start = i;
- var parent = getParentSymbolOfTypeParameter(outerTypeParameters[i]);
- do {
- i++;
- } while (i < length_2 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent);
- if (!ts.rangeEquals(outerTypeParameters, typeArguments, start, i)) {
- var typeArgumentSlice = mapToTypeNodes(typeArguments.slice(start, i), context);
- var flags_2 = context.flags;
- context.flags |= 16;
- var ref = symbolToTypeNode(parent, context, 788968, typeArgumentSlice);
- context.flags = flags_2;
- resultType = !resultType ? ref : appendReferenceToType(resultType, ref);
- }
- }
- }
- var typeArgumentNodes = void 0;
- if (typeArguments.length > 0) {
- var typeParameterCount = (type.target.typeParameters || ts.emptyArray).length;
- typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context);
- }
- var flags = context.flags;
- context.flags |= 16;
- var finalRef = symbolToTypeNode(type.symbol, context, 788968, typeArgumentNodes);
- context.flags = flags;
- return !resultType ? finalRef : appendReferenceToType(resultType, finalRef);
- }
+ else {
+ declareSymbolAndAddToSymbolTable(node, 262144, 526824);
}
- function appendReferenceToType(root, ref) {
- if (ts.isImportTypeNode(root)) {
- var innerParams = root.typeArguments;
- if (root.qualifier) {
- (ts.isIdentifier(root.qualifier) ? root.qualifier : root.qualifier.right).typeArguments = innerParams;
- }
- root.typeArguments = ref.typeArguments;
- var ids = getAccessStack(ref);
- for (var _i = 0, ids_1 = ids; _i < ids_1.length; _i++) {
- var id = ids_1[_i];
- root.qualifier = root.qualifier ? ts.createQualifiedName(root.qualifier, id) : id;
- }
- return root;
- }
- else {
- var innerParams = root.typeArguments;
- (ts.isIdentifier(root.typeName) ? root.typeName : root.typeName.right).typeArguments = innerParams;
- root.typeArguments = ref.typeArguments;
- var ids = getAccessStack(ref);
- for (var _a = 0, ids_2 = ids; _a < ids_2.length; _a++) {
- var id = ids_2[_a];
- root.typeName = ts.createQualifiedName(root.typeName, id);
- }
- return root;
+ }
+ else if (node.parent.kind === 185) {
+ var container_2 = getInferTypeContainer(node.parent);
+ if (container_2) {
+ if (!container_2.locals) {
+ container_2.locals = ts.createSymbolTable();
}
+ declareSymbol(container_2.locals, undefined, node, 262144, 526824);
}
- function getAccessStack(ref) {
- var state = ref.typeName;
- var ids = [];
- while (!ts.isIdentifier(state)) {
- ids.unshift(state.right);
- state = state.left;
- }
- ids.unshift(state);
- return ids;
+ else {
+ bindAnonymousDeclaration(node, 262144, getDeclarationName(node));
}
- function createTypeNodesFromResolvedType(resolvedType) {
- if (checkTruncationLength(context)) {
- return [ts.createPropertySignature(undefined, "...", undefined, undefined, undefined)];
- }
- var typeElements = [];
- for (var _i = 0, _a = resolvedType.callSignatures; _i < _a.length; _i++) {
- var signature = _a[_i];
- typeElements.push(signatureToSignatureDeclarationHelper(signature, 165, context));
- }
- for (var _b = 0, _c = resolvedType.constructSignatures; _b < _c.length; _b++) {
- var signature = _c[_b];
- typeElements.push(signatureToSignatureDeclarationHelper(signature, 166, context));
- }
- if (resolvedType.stringIndexInfo) {
- var indexSignature = void 0;
- if (resolvedType.objectFlags & 2048) {
- indexSignature = indexInfoToIndexSignatureDeclarationHelper(createIndexInfo(anyType, resolvedType.stringIndexInfo.isReadonly, resolvedType.stringIndexInfo.declaration), 0, context);
- indexSignature.type = createElidedInformationPlaceholder(context);
- }
- else {
- indexSignature = indexInfoToIndexSignatureDeclarationHelper(resolvedType.stringIndexInfo, 0, context);
- }
- typeElements.push(indexSignature);
- }
- if (resolvedType.numberIndexInfo) {
- typeElements.push(indexInfoToIndexSignatureDeclarationHelper(resolvedType.numberIndexInfo, 1, context));
- }
- var properties = resolvedType.properties;
- if (!properties) {
- return typeElements;
- }
- var i = 0;
- for (var _d = 0, properties_1 = properties; _d < properties_1.length; _d++) {
- var propertySymbol = properties_1[_d];
- i++;
- if (context.flags & 2048) {
- if (propertySymbol.flags & 4194304) {
- continue;
- }
- if (ts.getDeclarationModifierFlagsFromSymbol(propertySymbol) & (8 | 16) && context.tracker.reportPrivateInBaseOfClassExpression) {
- context.tracker.reportPrivateInBaseOfClassExpression(ts.unescapeLeadingUnderscores(propertySymbol.escapedName));
- }
- }
- if (checkTruncationLength(context) && (i + 2 < properties.length - 1)) {
- typeElements.push(ts.createPropertySignature(undefined, "... " + (properties.length - i) + " more ...", undefined, undefined, undefined));
- addPropertyToElementList(properties[properties.length - 1], context, typeElements);
- break;
- }
- addPropertyToElementList(propertySymbol, context, typeElements);
+ }
+ else {
+ declareSymbolAndAddToSymbolTable(node, 262144, 526824);
+ }
+ }
+ function shouldReportErrorOnModuleDeclaration(node) {
+ var instanceState = getModuleInstanceState(node);
+ return instanceState === 1 || (instanceState === 2 && !!options.preserveConstEnums);
+ }
+ function checkUnreachable(node) {
+ if (!(currentFlow.flags & 1)) {
+ return false;
+ }
+ if (currentFlow === unreachableFlow) {
+ var reportError = (ts.isStatementButNotDeclaration(node) && node.kind !== 231) ||
+ node.kind === 252 ||
+ (node.kind === 256 && shouldReportErrorOnModuleDeclaration(node));
+ if (reportError) {
+ currentFlow = reportedUnreachableFlow;
+ if (!options.allowUnreachableCode) {
+ var isError_1 = ts.unreachableCodeIsError(options) &&
+ !(node.flags & 8388608) &&
+ (!ts.isVariableStatement(node) ||
+ !!(ts.getCombinedNodeFlags(node.declarationList) & 3) ||
+ node.declarationList.declarations.some(function (d) { return !!d.initializer; }));
+ eachUnreachableRange(node, function (start, end) { return errorOrSuggestionOnRange(isError_1, start, end, ts.Diagnostics.Unreachable_code_detected); });
}
- return typeElements.length ? typeElements : undefined;
}
}
- function createElidedInformationPlaceholder(context) {
- context.approximateLength += 3;
- if (!(context.flags & 1)) {
- return ts.createTypeReferenceNode(ts.createIdentifier("..."), undefined);
- }
- return ts.createKeywordTypeNode(125);
+ return true;
+ }
+ }
+ function eachUnreachableRange(node, cb) {
+ if (ts.isStatement(node) && isExecutableStatement(node) && ts.isBlock(node.parent)) {
+ var statements = node.parent.statements;
+ var slice_1 = ts.sliceAfter(statements, node);
+ ts.getRangesWhere(slice_1, isExecutableStatement, function (start, afterEnd) { return cb(slice_1[start], slice_1[afterEnd - 1]); });
+ }
+ else {
+ cb(node, node);
+ }
+ }
+ function isExecutableStatement(s) {
+ return !ts.isFunctionDeclaration(s) && !isPurelyTypeDeclaration(s) && !ts.isEnumDeclaration(s) &&
+ !(ts.isVariableStatement(s) && !(ts.getCombinedNodeFlags(s) & (1 | 2)) && s.declarationList.declarations.some(function (d) { return !d.initializer; }));
+ }
+ function isPurelyTypeDeclaration(s) {
+ switch (s.kind) {
+ case 253:
+ case 254:
+ return true;
+ case 256:
+ return getModuleInstanceState(s) !== 1;
+ case 255:
+ return ts.hasSyntacticModifier(s, 2048);
+ default:
+ return false;
+ }
+ }
+ function isExportsOrModuleExportsOrAlias(sourceFile, node) {
+ var i = 0;
+ var q = [node];
+ while (q.length && i < 100) {
+ i++;
+ node = q.shift();
+ if (ts.isExportsIdentifier(node) || ts.isModuleExportsAccessExpression(node)) {
+ return true;
}
- function addPropertyToElementList(propertySymbol, context, typeElements) {
- var propertyIsReverseMapped = !!(ts.getCheckFlags(propertySymbol) & 8192);
- var propertyType = propertyIsReverseMapped && context.flags & 33554432 ?
- anyType : getTypeOfSymbol(propertySymbol);
- var saveEnclosingDeclaration = context.enclosingDeclaration;
- context.enclosingDeclaration = undefined;
- if (context.tracker.trackSymbol && ts.getCheckFlags(propertySymbol) & 4096) {
- var decl = ts.first(propertySymbol.declarations);
- if (hasLateBindableName(decl)) {
- if (ts.isBinaryExpression(decl)) {
- var name = ts.getNameOfDeclaration(decl);
- if (name && ts.isElementAccessExpression(name) && ts.isPropertyAccessEntityNameExpression(name.argumentExpression)) {
- trackComputedName(name.argumentExpression, saveEnclosingDeclaration, context);
- }
- }
- else {
- trackComputedName(decl.name.expression, saveEnclosingDeclaration, context);
- }
+ else if (ts.isIdentifier(node)) {
+ var symbol = lookupSymbolForName(sourceFile, node.escapedText);
+ if (!!symbol && !!symbol.valueDeclaration && ts.isVariableDeclaration(symbol.valueDeclaration) && !!symbol.valueDeclaration.initializer) {
+ var init = symbol.valueDeclaration.initializer;
+ q.push(init);
+ if (ts.isAssignmentExpression(init, true)) {
+ q.push(init.left);
+ q.push(init.right);
}
}
- context.enclosingDeclaration = saveEnclosingDeclaration;
- var propertyName = getPropertyNameNodeForSymbol(propertySymbol, context);
- context.approximateLength += (ts.symbolName(propertySymbol).length + 1);
- var optionalToken = propertySymbol.flags & 16777216 ? ts.createToken(57) : undefined;
- if (propertySymbol.flags & (16 | 8192) && !getPropertiesOfObjectType(propertyType).length && !isReadonlySymbol(propertySymbol)) {
- var signatures = getSignaturesOfType(filterType(propertyType, function (t) { return !(t.flags & 32768); }), 0);
- for (var _i = 0, signatures_1 = signatures; _i < signatures_1.length; _i++) {
- var signature = signatures_1[_i];
- var methodDeclaration = signatureToSignatureDeclarationHelper(signature, 160, context);
- methodDeclaration.name = propertyName;
- methodDeclaration.questionToken = optionalToken;
- typeElements.push(preserveCommentsOn(methodDeclaration));
+ }
+ }
+ return false;
+ }
+ ts.isExportsOrModuleExportsOrAlias = isExportsOrModuleExportsOrAlias;
+ function lookupSymbolForName(container, name) {
+ var local = container.locals && container.locals.get(name);
+ if (local) {
+ return local.exportSymbol || local;
+ }
+ if (ts.isSourceFile(container) && container.jsGlobalAugmentations && container.jsGlobalAugmentations.has(name)) {
+ return container.jsGlobalAugmentations.get(name);
+ }
+ return container.symbol && container.symbol.exports && container.symbol.exports.get(name);
+ }
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getIndexTypeOfStructuredType, getConstraintOfTypeParameter, getFirstIdentifier, getTypeArguments) {
+ return getSymbolWalker;
+ function getSymbolWalker(accept) {
+ if (accept === void 0) { accept = function () { return true; }; }
+ var visitedTypes = [];
+ var visitedSymbols = [];
+ return {
+ walkType: function (type) {
+ try {
+ visitType(type);
+ return { visitedTypes: ts.getOwnValues(visitedTypes), visitedSymbols: ts.getOwnValues(visitedSymbols) };
}
- }
- else {
- var savedFlags = context.flags;
- context.flags |= propertyIsReverseMapped ? 33554432 : 0;
- var propertyTypeNode = void 0;
- if (propertyIsReverseMapped && !!(savedFlags & 33554432)) {
- propertyTypeNode = createElidedInformationPlaceholder(context);
+ finally {
+ ts.clear(visitedTypes);
+ ts.clear(visitedSymbols);
}
- else {
- propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : ts.createKeywordTypeNode(125);
+ },
+ walkSymbol: function (symbol) {
+ try {
+ visitSymbol(symbol);
+ return { visitedTypes: ts.getOwnValues(visitedTypes), visitedSymbols: ts.getOwnValues(visitedSymbols) };
}
- context.flags = savedFlags;
- var modifiers = isReadonlySymbol(propertySymbol) ? [ts.createToken(138)] : undefined;
- if (modifiers) {
- context.approximateLength += 9;
+ finally {
+ ts.clear(visitedTypes);
+ ts.clear(visitedSymbols);
}
- var propertySignature = ts.createPropertySignature(modifiers, propertyName, optionalToken, propertyTypeNode, undefined);
- typeElements.push(preserveCommentsOn(propertySignature));
+ },
+ };
+ function visitType(type) {
+ if (!type) {
+ return;
}
- function preserveCommentsOn(node) {
- if (ts.some(propertySymbol.declarations, function (d) { return d.kind === 323; })) {
- var d = ts.find(propertySymbol.declarations, function (d) { return d.kind === 323; });
- var commentText = d.comment;
- if (commentText) {
- ts.setSyntheticLeadingComments(node, [{ kind: 3, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]);
- }
- }
- else if (propertySymbol.valueDeclaration) {
- ts.setCommentRange(node, propertySymbol.valueDeclaration);
- }
- return node;
+ if (visitedTypes[type.id]) {
+ return;
}
- }
- function mapToTypeNodes(types, context, isBareList) {
- if (ts.some(types)) {
- if (checkTruncationLength(context)) {
- if (!isBareList) {
- return [ts.createTypeReferenceNode("...", undefined)];
- }
- else if (types.length > 2) {
- return [
- typeToTypeNodeHelper(types[0], context),
- ts.createTypeReferenceNode("... " + (types.length - 2) + " more ...", undefined),
- typeToTypeNodeHelper(types[types.length - 1], context)
- ];
- }
+ visitedTypes[type.id] = type;
+ var shouldBail = visitSymbol(type.symbol);
+ if (shouldBail)
+ return;
+ if (type.flags & 524288) {
+ var objectType = type;
+ var objectFlags = objectType.objectFlags;
+ if (objectFlags & 4) {
+ visitTypeReference(type);
}
- var mayHaveNameCollisions = !(context.flags & 64);
- var seenNames = mayHaveNameCollisions ? ts.createUnderscoreEscapedMultiMap() : undefined;
- var result_3 = [];
- var i = 0;
- for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
- var type = types_1[_i];
- i++;
- if (checkTruncationLength(context) && (i + 2 < types.length - 1)) {
- result_3.push(ts.createTypeReferenceNode("... " + (types.length - i) + " more ...", undefined));
- var typeNode_1 = typeToTypeNodeHelper(types[types.length - 1], context);
- if (typeNode_1) {
- result_3.push(typeNode_1);
- }
- break;
- }
- context.approximateLength += 2;
- var typeNode = typeToTypeNodeHelper(type, context);
- if (typeNode) {
- result_3.push(typeNode);
- if (seenNames && ts.isIdentifierTypeReference(typeNode)) {
- seenNames.add(typeNode.typeName.escapedText, [type, result_3.length - 1]);
- }
- }
+ if (objectFlags & 32) {
+ visitMappedType(type);
}
- if (seenNames) {
- var saveContextFlags = context.flags;
- context.flags |= 64;
- seenNames.forEach(function (types) {
- if (!ts.arrayIsHomogeneous(types, function (_a, _b) {
- var a = _a[0];
- var b = _b[0];
- return typesAreSameReference(a, b);
- })) {
- for (var _i = 0, types_2 = types; _i < types_2.length; _i++) {
- var _a = types_2[_i], type = _a[0], resultIndex = _a[1];
- result_3[resultIndex] = typeToTypeNodeHelper(type, context);
- }
- }
- });
- context.flags = saveContextFlags;
+ if (objectFlags & (1 | 2)) {
+ visitInterfaceType(type);
+ }
+ if (objectFlags & (8 | 16)) {
+ visitObjectType(objectType);
}
- return result_3;
- }
- }
- function typesAreSameReference(a, b) {
- return a === b
- || !!a.symbol && a.symbol === b.symbol
- || !!a.aliasSymbol && a.aliasSymbol === b.aliasSymbol;
- }
- function indexInfoToIndexSignatureDeclarationHelper(indexInfo, kind, context) {
- var name = ts.getNameFromIndexInfo(indexInfo) || "x";
- var indexerTypeNode = ts.createKeywordTypeNode(kind === 0 ? 143 : 140);
- var indexingParameter = ts.createParameter(undefined, undefined, undefined, name, undefined, indexerTypeNode, undefined);
- var typeNode = typeToTypeNodeHelper(indexInfo.type || anyType, context);
- if (!indexInfo.type && !(context.flags & 2097152)) {
- context.encounteredError = true;
- }
- context.approximateLength += (name.length + 4);
- return ts.createIndexSignature(undefined, indexInfo.isReadonly ? [ts.createToken(138)] : undefined, [indexingParameter], typeNode);
- }
- function signatureToSignatureDeclarationHelper(signature, kind, context, privateSymbolVisitor, bundledImports) {
- var suppressAny = context.flags & 256;
- if (suppressAny)
- context.flags &= ~256;
- var typeParameters;
- var typeArguments;
- if (context.flags & 32 && signature.target && signature.mapper && signature.target.typeParameters) {
- typeArguments = signature.target.typeParameters.map(function (parameter) { return typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context); });
}
- else {
- typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return typeParameterToDeclaration(parameter, context); });
+ if (type.flags & 262144) {
+ visitTypeParameter(type);
}
- var parameters = getExpandedParameters(signature).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 162, privateSymbolVisitor, bundledImports); });
- if (signature.thisParameter) {
- var thisParameter = symbolToParameterDeclaration(signature.thisParameter, context);
- parameters.unshift(thisParameter);
+ if (type.flags & 3145728) {
+ visitUnionOrIntersectionType(type);
}
- var returnTypeNode;
- var typePredicate = getTypePredicateOfSignature(signature);
- if (typePredicate) {
- var assertsModifier = typePredicate.kind === 2 || typePredicate.kind === 3 ?
- ts.createToken(124) :
- undefined;
- var parameterName = typePredicate.kind === 1 || typePredicate.kind === 3 ?
- ts.setEmitFlags(ts.createIdentifier(typePredicate.parameterName), 16777216) :
- ts.createThisTypeNode();
- var typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context);
- returnTypeNode = ts.createTypePredicateNodeWithModifier(assertsModifier, parameterName, typeNode);
+ if (type.flags & 4194304) {
+ visitIndexType(type);
}
- else {
- var returnType = getReturnTypeOfSignature(signature);
- if (returnType && !(suppressAny && isTypeAny(returnType))) {
- returnTypeNode = serializeReturnTypeForSignature(context, returnType, signature, privateSymbolVisitor, bundledImports);
- }
- else if (!suppressAny) {
- returnTypeNode = ts.createKeywordTypeNode(125);
- }
+ if (type.flags & 8388608) {
+ visitIndexedAccessType(type);
}
- context.approximateLength += 3;
- return ts.createSignatureDeclaration(kind, typeParameters, parameters, returnTypeNode, typeArguments);
}
- function typeParameterToDeclarationWithConstraint(type, context, constraintNode) {
- var savedContextFlags = context.flags;
- context.flags &= ~512;
- var name = typeParameterToName(type, context);
- var defaultParameter = getDefaultFromTypeParameter(type);
- var defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context);
- context.flags = savedContextFlags;
- return ts.createTypeParameterDeclaration(name, constraintNode, defaultParameterNode);
+ function visitTypeReference(type) {
+ visitType(type.target);
+ ts.forEach(getTypeArguments(type), visitType);
}
- function typeParameterToDeclaration(type, context, constraint) {
- if (constraint === void 0) { constraint = getConstraintOfTypeParameter(type); }
- var constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
- return typeParameterToDeclarationWithConstraint(type, context, constraintNode);
+ function visitTypeParameter(type) {
+ visitType(getConstraintOfTypeParameter(type));
}
- function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
- var parameterDeclaration = ts.getDeclarationOfKind(parameterSymbol, 156);
- if (!parameterDeclaration && !ts.isTransientSymbol(parameterSymbol)) {
- parameterDeclaration = ts.getDeclarationOfKind(parameterSymbol, 317);
- }
- var parameterType = getTypeOfSymbol(parameterSymbol);
- if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
- parameterType = getOptionalType(parameterType);
- }
- var parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports);
- var modifiers = !(context.flags & 8192) && preserveModifierFlags && parameterDeclaration && parameterDeclaration.modifiers ? parameterDeclaration.modifiers.map(ts.getSynthesizedClone) : undefined;
- var isRest = parameterDeclaration && ts.isRestParameter(parameterDeclaration) || ts.getCheckFlags(parameterSymbol) & 32768;
- var dotDotDotToken = isRest ? ts.createToken(25) : undefined;
- var name = parameterDeclaration ? parameterDeclaration.name ?
- parameterDeclaration.name.kind === 75 ? ts.setEmitFlags(ts.getSynthesizedClone(parameterDeclaration.name), 16777216) :
- parameterDeclaration.name.kind === 153 ? ts.setEmitFlags(ts.getSynthesizedClone(parameterDeclaration.name.right), 16777216) :
- cloneBindingName(parameterDeclaration.name) :
- ts.symbolName(parameterSymbol) :
- ts.symbolName(parameterSymbol);
- var isOptional = parameterDeclaration && isOptionalParameter(parameterDeclaration) || ts.getCheckFlags(parameterSymbol) & 16384;
- var questionToken = isOptional ? ts.createToken(57) : undefined;
- var parameterNode = ts.createParameter(undefined, modifiers, dotDotDotToken, name, questionToken, parameterTypeNode, undefined);
- context.approximateLength += ts.symbolName(parameterSymbol).length + 3;
- return parameterNode;
- function cloneBindingName(node) {
- return elideInitializerAndSetEmitFlags(node);
- function elideInitializerAndSetEmitFlags(node) {
- if (context.tracker.trackSymbol && ts.isComputedPropertyName(node) && isLateBindableName(node)) {
- trackComputedName(node.expression, context.enclosingDeclaration, context);
- }
- var visited = ts.visitEachChild(node, elideInitializerAndSetEmitFlags, ts.nullTransformationContext, undefined, elideInitializerAndSetEmitFlags);
- var clone = ts.nodeIsSynthesized(visited) ? visited : ts.getSynthesizedClone(visited);
- if (clone.kind === 191) {
- clone.initializer = undefined;
- }
- return ts.setEmitFlags(clone, 1 | 16777216);
- }
- }
+ function visitUnionOrIntersectionType(type) {
+ ts.forEach(type.types, visitType);
}
- function trackComputedName(accessExpression, enclosingDeclaration, context) {
- if (!context.tracker.trackSymbol)
- return;
- var firstIdentifier = ts.getFirstIdentifier(accessExpression);
- var name = resolveName(firstIdentifier, firstIdentifier.escapedText, 111551 | 1048576, undefined, undefined, true);
- if (name) {
- context.tracker.trackSymbol(name, enclosingDeclaration, 111551);
+ function visitIndexType(type) {
+ visitType(type.type);
+ }
+ function visitIndexedAccessType(type) {
+ visitType(type.objectType);
+ visitType(type.indexType);
+ visitType(type.constraint);
+ }
+ function visitMappedType(type) {
+ visitType(type.typeParameter);
+ visitType(type.constraintType);
+ visitType(type.templateType);
+ visitType(type.modifiersType);
+ }
+ function visitSignature(signature) {
+ var typePredicate = getTypePredicateOfSignature(signature);
+ if (typePredicate) {
+ visitType(typePredicate.type);
+ }
+ ts.forEach(signature.typeParameters, visitType);
+ for (var _i = 0, _a = signature.parameters; _i < _a.length; _i++) {
+ var parameter = _a[_i];
+ visitSymbol(parameter);
}
+ visitType(getRestTypeOfSignature(signature));
+ visitType(getReturnTypeOfSignature(signature));
}
- function lookupSymbolChain(symbol, context, meaning, yieldModuleSymbol) {
- context.tracker.trackSymbol(symbol, context.enclosingDeclaration, meaning);
- return lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol);
+ function visitInterfaceType(interfaceT) {
+ visitObjectType(interfaceT);
+ ts.forEach(interfaceT.typeParameters, visitType);
+ ts.forEach(getBaseTypes(interfaceT), visitType);
+ visitType(interfaceT.thisType);
}
- function lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol) {
- var chain;
- var isTypeParameter = symbol.flags & 262144;
- if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64) && !(context.flags & 134217728)) {
- chain = ts.Debug.checkDefined(getSymbolChain(symbol, meaning, true));
- ts.Debug.assert(chain && chain.length > 0);
+ function visitObjectType(type) {
+ var stringIndexType = getIndexTypeOfStructuredType(type, 0);
+ visitType(stringIndexType);
+ var numberIndexType = getIndexTypeOfStructuredType(type, 1);
+ visitType(numberIndexType);
+ var resolved = resolveStructuredTypeMembers(type);
+ for (var _i = 0, _a = resolved.callSignatures; _i < _a.length; _i++) {
+ var signature = _a[_i];
+ visitSignature(signature);
}
- else {
- chain = [symbol];
+ for (var _b = 0, _c = resolved.constructSignatures; _b < _c.length; _b++) {
+ var signature = _c[_b];
+ visitSignature(signature);
}
- return chain;
- function getSymbolChain(symbol, meaning, endOfChain) {
- var accessibleSymbolChain = getAccessibleSymbolChain(symbol, context.enclosingDeclaration, meaning, !!(context.flags & 128));
- var parentSpecifiers;
- if (!accessibleSymbolChain ||
- needsQualification(accessibleSymbolChain[0], context.enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {
- var parents_1 = getContainersOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol, context.enclosingDeclaration);
- if (ts.length(parents_1)) {
- parentSpecifiers = parents_1.map(function (symbol) {
- return ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)
- ? getSpecifierForModuleSymbol(symbol, context)
- : undefined;
- });
- var indices = parents_1.map(function (_, i) { return i; });
- indices.sort(sortByBestName);
- var sortedParents = indices.map(function (i) { return parents_1[i]; });
- for (var _i = 0, sortedParents_1 = sortedParents; _i < sortedParents_1.length; _i++) {
- var parent = sortedParents_1[_i];
- var parentChain = getSymbolChain(parent, getQualifiedLeftMeaning(meaning), false);
- if (parentChain) {
- if (parent.exports && parent.exports.get("export=") &&
- getSymbolIfSameReference(parent.exports.get("export="), symbol)) {
- accessibleSymbolChain = parentChain;
- break;
- }
- accessibleSymbolChain = parentChain.concat(accessibleSymbolChain || [getAliasForSymbolInContainer(parent, symbol) || symbol]);
- break;
- }
- }
- }
- }
- if (accessibleSymbolChain) {
- return accessibleSymbolChain;
- }
- if (endOfChain ||
- !(symbol.flags & (2048 | 4096))) {
- if (!endOfChain && !yieldModuleSymbol && !!ts.forEach(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
- return;
- }
- return [symbol];
- }
- function sortByBestName(a, b) {
- var specifierA = parentSpecifiers[a];
- var specifierB = parentSpecifiers[b];
- if (specifierA && specifierB) {
- var isBRelative = ts.pathIsRelative(specifierB);
- if (ts.pathIsRelative(specifierA) === isBRelative) {
- return ts.moduleSpecifiers.countPathComponents(specifierA) - ts.moduleSpecifiers.countPathComponents(specifierB);
- }
- if (isBRelative) {
- return -1;
- }
- return 1;
- }
- return 0;
- }
+ for (var _d = 0, _e = resolved.properties; _d < _e.length; _d++) {
+ var p = _e[_d];
+ visitSymbol(p);
}
}
- function typeParametersToTypeParameterDeclarations(symbol, context) {
- var typeParameterNodes;
- var targetSymbol = getTargetSymbol(symbol);
- if (targetSymbol.flags & (32 | 64 | 524288)) {
- typeParameterNodes = ts.createNodeArray(ts.map(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), function (tp) { return typeParameterToDeclaration(tp, context); }));
+ function visitSymbol(symbol) {
+ if (!symbol) {
+ return false;
}
- return typeParameterNodes;
- }
- function lookupTypeParameterNodes(chain, index, context) {
- ts.Debug.assert(chain && 0 <= index && index < chain.length);
- var symbol = chain[index];
- var symbolId = "" + getSymbolId(symbol);
- if (context.typeParameterSymbolList && context.typeParameterSymbolList.get(symbolId)) {
- return undefined;
+ var symbolId = ts.getSymbolId(symbol);
+ if (visitedSymbols[symbolId]) {
+ return false;
}
- (context.typeParameterSymbolList || (context.typeParameterSymbolList = ts.createMap())).set(symbolId, true);
- var typeParameterNodes;
- if (context.flags & 512 && index < (chain.length - 1)) {
- var parentSymbol = symbol;
- var nextSymbol_1 = chain[index + 1];
- if (ts.getCheckFlags(nextSymbol_1) & 1) {
- var params = getTypeParametersOfClassOrInterface(parentSymbol.flags & 2097152 ? resolveAlias(parentSymbol) : parentSymbol);
- typeParameterNodes = mapToTypeNodes(ts.map(params, function (t) { return getMappedType(t, nextSymbol_1.mapper); }), context);
- }
- else {
- typeParameterNodes = typeParametersToTypeParameterDeclarations(symbol, context);
- }
+ visitedSymbols[symbolId] = symbol;
+ if (!accept(symbol)) {
+ return true;
}
- return typeParameterNodes;
- }
- function getTopmostIndexedAccessType(top) {
- if (ts.isIndexedAccessTypeNode(top.objectType)) {
- return getTopmostIndexedAccessType(top.objectType);
+ var t = getTypeOfSymbol(symbol);
+ visitType(t);
+ if (symbol.exports) {
+ symbol.exports.forEach(visitSymbol);
}
- return top;
- }
- function getSpecifierForModuleSymbol(symbol, context) {
- var file = ts.getDeclarationOfKind(symbol, 290);
- if (!file) {
- var equivalentFileSymbol = ts.firstDefined(symbol.declarations, function (d) { return getFileSymbolIfFileSymbolExportEqualsContainer(d, symbol); });
- if (equivalentFileSymbol) {
- file = ts.getDeclarationOfKind(equivalentFileSymbol, 290);
+ ts.forEach(symbol.declarations, function (d) {
+ if (d.type && d.type.kind === 176) {
+ var query = d.type;
+ var entity = getResolvedSymbol(getFirstIdentifier(query.exprName));
+ visitSymbol(entity);
}
+ });
+ return false;
+ }
+ }
+ }
+ ts.createGetSymbolWalker = createGetSymbolWalker;
+})(ts || (ts = {}));
+var ts;
+(function (ts) {
+ var ambientModuleSymbolRegex = /^".+"$/;
+ var anon = "(anonymous)";
+ var nextSymbolId = 1;
+ var nextNodeId = 1;
+ var nextMergeId = 1;
+ var nextFlowId = 1;
+ var typeofEQFacts = new ts.Map(ts.getEntries({
+ string: 1,
+ number: 2,
+ bigint: 4,
+ boolean: 8,
+ symbol: 16,
+ undefined: 65536,
+ object: 32,
+ function: 64
+ }));
+ var typeofNEFacts = new ts.Map(ts.getEntries({
+ string: 256,
+ number: 512,
+ bigint: 1024,
+ boolean: 2048,
+ symbol: 4096,
+ undefined: 524288,
+ object: 8192,
+ function: 16384
+ }));
+ var isNotOverloadAndNotAccessor = ts.and(isNotOverload, isNotAccessor);
+ var intrinsicTypeKinds = new ts.Map(ts.getEntries({
+ Uppercase: 0,
+ Lowercase: 1,
+ Capitalize: 2,
+ Uncapitalize: 3
+ }));
+ function SymbolLinks() {
+ }
+ function NodeLinks() {
+ this.flags = 0;
+ }
+ function getNodeId(node) {
+ if (!node.id) {
+ node.id = nextNodeId;
+ nextNodeId++;
+ }
+ return node.id;
+ }
+ ts.getNodeId = getNodeId;
+ function getSymbolId(symbol) {
+ if (!symbol.id) {
+ symbol.id = nextSymbolId;
+ nextSymbolId++;
+ }
+ return symbol.id;
+ }
+ ts.getSymbolId = getSymbolId;
+ function isInstantiatedModule(node, preserveConstEnums) {
+ var moduleState = ts.getModuleInstanceState(node);
+ return moduleState === 1 ||
+ (preserveConstEnums && moduleState === 2);
+ }
+ ts.isInstantiatedModule = isInstantiatedModule;
+ function createTypeChecker(host, produceDiagnostics) {
+ var getPackagesSet = ts.memoize(function () {
+ var set = new ts.Set();
+ host.getSourceFiles().forEach(function (sf) {
+ if (!sf.resolvedModules)
+ return;
+ ts.forEachEntry(sf.resolvedModules, function (r) {
+ if (r && r.packageId)
+ set.add(r.packageId.name);
+ });
+ });
+ return set;
+ });
+ var cancellationToken;
+ var requestedExternalEmitHelpers;
+ var externalHelpersModule;
+ var Symbol = ts.objectAllocator.getSymbolConstructor();
+ var Type = ts.objectAllocator.getTypeConstructor();
+ var Signature = ts.objectAllocator.getSignatureConstructor();
+ var typeCount = 0;
+ var symbolCount = 0;
+ var enumCount = 0;
+ var totalInstantiationCount = 0;
+ var instantiationCount = 0;
+ var instantiationDepth = 0;
+ var constraintDepth = 0;
+ var currentNode;
+ var typeCatalog = [];
+ var emptySymbols = ts.createSymbolTable();
+ var arrayVariances = [1];
+ var compilerOptions = host.getCompilerOptions();
+ var languageVersion = ts.getEmitScriptTarget(compilerOptions);
+ var moduleKind = ts.getEmitModuleKind(compilerOptions);
+ var allowSyntheticDefaultImports = ts.getAllowSyntheticDefaultImports(compilerOptions);
+ var strictNullChecks = ts.getStrictOptionValue(compilerOptions, "strictNullChecks");
+ var strictFunctionTypes = ts.getStrictOptionValue(compilerOptions, "strictFunctionTypes");
+ var strictBindCallApply = ts.getStrictOptionValue(compilerOptions, "strictBindCallApply");
+ var strictPropertyInitialization = ts.getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
+ var noImplicitAny = ts.getStrictOptionValue(compilerOptions, "noImplicitAny");
+ var noImplicitThis = ts.getStrictOptionValue(compilerOptions, "noImplicitThis");
+ var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
+ var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 32768;
+ var emitResolver = createResolver();
+ var nodeBuilder = createNodeBuilder();
+ var globals = ts.createSymbolTable();
+ var undefinedSymbol = createSymbol(4, "undefined");
+ undefinedSymbol.declarations = [];
+ var globalThisSymbol = createSymbol(1536, "globalThis", 8);
+ globalThisSymbol.exports = globals;
+ globalThisSymbol.declarations = [];
+ globals.set(globalThisSymbol.escapedName, globalThisSymbol);
+ var argumentsSymbol = createSymbol(4, "arguments");
+ var requireSymbol = createSymbol(4, "require");
+ var apparentArgumentCount;
+ var checker = {
+ getNodeCount: function () { return ts.sum(host.getSourceFiles(), "nodeCount"); },
+ getIdentifierCount: function () { return ts.sum(host.getSourceFiles(), "identifierCount"); },
+ getSymbolCount: function () { return ts.sum(host.getSourceFiles(), "symbolCount") + symbolCount; },
+ getTypeCatalog: function () { return typeCatalog; },
+ getTypeCount: function () { return typeCount; },
+ getInstantiationCount: function () { return totalInstantiationCount; },
+ getRelationCacheSizes: function () { return ({
+ assignable: assignableRelation.size,
+ identity: identityRelation.size,
+ subtype: subtypeRelation.size,
+ strictSubtype: strictSubtypeRelation.size,
+ }); },
+ isUndefinedSymbol: function (symbol) { return symbol === undefinedSymbol; },
+ isArgumentsSymbol: function (symbol) { return symbol === argumentsSymbol; },
+ isUnknownSymbol: function (symbol) { return symbol === unknownSymbol; },
+ getMergedSymbol: getMergedSymbol,
+ getDiagnostics: getDiagnostics,
+ getGlobalDiagnostics: getGlobalDiagnostics,
+ getRecursionIdentity: getRecursionIdentity,
+ getTypeOfSymbolAtLocation: function (symbol, locationIn) {
+ var location = ts.getParseTreeNode(locationIn);
+ return location ? getTypeOfSymbolAtLocation(symbol, location) : errorType;
+ },
+ getSymbolsOfParameterPropertyDeclaration: function (parameterIn, parameterName) {
+ var parameter = ts.getParseTreeNode(parameterIn, ts.isParameter);
+ if (parameter === undefined)
+ return ts.Debug.fail("Cannot get symbols of a synthetic parameter that cannot be resolved to a parse-tree node.");
+ return getSymbolsOfParameterPropertyDeclaration(parameter, ts.escapeLeadingUnderscores(parameterName));
+ },
+ getDeclaredTypeOfSymbol: getDeclaredTypeOfSymbol,
+ getPropertiesOfType: getPropertiesOfType,
+ getPropertyOfType: function (type, name) { return getPropertyOfType(type, ts.escapeLeadingUnderscores(name)); },
+ getPrivateIdentifierPropertyOfType: function (leftType, name, location) {
+ var node = ts.getParseTreeNode(location);
+ if (!node) {
+ return undefined;
}
- if (file && file.moduleName !== undefined) {
- return file.moduleName;
+ var propName = ts.escapeLeadingUnderscores(name);
+ var lexicallyScopedIdentifier = lookupSymbolForPrivateIdentifierDeclaration(propName, node);
+ return lexicallyScopedIdentifier ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) : undefined;
+ },
+ getTypeOfPropertyOfType: function (type, name) { return getTypeOfPropertyOfType(type, ts.escapeLeadingUnderscores(name)); },
+ getIndexInfoOfType: getIndexInfoOfType,
+ getSignaturesOfType: getSignaturesOfType,
+ getIndexTypeOfType: getIndexTypeOfType,
+ getBaseTypes: getBaseTypes,
+ getBaseTypeOfLiteralType: getBaseTypeOfLiteralType,
+ getWidenedType: getWidenedType,
+ getTypeFromTypeNode: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode);
+ return node ? getTypeFromTypeNode(node) : errorType;
+ },
+ getParameterType: getTypeAtPosition,
+ getPromisedTypeOfPromise: getPromisedTypeOfPromise,
+ getAwaitedType: function (type) { return getAwaitedType(type); },
+ getReturnTypeOfSignature: getReturnTypeOfSignature,
+ isNullableType: isNullableType,
+ getNullableType: getNullableType,
+ getNonNullableType: getNonNullableType,
+ getNonOptionalType: removeOptionalTypeMarker,
+ getTypeArguments: getTypeArguments,
+ typeToTypeNode: nodeBuilder.typeToTypeNode,
+ indexInfoToIndexSignatureDeclaration: nodeBuilder.indexInfoToIndexSignatureDeclaration,
+ signatureToSignatureDeclaration: nodeBuilder.signatureToSignatureDeclaration,
+ symbolToEntityName: nodeBuilder.symbolToEntityName,
+ symbolToExpression: nodeBuilder.symbolToExpression,
+ symbolToTypeParameterDeclarations: nodeBuilder.symbolToTypeParameterDeclarations,
+ symbolToParameterDeclaration: nodeBuilder.symbolToParameterDeclaration,
+ typeParameterToDeclaration: nodeBuilder.typeParameterToDeclaration,
+ getSymbolsInScope: function (locationIn, meaning) {
+ var location = ts.getParseTreeNode(locationIn);
+ return location ? getSymbolsInScope(location, meaning) : [];
+ },
+ getSymbolAtLocation: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn);
+ return node ? getSymbolAtLocation(node, true) : undefined;
+ },
+ getShorthandAssignmentValueSymbol: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn);
+ return node ? getShorthandAssignmentValueSymbol(node) : undefined;
+ },
+ getExportSpecifierLocalTargetSymbol: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isExportSpecifier);
+ return node ? getExportSpecifierLocalTargetSymbol(node) : undefined;
+ },
+ getExportSymbolOfSymbol: function (symbol) {
+ return getMergedSymbol(symbol.exportSymbol || symbol);
+ },
+ getTypeAtLocation: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn);
+ return node ? getTypeOfNode(node) : errorType;
+ },
+ getTypeOfAssignmentPattern: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isAssignmentPattern);
+ return node && getTypeOfAssignmentPattern(node) || errorType;
+ },
+ getPropertySymbolOfDestructuringAssignment: function (locationIn) {
+ var location = ts.getParseTreeNode(locationIn, ts.isIdentifier);
+ return location ? getPropertySymbolOfDestructuringAssignment(location) : undefined;
+ },
+ signatureToString: function (signature, enclosingDeclaration, flags, kind) {
+ return signatureToString(signature, ts.getParseTreeNode(enclosingDeclaration), flags, kind);
+ },
+ typeToString: function (type, enclosingDeclaration, flags) {
+ return typeToString(type, ts.getParseTreeNode(enclosingDeclaration), flags);
+ },
+ symbolToString: function (symbol, enclosingDeclaration, meaning, flags) {
+ return symbolToString(symbol, ts.getParseTreeNode(enclosingDeclaration), meaning, flags);
+ },
+ typePredicateToString: function (predicate, enclosingDeclaration, flags) {
+ return typePredicateToString(predicate, ts.getParseTreeNode(enclosingDeclaration), flags);
+ },
+ writeSignature: function (signature, enclosingDeclaration, flags, kind, writer) {
+ return signatureToString(signature, ts.getParseTreeNode(enclosingDeclaration), flags, kind, writer);
+ },
+ writeType: function (type, enclosingDeclaration, flags, writer) {
+ return typeToString(type, ts.getParseTreeNode(enclosingDeclaration), flags, writer);
+ },
+ writeSymbol: function (symbol, enclosingDeclaration, meaning, flags, writer) {
+ return symbolToString(symbol, ts.getParseTreeNode(enclosingDeclaration), meaning, flags, writer);
+ },
+ writeTypePredicate: function (predicate, enclosingDeclaration, flags, writer) {
+ return typePredicateToString(predicate, ts.getParseTreeNode(enclosingDeclaration), flags, writer);
+ },
+ getAugmentedPropertiesOfType: getAugmentedPropertiesOfType,
+ getRootSymbols: getRootSymbols,
+ getSymbolOfExpando: getSymbolOfExpando,
+ getContextualType: function (nodeIn, contextFlags) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isExpression);
+ if (!node) {
+ return undefined;
}
- if (!file) {
- if (context.tracker.trackReferencedAmbientModule) {
- var ambientDecls = ts.filter(symbol.declarations, ts.isAmbientModule);
- if (ts.length(ambientDecls)) {
- for (var _i = 0, ambientDecls_1 = ambientDecls; _i < ambientDecls_1.length; _i++) {
- var decl = ambientDecls_1[_i];
- context.tracker.trackReferencedAmbientModule(decl, symbol);
- }
- }
- }
- if (ambientModuleSymbolRegex.test(symbol.escapedName)) {
- return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
- }
+ var containingCall = ts.findAncestor(node, ts.isCallLikeExpression);
+ var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
+ if (contextFlags & 4 && containingCall) {
+ var toMarkSkip = node;
+ do {
+ getNodeLinks(toMarkSkip).skipDirectInference = true;
+ toMarkSkip = toMarkSkip.parent;
+ } while (toMarkSkip && toMarkSkip !== containingCall);
+ getNodeLinks(containingCall).resolvedSignature = undefined;
}
- if (!context.enclosingDeclaration || !context.tracker.moduleResolverHost) {
- if (ambientModuleSymbolRegex.test(symbol.escapedName)) {
- return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
- }
- return ts.getSourceFileOfNode(ts.getNonAugmentationDeclaration(symbol)).fileName;
+ var result = getContextualType(node, contextFlags);
+ if (contextFlags & 4 && containingCall) {
+ var toMarkSkip = node;
+ do {
+ getNodeLinks(toMarkSkip).skipDirectInference = undefined;
+ toMarkSkip = toMarkSkip.parent;
+ } while (toMarkSkip && toMarkSkip !== containingCall);
+ getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
}
- var contextFile = ts.getSourceFileOfNode(ts.getOriginalNode(context.enclosingDeclaration));
- var links = getSymbolLinks(symbol);
- var specifier = links.specifierCache && links.specifierCache.get(contextFile.path);
- if (!specifier) {
- var isBundle_1 = (compilerOptions.out || compilerOptions.outFile);
- var moduleResolverHost = context.tracker.moduleResolverHost;
- var specifierCompilerOptions = isBundle_1 ? __assign(__assign({}, compilerOptions), { baseUrl: moduleResolverHost.getCommonSourceDirectory() }) : compilerOptions;
- specifier = ts.first(ts.moduleSpecifiers.getModuleSpecifiers(symbol, specifierCompilerOptions, contextFile, moduleResolverHost, { importModuleSpecifierPreference: isBundle_1 ? "non-relative" : "relative" }));
- links.specifierCache = links.specifierCache || ts.createMap();
- links.specifierCache.set(contextFile.path, specifier);
+ return result;
+ },
+ getContextualTypeForObjectLiteralElement: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike);
+ return node ? getContextualTypeForObjectLiteralElement(node) : undefined;
+ },
+ getContextualTypeForArgumentAtIndex: function (nodeIn, argIndex) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
+ return node && getContextualTypeForArgumentAtIndex(node, argIndex);
+ },
+ getContextualTypeForJsxAttribute: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isJsxAttributeLike);
+ return node && getContextualTypeForJsxAttribute(node);
+ },
+ isContextSensitive: isContextSensitive,
+ getFullyQualifiedName: getFullyQualifiedName,
+ getResolvedSignature: function (node, candidatesOutArray, argumentCount) {
+ return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0);
+ },
+ getResolvedSignatureForSignatureHelp: function (node, candidatesOutArray, argumentCount) {
+ return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16);
+ },
+ getExpandedParameters: getExpandedParameters,
+ hasEffectiveRestParameter: hasEffectiveRestParameter,
+ getConstantValue: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, canHaveConstantValue);
+ return node ? getConstantValue(node) : undefined;
+ },
+ isValidPropertyAccess: function (nodeIn, propertyName) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isPropertyAccessOrQualifiedNameOrImportTypeNode);
+ return !!node && isValidPropertyAccess(node, ts.escapeLeadingUnderscores(propertyName));
+ },
+ isValidPropertyAccessForCompletions: function (nodeIn, type, property) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isPropertyAccessExpression);
+ return !!node && isValidPropertyAccessForCompletions(node, type, property);
+ },
+ getSignatureFromDeclaration: function (declarationIn) {
+ var declaration = ts.getParseTreeNode(declarationIn, ts.isFunctionLike);
+ return declaration ? getSignatureFromDeclaration(declaration) : undefined;
+ },
+ isImplementationOfOverload: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isFunctionLike);
+ return node ? isImplementationOfOverload(node) : undefined;
+ },
+ getImmediateAliasedSymbol: getImmediateAliasedSymbol,
+ getAliasedSymbol: resolveAlias,
+ getEmitResolver: getEmitResolver,
+ getExportsOfModule: getExportsOfModuleAsArray,
+ getExportsAndPropertiesOfModule: getExportsAndPropertiesOfModule,
+ getSymbolWalker: ts.createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getIndexTypeOfStructuredType, getConstraintOfTypeParameter, ts.getFirstIdentifier, getTypeArguments),
+ getAmbientModules: getAmbientModules,
+ getJsxIntrinsicTagNamesAt: getJsxIntrinsicTagNamesAt,
+ isOptionalParameter: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isParameter);
+ return node ? isOptionalParameter(node) : false;
+ },
+ tryGetMemberInModuleExports: function (name, symbol) { return tryGetMemberInModuleExports(ts.escapeLeadingUnderscores(name), symbol); },
+ tryGetMemberInModuleExportsAndProperties: function (name, symbol) { return tryGetMemberInModuleExportsAndProperties(ts.escapeLeadingUnderscores(name), symbol); },
+ tryFindAmbientModuleWithoutAugmentations: function (moduleName) {
+ return tryFindAmbientModule(moduleName, false);
+ },
+ getApparentType: getApparentType,
+ getUnionType: getUnionType,
+ isTypeAssignableTo: isTypeAssignableTo,
+ createAnonymousType: createAnonymousType,
+ createSignature: createSignature,
+ createSymbol: createSymbol,
+ createIndexInfo: createIndexInfo,
+ getAnyType: function () { return anyType; },
+ getStringType: function () { return stringType; },
+ getNumberType: function () { return numberType; },
+ createPromiseType: createPromiseType,
+ createArrayType: createArrayType,
+ getElementTypeOfArrayType: getElementTypeOfArrayType,
+ getBooleanType: function () { return booleanType; },
+ getFalseType: function (fresh) { return fresh ? falseType : regularFalseType; },
+ getTrueType: function (fresh) { return fresh ? trueType : regularTrueType; },
+ getVoidType: function () { return voidType; },
+ getUndefinedType: function () { return undefinedType; },
+ getNullType: function () { return nullType; },
+ getESSymbolType: function () { return esSymbolType; },
+ getNeverType: function () { return neverType; },
+ getOptionalType: function () { return optionalType; },
+ isSymbolAccessible: isSymbolAccessible,
+ isArrayType: isArrayType,
+ isTupleType: isTupleType,
+ isArrayLikeType: isArrayLikeType,
+ isTypeInvalidDueToUnionDiscriminant: isTypeInvalidDueToUnionDiscriminant,
+ getAllPossiblePropertiesOfTypes: getAllPossiblePropertiesOfTypes,
+ getSuggestedSymbolForNonexistentProperty: getSuggestedSymbolForNonexistentProperty,
+ getSuggestionForNonexistentProperty: getSuggestionForNonexistentProperty,
+ getSuggestedSymbolForNonexistentJSXAttribute: getSuggestedSymbolForNonexistentJSXAttribute,
+ getSuggestedSymbolForNonexistentSymbol: function (location, name, meaning) { return getSuggestedSymbolForNonexistentSymbol(location, ts.escapeLeadingUnderscores(name), meaning); },
+ getSuggestionForNonexistentSymbol: function (location, name, meaning) { return getSuggestionForNonexistentSymbol(location, ts.escapeLeadingUnderscores(name), meaning); },
+ getSuggestedSymbolForNonexistentModule: getSuggestedSymbolForNonexistentModule,
+ getSuggestionForNonexistentExport: getSuggestionForNonexistentExport,
+ getBaseConstraintOfType: getBaseConstraintOfType,
+ getDefaultFromTypeParameter: function (type) { return type && type.flags & 262144 ? getDefaultFromTypeParameter(type) : undefined; },
+ resolveName: function (name, location, meaning, excludeGlobals) {
+ return resolveName(location, ts.escapeLeadingUnderscores(name), meaning, undefined, undefined, false, excludeGlobals);
+ },
+ getJsxNamespace: function (n) { return ts.unescapeLeadingUnderscores(getJsxNamespace(n)); },
+ getAccessibleSymbolChain: getAccessibleSymbolChain,
+ getTypePredicateOfSignature: getTypePredicateOfSignature,
+ resolveExternalModuleName: function (moduleSpecifierIn) {
+ var moduleSpecifier = ts.getParseTreeNode(moduleSpecifierIn, ts.isExpression);
+ return moduleSpecifier && resolveExternalModuleName(moduleSpecifier, moduleSpecifier, true);
+ },
+ resolveExternalModuleSymbol: resolveExternalModuleSymbol,
+ tryGetThisTypeAt: function (nodeIn, includeGlobalThis) {
+ var node = ts.getParseTreeNode(nodeIn);
+ return node && tryGetThisTypeAt(node, includeGlobalThis);
+ },
+ getTypeArgumentConstraint: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode);
+ return node && getTypeArgumentConstraint(node);
+ },
+ getSuggestionDiagnostics: function (fileIn, ct) {
+ var file = ts.getParseTreeNode(fileIn, ts.isSourceFile) || ts.Debug.fail("Could not determine parsed source file.");
+ if (ts.skipTypeChecking(file, compilerOptions, host)) {
+ return ts.emptyArray;
}
- return specifier;
- }
- function symbolToTypeNode(symbol, context, meaning, overrideTypeArguments) {
- var chain = lookupSymbolChain(symbol, context, meaning, !(context.flags & 16384));
- var isTypeOf = meaning === 111551;
- if (ts.some(chain[0].declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
- var nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(chain, chain.length - 1, 1) : undefined;
- var typeParameterNodes = overrideTypeArguments || lookupTypeParameterNodes(chain, 0, context);
- var specifier = getSpecifierForModuleSymbol(chain[0], context);
- if (!(context.flags & 67108864) && ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs && specifier.indexOf("/node_modules/") >= 0) {
- context.encounteredError = true;
- if (context.tracker.reportLikelyUnsafeImportRequiredError) {
- context.tracker.reportLikelyUnsafeImportRequiredError(specifier);
- }
- }
- var lit = ts.createLiteralTypeNode(ts.createLiteral(specifier));
- if (context.tracker.trackExternalModuleSymbolOfImportTypeNode)
- context.tracker.trackExternalModuleSymbolOfImportTypeNode(chain[0]);
- context.approximateLength += specifier.length + 10;
- if (!nonRootParts || ts.isEntityName(nonRootParts)) {
- if (nonRootParts) {
- var lastId = ts.isIdentifier(nonRootParts) ? nonRootParts : nonRootParts.right;
- lastId.typeArguments = undefined;
+ var diagnostics;
+ try {
+ cancellationToken = ct;
+ checkSourceFile(file);
+ ts.Debug.assert(!!(getNodeLinks(file).flags & 1));
+ diagnostics = ts.addRange(diagnostics, suggestionDiagnostics.getDiagnostics(file.fileName));
+ checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(file), function (containingNode, kind, diag) {
+ if (!ts.containsParseError(containingNode) && !unusedIsError(kind, !!(containingNode.flags & 8388608))) {
+ (diagnostics || (diagnostics = [])).push(__assign(__assign({}, diag), { category: ts.DiagnosticCategory.Suggestion }));
}
- return ts.createImportTypeNode(lit, nonRootParts, typeParameterNodes, isTypeOf);
- }
- else {
- var splitNode = getTopmostIndexedAccessType(nonRootParts);
- var qualifier = splitNode.objectType.typeName;
- return ts.createIndexedAccessTypeNode(ts.createImportTypeNode(lit, qualifier, typeParameterNodes, isTypeOf), splitNode.indexType);
- }
+ });
+ return diagnostics || ts.emptyArray;
}
- var entityName = createAccessFromSymbolChain(chain, chain.length - 1, 0);
- if (ts.isIndexedAccessTypeNode(entityName)) {
- return entityName;
+ finally {
+ cancellationToken = undefined;
}
- if (isTypeOf) {
- return ts.createTypeQueryNode(entityName);
+ },
+ runWithCancellationToken: function (token, callback) {
+ try {
+ cancellationToken = token;
+ return callback(checker);
}
- else {
- var lastId = ts.isIdentifier(entityName) ? entityName : entityName.right;
- var lastTypeArgs = lastId.typeArguments;
- lastId.typeArguments = undefined;
- return ts.createTypeReferenceNode(entityName, lastTypeArgs);
+ finally {
+ cancellationToken = undefined;
}
- function createAccessFromSymbolChain(chain, index, stopper) {
- var typeParameterNodes = index === (chain.length - 1) ? overrideTypeArguments : lookupTypeParameterNodes(chain, index, context);
- var symbol = chain[index];
- var parent = chain[index - 1];
- var symbolName;
- if (index === 0) {
- context.flags |= 16777216;
- symbolName = getNameOfSymbolAsWritten(symbol, context);
- context.approximateLength += (symbolName ? symbolName.length : 0) + 1;
- context.flags ^= 16777216;
- }
- else {
- if (parent && getExportsOfSymbol(parent)) {
- var exports_1 = getExportsOfSymbol(parent);
- ts.forEachEntry(exports_1, function (ex, name) {
- if (getSymbolIfSameReference(ex, symbol) && !isLateBoundName(name) && name !== "export=") {
- symbolName = ts.unescapeLeadingUnderscores(name);
- return true;
- }
- });
- }
- }
- if (!symbolName) {
- symbolName = getNameOfSymbolAsWritten(symbol, context);
- }
- context.approximateLength += symbolName.length + 1;
- if (!(context.flags & 16) && parent &&
- getMembersOfSymbol(parent) && getMembersOfSymbol(parent).get(symbol.escapedName) &&
- getSymbolIfSameReference(getMembersOfSymbol(parent).get(symbol.escapedName), symbol)) {
- var LHS = createAccessFromSymbolChain(chain, index - 1, stopper);
- if (ts.isIndexedAccessTypeNode(LHS)) {
- return ts.createIndexedAccessTypeNode(LHS, ts.createLiteralTypeNode(ts.createLiteral(symbolName)));
+ },
+ getLocalTypeParametersOfClassOrInterfaceOrTypeAlias: getLocalTypeParametersOfClassOrInterfaceOrTypeAlias,
+ isDeclarationVisible: isDeclarationVisible,
+ };
+ function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
+ apparentArgumentCount = argumentCount;
+ var res = node ? getResolvedSignature(node, candidatesOutArray, checkMode) : undefined;
+ apparentArgumentCount = undefined;
+ return res;
+ }
+ var tupleTypes = new ts.Map();
+ var unionTypes = new ts.Map();
+ var intersectionTypes = new ts.Map();
+ var literalTypes = new ts.Map();
+ var indexedAccessTypes = new ts.Map();
+ var templateLiteralTypes = new ts.Map();
+ var stringMappingTypes = new ts.Map();
+ var substitutionTypes = new ts.Map();
+ var evolvingArrayTypes = [];
+ var undefinedProperties = new ts.Map();
+ var unknownSymbol = createSymbol(4, "unknown");
+ var resolvingSymbol = createSymbol(0, "__resolving__");
+ var anyType = createIntrinsicType(1, "any");
+ var autoType = createIntrinsicType(1, "any");
+ var wildcardType = createIntrinsicType(1, "any");
+ var errorType = createIntrinsicType(1, "error");
+ var nonInferrableAnyType = createIntrinsicType(1, "any", 524288);
+ var intrinsicMarkerType = createIntrinsicType(1, "intrinsic");
+ var unknownType = createIntrinsicType(2, "unknown");
+ var undefinedType = createIntrinsicType(32768, "undefined");
+ var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768, "undefined", 524288);
+ var optionalType = createIntrinsicType(32768, "undefined");
+ var nullType = createIntrinsicType(65536, "null");
+ var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536, "null", 524288);
+ var stringType = createIntrinsicType(4, "string");
+ var numberType = createIntrinsicType(8, "number");
+ var bigintType = createIntrinsicType(64, "bigint");
+ var falseType = createIntrinsicType(512, "false");
+ var regularFalseType = createIntrinsicType(512, "false");
+ var trueType = createIntrinsicType(512, "true");
+ var regularTrueType = createIntrinsicType(512, "true");
+ trueType.regularType = regularTrueType;
+ trueType.freshType = trueType;
+ regularTrueType.regularType = regularTrueType;
+ regularTrueType.freshType = trueType;
+ falseType.regularType = regularFalseType;
+ falseType.freshType = falseType;
+ regularFalseType.regularType = regularFalseType;
+ regularFalseType.freshType = falseType;
+ var booleanType = createBooleanType([regularFalseType, regularTrueType]);
+ createBooleanType([regularFalseType, trueType]);
+ createBooleanType([falseType, regularTrueType]);
+ createBooleanType([falseType, trueType]);
+ var esSymbolType = createIntrinsicType(4096, "symbol");
+ var voidType = createIntrinsicType(16384, "void");
+ var neverType = createIntrinsicType(131072, "never");
+ var silentNeverType = createIntrinsicType(131072, "never");
+ var nonInferrableType = createIntrinsicType(131072, "never", 2097152);
+ var implicitNeverType = createIntrinsicType(131072, "never");
+ var unreachableNeverType = createIntrinsicType(131072, "never");
+ var nonPrimitiveType = createIntrinsicType(67108864, "object");
+ var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
+ var keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
+ var numberOrBigIntType = getUnionType([numberType, bigintType]);
+ var templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
+ var restrictiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 ? getRestrictiveTypeParameter(t) : t; });
+ var permissiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 ? wildcardType : t; });
+ var emptyObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ var emptyJsxObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ emptyJsxObjectType.objectFlags |= 4096;
+ var emptyTypeLiteralSymbol = createSymbol(2048, "__type");
+ emptyTypeLiteralSymbol.members = ts.createSymbolTable();
+ var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ var emptyGenericType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ emptyGenericType.instantiations = new ts.Map();
+ var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ anyFunctionType.objectFlags |= 2097152;
+ var noConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ var circularConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ var markerSuperType = createTypeParameter();
+ var markerSubType = createTypeParameter();
+ markerSubType.constraint = markerSuperType;
+ var markerOtherType = createTypeParameter();
+ var noTypePredicate = createTypePredicate(1, "<<unresolved>>", 0, anyType);
+ var anySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, anyType, undefined, 0, 0);
+ var unknownSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, errorType, undefined, 0, 0);
+ var resolvingSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, anyType, undefined, 0, 0);
+ var silentNeverSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, silentNeverType, undefined, 0, 0);
+ var enumNumberIndexInfo = createIndexInfo(stringType, true);
+ var iterationTypesCache = new ts.Map();
+ var noIterationTypes = {
+ get yieldType() { return ts.Debug.fail("Not supported"); },
+ get returnType() { return ts.Debug.fail("Not supported"); },
+ get nextType() { return ts.Debug.fail("Not supported"); },
+ };
+ var anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
+ var anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
+ var defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType);
+ var asyncIterationTypesResolver = {
+ iterableCacheKey: "iterationTypesOfAsyncIterable",
+ iteratorCacheKey: "iterationTypesOfAsyncIterator",
+ iteratorSymbolName: "asyncIterator",
+ getGlobalIteratorType: getGlobalAsyncIteratorType,
+ getGlobalIterableType: getGlobalAsyncIterableType,
+ getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
+ getGlobalGeneratorType: getGlobalAsyncGeneratorType,
+ resolveIterationType: getAwaitedType,
+ mustHaveANextMethodDiagnostic: ts.Diagnostics.An_async_iterator_must_have_a_next_method,
+ mustBeAMethodDiagnostic: ts.Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
+ mustHaveAValueDiagnostic: ts.Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property,
+ };
+ var syncIterationTypesResolver = {
+ iterableCacheKey: "iterationTypesOfIterable",
+ iteratorCacheKey: "iterationTypesOfIterator",
+ iteratorSymbolName: "iterator",
+ getGlobalIteratorType: getGlobalIteratorType,
+ getGlobalIterableType: getGlobalIterableType,
+ getGlobalIterableIteratorType: getGlobalIterableIteratorType,
+ getGlobalGeneratorType: getGlobalGeneratorType,
+ resolveIterationType: function (type, _errorNode) { return type; },
+ mustHaveANextMethodDiagnostic: ts.Diagnostics.An_iterator_must_have_a_next_method,
+ mustBeAMethodDiagnostic: ts.Diagnostics.The_0_property_of_an_iterator_must_be_a_method,
+ mustHaveAValueDiagnostic: ts.Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property,
+ };
+ var amalgamatedDuplicates;
+ var reverseMappedCache = new ts.Map();
+ var inInferTypeForHomomorphicMappedType = false;
+ var ambientModulesCache;
+ var patternAmbientModules;
+ var patternAmbientModuleAugmentations;
+ var globalObjectType;
+ var globalFunctionType;
+ var globalCallableFunctionType;
+ var globalNewableFunctionType;
+ var globalArrayType;
+ var globalReadonlyArrayType;
+ var globalStringType;
+ var globalNumberType;
+ var globalBooleanType;
+ var globalRegExpType;
+ var globalThisType;
+ var anyArrayType;
+ var autoArrayType;
+ var anyReadonlyArrayType;
+ var deferredGlobalNonNullableTypeAlias;
+ var deferredGlobalESSymbolConstructorSymbol;
+ var deferredGlobalESSymbolType;
+ var deferredGlobalTypedPropertyDescriptorType;
+ var deferredGlobalPromiseType;
+ var deferredGlobalPromiseLikeType;
+ var deferredGlobalPromiseConstructorSymbol;
+ var deferredGlobalPromiseConstructorLikeType;
+ var deferredGlobalIterableType;
+ var deferredGlobalIteratorType;
+ var deferredGlobalIterableIteratorType;
+ var deferredGlobalGeneratorType;
+ var deferredGlobalIteratorYieldResultType;
+ var deferredGlobalIteratorReturnResultType;
+ var deferredGlobalAsyncIterableType;
+ var deferredGlobalAsyncIteratorType;
+ var deferredGlobalAsyncIterableIteratorType;
+ var deferredGlobalAsyncGeneratorType;
+ var deferredGlobalTemplateStringsArrayType;
+ var deferredGlobalImportMetaType;
+ var deferredGlobalExtractSymbol;
+ var deferredGlobalOmitSymbol;
+ var deferredGlobalBigIntType;
+ var allPotentiallyUnusedIdentifiers = new ts.Map();
+ var flowLoopStart = 0;
+ var flowLoopCount = 0;
+ var sharedFlowCount = 0;
+ var flowAnalysisDisabled = false;
+ var flowInvocationCount = 0;
+ var lastFlowNode;
+ var lastFlowNodeReachable;
+ var flowTypeCache;
+ var emptyStringType = getLiteralType("");
+ var zeroType = getLiteralType(0);
+ var zeroBigIntType = getLiteralType({ negative: false, base10Value: "0" });
+ var resolutionTargets = [];
+ var resolutionResults = [];
+ var resolutionPropertyNames = [];
+ var suggestionCount = 0;
+ var maximumSuggestionCount = 10;
+ var mergedSymbols = [];
+ var symbolLinks = [];
+ var nodeLinks = [];
+ var flowLoopCaches = [];
+ var flowLoopNodes = [];
+ var flowLoopKeys = [];
+ var flowLoopTypes = [];
+ var sharedFlowNodes = [];
+ var sharedFlowTypes = [];
+ var flowNodeReachable = [];
+ var flowNodePostSuper = [];
+ var potentialThisCollisions = [];
+ var potentialNewTargetCollisions = [];
+ var potentialWeakMapCollisions = [];
+ var awaitedTypeStack = [];
+ var diagnostics = ts.createDiagnosticCollection();
+ var suggestionDiagnostics = ts.createDiagnosticCollection();
+ var typeofTypesByName = new ts.Map(ts.getEntries({
+ string: stringType,
+ number: numberType,
+ bigint: bigintType,
+ boolean: booleanType,
+ symbol: esSymbolType,
+ undefined: undefinedType
+ }));
+ var typeofType = createTypeofType();
+ var _jsxNamespace;
+ var _jsxFactoryEntity;
+ var outofbandVarianceMarkerHandler;
+ var subtypeRelation = new ts.Map();
+ var strictSubtypeRelation = new ts.Map();
+ var assignableRelation = new ts.Map();
+ var comparableRelation = new ts.Map();
+ var identityRelation = new ts.Map();
+ var enumRelation = new ts.Map();
+ var builtinGlobals = ts.createSymbolTable();
+ builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
+ initializeTypeChecker();
+ return checker;
+ function getJsxNamespace(location) {
+ if (location) {
+ var file = ts.getSourceFileOfNode(location);
+ if (file) {
+ if (ts.isJsxOpeningFragment(location)) {
+ if (file.localJsxFragmentNamespace) {
+ return file.localJsxFragmentNamespace;
+ }
+ var jsxFragmentPragma = file.pragmas.get("jsxfrag");
+ if (jsxFragmentPragma) {
+ var chosenPragma = ts.isArray(jsxFragmentPragma) ? jsxFragmentPragma[0] : jsxFragmentPragma;
+ file.localJsxFragmentFactory = ts.parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
+ ts.visitNode(file.localJsxFragmentFactory, markAsSynthetic);
+ if (file.localJsxFragmentFactory) {
+ return file.localJsxFragmentNamespace = ts.getFirstIdentifier(file.localJsxFragmentFactory).escapedText;
+ }
}
- else {
- return ts.createIndexedAccessTypeNode(ts.createTypeReferenceNode(LHS, typeParameterNodes), ts.createLiteralTypeNode(ts.createLiteral(symbolName)));
+ var entity = getJsxFragmentFactoryEntity(location);
+ if (entity) {
+ file.localJsxFragmentFactory = entity;
+ return file.localJsxFragmentNamespace = ts.getFirstIdentifier(entity).escapedText;
}
}
- var identifier = ts.setEmitFlags(ts.createIdentifier(symbolName, typeParameterNodes), 16777216);
- identifier.symbol = symbol;
- if (index > stopper) {
- var LHS = createAccessFromSymbolChain(chain, index - 1, stopper);
- if (!ts.isEntityName(LHS)) {
- return ts.Debug.fail("Impossible construct - an export of an indexed access cannot be reachable");
+ else {
+ if (file.localJsxNamespace) {
+ return file.localJsxNamespace;
+ }
+ var jsxPragma = file.pragmas.get("jsx");
+ if (jsxPragma) {
+ var chosenPragma = ts.isArray(jsxPragma) ? jsxPragma[0] : jsxPragma;
+ file.localJsxFactory = ts.parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
+ ts.visitNode(file.localJsxFactory, markAsSynthetic);
+ if (file.localJsxFactory) {
+ return file.localJsxNamespace = ts.getFirstIdentifier(file.localJsxFactory).escapedText;
+ }
}
- return ts.createQualifiedName(LHS, identifier);
- }
- return identifier;
- }
- }
- function typeParameterShadowsNameInScope(escapedName, context, type) {
- var result = resolveName(context.enclosingDeclaration, escapedName, 788968, undefined, escapedName, false);
- if (result) {
- if (result.flags & 262144 && result === type.symbol) {
- return false;
}
- return true;
}
- return false;
}
- function typeParameterToName(type, context) {
- if (context.flags & 4 && context.typeParameterNames) {
- var cached = context.typeParameterNames.get("" + getTypeId(type));
- if (cached) {
- return cached;
+ if (!_jsxNamespace) {
+ _jsxNamespace = "React";
+ if (compilerOptions.jsxFactory) {
+ _jsxFactoryEntity = ts.parseIsolatedEntityName(compilerOptions.jsxFactory, languageVersion);
+ ts.visitNode(_jsxFactoryEntity, markAsSynthetic);
+ if (_jsxFactoryEntity) {
+ _jsxNamespace = ts.getFirstIdentifier(_jsxFactoryEntity).escapedText;
}
}
- var result = symbolToName(type.symbol, context, 788968, true);
- if (!(result.kind & 75)) {
- return ts.createIdentifier("(Missing type parameter)");
- }
- if (context.flags & 4) {
- var rawtext = result.escapedText;
- var i = 0;
- var text = rawtext;
- while ((context.typeParameterNamesByText && context.typeParameterNamesByText.get(text)) || typeParameterShadowsNameInScope(text, context, type)) {
- i++;
- text = rawtext + "_" + i;
- }
- if (text !== rawtext) {
- result = ts.createIdentifier(text, result.typeArguments);
- }
- (context.typeParameterNames || (context.typeParameterNames = ts.createMap())).set("" + getTypeId(type), result);
- (context.typeParameterNamesByText || (context.typeParameterNamesByText = ts.createMap())).set(result.escapedText, true);
+ else if (compilerOptions.reactNamespace) {
+ _jsxNamespace = ts.escapeLeadingUnderscores(compilerOptions.reactNamespace);
}
- return result;
}
- function symbolToName(symbol, context, meaning, expectsIdentifier) {
- var chain = lookupSymbolChain(symbol, context, meaning);
- if (expectsIdentifier && chain.length !== 1
- && !context.encounteredError
- && !(context.flags & 65536)) {
- context.encounteredError = true;
- }
- return createEntityNameFromSymbolChain(chain, chain.length - 1);
- function createEntityNameFromSymbolChain(chain, index) {
- var typeParameterNodes = lookupTypeParameterNodes(chain, index, context);
- var symbol = chain[index];
- if (index === 0) {
- context.flags |= 16777216;
- }
- var symbolName = getNameOfSymbolAsWritten(symbol, context);
- if (index === 0) {
- context.flags ^= 16777216;
- }
- var identifier = ts.setEmitFlags(ts.createIdentifier(symbolName, typeParameterNodes), 16777216);
- identifier.symbol = symbol;
- return index > 0 ? ts.createQualifiedName(createEntityNameFromSymbolChain(chain, index - 1), identifier) : identifier;
- }
+ if (!_jsxFactoryEntity) {
+ _jsxFactoryEntity = ts.factory.createQualifiedName(ts.factory.createIdentifier(ts.unescapeLeadingUnderscores(_jsxNamespace)), "createElement");
}
- function symbolToExpression(symbol, context, meaning) {
- var chain = lookupSymbolChain(symbol, context, meaning);
- return createExpressionFromSymbolChain(chain, chain.length - 1);
- function createExpressionFromSymbolChain(chain, index) {
- var typeParameterNodes = lookupTypeParameterNodes(chain, index, context);
- var symbol = chain[index];
- if (index === 0) {
- context.flags |= 16777216;
- }
- var symbolName = getNameOfSymbolAsWritten(symbol, context);
- if (index === 0) {
- context.flags ^= 16777216;
- }
- var firstChar = symbolName.charCodeAt(0);
- if (ts.isSingleOrDoubleQuote(firstChar) && ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
- return ts.createLiteral(getSpecifierForModuleSymbol(symbol, context));
- }
- var canUsePropertyAccess = firstChar === 35 ?
- symbolName.length > 1 && ts.isIdentifierStart(symbolName.charCodeAt(1), languageVersion) :
- ts.isIdentifierStart(firstChar, languageVersion);
- if (index === 0 || canUsePropertyAccess) {
- var identifier = ts.setEmitFlags(ts.createIdentifier(symbolName, typeParameterNodes), 16777216);
- identifier.symbol = symbol;
- return index > 0 ? ts.createPropertyAccess(createExpressionFromSymbolChain(chain, index - 1), identifier) : identifier;
- }
- else {
- if (firstChar === 91) {
- symbolName = symbolName.substring(1, symbolName.length - 1);
- firstChar = symbolName.charCodeAt(0);
- }
- var expression = void 0;
- if (ts.isSingleOrDoubleQuote(firstChar)) {
- expression = ts.createLiteral(symbolName.substring(1, symbolName.length - 1).replace(/\\./g, function (s) { return s.substring(1); }));
- expression.singleQuote = firstChar === 39;
- }
- else if (("" + +symbolName) === symbolName) {
- expression = ts.createLiteral(+symbolName);
- }
- if (!expression) {
- expression = ts.setEmitFlags(ts.createIdentifier(symbolName, typeParameterNodes), 16777216);
- expression.symbol = symbol;
- }
- return ts.createElementAccess(createExpressionFromSymbolChain(chain, index - 1), expression);
- }
- }
+ return _jsxNamespace;
+ function markAsSynthetic(node) {
+ ts.setTextRangePosEnd(node, -1, -1);
+ return ts.visitEachChild(node, markAsSynthetic, ts.nullTransformationContext);
}
- function isSingleQuotedStringNamed(d) {
- var name = ts.getNameOfDeclaration(d);
- if (name && ts.isStringLiteral(name) && (name.singleQuote ||
- (!ts.nodeIsSynthesized(name) && ts.startsWith(ts.getTextOfNode(name, false), "'")))) {
- return true;
- }
- return false;
+ }
+ function getEmitResolver(sourceFile, cancellationToken) {
+ getDiagnostics(sourceFile, cancellationToken);
+ return emitResolver;
+ }
+ function lookupOrIssueError(location, message, arg0, arg1, arg2, arg3) {
+ var diagnostic = location
+ ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3)
+ : ts.createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
+ var existing = diagnostics.lookup(diagnostic);
+ if (existing) {
+ return existing;
}
- function getPropertyNameNodeForSymbol(symbol, context) {
- var singleQuote = !!ts.length(symbol.declarations) && ts.every(symbol.declarations, isSingleQuotedStringNamed);
- var fromNameType = getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote);
- if (fromNameType) {
- return fromNameType;
- }
- if (ts.isKnownSymbol(symbol)) {
- return ts.createComputedPropertyName(ts.createPropertyAccess(ts.createIdentifier("Symbol"), symbol.escapedName.substr(3)));
- }
- var rawName = ts.unescapeLeadingUnderscores(symbol.escapedName);
- return createPropertyNameNodeForIdentifierOrLiteral(rawName, singleQuote);
+ else {
+ diagnostics.add(diagnostic);
+ return diagnostic;
}
- function getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote) {
- var nameType = getSymbolLinks(symbol).nameType;
- if (nameType) {
- if (nameType.flags & 384) {
- var name = "" + nameType.value;
- if (!ts.isIdentifierText(name, compilerOptions.target) && !isNumericLiteralName(name)) {
- return ts.createLiteral(name, !!singleQuote);
- }
- if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
- return ts.createComputedPropertyName(ts.createLiteral(+name));
- }
- return createPropertyNameNodeForIdentifierOrLiteral(name);
- }
- if (nameType.flags & 8192) {
- return ts.createComputedPropertyName(symbolToExpression(nameType.symbol, context, 111551));
- }
- }
+ }
+ function errorSkippedOn(key, location, message, arg0, arg1, arg2, arg3) {
+ var diagnostic = error(location, message, arg0, arg1, arg2, arg3);
+ diagnostic.skippedOn = key;
+ return diagnostic;
+ }
+ function error(location, message, arg0, arg1, arg2, arg3) {
+ var diagnostic = location
+ ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3)
+ : ts.createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
+ diagnostics.add(diagnostic);
+ return diagnostic;
+ }
+ function addErrorOrSuggestion(isError, diagnostic) {
+ if (isError) {
+ diagnostics.add(diagnostic);
}
- function createPropertyNameNodeForIdentifierOrLiteral(name, singleQuote) {
- return ts.isIdentifierText(name, compilerOptions.target) ? ts.createIdentifier(name) : ts.createLiteral(isNumericLiteralName(name) && +name >= 0 ? +name : name, !!singleQuote);
+ else {
+ suggestionDiagnostics.add(__assign(__assign({}, diagnostic), { category: ts.DiagnosticCategory.Suggestion }));
}
- function cloneNodeBuilderContext(context) {
- var initial = __assign({}, context);
- if (initial.typeParameterNames) {
- initial.typeParameterNames = ts.cloneMap(initial.typeParameterNames);
- }
- if (initial.typeParameterNamesByText) {
- initial.typeParameterNamesByText = ts.cloneMap(initial.typeParameterNamesByText);
- }
- if (initial.typeParameterSymbolList) {
- initial.typeParameterSymbolList = ts.cloneMap(initial.typeParameterSymbolList);
+ }
+ function errorOrSuggestion(isError, location, message, arg0, arg1, arg2, arg3) {
+ if (location.pos < 0 || location.end < 0) {
+ if (!isError) {
+ return;
}
- return initial;
+ var file = ts.getSourceFileOfNode(location);
+ addErrorOrSuggestion(isError, "message" in message ? ts.createFileDiagnostic(file, 0, 0, message, arg0, arg1, arg2, arg3) : ts.createDiagnosticForFileFromMessageChain(file, message));
+ return;
}
- function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
- return symbol.declarations && ts.find(symbol.declarations, function (s) { return !!ts.getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!ts.findAncestor(s, function (n) { return n === enclosingDeclaration; })); });
+ addErrorOrSuggestion(isError, "message" in message ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : ts.createDiagnosticForNodeFromMessageChain(location, message));
+ }
+ function errorAndMaybeSuggestAwait(location, maybeMissingAwait, message, arg0, arg1, arg2, arg3) {
+ var diagnostic = error(location, message, arg0, arg1, arg2, arg3);
+ if (maybeMissingAwait) {
+ var related = ts.createDiagnosticForNode(location, ts.Diagnostics.Did_you_forget_to_use_await);
+ ts.addRelatedInfo(diagnostic, related);
}
- function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
- return !(ts.getObjectFlags(type) & 4) || !ts.isTypeReferenceNode(existing) || ts.length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
+ return diagnostic;
+ }
+ function createSymbol(flags, name, checkFlags) {
+ symbolCount++;
+ var symbol = (new Symbol(flags | 33554432, name));
+ symbol.checkFlags = checkFlags || 0;
+ return symbol;
+ }
+ function getExcludedSymbolFlags(flags) {
+ var result = 0;
+ if (flags & 2)
+ result |= 111551;
+ if (flags & 1)
+ result |= 111550;
+ if (flags & 4)
+ result |= 0;
+ if (flags & 8)
+ result |= 900095;
+ if (flags & 16)
+ result |= 110991;
+ if (flags & 32)
+ result |= 899503;
+ if (flags & 64)
+ result |= 788872;
+ if (flags & 256)
+ result |= 899327;
+ if (flags & 128)
+ result |= 899967;
+ if (flags & 512)
+ result |= 110735;
+ if (flags & 8192)
+ result |= 103359;
+ if (flags & 32768)
+ result |= 46015;
+ if (flags & 65536)
+ result |= 78783;
+ if (flags & 262144)
+ result |= 526824;
+ if (flags & 524288)
+ result |= 788968;
+ if (flags & 2097152)
+ result |= 2097152;
+ return result;
+ }
+ function recordMergedSymbol(target, source) {
+ if (!source.mergeId) {
+ source.mergeId = nextMergeId;
+ nextMergeId++;
}
- function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
- if (type !== errorType && enclosingDeclaration) {
- var declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration);
- if (declWithExistingAnnotation && !ts.isFunctionLikeDeclaration(declWithExistingAnnotation)) {
- var existing = ts.getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
- if (getTypeFromTypeNode(existing) === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
- var result_4 = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
- if (result_4) {
- return result_4;
- }
- }
+ mergedSymbols[source.mergeId] = target;
+ }
+ function cloneSymbol(symbol) {
+ var result = createSymbol(symbol.flags, symbol.escapedName);
+ result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
+ result.parent = symbol.parent;
+ if (symbol.valueDeclaration)
+ result.valueDeclaration = symbol.valueDeclaration;
+ if (symbol.constEnumOnlyModule)
+ result.constEnumOnlyModule = true;
+ if (symbol.members)
+ result.members = new ts.Map(symbol.members);
+ if (symbol.exports)
+ result.exports = new ts.Map(symbol.exports);
+ recordMergedSymbol(result, symbol);
+ return result;
+ }
+ function mergeSymbol(target, source, unidirectional) {
+ if (unidirectional === void 0) { unidirectional = false; }
+ if (!(target.flags & getExcludedSymbolFlags(source.flags)) ||
+ (source.flags | target.flags) & 67108864) {
+ if (source === target) {
+ return target;
+ }
+ if (!(target.flags & 33554432)) {
+ var resolvedTarget = resolveSymbol(target);
+ if (resolvedTarget === unknownSymbol) {
+ return source;
}
+ target = cloneSymbol(resolvedTarget);
}
- var oldFlags = context.flags;
- if (type.flags & 8192 &&
- type.symbol === symbol) {
- context.flags |= 1048576;
+ if (source.flags & 512 && target.flags & 512 && target.constEnumOnlyModule && !source.constEnumOnlyModule) {
+ target.constEnumOnlyModule = false;
}
- var result = typeToTypeNodeHelper(type, context);
- context.flags = oldFlags;
- return result;
- }
- function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
- if (type !== errorType && context.enclosingDeclaration) {
- var annotation = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration);
- if (!!ts.findAncestor(annotation, function (n) { return n === context.enclosingDeclaration; }) && annotation && instantiateType(getTypeFromTypeNode(annotation), signature.mapper) === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
- var result = serializeExistingTypeNode(context, annotation, includePrivateSymbol, bundled);
- if (result) {
- return result;
- }
- }
+ target.flags |= source.flags;
+ if (source.valueDeclaration) {
+ ts.setValueDeclaration(target, source.valueDeclaration);
}
- return typeToTypeNodeHelper(type, context);
- }
- function serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled) {
- if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
- cancellationToken.throwIfCancellationRequested();
+ ts.addRange(target.declarations, source.declarations);
+ if (source.members) {
+ if (!target.members)
+ target.members = ts.createSymbolTable();
+ mergeSymbolTable(target.members, source.members, unidirectional);
}
- var hadError = false;
- var transformed = ts.visitNode(existing, visitExistingNodeTreeSymbols);
- if (hadError) {
- return undefined;
+ if (source.exports) {
+ if (!target.exports)
+ target.exports = ts.createSymbolTable();
+ mergeSymbolTable(target.exports, source.exports, unidirectional);
}
- return transformed === existing ? ts.getMutableClone(existing) : transformed;
- function visitExistingNodeTreeSymbols(node) {
- var _a, _b;
- if (ts.isJSDocAllType(node) || node.kind === 302) {
- return ts.createKeywordTypeNode(125);
- }
- if (ts.isJSDocUnknownType(node)) {
- return ts.createKeywordTypeNode(148);
- }
- if (ts.isJSDocNullableType(node)) {
- return ts.createUnionTypeNode([ts.visitNode(node.type, visitExistingNodeTreeSymbols), ts.createKeywordTypeNode(100)]);
- }
- if (ts.isJSDocOptionalType(node)) {
- return ts.createUnionTypeNode([ts.visitNode(node.type, visitExistingNodeTreeSymbols), ts.createKeywordTypeNode(146)]);
- }
- if (ts.isJSDocNonNullableType(node)) {
- return ts.visitNode(node.type, visitExistingNodeTreeSymbols);
- }
- if (ts.isJSDocVariadicType(node)) {
- return ts.createArrayTypeNode(ts.visitNode(node.type, visitExistingNodeTreeSymbols));
- }
- if (ts.isJSDocTypeLiteral(node)) {
- return ts.createTypeLiteralNode(ts.map(node.jsDocPropertyTags, function (t) {
- var name = ts.isIdentifier(t.name) ? t.name : t.name.right;
- var typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode(node), name.escapedText);
- var overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode(t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : undefined;
- return ts.createPropertySignature(undefined, name, t.typeExpression && ts.isJSDocOptionalType(t.typeExpression.type) ? ts.createToken(57) : undefined, overrideTypeNode || (t.typeExpression && ts.visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols)) || ts.createKeywordTypeNode(125), undefined);
- }));
- }
- if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.escapedText === "") {
- return ts.setOriginalNode(ts.createKeywordTypeNode(125), node);
- }
- if ((ts.isExpressionWithTypeArguments(node) || ts.isTypeReferenceNode(node)) && ts.isJSDocIndexSignature(node)) {
- return ts.createTypeLiteralNode([ts.createIndexSignature(undefined, undefined, [ts.createParameter(undefined, undefined, undefined, "x", undefined, ts.visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols))], ts.visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols))]);
- }
- if (ts.isJSDocFunctionType(node)) {
- if (ts.isJSDocConstructSignature(node)) {
- var newTypeNode_1;
- return ts.createConstructorTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.mapDefined(node.parameters, function (p, i) { return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode_1 = p.type, undefined) : ts.createParameter(undefined, undefined, getEffectiveDotDotDotForParameter(p), p.name || getEffectiveDotDotDotForParameter(p) ? "args" : "arg" + i, p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), undefined); }), ts.visitNode(newTypeNode_1 || node.type, visitExistingNodeTreeSymbols));
- }
- else {
- return ts.createFunctionTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.map(node.parameters, function (p, i) { return ts.createParameter(undefined, undefined, getEffectiveDotDotDotForParameter(p), p.name || getEffectiveDotDotDotForParameter(p) ? "args" : "arg" + i, p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), undefined); }), ts.visitNode(node.type, visitExistingNodeTreeSymbols));
- }
- }
- if (ts.isTypeReferenceNode(node) && ts.isInJSDoc(node) && (getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(getTypeReferenceName(node), 788968, true))) {
- return ts.setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
- }
- if (ts.isLiteralImportTypeNode(node)) {
- return ts.updateImportTypeNode(node, ts.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier(node, node.argument.literal)), node.qualifier, ts.visitNodes(node.typeArguments, visitExistingNodeTreeSymbols, ts.isTypeNode), node.isTypeOf);
- }
- if (ts.isEntityName(node) || ts.isEntityNameExpression(node)) {
- var leftmost = ts.getFirstIdentifier(node);
- if (ts.isInJSFile(node) && (ts.isExportsIdentifier(leftmost) || ts.isModuleExportsAccessExpression(leftmost.parent) || (ts.isQualifiedName(leftmost.parent) && ts.isModuleIdentifier(leftmost.parent.left) && ts.isExportsIdentifier(leftmost.parent.right)))) {
- hadError = true;
- return node;
- }
- var sym = resolveEntityName(leftmost, 67108863, true, true);
- if (sym) {
- if (isSymbolAccessible(sym, context.enclosingDeclaration, 67108863, false).accessibility !== 0) {
- hadError = true;
- }
- else {
- (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.trackSymbol) === null || _b === void 0 ? void 0 : _b.call(_a, sym, context.enclosingDeclaration, 67108863);
- includePrivateSymbol === null || includePrivateSymbol === void 0 ? void 0 : includePrivateSymbol(sym);
- }
- if (ts.isIdentifier(node)) {
- var name = sym.flags & 262144 ? typeParameterToName(getDeclaredTypeOfSymbol(sym), context) : ts.getMutableClone(node);
- name.symbol = sym;
- return ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216);
- }
- }
- }
- return ts.visitEachChild(node, visitExistingNodeTreeSymbols, ts.nullTransformationContext);
- function getEffectiveDotDotDotForParameter(p) {
- return p.dotDotDotToken || (p.type && ts.isJSDocVariadicType(p.type) ? ts.createToken(25) : undefined);
- }
- function rewriteModuleSpecifier(parent, lit) {
- if (bundled) {
- if (context.tracker && context.tracker.moduleResolverHost) {
- var targetFile = getExternalModuleFileFromDeclaration(parent);
- if (targetFile) {
- var getCanonicalFileName = ts.createGetCanonicalFileName(!!host.useCaseSensitiveFileNames);
- var resolverHost = {
- getCanonicalFileName: getCanonicalFileName,
- getCurrentDirectory: function () { return context.tracker.moduleResolverHost.getCurrentDirectory(); },
- getCommonSourceDirectory: function () { return context.tracker.moduleResolverHost.getCommonSourceDirectory(); }
- };
- var newName = ts.getResolvedExternalModuleName(resolverHost, targetFile);
- return ts.createLiteral(newName);
- }
- }
- }
- else {
- if (context.tracker && context.tracker.trackExternalModuleSymbolOfImportTypeNode) {
- var moduleSym = resolveExternalModuleNameWorker(lit, lit, undefined);
- if (moduleSym) {
- context.tracker.trackExternalModuleSymbolOfImportTypeNode(moduleSym);
- }
- }
- }
- return lit;
- }
+ if (!unidirectional) {
+ recordMergedSymbol(target, source);
}
}
- function symbolTableToDeclarationStatements(symbolTable, context, bundled) {
- var serializePropertySymbolForClass = makeSerializePropertySymbol(ts.createProperty, 161, true);
- var serializePropertySymbolForInterfaceWorker = makeSerializePropertySymbol(function (_decorators, mods, name, question, type, initializer) { return ts.createPropertySignature(mods, name, question, type, initializer); }, 160, false);
- var enclosingDeclaration = context.enclosingDeclaration;
- var results = [];
- var visitedSymbols = ts.createMap();
- var deferredPrivates;
- var oldcontext = context;
- context = __assign(__assign({}, oldcontext), { usedSymbolNames: ts.createMap(), remappedSymbolNames: ts.createMap(), tracker: __assign(__assign({}, oldcontext.tracker), { trackSymbol: function (sym, decl, meaning) {
- var accessibleResult = isSymbolAccessible(sym, decl, meaning, false);
- if (accessibleResult.accessibility === 0) {
- var chain = lookupSymbolChainWorker(sym, context, meaning);
- if (!(sym.flags & 4)) {
- includePrivateSymbol(chain[0]);
- }
- }
- else if (oldcontext.tracker && oldcontext.tracker.trackSymbol) {
- oldcontext.tracker.trackSymbol(sym, decl, meaning);
- }
- } }) });
- if (oldcontext.usedSymbolNames) {
- oldcontext.usedSymbolNames.forEach(function (_, name) {
- context.usedSymbolNames.set(name, true);
- });
+ else if (target.flags & 1024) {
+ if (target !== globalThisSymbol) {
+ error(ts.getNameOfDeclaration(source.declarations[0]), ts.Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity, symbolToString(target));
}
- ts.forEachEntry(symbolTable, function (symbol, name) {
- var baseName = ts.unescapeLeadingUnderscores(name);
- void getInternalSymbolName(symbol, baseName);
- });
- var addingDeclare = !bundled;
- var exportEquals = symbolTable.get("export=");
- if (exportEquals && symbolTable.size > 1 && exportEquals.flags & 2097152) {
- symbolTable = ts.createSymbolTable();
- symbolTable.set("export=", exportEquals);
+ }
+ else {
+ var isEitherEnum = !!(target.flags & 384 || source.flags & 384);
+ var isEitherBlockScoped_1 = !!(target.flags & 2 || source.flags & 2);
+ var message = isEitherEnum
+ ? ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations
+ : isEitherBlockScoped_1
+ ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
+ : ts.Diagnostics.Duplicate_identifier_0;
+ var sourceSymbolFile = source.declarations && ts.getSourceFileOfNode(source.declarations[0]);
+ var targetSymbolFile = target.declarations && ts.getSourceFileOfNode(target.declarations[0]);
+ var symbolName_1 = symbolToString(source);
+ if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) {
+ var firstFile_1 = ts.comparePaths(sourceSymbolFile.path, targetSymbolFile.path) === -1 ? sourceSymbolFile : targetSymbolFile;
+ var secondFile_1 = firstFile_1 === sourceSymbolFile ? targetSymbolFile : sourceSymbolFile;
+ var filesDuplicates = ts.getOrUpdate(amalgamatedDuplicates, firstFile_1.path + "|" + secondFile_1.path, function () {
+ return ({ firstFile: firstFile_1, secondFile: secondFile_1, conflictingSymbols: new ts.Map() });
+ });
+ var conflictingSymbolInfo = ts.getOrUpdate(filesDuplicates.conflictingSymbols, symbolName_1, function () {
+ return ({ isBlockScoped: isEitherBlockScoped_1, firstFileLocations: [], secondFileLocations: [] });
+ });
+ addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
+ addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
}
- visitSymbolTable(symbolTable);
- return mergeRedundantStatements(results);
- function isIdentifierAndNotUndefined(node) {
- return !!node && node.kind === 75;
+ else {
+ addDuplicateDeclarationErrorsForSymbols(source, message, symbolName_1, target);
+ addDuplicateDeclarationErrorsForSymbols(target, message, symbolName_1, source);
}
- function getNamesOfDeclaration(statement) {
- if (ts.isVariableStatement(statement)) {
- return ts.filter(ts.map(statement.declarationList.declarations, ts.getNameOfDeclaration), isIdentifierAndNotUndefined);
- }
- return ts.filter([ts.getNameOfDeclaration(statement)], isIdentifierAndNotUndefined);
+ }
+ return target;
+ function addDuplicateLocations(locs, symbol) {
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ ts.pushIfUnique(locs, decl);
}
- function flattenExportAssignedNamespace(statements) {
- var exportAssignment = ts.find(statements, ts.isExportAssignment);
- var ns = ts.find(statements, ts.isModuleDeclaration);
- if (ns && exportAssignment && exportAssignment.isExportEquals &&
- ts.isIdentifier(exportAssignment.expression) && ts.isIdentifier(ns.name) && ts.idText(ns.name) === ts.idText(exportAssignment.expression) &&
- ns.body && ts.isModuleBlock(ns.body)) {
- var excessExports = ts.filter(statements, function (s) { return !!(ts.getModifierFlags(s) & 1); });
- if (ts.length(excessExports)) {
- ns.body.statements = ts.createNodeArray(__spreadArrays(ns.body.statements, [ts.createExportDeclaration(undefined, undefined, ts.createNamedExports(ts.map(ts.flatMap(excessExports, function (e) { return getNamesOfDeclaration(e); }), function (id) { return ts.createExportSpecifier(undefined, id); })), undefined)]));
- }
- if (!ts.find(statements, function (s) { return s !== ns && ts.nodeHasName(s, ns.name); })) {
- results = [];
- ts.forEach(ns.body.statements, function (s) {
- addResult(s, 0);
- });
- statements = __spreadArrays(ts.filter(statements, function (s) { return s !== ns && s !== exportAssignment; }), results);
- }
- }
- return statements;
+ }
+ }
+ function addDuplicateDeclarationErrorsForSymbols(target, message, symbolName, source) {
+ ts.forEach(target.declarations, function (node) {
+ addDuplicateDeclarationError(node, message, symbolName, source.declarations);
+ });
+ }
+ function addDuplicateDeclarationError(node, message, symbolName, relatedNodes) {
+ var errorNode = (ts.getExpandoInitializer(node, false) ? ts.getNameOfExpando(node) : ts.getNameOfDeclaration(node)) || node;
+ var err = lookupOrIssueError(errorNode, message, symbolName);
+ var _loop_7 = function (relatedNode) {
+ var adjustedNode = (ts.getExpandoInitializer(relatedNode, false) ? ts.getNameOfExpando(relatedNode) : ts.getNameOfDeclaration(relatedNode)) || relatedNode;
+ if (adjustedNode === errorNode)
+ return "continue";
+ err.relatedInformation = err.relatedInformation || [];
+ var leadingMessage = ts.createDiagnosticForNode(adjustedNode, ts.Diagnostics._0_was_also_declared_here, symbolName);
+ var followOnMessage = ts.createDiagnosticForNode(adjustedNode, ts.Diagnostics.and_here);
+ if (ts.length(err.relatedInformation) >= 5 || ts.some(err.relatedInformation, function (r) { return ts.compareDiagnostics(r, followOnMessage) === 0 || ts.compareDiagnostics(r, leadingMessage) === 0; }))
+ return "continue";
+ ts.addRelatedInfo(err, !ts.length(err.relatedInformation) ? leadingMessage : followOnMessage);
+ };
+ for (var _i = 0, _a = relatedNodes || ts.emptyArray; _i < _a.length; _i++) {
+ var relatedNode = _a[_i];
+ _loop_7(relatedNode);
+ }
+ }
+ function combineSymbolTables(first, second) {
+ if (!(first === null || first === void 0 ? void 0 : first.size))
+ return second;
+ if (!(second === null || second === void 0 ? void 0 : second.size))
+ return first;
+ var combined = ts.createSymbolTable();
+ mergeSymbolTable(combined, first);
+ mergeSymbolTable(combined, second);
+ return combined;
+ }
+ function mergeSymbolTable(target, source, unidirectional) {
+ if (unidirectional === void 0) { unidirectional = false; }
+ source.forEach(function (sourceSymbol, id) {
+ var targetSymbol = target.get(id);
+ target.set(id, targetSymbol ? mergeSymbol(targetSymbol, sourceSymbol, unidirectional) : sourceSymbol);
+ });
+ }
+ function mergeModuleAugmentation(moduleName) {
+ var _a, _b;
+ var moduleAugmentation = moduleName.parent;
+ if (moduleAugmentation.symbol.declarations[0] !== moduleAugmentation) {
+ ts.Debug.assert(moduleAugmentation.symbol.declarations.length > 1);
+ return;
+ }
+ if (ts.isGlobalScopeAugmentation(moduleAugmentation)) {
+ mergeSymbolTable(globals, moduleAugmentation.symbol.exports);
+ }
+ else {
+ var moduleNotFoundError = !(moduleName.parent.parent.flags & 8388608)
+ ? ts.Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found
+ : undefined;
+ var mainModule_1 = resolveExternalModuleNameWorker(moduleName, moduleName, moduleNotFoundError, true);
+ if (!mainModule_1) {
+ return;
}
- function mergeExportDeclarations(statements) {
- var exports = ts.filter(statements, function (d) { return ts.isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); });
- if (ts.length(exports) > 1) {
- var nonExports = ts.filter(statements, function (d) { return !ts.isExportDeclaration(d) || !!d.moduleSpecifier || !d.exportClause; });
- statements = __spreadArrays(nonExports, [ts.createExportDeclaration(undefined, undefined, ts.createNamedExports(ts.flatMap(exports, function (e) { return ts.cast(e.exportClause, ts.isNamedExports).elements; })), undefined)]);
- }
- var reexports = ts.filter(statements, function (d) { return ts.isExportDeclaration(d) && !!d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); });
- if (ts.length(reexports) > 1) {
- var groups = ts.group(reexports, function (decl) { return ts.isStringLiteral(decl.moduleSpecifier) ? ">" + decl.moduleSpecifier.text : ">"; });
- if (groups.length !== reexports.length) {
- var _loop_8 = function (group_1) {
- if (group_1.length > 1) {
- statements = __spreadArrays(ts.filter(statements, function (s) { return group_1.indexOf(s) === -1; }), [
- ts.createExportDeclaration(undefined, undefined, ts.createNamedExports(ts.flatMap(group_1, function (e) { return ts.cast(e.exportClause, ts.isNamedExports).elements; })), group_1[0].moduleSpecifier)
- ]);
- }
- };
- for (var _i = 0, groups_1 = groups; _i < groups_1.length; _i++) {
- var group_1 = groups_1[_i];
- _loop_8(group_1);
- }
+ mainModule_1 = resolveExternalModuleSymbol(mainModule_1);
+ if (mainModule_1.flags & 1920) {
+ if (ts.some(patternAmbientModules, function (module) { return mainModule_1 === module.symbol; })) {
+ var merged = mergeSymbol(moduleAugmentation.symbol, mainModule_1, true);
+ if (!patternAmbientModuleAugmentations) {
+ patternAmbientModuleAugmentations = new ts.Map();
}
+ patternAmbientModuleAugmentations.set(moduleName.text, merged);
}
- return statements;
- }
- function inlineExportModifiers(statements) {
- var exportDecl = ts.find(statements, function (d) { return ts.isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause; });
- if (exportDecl && exportDecl.exportClause && ts.isNamedExports(exportDecl.exportClause)) {
- var replacements = ts.mapDefined(exportDecl.exportClause.elements, function (e) {
- if (!e.propertyName) {
- var associated = ts.filter(statements, function (s) { return ts.nodeHasName(s, e.name); });
- if (ts.length(associated) && ts.every(associated, canHaveExportModifier)) {
- ts.forEach(associated, addExportModifier);
- return undefined;
+ else {
+ if (((_a = mainModule_1.exports) === null || _a === void 0 ? void 0 : _a.get("__export")) && ((_b = moduleAugmentation.symbol.exports) === null || _b === void 0 ? void 0 : _b.size)) {
+ var resolvedExports = getResolvedMembersOrExportsOfSymbol(mainModule_1, "resolvedExports");
+ for (var _i = 0, _c = ts.arrayFrom(moduleAugmentation.symbol.exports.entries()); _i < _c.length; _i++) {
+ var _d = _c[_i], key = _d[0], value = _d[1];
+ if (resolvedExports.has(key) && !mainModule_1.exports.has(key)) {
+ mergeSymbol(resolvedExports.get(key), value);
}
}
- return e;
- });
- if (!ts.length(replacements)) {
- statements = ts.filter(statements, function (s) { return s !== exportDecl; });
- }
- else {
- exportDecl.exportClause.elements = ts.createNodeArray(replacements);
}
+ mergeSymbol(mainModule_1, moduleAugmentation.symbol);
}
- return statements;
- }
- function mergeRedundantStatements(statements) {
- statements = flattenExportAssignedNamespace(statements);
- statements = mergeExportDeclarations(statements);
- statements = inlineExportModifiers(statements);
- if (enclosingDeclaration &&
- ((ts.isSourceFile(enclosingDeclaration) && ts.isExternalOrCommonJsModule(enclosingDeclaration)) || ts.isModuleDeclaration(enclosingDeclaration)) &&
- (!ts.some(statements, ts.isExternalModuleIndicator) || (!ts.hasScopeMarker(statements) && ts.some(statements, ts.needsScopeMarker)))) {
- statements.push(ts.createEmptyExports());
- }
- return statements;
- }
- function canHaveExportModifier(node) {
- return ts.isEnumDeclaration(node) ||
- ts.isVariableStatement(node) ||
- ts.isFunctionDeclaration(node) ||
- ts.isClassDeclaration(node) ||
- (ts.isModuleDeclaration(node) && !ts.isExternalModuleAugmentation(node) && !ts.isGlobalScopeAugmentation(node)) ||
- ts.isInterfaceDeclaration(node) ||
- isTypeDeclaration(node);
}
- function addExportModifier(statement) {
- var flags = (ts.getModifierFlags(statement) | 1) & ~2;
- statement.modifiers = ts.createNodeArray(ts.createModifiersFromModifierFlags(flags));
- statement.modifierFlagsCache = 0;
+ else {
+ error(moduleName, ts.Diagnostics.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity, moduleName.text);
}
- function visitSymbolTable(symbolTable, suppressNewPrivateContext, propertyAsAlias) {
- var oldDeferredPrivates = deferredPrivates;
- if (!suppressNewPrivateContext) {
- deferredPrivates = ts.createMap();
- }
- symbolTable.forEach(function (symbol) {
- serializeSymbol(symbol, false, !!propertyAsAlias);
- });
- if (!suppressNewPrivateContext) {
- deferredPrivates.forEach(function (symbol) {
- serializeSymbol(symbol, true, !!propertyAsAlias);
- });
- }
- deferredPrivates = oldDeferredPrivates;
+ }
+ }
+ function addToSymbolTable(target, source, message) {
+ source.forEach(function (sourceSymbol, id) {
+ var targetSymbol = target.get(id);
+ if (targetSymbol) {
+ ts.forEach(targetSymbol.declarations, addDeclarationDiagnostic(ts.unescapeLeadingUnderscores(id), message));
}
- function serializeSymbol(symbol, isPrivate, propertyAsAlias) {
- var visitedSym = getMergedSymbol(symbol);
- if (visitedSymbols.has("" + getSymbolId(visitedSym))) {
- return;
- }
- visitedSymbols.set("" + getSymbolId(visitedSym), true);
- var skipMembershipCheck = !isPrivate;
- if (skipMembershipCheck || (!!ts.length(symbol.declarations) && ts.some(symbol.declarations, function (d) { return !!ts.findAncestor(d, function (n) { return n === enclosingDeclaration; }); }))) {
- var oldContext = context;
- context = cloneNodeBuilderContext(context);
- var result = serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
- context = oldContext;
- return result;
- }
+ else {
+ target.set(id, sourceSymbol);
}
- function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias) {
- var symbolName = ts.unescapeLeadingUnderscores(symbol.escapedName);
- var isDefault = symbol.escapedName === "default";
- if (!(context.flags & 131072) && ts.isStringANonContextualKeyword(symbolName) && !isDefault) {
- context.encounteredError = true;
- return;
- }
- var needsPostExportDefault = isDefault && !!(symbol.flags & -113
- || (symbol.flags & 16 && ts.length(getPropertiesOfType(getTypeOfSymbol(symbol))))) && !(symbol.flags & 2097152);
- if (needsPostExportDefault) {
- isPrivate = true;
- }
- var modifierFlags = (!isPrivate ? 1 : 0) | (isDefault && !needsPostExportDefault ? 512 : 0);
- var isConstMergedWithNS = symbol.flags & 1536 &&
- symbol.flags & (2 | 1 | 4) &&
- symbol.escapedName !== "export=";
- var isConstMergedWithNSPrintableAsSignatureMerge = isConstMergedWithNS && isTypeRepresentableAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol);
- if (symbol.flags & (16 | 8192) || isConstMergedWithNSPrintableAsSignatureMerge) {
- serializeAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol, getInternalSymbolName(symbol, symbolName), modifierFlags);
- }
- if (symbol.flags & 524288) {
- serializeTypeAlias(symbol, symbolName, modifierFlags);
- }
- if (symbol.flags & (2 | 1 | 4)
- && symbol.escapedName !== "export="
- && !(symbol.flags & 4194304)
- && !(symbol.flags & 32)
- && !isConstMergedWithNSPrintableAsSignatureMerge) {
- serializeVariableOrProperty(symbol, symbolName, isPrivate, needsPostExportDefault, propertyAsAlias, modifierFlags);
- }
- if (symbol.flags & 384) {
- serializeEnum(symbol, symbolName, modifierFlags);
- }
- if (symbol.flags & 32) {
- if (symbol.flags & 4 && ts.isBinaryExpression(symbol.valueDeclaration.parent) && ts.isClassExpression(symbol.valueDeclaration.parent.right)) {
- serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags);
- }
- else {
- serializeAsClass(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags);
- }
- }
- if ((symbol.flags & (512 | 1024) && (!isConstMergedWithNS || isTypeOnlyNamespace(symbol))) || isConstMergedWithNSPrintableAsSignatureMerge) {
- serializeModule(symbol, symbolName, modifierFlags);
- }
- if (symbol.flags & 64) {
- serializeInterface(symbol, symbolName, modifierFlags);
+ });
+ function addDeclarationDiagnostic(id, message) {
+ return function (declaration) { return diagnostics.add(ts.createDiagnosticForNode(declaration, message, id)); };
+ }
+ }
+ function getSymbolLinks(symbol) {
+ if (symbol.flags & 33554432)
+ return symbol;
+ var id = getSymbolId(symbol);
+ return symbolLinks[id] || (symbolLinks[id] = new SymbolLinks());
+ }
+ function getNodeLinks(node) {
+ var nodeId = getNodeId(node);
+ return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
+ }
+ function isGlobalSourceFile(node) {
+ return node.kind === 297 && !ts.isExternalOrCommonJsModule(node);
+ }
+ function getSymbol(symbols, name, meaning) {
+ if (meaning) {
+ var symbol = getMergedSymbol(symbols.get(name));
+ if (symbol) {
+ ts.Debug.assert((ts.getCheckFlags(symbol) & 1) === 0, "Should never get an instantiated symbol here.");
+ if (symbol.flags & meaning) {
+ return symbol;
}
if (symbol.flags & 2097152) {
- serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags);
- }
- if (symbol.flags & 4 && symbol.escapedName === "export=") {
- serializeMaybeAliasAssignment(symbol);
- }
- if (symbol.flags & 8388608) {
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var node = _a[_i];
- var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
- if (!resolvedModule)
- continue;
- addResult(ts.createExportDeclaration(undefined, undefined, undefined, ts.createLiteral(getSpecifierForModuleSymbol(resolvedModule, context))), 0);
+ var target = resolveAlias(symbol);
+ if (target === unknownSymbol || target.flags & meaning) {
+ return symbol;
}
}
- if (needsPostExportDefault) {
- addResult(ts.createExportAssignment(undefined, undefined, false, ts.createIdentifier(getInternalSymbolName(symbol, symbolName))), 0);
- }
}
- function includePrivateSymbol(symbol) {
- if (ts.some(symbol.declarations, ts.isParameterDeclaration))
- return;
- ts.Debug.assertIsDefined(deferredPrivates);
- getUnusedName(ts.unescapeLeadingUnderscores(symbol.escapedName), symbol);
- deferredPrivates.set("" + getSymbolId(symbol), symbol);
+ }
+ }
+ function getSymbolsOfParameterPropertyDeclaration(parameter, parameterName) {
+ var constructorDeclaration = parameter.parent;
+ var classDeclaration = parameter.parent.parent;
+ var parameterSymbol = getSymbol(constructorDeclaration.locals, parameterName, 111551);
+ var propertySymbol = getSymbol(getMembersOfSymbol(classDeclaration.symbol), parameterName, 111551);
+ if (parameterSymbol && propertySymbol) {
+ return [parameterSymbol, propertySymbol];
+ }
+ return ts.Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration");
+ }
+ function isBlockScopedNameDeclaredBeforeUse(declaration, usage) {
+ var declarationFile = ts.getSourceFileOfNode(declaration);
+ var useFile = ts.getSourceFileOfNode(usage);
+ var declContainer = ts.getEnclosingBlockScopeContainer(declaration);
+ if (declarationFile !== useFile) {
+ if ((moduleKind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator)) ||
+ (!ts.outFile(compilerOptions)) ||
+ isInTypeQuery(usage) ||
+ declaration.flags & 8388608) {
+ return true;
}
- function isExportingScope(enclosingDeclaration) {
- return ((ts.isSourceFile(enclosingDeclaration) && (ts.isExternalOrCommonJsModule(enclosingDeclaration) || ts.isJsonSourceFile(enclosingDeclaration))) ||
- (ts.isAmbientModule(enclosingDeclaration) && !ts.isGlobalScopeAugmentation(enclosingDeclaration)));
+ if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
+ return true;
}
- function addResult(node, additionalModifierFlags) {
- var newModifierFlags = 0;
- if (additionalModifierFlags & 1 &&
- enclosingDeclaration &&
- isExportingScope(enclosingDeclaration) &&
- canHaveExportModifier(node)) {
- newModifierFlags |= 1;
- }
- if (addingDeclare && !(newModifierFlags & 1) &&
- (!enclosingDeclaration || !(enclosingDeclaration.flags & 8388608)) &&
- (ts.isEnumDeclaration(node) || ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isModuleDeclaration(node))) {
- newModifierFlags |= 2;
- }
- if ((additionalModifierFlags & 512) && (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isFunctionDeclaration(node))) {
- newModifierFlags |= 512;
- }
- if (newModifierFlags) {
- node.modifiers = ts.createNodeArray(ts.createModifiersFromModifierFlags(newModifierFlags | ts.getModifierFlags(node)));
- node.modifierFlagsCache = 0;
+ var sourceFiles = host.getSourceFiles();
+ return sourceFiles.indexOf(declarationFile) <= sourceFiles.indexOf(useFile);
+ }
+ if (declaration.pos <= usage.pos && !(ts.isPropertyDeclaration(declaration) && ts.isThisProperty(usage.parent) && !declaration.initializer && !declaration.exclamationToken)) {
+ if (declaration.kind === 198) {
+ var errorBindingElement = ts.getAncestor(usage, 198);
+ if (errorBindingElement) {
+ return ts.findAncestor(errorBindingElement, ts.isBindingElement) !== ts.findAncestor(declaration, ts.isBindingElement) ||
+ declaration.pos < errorBindingElement.pos;
}
- results.push(node);
+ return isBlockScopedNameDeclaredBeforeUse(ts.getAncestor(declaration, 249), usage);
}
- function serializeTypeAlias(symbol, symbolName, modifierFlags) {
- var aliasType = getDeclaredTypeOfTypeAlias(symbol);
- var typeParams = getSymbolLinks(symbol).typeParameters;
- var typeParamDecls = ts.map(typeParams, function (p) { return typeParameterToDeclaration(p, context); });
- var jsdocAliasDecl = ts.find(symbol.declarations, ts.isJSDocTypeAlias);
- var commentText = jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : undefined;
- var oldFlags = context.flags;
- context.flags |= 8388608;
- addResult(ts.setSyntheticLeadingComments(ts.createTypeAliasDeclaration(undefined, undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, typeToTypeNodeHelper(aliasType, context)), !commentText ? [] : [{ kind: 3, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]), modifierFlags);
- context.flags = oldFlags;
+ else if (declaration.kind === 249) {
+ return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage);
}
- function serializeInterface(symbol, symbolName, modifierFlags) {
- var interfaceType = getDeclaredTypeOfClassOrInterface(symbol);
- var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
- var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); });
- var baseTypes = getBaseTypes(interfaceType);
- var baseType = ts.length(baseTypes) ? getIntersectionType(baseTypes) : undefined;
- var members = ts.flatMap(getPropertiesOfType(interfaceType), function (p) { return serializePropertySymbolForInterface(p, baseType); });
- var callSignatures = serializeSignatures(0, interfaceType, baseType, 165);
- var constructSignatures = serializeSignatures(1, interfaceType, baseType, 166);
- var indexSignatures = serializeIndexSignatures(interfaceType, baseType);
- var heritageClauses = !ts.length(baseTypes) ? undefined : [ts.createHeritageClause(90, ts.mapDefined(baseTypes, function (b) { return trySerializeAsTypeReference(b); }))];
- addResult(ts.createInterfaceDeclaration(undefined, undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, heritageClauses, __spreadArrays(indexSignatures, constructSignatures, callSignatures, members)), modifierFlags);
+ else if (ts.isClassDeclaration(declaration)) {
+ return !ts.findAncestor(usage, function (n) { return ts.isComputedPropertyName(n) && n.parent.parent === declaration; });
}
- function getNamespaceMembersForSerialization(symbol) {
- return !symbol.exports ? [] : ts.filter(ts.arrayFrom(symbol.exports.values()), isNamespaceMember);
+ else if (ts.isPropertyDeclaration(declaration)) {
+ return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, false);
}
- function isTypeOnlyNamespace(symbol) {
- return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(resolveSymbol(m).flags & 111551); });
+ else if (ts.isParameterPropertyDeclaration(declaration, declaration.parent)) {
+ return !(compilerOptions.target === 99 && !!compilerOptions.useDefineForClassFields
+ && ts.getContainingClass(declaration) === ts.getContainingClass(usage)
+ && isUsedInFunctionOrInstanceProperty(usage, declaration));
}
- function serializeModule(symbol, symbolName, modifierFlags) {
- var members = getNamespaceMembersForSerialization(symbol);
- var locationMap = ts.arrayToMultiMap(members, function (m) { return m.parent && m.parent === symbol ? "real" : "merged"; });
- var realMembers = locationMap.get("real") || ts.emptyArray;
- var mergedMembers = locationMap.get("merged") || ts.emptyArray;
- if (ts.length(realMembers)) {
- var localName = getInternalSymbolName(symbol, symbolName);
- serializeAsNamespaceDeclaration(realMembers, localName, modifierFlags, !!(symbol.flags & (16 | 67108864)));
- }
- if (ts.length(mergedMembers)) {
- var containingFile_1 = ts.getSourceFileOfNode(context.enclosingDeclaration);
- var localName = getInternalSymbolName(symbol, symbolName);
- var nsBody = ts.createModuleBlock([ts.createExportDeclaration(undefined, undefined, ts.createNamedExports(ts.mapDefined(ts.filter(mergedMembers, function (n) { return n.escapedName !== "export="; }), function (s) {
- var _a, _b;
- var name = ts.unescapeLeadingUnderscores(s.escapedName);
- var localName = getInternalSymbolName(s, name);
- var aliasDecl = s.declarations && getDeclarationOfAliasSymbol(s);
- if (containingFile_1 && (aliasDecl ? containingFile_1 !== ts.getSourceFileOfNode(aliasDecl) : !ts.some(s.declarations, function (d) { return ts.getSourceFileOfNode(d) === containingFile_1; }))) {
- (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.reportNonlocalAugmentation) === null || _b === void 0 ? void 0 : _b.call(_a, containingFile_1, symbol, s);
- return undefined;
- }
- var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true);
- includePrivateSymbol(target || s);
- var targetName = target ? getInternalSymbolName(target, ts.unescapeLeadingUnderscores(target.escapedName)) : localName;
- return ts.createExportSpecifier(name === targetName ? undefined : targetName, name);
- })))]);
- addResult(ts.createModuleDeclaration(undefined, undefined, ts.createIdentifier(localName), nsBody, 16), 0);
- }
+ return true;
+ }
+ if (usage.parent.kind === 270 || (usage.parent.kind === 266 && usage.parent.isExportEquals)) {
+ return true;
+ }
+ if (usage.kind === 266 && usage.isExportEquals) {
+ return true;
+ }
+ if (!!(usage.flags & 4194304) || isInTypeQuery(usage) || usageInTypeDeclaration()) {
+ return true;
+ }
+ if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
+ if (compilerOptions.target === 99 && !!compilerOptions.useDefineForClassFields
+ && ts.getContainingClass(declaration)
+ && (ts.isPropertyDeclaration(declaration) || ts.isParameterPropertyDeclaration(declaration, declaration.parent))) {
+ return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, true);
}
- function serializeEnum(symbol, symbolName, modifierFlags) {
- addResult(ts.createEnumDeclaration(undefined, ts.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 2048 : 0), getInternalSymbolName(symbol, symbolName), ts.map(ts.filter(getPropertiesOfType(getTypeOfSymbol(symbol)), function (p) { return !!(p.flags & 8); }), function (p) {
- var initializedValue = p.declarations && p.declarations[0] && ts.isEnumMember(p.declarations[0]) && getConstantValue(p.declarations[0]);
- return ts.createEnumMember(ts.unescapeLeadingUnderscores(p.escapedName), initializedValue === undefined ? undefined : ts.createLiteral(initializedValue));
- })), modifierFlags);
+ else {
+ return true;
}
- function serializeVariableOrProperty(symbol, symbolName, isPrivate, needsPostExportDefault, propertyAsAlias, modifierFlags) {
- if (propertyAsAlias) {
- serializeMaybeAliasAssignment(symbol);
+ }
+ return false;
+ function usageInTypeDeclaration() {
+ return !!ts.findAncestor(usage, function (node) { return ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node); });
+ }
+ function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage) {
+ switch (declaration.parent.parent.kind) {
+ case 232:
+ case 237:
+ case 239:
+ if (isSameScopeDescendentOf(usage, declaration, declContainer)) {
+ return true;
+ }
+ break;
+ }
+ var grandparent = declaration.parent.parent;
+ return ts.isForInOrOfStatement(grandparent) && isSameScopeDescendentOf(usage, grandparent.expression, declContainer);
+ }
+ function isUsedInFunctionOrInstanceProperty(usage, declaration) {
+ return !!ts.findAncestor(usage, function (current) {
+ if (current === declContainer) {
+ return "quit";
}
- else {
- var type = getTypeOfSymbol(symbol);
- var localName = getInternalSymbolName(symbol, symbolName);
- if (!(symbol.flags & 16) && isTypeRepresentableAsFunctionNamespaceMerge(type, symbol)) {
- serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags);
+ if (ts.isFunctionLike(current)) {
+ return true;
+ }
+ var initializerOfProperty = current.parent &&
+ current.parent.kind === 163 &&
+ current.parent.initializer === current;
+ if (initializerOfProperty) {
+ if (ts.hasSyntacticModifier(current.parent, 32)) {
+ if (declaration.kind === 165) {
+ return true;
+ }
}
else {
- var flags = !(symbol.flags & 2) ? undefined
- : isConstVariable(symbol) ? 2
- : 1;
- var name = (needsPostExportDefault || !(symbol.flags & 4)) ? localName : getUnusedName(localName, symbol);
- var textRange = symbol.declarations && ts.find(symbol.declarations, function (d) { return ts.isVariableDeclaration(d); });
- if (textRange && ts.isVariableDeclarationList(textRange.parent) && textRange.parent.declarations.length === 1) {
- textRange = textRange.parent.parent;
- }
- var statement = ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(name, serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled))
- ], flags)), textRange);
- addResult(statement, name !== localName ? modifierFlags & ~1 : modifierFlags);
- if (name !== localName && !isPrivate) {
- addResult(ts.createExportDeclaration(undefined, undefined, ts.createNamedExports([ts.createExportSpecifier(name, localName)])), 0);
+ var isDeclarationInstanceProperty = declaration.kind === 163 && !ts.hasSyntacticModifier(declaration, 32);
+ if (!isDeclarationInstanceProperty || ts.getContainingClass(usage) !== ts.getContainingClass(declaration)) {
+ return true;
}
}
}
+ return false;
+ });
+ }
+ function isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, stopAtAnyPropertyDeclaration) {
+ if (usage.end > declaration.end) {
+ return false;
}
- function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) {
- var signatures = getSignaturesOfType(type, 0);
- for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) {
- var sig = signatures_2[_i];
- var decl = signatureToSignatureDeclarationHelper(sig, 244, context, includePrivateSymbol, bundled);
- decl.name = ts.createIdentifier(localName);
- addResult(ts.setTextRange(decl, sig.declaration && ts.isVariableDeclaration(sig.declaration.parent) && sig.declaration.parent.parent || sig.declaration), modifierFlags);
+ var ancestorChangingReferenceScope = ts.findAncestor(usage, function (node) {
+ if (node === declaration) {
+ return "quit";
}
- if (!(symbol.flags & (512 | 1024) && !!symbol.exports && !!symbol.exports.size)) {
- var props = ts.filter(getPropertiesOfType(type), isNamespaceMember);
- serializeAsNamespaceDeclaration(props, localName, modifierFlags, true);
+ switch (node.kind) {
+ case 209:
+ return true;
+ case 163:
+ return stopAtAnyPropertyDeclaration &&
+ (ts.isPropertyDeclaration(declaration) && node.parent === declaration.parent
+ || ts.isParameterPropertyDeclaration(declaration, declaration.parent) && node.parent === declaration.parent.parent)
+ ? "quit" : true;
+ case 230:
+ switch (node.parent.kind) {
+ case 167:
+ case 165:
+ case 168:
+ return true;
+ default:
+ return false;
+ }
+ default:
+ return false;
}
- }
- function serializeAsNamespaceDeclaration(props, localName, modifierFlags, suppressNewPrivateContext) {
- if (ts.length(props)) {
- var localVsRemoteMap = ts.arrayToMultiMap(props, function (p) {
- return !ts.length(p.declarations) || ts.some(p.declarations, function (d) {
- return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(context.enclosingDeclaration);
- }) ? "local" : "remote";
- });
- var localProps = localVsRemoteMap.get("local") || ts.emptyArray;
- var fakespace = ts.createModuleDeclaration(undefined, undefined, ts.createIdentifier(localName), ts.createModuleBlock([]), 16);
- fakespace.flags ^= 8;
- fakespace.parent = enclosingDeclaration;
- fakespace.locals = ts.createSymbolTable(props);
- fakespace.symbol = props[0].parent;
- var oldResults = results;
- results = [];
- var oldAddingDeclare = addingDeclare;
- addingDeclare = false;
- var subcontext = __assign(__assign({}, context), { enclosingDeclaration: fakespace });
- var oldContext = context;
- context = subcontext;
- visitSymbolTable(ts.createSymbolTable(localProps), suppressNewPrivateContext, true);
- context = oldContext;
- addingDeclare = oldAddingDeclare;
- var declarations = results;
- results = oldResults;
- fakespace.flags ^= 8;
- fakespace.parent = undefined;
- fakespace.locals = undefined;
- fakespace.symbol = undefined;
- fakespace.body = ts.createModuleBlock(declarations);
- addResult(fakespace, modifierFlags);
+ });
+ return ancestorChangingReferenceScope === undefined;
+ }
+ }
+ function useOuterVariableScopeInParameter(result, location, lastLocation) {
+ var target = ts.getEmitScriptTarget(compilerOptions);
+ var functionLocation = location;
+ if (ts.isParameter(lastLocation) && functionLocation.body && result.valueDeclaration.pos >= functionLocation.body.pos && result.valueDeclaration.end <= functionLocation.body.end) {
+ if (target >= 2) {
+ var links = getNodeLinks(functionLocation);
+ if (links.declarationRequiresScopeChange === undefined) {
+ links.declarationRequiresScopeChange = ts.forEach(functionLocation.parameters, requiresScopeChange) || false;
}
+ return !links.declarationRequiresScopeChange;
}
- function isNamespaceMember(p) {
- return !(p.flags & 4194304 || p.escapedName === "prototype" || p.valueDeclaration && ts.isClassLike(p.valueDeclaration.parent));
+ }
+ return false;
+ function requiresScopeChange(node) {
+ return requiresScopeChangeWorker(node.name)
+ || !!node.initializer && requiresScopeChangeWorker(node.initializer);
+ }
+ function requiresScopeChangeWorker(node) {
+ switch (node.kind) {
+ case 209:
+ case 208:
+ case 251:
+ case 166:
+ return false;
+ case 165:
+ case 167:
+ case 168:
+ case 288:
+ return requiresScopeChangeWorker(node.name);
+ case 163:
+ if (ts.hasStaticModifier(node)) {
+ return target < 99 || !compilerOptions.useDefineForClassFields;
+ }
+ return requiresScopeChangeWorker(node.name);
+ default:
+ if (ts.isNullishCoalesce(node) || ts.isOptionalChain(node)) {
+ return target < 7;
+ }
+ if (ts.isBindingElement(node) && node.dotDotDotToken && ts.isObjectBindingPattern(node.parent)) {
+ return target < 4;
+ }
+ if (ts.isTypeNode(node))
+ return false;
+ return ts.forEachChild(node, requiresScopeChangeWorker) || false;
}
- function serializeAsClass(symbol, localName, modifierFlags) {
- var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
- var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); });
- var classType = getDeclaredTypeOfClassOrInterface(symbol);
- var baseTypes = getBaseTypes(classType);
- var implementsTypes = getImplementsTypes(classType);
- var staticType = getTypeOfSymbol(symbol);
- var staticBaseType = getBaseConstructorTypeOfClass(staticType);
- var heritageClauses = __spreadArrays(!ts.length(baseTypes) ? [] : [ts.createHeritageClause(90, ts.map(baseTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))], !ts.length(implementsTypes) ? [] : [ts.createHeritageClause(113, ts.map(implementsTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))]);
- var symbolProps = getNonInterhitedProperties(classType, baseTypes, getPropertiesOfType(classType));
- var publicSymbolProps = ts.filter(symbolProps, function (s) {
- var valueDecl = s.valueDeclaration;
- return valueDecl && !(ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name));
- });
- var hasPrivateIdentifier = ts.some(symbolProps, function (s) {
- var valueDecl = s.valueDeclaration;
- return valueDecl && ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name);
- });
- var privateProperties = hasPrivateIdentifier ?
- [ts.createProperty(undefined, undefined, ts.createPrivateIdentifier("#private"), undefined, undefined, undefined)] :
- ts.emptyArray;
- var publicProperties = ts.flatMap(publicSymbolProps, function (p) { return serializePropertySymbolForClass(p, false, baseTypes[0]); });
- var staticMembers = ts.flatMap(ts.filter(getPropertiesOfType(staticType), function (p) { return !(p.flags & 4194304) && p.escapedName !== "prototype" && !isNamespaceMember(p); }), function (p) { return serializePropertySymbolForClass(p, true, staticBaseType); });
- var constructors = serializeSignatures(1, staticType, baseTypes[0], 162);
- for (var _i = 0, constructors_1 = constructors; _i < constructors_1.length; _i++) {
- var c = constructors_1[_i];
- c.type = undefined;
- c.typeParameters = undefined;
+ }
+ }
+ function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, suggestedNameNotFoundMessage) {
+ if (excludeGlobals === void 0) { excludeGlobals = false; }
+ return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSymbol, suggestedNameNotFoundMessage);
+ }
+ function resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, lookup, suggestedNameNotFoundMessage) {
+ var originalLocation = location;
+ var result;
+ var lastLocation;
+ var lastSelfReferenceLocation;
+ var propertyWithInvalidInitializer;
+ var associatedDeclarationForContainingInitializerOrBindingName;
+ var withinDeferredContext = false;
+ var errorLocation = location;
+ var grandparent;
+ var isInExternalModule = false;
+ loop: while (location) {
+ if (location.locals && !isGlobalSourceFile(location)) {
+ if (result = lookup(location.locals, name, meaning)) {
+ var useResult = true;
+ if (ts.isFunctionLike(location) && lastLocation && lastLocation !== location.body) {
+ if (meaning & result.flags & 788968 && lastLocation.kind !== 311) {
+ useResult = result.flags & 262144
+ ? lastLocation === location.type ||
+ lastLocation.kind === 160 ||
+ lastLocation.kind === 159
+ : false;
+ }
+ if (meaning & result.flags & 3) {
+ if (useOuterVariableScopeInParameter(result, location, lastLocation)) {
+ useResult = false;
+ }
+ else if (result.flags & 1) {
+ useResult =
+ lastLocation.kind === 160 ||
+ (lastLocation === location.type &&
+ !!ts.findAncestor(result.valueDeclaration, ts.isParameter));
+ }
+ }
+ }
+ else if (location.kind === 184) {
+ useResult = lastLocation === location.trueType;
+ }
+ if (useResult) {
+ break loop;
+ }
+ else {
+ result = undefined;
+ }
}
- var indexSignatures = serializeIndexSignatures(classType, baseTypes[0]);
- addResult(ts.setTextRange(ts.createClassDeclaration(undefined, undefined, localName, typeParamDecls, heritageClauses, __spreadArrays(indexSignatures, staticMembers, constructors, publicProperties, privateProperties)), symbol.declarations && ts.filter(symbol.declarations, function (d) { return ts.isClassDeclaration(d) || ts.isClassExpression(d); })[0]), modifierFlags);
}
- function serializeAsAlias(symbol, localName, modifierFlags) {
- var node = getDeclarationOfAliasSymbol(symbol);
- if (!node)
- return ts.Debug.fail();
- var target = getMergedSymbol(getTargetOfAliasDeclaration(node, true));
- if (!target) {
- return;
- }
- var verbatimTargetName = ts.unescapeLeadingUnderscores(target.escapedName);
- if (verbatimTargetName === "export=" && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) {
- verbatimTargetName = "default";
- }
- var targetName = getInternalSymbolName(target, verbatimTargetName);
- includePrivateSymbol(target);
- switch (node.kind) {
- case 253:
- var isLocalImport = !(target.flags & 512);
- addResult(ts.createImportEqualsDeclaration(undefined, undefined, ts.createIdentifier(localName), isLocalImport
- ? symbolToName(target, context, 67108863, false)
- : ts.createExternalModuleReference(ts.createLiteral(getSpecifierForModuleSymbol(symbol, context)))), isLocalImport ? modifierFlags : 0);
- break;
- case 252:
- addResult(ts.createNamespaceExportDeclaration(ts.idText(node.name)), 0);
- break;
- case 255:
- addResult(ts.createImportDeclaration(undefined, undefined, ts.createImportClause(ts.createIdentifier(localName), undefined), ts.createLiteral(getSpecifierForModuleSymbol(target.parent || target, context))), 0);
- break;
- case 256:
- addResult(ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamespaceImport(ts.createIdentifier(localName))), ts.createLiteral(getSpecifierForModuleSymbol(target, context))), 0);
- break;
- case 262:
- addResult(ts.createExportDeclaration(undefined, undefined, ts.createNamespaceExport(ts.createIdentifier(localName)), ts.createLiteral(getSpecifierForModuleSymbol(target, context))), 0);
- break;
- case 258:
- addResult(ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamedImports([
- ts.createImportSpecifier(localName !== verbatimTargetName ? ts.createIdentifier(verbatimTargetName) : undefined, ts.createIdentifier(localName))
- ])), ts.createLiteral(getSpecifierForModuleSymbol(target.parent || target, context))), 0);
- break;
- case 263:
- var specifier = node.parent.parent.moduleSpecifier;
- serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? verbatimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.createLiteral(specifier.text) : undefined);
- break;
- case 259:
- serializeMaybeAliasAssignment(symbol);
+ withinDeferredContext = withinDeferredContext || getIsDeferredContext(location, lastLocation);
+ switch (location.kind) {
+ case 297:
+ if (!ts.isExternalOrCommonJsModule(location))
break;
- case 209:
- case 194:
- if (symbol.escapedName === "default" || symbol.escapedName === "export=") {
- serializeMaybeAliasAssignment(symbol);
+ isInExternalModule = true;
+ case 256:
+ var moduleExports = getSymbolOfNode(location).exports || emptySymbols;
+ if (location.kind === 297 || (ts.isModuleDeclaration(location) && location.flags & 8388608 && !ts.isGlobalScopeAugmentation(location))) {
+ if (result = moduleExports.get("default")) {
+ var localSymbol = ts.getLocalSymbolForExportDefault(result);
+ if (localSymbol && (result.flags & meaning) && localSymbol.escapedName === name) {
+ break loop;
+ }
+ result = undefined;
+ }
+ var moduleExport = moduleExports.get(name);
+ if (moduleExport &&
+ moduleExport.flags === 2097152 &&
+ (ts.getDeclarationOfKind(moduleExport, 270) || ts.getDeclarationOfKind(moduleExport, 269))) {
+ break;
+ }
+ }
+ if (name !== "default" && (result = lookup(moduleExports, name, meaning & 2623475))) {
+ if (ts.isSourceFile(location) && location.commonJsModuleIndicator && !result.declarations.some(ts.isJSDocTypeAlias)) {
+ result = undefined;
}
else {
- serializeExportSpecifier(localName, targetName);
+ break loop;
}
- break;
- default:
- return ts.Debug.failBadSyntaxKind(node, "Unhandled alias declaration kind in symbol serializer!");
- }
- }
- function serializeExportSpecifier(localName, targetName, specifier) {
- addResult(ts.createExportDeclaration(undefined, undefined, ts.createNamedExports([ts.createExportSpecifier(localName !== targetName ? targetName : undefined, localName)]), specifier), 0);
- }
- function serializeMaybeAliasAssignment(symbol) {
- if (symbol.flags & 4194304) {
- return;
- }
- var name = ts.unescapeLeadingUnderscores(symbol.escapedName);
- var isExportEquals = name === "export=";
- var isDefault = name === "default";
- var isExportAssignment = isExportEquals || isDefault;
- var aliasDecl = symbol.declarations && getDeclarationOfAliasSymbol(symbol);
- var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true);
- if (target && ts.length(target.declarations) && ts.some(target.declarations, function (d) { return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(enclosingDeclaration); })) {
- var expr = isExportAssignment ? ts.getExportAssignmentExpression(aliasDecl) : ts.getPropertyAssignmentAliasLikeExpression(aliasDecl);
- var first_1 = ts.isEntityNameExpression(expr) ? getFirstNonModuleExportsIdentifier(expr) : undefined;
- var referenced = first_1 && resolveEntityName(first_1, 67108863, true, true, enclosingDeclaration);
- if (referenced || target) {
- includePrivateSymbol(referenced || target);
}
- var oldTrack = context.tracker.trackSymbol;
- context.tracker.trackSymbol = ts.noop;
- if (isExportAssignment) {
- results.push(ts.createExportAssignment(undefined, undefined, isExportEquals, symbolToExpression(target, context, 67108863)));
+ break;
+ case 255:
+ if (result = lookup(getSymbolOfNode(location).exports, name, meaning & 8)) {
+ break loop;
}
- else {
- if (first_1 === expr) {
- serializeExportSpecifier(name, ts.idText(first_1));
+ break;
+ case 163:
+ if (!ts.hasSyntacticModifier(location, 32)) {
+ var ctor = findConstructorDeclaration(location.parent);
+ if (ctor && ctor.locals) {
+ if (lookup(ctor.locals, name, meaning & 111551)) {
+ propertyWithInvalidInitializer = location;
+ }
}
- else if (ts.isClassExpression(expr)) {
- serializeExportSpecifier(name, getInternalSymbolName(target, ts.symbolName(target)));
+ }
+ break;
+ case 252:
+ case 221:
+ case 253:
+ if (result = lookup(getSymbolOfNode(location).members || emptySymbols, name, meaning & 788968)) {
+ if (!isTypeParameterSymbolDeclaredInContainer(result, location)) {
+ result = undefined;
+ break;
}
- else {
- var varName = getUnusedName(name, symbol);
- addResult(ts.createImportEqualsDeclaration(undefined, undefined, ts.createIdentifier(varName), symbolToName(target, context, 67108863, false)), 0);
- serializeExportSpecifier(name, varName);
+ if (lastLocation && ts.hasSyntacticModifier(lastLocation, 32)) {
+ error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters);
+ return undefined;
}
+ break loop;
}
- context.tracker.trackSymbol = oldTrack;
- }
- else {
- var varName = getUnusedName(name, symbol);
- var typeToSerialize = getWidenedType(getTypeOfSymbol(getMergedSymbol(symbol)));
- if (isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, symbol)) {
- serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignment ? 0 : 1);
+ if (location.kind === 221 && meaning & 32) {
+ var className = location.name;
+ if (className && name === className.escapedText) {
+ result = location.symbol;
+ break loop;
+ }
}
- else {
- var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(varName, serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration, includePrivateSymbol, bundled))
- ], 2));
- addResult(statement, name === varName ? 1 : 0);
+ break;
+ case 223:
+ if (lastLocation === location.expression && location.parent.token === 93) {
+ var container = location.parent.parent;
+ if (ts.isClassLike(container) && (result = lookup(getSymbolOfNode(container).members, name, meaning & 788968))) {
+ if (nameNotFoundMessage) {
+ error(errorLocation, ts.Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters);
+ }
+ return undefined;
+ }
}
- if (isExportAssignment) {
- results.push(ts.createExportAssignment(undefined, undefined, isExportEquals, ts.createIdentifier(varName)));
+ break;
+ case 158:
+ grandparent = location.parent.parent;
+ if (ts.isClassLike(grandparent) || grandparent.kind === 253) {
+ if (result = lookup(getSymbolOfNode(grandparent).members, name, meaning & 788968)) {
+ error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
+ return undefined;
+ }
}
- else if (name !== varName) {
- serializeExportSpecifier(name, varName);
+ break;
+ case 209:
+ if (compilerOptions.target >= 2) {
+ break;
}
- }
- }
- function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, hostSymbol) {
- var ctxSrc = ts.getSourceFileOfNode(context.enclosingDeclaration);
- return ts.getObjectFlags(typeToSerialize) & (16 | 32) &&
- !getIndexInfoOfType(typeToSerialize, 0) &&
- !getIndexInfoOfType(typeToSerialize, 1) &&
- !!(ts.length(getPropertiesOfType(typeToSerialize)) || ts.length(getSignaturesOfType(typeToSerialize, 0))) &&
- !ts.length(getSignaturesOfType(typeToSerialize, 1)) &&
- !getDeclarationWithTypeAnnotation(hostSymbol, enclosingDeclaration) &&
- !(typeToSerialize.symbol && ts.some(typeToSerialize.symbol.declarations, function (d) { return ts.getSourceFileOfNode(d) !== ctxSrc; })) &&
- !ts.some(getPropertiesOfType(typeToSerialize), function (p) { return isLateBoundName(p.escapedName); }) &&
- !ts.some(getPropertiesOfType(typeToSerialize), function (p) { return ts.some(p.declarations, function (d) { return ts.getSourceFileOfNode(d) !== ctxSrc; }); }) &&
- ts.every(getPropertiesOfType(typeToSerialize), function (p) { return ts.isIdentifierText(ts.symbolName(p), languageVersion) && !ts.isStringAKeyword(ts.symbolName(p)); });
- }
- function makeSerializePropertySymbol(createProperty, methodKind, useAccessors) {
- return function serializePropertySymbol(p, isStatic, baseType) {
- var modifierFlags = ts.getDeclarationModifierFlagsFromSymbol(p);
- var isPrivate = !!(modifierFlags & 8);
- if (isStatic && (p.flags & (788968 | 1920 | 2097152))) {
- return [];
+ case 165:
+ case 166:
+ case 167:
+ case 168:
+ case 251:
+ if (meaning & 3 && name === "arguments") {
+ result = argumentsSymbol;
+ break loop;
}
- if (p.flags & 4194304 ||
- (baseType && getPropertyOfType(baseType, p.escapedName)
- && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p)
- && (p.flags & 16777216) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216)
- && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName)))) {
- return [];
+ break;
+ case 208:
+ if (meaning & 3 && name === "arguments") {
+ result = argumentsSymbol;
+ break loop;
}
- var flag = (modifierFlags & ~256) | (isStatic ? 32 : 0);
- var name = getPropertyNameNodeForSymbol(p, context);
- var firstPropertyLikeDecl = ts.find(p.declarations, ts.or(ts.isPropertyDeclaration, ts.isAccessor, ts.isVariableDeclaration, ts.isPropertySignature, ts.isBinaryExpression, ts.isPropertyAccessExpression));
- if (p.flags & 98304 && useAccessors) {
- var result = [];
- if (p.flags & 65536) {
- result.push(ts.setTextRange(ts.createSetAccessor(undefined, ts.createModifiersFromModifierFlags(flag), name, [ts.createParameter(undefined, undefined, undefined, "arg", undefined, isPrivate ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled))], undefined), ts.find(p.declarations, ts.isSetAccessor) || firstPropertyLikeDecl));
- }
- if (p.flags & 32768) {
- var isPrivate_1 = modifierFlags & 8;
- result.push(ts.setTextRange(ts.createGetAccessor(undefined, ts.createModifiersFromModifierFlags(flag), name, [], isPrivate_1 ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled), undefined), ts.find(p.declarations, ts.isGetAccessor) || firstPropertyLikeDecl));
+ if (meaning & 16) {
+ var functionName = location.name;
+ if (functionName && name === functionName.escapedText) {
+ result = location.symbol;
+ break loop;
}
- return result;
}
- else if (p.flags & (4 | 3)) {
- return ts.setTextRange(createProperty(undefined, ts.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 : 0) | flag), name, p.flags & 16777216 ? ts.createToken(57) : undefined, isPrivate ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled), undefined), ts.find(p.declarations, ts.or(ts.isPropertyDeclaration, ts.isVariableDeclaration)) || firstPropertyLikeDecl);
+ break;
+ case 161:
+ if (location.parent && location.parent.kind === 160) {
+ location = location.parent;
+ }
+ if (location.parent && (ts.isClassElement(location.parent) || location.parent.kind === 252)) {
+ location = location.parent;
}
- if (p.flags & (8192 | 16)) {
- var type = getTypeOfSymbol(p);
- var signatures = getSignaturesOfType(type, 0);
- if (flag & 8) {
- return ts.setTextRange(createProperty(undefined, ts.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 : 0) | flag), name, p.flags & 16777216 ? ts.createToken(57) : undefined, undefined, undefined), ts.find(p.declarations, ts.isFunctionLikeDeclaration) || signatures[0] && signatures[0].declaration || p.declarations[0]);
+ break;
+ case 331:
+ case 324:
+ case 325:
+ location = ts.getJSDocHost(location);
+ break;
+ case 160:
+ if (lastLocation && (lastLocation === location.initializer ||
+ lastLocation === location.name && ts.isBindingPattern(lastLocation))) {
+ if (!associatedDeclarationForContainingInitializerOrBindingName) {
+ associatedDeclarationForContainingInitializerOrBindingName = location;
}
- var results_1 = [];
- for (var _i = 0, signatures_3 = signatures; _i < signatures_3.length; _i++) {
- var sig = signatures_3[_i];
- var decl = signatureToSignatureDeclarationHelper(sig, methodKind, context);
- decl.name = name;
- if (flag) {
- decl.modifiers = ts.createNodeArray(ts.createModifiersFromModifierFlags(flag));
- }
- if (p.flags & 16777216) {
- decl.questionToken = ts.createToken(57);
- }
- results_1.push(ts.setTextRange(decl, sig.declaration));
+ }
+ break;
+ case 198:
+ if (lastLocation && (lastLocation === location.initializer ||
+ lastLocation === location.name && ts.isBindingPattern(lastLocation))) {
+ if (ts.isParameterDeclaration(location) && !associatedDeclarationForContainingInitializerOrBindingName) {
+ associatedDeclarationForContainingInitializerOrBindingName = location;
}
- return results_1;
}
- return ts.Debug.fail("Unhandled class member kind! " + (p.__debugFlags || p.flags));
- };
+ break;
+ case 185:
+ if (meaning & 262144) {
+ var parameterName = location.typeParameter.name;
+ if (parameterName && name === parameterName.escapedText) {
+ result = location.typeParameter.symbol;
+ break loop;
+ }
+ }
+ break;
}
- function serializePropertySymbolForInterface(p, baseType) {
- return serializePropertySymbolForInterfaceWorker(p, false, baseType);
+ if (isSelfReferenceLocation(location)) {
+ lastSelfReferenceLocation = location;
}
- function serializeSignatures(kind, input, baseType, outputKind) {
- var signatures = getSignaturesOfType(input, kind);
- if (kind === 1) {
- if (!baseType && ts.every(signatures, function (s) { return ts.length(s.parameters) === 0; })) {
- return [];
- }
- if (baseType) {
- var baseSigs = getSignaturesOfType(baseType, 1);
- if (!ts.length(baseSigs) && ts.every(signatures, function (s) { return ts.length(s.parameters) === 0; })) {
- return [];
- }
- if (baseSigs.length === signatures.length) {
- var failed = false;
- for (var i = 0; i < baseSigs.length; i++) {
- if (!compareSignaturesIdentical(signatures[i], baseSigs[i], false, false, true, compareTypesIdentical)) {
- failed = true;
- break;
- }
- }
- if (!failed) {
- return [];
+ lastLocation = location;
+ location = location.parent;
+ }
+ if (isUse && result && (!lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) {
+ result.isReferenced |= meaning;
+ }
+ if (!result) {
+ if (lastLocation) {
+ ts.Debug.assert(lastLocation.kind === 297);
+ if (lastLocation.commonJsModuleIndicator && name === "exports" && meaning & lastLocation.symbol.flags) {
+ return lastLocation.symbol;
+ }
+ }
+ if (!excludeGlobals) {
+ result = lookup(globals, name, meaning);
+ }
+ }
+ if (!result) {
+ if (originalLocation && ts.isInJSFile(originalLocation) && originalLocation.parent) {
+ if (ts.isRequireCall(originalLocation.parent, false)) {
+ return requireSymbol;
+ }
+ }
+ }
+ if (!result) {
+ if (nameNotFoundMessage) {
+ if (!errorLocation ||
+ !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
+ !checkAndReportErrorForExtendingInterface(errorLocation) &&
+ !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
+ !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) &&
+ !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) &&
+ !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
+ !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
+ var suggestion = void 0;
+ if (suggestedNameNotFoundMessage && suggestionCount < maximumSuggestionCount) {
+ suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
+ if (suggestion) {
+ var suggestionName = symbolToString(suggestion);
+ var diagnostic = error(errorLocation, suggestedNameNotFoundMessage, diagnosticName(nameArg), suggestionName);
+ if (suggestion.valueDeclaration) {
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName));
}
}
}
- var privateProtected = 0;
- for (var _i = 0, signatures_4 = signatures; _i < signatures_4.length; _i++) {
- var s = signatures_4[_i];
- if (s.declaration) {
- privateProtected |= ts.getSelectedModifierFlags(s.declaration, 8 | 16);
+ if (!suggestion) {
+ if (nameArg) {
+ var lib = getSuggestedLibForNonExistentName(nameArg);
+ if (lib) {
+ error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), lib);
+ }
+ else {
+ error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
+ }
}
}
- if (privateProtected) {
- return [ts.setTextRange(ts.createConstructor(undefined, ts.createModifiersFromModifierFlags(privateProtected), [], undefined), signatures[0].declaration)];
- }
+ suggestionCount++;
}
- var results = [];
- for (var _a = 0, signatures_5 = signatures; _a < signatures_5.length; _a++) {
- var sig = signatures_5[_a];
- var decl = signatureToSignatureDeclarationHelper(sig, outputKind, context);
- results.push(ts.setTextRange(decl, sig.declaration));
+ }
+ return undefined;
+ }
+ if (nameNotFoundMessage) {
+ if (propertyWithInvalidInitializer && !(compilerOptions.target === 99 && compilerOptions.useDefineForClassFields)) {
+ var propertyName = propertyWithInvalidInitializer.name;
+ error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), diagnosticName(nameArg));
+ return undefined;
+ }
+ if (errorLocation &&
+ (meaning & 2 ||
+ ((meaning & 32 || meaning & 384) && (meaning & 111551) === 111551))) {
+ var exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
+ if (exportOrLocalSymbol.flags & 2 || exportOrLocalSymbol.flags & 32 || exportOrLocalSymbol.flags & 384) {
+ checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
}
- return results;
}
- function serializeIndexSignatures(input, baseType) {
- var results = [];
- for (var _i = 0, _a = [0, 1]; _i < _a.length; _i++) {
- var type = _a[_i];
- var info = getIndexInfoOfType(input, type);
- if (info) {
- if (baseType) {
- var baseInfo = getIndexInfoOfType(baseType, type);
- if (baseInfo) {
- if (isTypeIdenticalTo(info.type, baseInfo.type)) {
- continue;
- }
- }
- }
- results.push(indexInfoToIndexSignatureDeclarationHelper(info, type, context));
- }
+ if (result && isInExternalModule && (meaning & 111551) === 111551 && !(originalLocation.flags & 4194304)) {
+ var merged = getMergedSymbol(result);
+ if (ts.length(merged.declarations) && ts.every(merged.declarations, function (d) { return ts.isNamespaceExportDeclaration(d) || ts.isSourceFile(d) && !!d.symbol.globalExports; })) {
+ errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, ts.unescapeLeadingUnderscores(name));
}
- return results;
}
- function serializeBaseType(t, staticType, rootName) {
- var ref = trySerializeAsTypeReference(t);
- if (ref) {
- return ref;
+ if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551) === 111551) {
+ var candidate = getMergedSymbol(getLateBoundSymbol(result));
+ var root = ts.getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
+ if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializerOrBindingName)) {
+ error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_itself, ts.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, ts.Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), ts.declarationNameToString(errorLocation));
}
- var tempName = getUnusedName(rootName + "_base");
- var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(tempName, typeToTypeNodeHelper(staticType, context))
- ], 2));
- addResult(statement, 0);
- return ts.createExpressionWithTypeArguments(undefined, ts.createIdentifier(tempName));
}
- function trySerializeAsTypeReference(t) {
- var typeArgs;
- var reference;
- if (t.target && getAccessibleSymbolChain(t.target.symbol, enclosingDeclaration, 111551, false)) {
- typeArgs = ts.map(getTypeArguments(t), function (t) { return typeToTypeNodeHelper(t, context); });
- reference = symbolToExpression(t.target.symbol, context, 788968);
+ if (result && errorLocation && meaning & 111551 && result.flags & 2097152) {
+ checkSymbolUsageInExpressionContext(result, name, errorLocation);
+ }
+ }
+ return result;
+ }
+ function checkSymbolUsageInExpressionContext(symbol, name, useSite) {
+ if (!ts.isValidTypeOnlyAliasUseSite(useSite)) {
+ var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(symbol);
+ if (typeOnlyDeclaration) {
+ var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration);
+ var message = isExport
+ ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type
+ : ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
+ var relatedMessage = isExport
+ ? ts.Diagnostics._0_was_exported_here
+ : ts.Diagnostics._0_was_imported_here;
+ var unescapedName = ts.unescapeLeadingUnderscores(name);
+ ts.addRelatedInfo(error(useSite, message, unescapedName), ts.createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, unescapedName));
+ }
+ }
+ }
+ function getIsDeferredContext(location, lastLocation) {
+ if (location.kind !== 209 && location.kind !== 208) {
+ return ts.isTypeQueryNode(location) || ((ts.isFunctionLikeDeclaration(location) ||
+ (location.kind === 163 && !ts.hasSyntacticModifier(location, 32))) && (!lastLocation || lastLocation !== location.name));
+ }
+ if (lastLocation && lastLocation === location.name) {
+ return false;
+ }
+ if (location.asteriskToken || ts.hasSyntacticModifier(location, 256)) {
+ return true;
+ }
+ return !ts.getImmediatelyInvokedFunctionExpression(location);
+ }
+ function isSelfReferenceLocation(node) {
+ switch (node.kind) {
+ case 251:
+ case 252:
+ case 253:
+ case 255:
+ case 254:
+ case 256:
+ return true;
+ default:
+ return false;
+ }
+ }
+ function diagnosticName(nameArg) {
+ return ts.isString(nameArg) ? ts.unescapeLeadingUnderscores(nameArg) : ts.declarationNameToString(nameArg);
+ }
+ function isTypeParameterSymbolDeclaredInContainer(symbol, container) {
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ if (decl.kind === 159) {
+ var parent = ts.isJSDocTemplateTag(decl.parent) ? ts.getJSDocHost(decl.parent) : decl.parent;
+ if (parent === container) {
+ return !(ts.isJSDocTemplateTag(decl.parent) && ts.find(decl.parent.parent.tags, ts.isJSDocTypeAlias));
}
- else if (t.symbol && getAccessibleSymbolChain(t.symbol, enclosingDeclaration, 111551, false)) {
- reference = symbolToExpression(t.symbol, context, 788968);
+ }
+ }
+ return false;
+ }
+ function checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) {
+ if (!ts.isIdentifier(errorLocation) || errorLocation.escapedText !== name || isTypeReferenceIdentifier(errorLocation) || isInTypeQuery(errorLocation)) {
+ return false;
+ }
+ var container = ts.getThisContainer(errorLocation, false);
+ var location = container;
+ while (location) {
+ if (ts.isClassLike(location.parent)) {
+ var classSymbol = getSymbolOfNode(location.parent);
+ if (!classSymbol) {
+ break;
}
- if (reference) {
- return ts.createExpressionWithTypeArguments(typeArgs, reference);
+ var constructorType = getTypeOfSymbol(classSymbol);
+ if (getPropertyOfType(constructorType, name)) {
+ error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0, diagnosticName(nameArg), symbolToString(classSymbol));
+ return true;
+ }
+ if (location === container && !ts.hasSyntacticModifier(location, 32)) {
+ var instanceType = getDeclaredTypeOfSymbol(classSymbol).thisType;
+ if (getPropertyOfType(instanceType, name)) {
+ error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0, diagnosticName(nameArg));
+ return true;
+ }
}
}
- function getUnusedName(input, symbol) {
- if (symbol) {
- if (context.remappedSymbolNames.has("" + getSymbolId(symbol))) {
- return context.remappedSymbolNames.get("" + getSymbolId(symbol));
+ location = location.parent;
+ }
+ return false;
+ }
+ function checkAndReportErrorForExtendingInterface(errorLocation) {
+ var expression = getEntityNameForExtendingInterface(errorLocation);
+ if (expression && resolveEntityName(expression, 64, true)) {
+ error(errorLocation, ts.Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, ts.getTextOfNode(expression));
+ return true;
+ }
+ return false;
+ }
+ function getEntityNameForExtendingInterface(node) {
+ switch (node.kind) {
+ case 78:
+ case 201:
+ return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined;
+ case 223:
+ if (ts.isEntityNameExpression(node.expression)) {
+ return node.expression;
+ }
+ default:
+ return undefined;
+ }
+ }
+ function checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) {
+ var namespaceMeaning = 1920 | (ts.isInJSFile(errorLocation) ? 111551 : 0);
+ if (meaning === namespaceMeaning) {
+ var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 & ~namespaceMeaning, undefined, undefined, false));
+ var parent = errorLocation.parent;
+ if (symbol) {
+ if (ts.isQualifiedName(parent)) {
+ ts.Debug.assert(parent.left === errorLocation, "Should only be resolving left side of qualified name as a namespace");
+ var propName = parent.right.escapedText;
+ var propType = getPropertyOfType(getDeclaredTypeOfSymbol(symbol), propName);
+ if (propType) {
+ error(parent, ts.Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1, ts.unescapeLeadingUnderscores(name), ts.unescapeLeadingUnderscores(propName));
+ return true;
}
}
- if (symbol) {
- input = getNameCandidateWorker(symbol, input);
- }
- var i = 0;
- var original = input;
- while (context.usedSymbolNames.has(input)) {
- i++;
- input = original + "_" + i;
- }
- context.usedSymbolNames.set(input, true);
- if (symbol) {
- context.remappedSymbolNames.set("" + getSymbolId(symbol), input);
- }
- return input;
+ error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here, ts.unescapeLeadingUnderscores(name));
+ return true;
}
- function getNameCandidateWorker(symbol, localName) {
- if (localName === "default" || localName === "__class" || localName === "__function") {
- var flags = context.flags;
- context.flags |= 16777216;
- var nameCandidate = getNameOfSymbolAsWritten(symbol, context);
- context.flags = flags;
- localName = nameCandidate.length > 0 && ts.isSingleOrDoubleQuote(nameCandidate.charCodeAt(0)) ? ts.stripQuotes(nameCandidate) : nameCandidate;
- }
- if (localName === "default") {
- localName = "_default";
+ }
+ return false;
+ }
+ function checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning) {
+ if (meaning & (788968 & ~1920)) {
+ var symbol = resolveSymbol(resolveName(errorLocation, name, ~788968 & 111551, undefined, undefined, false));
+ if (symbol && !(symbol.flags & 1920)) {
+ error(errorLocation, ts.Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0, ts.unescapeLeadingUnderscores(name));
+ return true;
+ }
+ }
+ return false;
+ }
+ function isPrimitiveTypeName(name) {
+ return name === "any" || name === "string" || name === "number" || name === "boolean" || name === "never" || name === "unknown";
+ }
+ function checkAndReportErrorForExportingPrimitiveType(errorLocation, name) {
+ if (isPrimitiveTypeName(name) && errorLocation.parent.kind === 270) {
+ error(errorLocation, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, name);
+ return true;
+ }
+ return false;
+ }
+ function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) {
+ if (meaning & (111551 & ~1024)) {
+ if (isPrimitiveTypeName(name)) {
+ error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, ts.unescapeLeadingUnderscores(name));
+ return true;
+ }
+ var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 & ~111551, undefined, undefined, false));
+ if (symbol && !(symbol.flags & 1024)) {
+ var rawName = ts.unescapeLeadingUnderscores(name);
+ if (isES2015OrLaterConstructorName(name)) {
+ error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later, rawName);
}
- else if (localName === "export=") {
- localName = "_exports";
+ else if (maybeMappedType(errorLocation, symbol)) {
+ error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0, rawName, rawName === "K" ? "P" : "K");
}
- localName = ts.isIdentifierText(localName, languageVersion) && !ts.isStringANonContextualKeyword(localName) ? localName : "_" + localName.replace(/[^a-zA-Z0-9]/g, "_");
- return localName;
- }
- function getInternalSymbolName(symbol, localName) {
- if (context.remappedSymbolNames.has("" + getSymbolId(symbol))) {
- return context.remappedSymbolNames.get("" + getSymbolId(symbol));
+ else {
+ error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, rawName);
}
- localName = getNameCandidateWorker(symbol, localName);
- context.remappedSymbolNames.set("" + getSymbolId(symbol), localName);
- return localName;
+ return true;
}
}
+ return false;
}
- function typePredicateToString(typePredicate, enclosingDeclaration, flags, writer) {
- if (flags === void 0) { flags = 16384; }
- return writer ? typePredicateToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(typePredicateToStringWorker);
- function typePredicateToStringWorker(writer) {
- var predicate = ts.createTypePredicateNodeWithModifier(typePredicate.kind === 2 || typePredicate.kind === 3 ? ts.createToken(124) : undefined, typePredicate.kind === 1 || typePredicate.kind === 3 ? ts.createIdentifier(typePredicate.parameterName) : ts.createThisTypeNode(), typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | 512));
- var printer = ts.createPrinter({ removeComments: true });
- var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
- printer.writeNode(4, predicate, sourceFile, writer);
- return writer;
+ function maybeMappedType(node, symbol) {
+ var container = ts.findAncestor(node.parent, function (n) {
+ return ts.isComputedPropertyName(n) || ts.isPropertySignature(n) ? false : ts.isTypeLiteralNode(n) || "quit";
+ });
+ if (container && container.members.length === 1) {
+ var type = getDeclaredTypeOfSymbol(symbol);
+ return !!(type.flags & 1048576) && allTypesAssignableToKind(type, 384, true);
}
+ return false;
}
- function formatUnionTypes(types) {
- var result = [];
- var flags = 0;
- for (var i = 0; i < types.length; i++) {
- var t = types[i];
- flags |= t.flags;
- if (!(t.flags & 98304)) {
- if (t.flags & (512 | 1024)) {
- var baseType = t.flags & 512 ? booleanType : getBaseTypeOfEnumLiteralType(t);
- if (baseType.flags & 1048576) {
- var count = baseType.types.length;
- if (i + count <= types.length && getRegularTypeOfLiteralType(types[i + count - 1]) === getRegularTypeOfLiteralType(baseType.types[count - 1])) {
- result.push(baseType);
- i += count - 1;
- continue;
- }
- }
+ function isES2015OrLaterConstructorName(n) {
+ switch (n) {
+ case "Promise":
+ case "Symbol":
+ case "Map":
+ case "WeakMap":
+ case "Set":
+ case "WeakSet":
+ return true;
+ }
+ return false;
+ }
+ function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) {
+ if (meaning & (111551 & ~1024 & ~788968)) {
+ var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 & ~111551, undefined, undefined, false));
+ if (symbol) {
+ error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_value, ts.unescapeLeadingUnderscores(name));
+ return true;
+ }
+ }
+ else if (meaning & (788968 & ~1024 & ~111551)) {
+ var symbol = resolveSymbol(resolveName(errorLocation, name, (512 | 1024) & ~788968, undefined, undefined, false));
+ if (symbol) {
+ error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_type, ts.unescapeLeadingUnderscores(name));
+ return true;
+ }
+ }
+ return false;
+ }
+ function checkResolvedBlockScopedVariable(result, errorLocation) {
+ ts.Debug.assert(!!(result.flags & 2 || result.flags & 32 || result.flags & 384));
+ if (result.flags & (16 | 1 | 67108864) && result.flags & 32) {
+ return;
+ }
+ var declaration = ts.find(result.declarations, function (d) { return ts.isBlockOrCatchScoped(d) || ts.isClassLike(d) || (d.kind === 255); });
+ if (declaration === undefined)
+ return ts.Debug.fail("checkResolvedBlockScopedVariable could not find block-scoped declaration");
+ if (!(declaration.flags & 8388608) && !isBlockScopedNameDeclaredBeforeUse(declaration, errorLocation)) {
+ var diagnosticMessage = void 0;
+ var declarationName = ts.declarationNameToString(ts.getNameOfDeclaration(declaration));
+ if (result.flags & 2) {
+ diagnosticMessage = error(errorLocation, ts.Diagnostics.Block_scoped_variable_0_used_before_its_declaration, declarationName);
+ }
+ else if (result.flags & 32) {
+ diagnosticMessage = error(errorLocation, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName);
+ }
+ else if (result.flags & 256) {
+ diagnosticMessage = error(errorLocation, ts.Diagnostics.Enum_0_used_before_its_declaration, declarationName);
+ }
+ else {
+ ts.Debug.assert(!!(result.flags & 128));
+ if (compilerOptions.preserveConstEnums) {
+ diagnosticMessage = error(errorLocation, ts.Diagnostics.Enum_0_used_before_its_declaration, declarationName);
}
- result.push(t);
+ }
+ if (diagnosticMessage) {
+ ts.addRelatedInfo(diagnosticMessage, ts.createDiagnosticForNode(declaration, ts.Diagnostics._0_is_declared_here, declarationName));
}
}
- if (flags & 65536)
- result.push(nullType);
- if (flags & 32768)
- result.push(undefinedType);
- return result || types;
}
- function visibilityToString(flags) {
- if (flags === 8) {
- return "private";
+ function isSameScopeDescendentOf(initial, parent, stopAt) {
+ return !!parent && !!ts.findAncestor(initial, function (n) { return n === stopAt || ts.isFunctionLike(n) ? "quit" : n === parent; });
+ }
+ function getAnyImportSyntax(node) {
+ switch (node.kind) {
+ case 260:
+ return node;
+ case 262:
+ return node.parent;
+ case 263:
+ return node.parent.parent;
+ case 265:
+ return node.parent.parent.parent;
+ default:
+ return undefined;
}
- if (flags === 16) {
- return "protected";
+ }
+ function getDeclarationOfAliasSymbol(symbol) {
+ return ts.find(symbol.declarations, isAliasSymbolDeclaration);
+ }
+ function isAliasSymbolDeclaration(node) {
+ return node.kind === 260
+ || node.kind === 259
+ || node.kind === 262 && !!node.name
+ || node.kind === 263
+ || node.kind === 269
+ || node.kind === 265
+ || node.kind === 270
+ || node.kind === 266 && ts.exportAssignmentIsAlias(node)
+ || ts.isBinaryExpression(node) && ts.getAssignmentDeclarationKind(node) === 2 && ts.exportAssignmentIsAlias(node)
+ || ts.isAccessExpression(node)
+ && ts.isBinaryExpression(node.parent)
+ && node.parent.left === node
+ && node.parent.operatorToken.kind === 62
+ && isAliasableOrJsExpression(node.parent.right)
+ || node.kind === 289
+ || node.kind === 288 && isAliasableOrJsExpression(node.initializer)
+ || ts.isRequireVariableDeclaration(node, true);
+ }
+ function isAliasableOrJsExpression(e) {
+ return ts.isAliasableExpression(e) || ts.isFunctionExpression(e) && isJSConstructor(e);
+ }
+ function getTargetOfImportEqualsDeclaration(node, dontResolveAlias) {
+ var commonJSPropertyAccess = getCommonJSPropertyAccess(node);
+ if (commonJSPropertyAccess) {
+ var name = ts.getLeftmostAccessExpression(commonJSPropertyAccess.expression).arguments[0];
+ return ts.isIdentifier(commonJSPropertyAccess.name)
+ ? resolveSymbol(getPropertyOfType(resolveExternalModuleTypeByLiteral(name), commonJSPropertyAccess.name.escapedText))
+ : undefined;
}
- return "public";
+ if (ts.isVariableDeclaration(node) || node.moduleReference.kind === 272) {
+ var immediate = resolveExternalModuleName(node, ts.getExternalModuleRequireArgument(node) || ts.getExternalModuleImportEqualsDeclarationExpression(node));
+ var resolved_4 = resolveExternalModuleSymbol(immediate);
+ markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved_4, false);
+ return resolved_4;
+ }
+ var resolved = getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, dontResolveAlias);
+ checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved);
+ return resolved;
}
- function getTypeAliasForTypeLiteral(type) {
- if (type.symbol && type.symbol.flags & 2048) {
- var node = ts.findAncestor(type.symbol.declarations[0].parent, function (n) { return n.kind !== 182; });
- if (node.kind === 247) {
- return getSymbolOfNode(node);
- }
+ function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved) {
+ if (markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false)) {
+ var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(getSymbolOfNode(node));
+ var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration);
+ var message = isExport
+ ? ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type
+ : ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type;
+ var relatedMessage = isExport
+ ? ts.Diagnostics._0_was_exported_here
+ : ts.Diagnostics._0_was_imported_here;
+ var name = ts.unescapeLeadingUnderscores(typeOnlyDeclaration.name.escapedText);
+ ts.addRelatedInfo(error(node.moduleReference, message), ts.createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, name));
}
- return undefined;
}
- function isTopLevelInExternalModuleAugmentation(node) {
- return node && node.parent &&
- node.parent.kind === 250 &&
- ts.isExternalModuleAugmentation(node.parent.parent);
+ function resolveExportByName(moduleSymbol, name, sourceNode, dontResolveAlias) {
+ var exportValue = moduleSymbol.exports.get("export=");
+ var exportSymbol = exportValue ? getPropertyOfType(getTypeOfSymbol(exportValue), name) : moduleSymbol.exports.get(name);
+ var resolved = resolveSymbol(exportSymbol, dontResolveAlias);
+ markSymbolOfAliasDeclarationIfTypeOnly(sourceNode, exportSymbol, resolved, false);
+ return resolved;
}
- function isDefaultBindingContext(location) {
- return location.kind === 290 || ts.isAmbientModule(location);
+ function isSyntacticDefault(node) {
+ return ((ts.isExportAssignment(node) && !node.isExportEquals) || ts.hasSyntacticModifier(node, 512) || ts.isExportSpecifier(node));
}
- function getNameOfSymbolFromNameType(symbol, context) {
- var nameType = getSymbolLinks(symbol).nameType;
- if (nameType) {
- if (nameType.flags & 384) {
- var name = "" + nameType.value;
- if (!ts.isIdentifierText(name, compilerOptions.target) && !isNumericLiteralName(name)) {
- return "\"" + ts.escapeString(name, 34) + "\"";
- }
- if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
- return "[" + name + "]";
- }
- return name;
+ function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias) {
+ if (!allowSyntheticDefaultImports) {
+ return false;
+ }
+ if (!file || file.isDeclarationFile) {
+ var defaultExportSymbol = resolveExportByName(moduleSymbol, "default", undefined, true);
+ if (defaultExportSymbol && ts.some(defaultExportSymbol.declarations, isSyntacticDefault)) {
+ return false;
}
- if (nameType.flags & 8192) {
- return "[" + getNameOfSymbolAsWritten(nameType.symbol, context) + "]";
+ if (resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), undefined, dontResolveAlias)) {
+ return false;
}
+ return true;
}
- }
- function getNameOfSymbolAsWritten(symbol, context) {
- if (context && symbol.escapedName === "default" && !(context.flags & 16384) &&
- (!(context.flags & 16777216) ||
- !symbol.declarations ||
- (context.enclosingDeclaration && ts.findAncestor(symbol.declarations[0], isDefaultBindingContext) !== ts.findAncestor(context.enclosingDeclaration, isDefaultBindingContext)))) {
- return "default";
+ if (!ts.isSourceFileJS(file)) {
+ return hasExportAssignmentSymbol(moduleSymbol);
}
- if (symbol.declarations && symbol.declarations.length) {
- var declaration = ts.firstDefined(symbol.declarations, function (d) { return ts.getNameOfDeclaration(d) ? d : undefined; });
- var name_2 = declaration && ts.getNameOfDeclaration(declaration);
- if (declaration && name_2) {
- if (ts.isCallExpression(declaration) && ts.isBindableObjectDefinePropertyCall(declaration)) {
- return ts.symbolName(symbol);
- }
- if (ts.isComputedPropertyName(name_2) && !(ts.getCheckFlags(symbol) & 4096)) {
- var nameType = getSymbolLinks(symbol).nameType;
- if (nameType && nameType.flags & 384) {
- var result = getNameOfSymbolFromNameType(symbol, context);
- if (result !== undefined) {
- return result;
- }
- }
- }
- return ts.declarationNameToString(name_2);
+ return !file.externalModuleIndicator && !resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), undefined, dontResolveAlias);
+ }
+ function getTargetOfImportClause(node, dontResolveAlias) {
+ var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier);
+ if (moduleSymbol) {
+ var exportDefaultSymbol = void 0;
+ if (ts.isShorthandAmbientModuleSymbol(moduleSymbol)) {
+ exportDefaultSymbol = moduleSymbol;
}
- if (!declaration) {
- declaration = symbol.declarations[0];
+ else {
+ exportDefaultSymbol = resolveExportByName(moduleSymbol, "default", node, dontResolveAlias);
}
- if (declaration.parent && declaration.parent.kind === 242) {
- return ts.declarationNameToString(declaration.parent.name);
+ var file = ts.find(moduleSymbol.declarations, ts.isSourceFile);
+ var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias);
+ if (!exportDefaultSymbol && !hasSyntheticDefault) {
+ if (hasExportAssignmentSymbol(moduleSymbol)) {
+ var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop";
+ var exportEqualsSymbol = moduleSymbol.exports.get("export=");
+ var exportAssignment = exportEqualsSymbol.valueDeclaration;
+ var err = error(node.name, ts.Diagnostics.Module_0_can_only_be_default_imported_using_the_1_flag, symbolToString(moduleSymbol), compilerOptionName);
+ ts.addRelatedInfo(err, ts.createDiagnosticForNode(exportAssignment, ts.Diagnostics.This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag, compilerOptionName));
+ }
+ else {
+ reportNonDefaultExport(moduleSymbol, node);
+ }
}
- switch (declaration.kind) {
- case 214:
- case 201:
- case 202:
- if (context && !context.encounteredError && !(context.flags & 131072)) {
- context.encounteredError = true;
- }
- return declaration.kind === 214 ? "(Anonymous class)" : "(Anonymous function)";
+ else if (hasSyntheticDefault) {
+ var resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
+ markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, false);
+ return resolved;
}
+ markSymbolOfAliasDeclarationIfTypeOnly(node, exportDefaultSymbol, undefined, false);
+ return exportDefaultSymbol;
}
- var name = getNameOfSymbolFromNameType(symbol, context);
- return name !== undefined ? name : ts.symbolName(symbol);
}
- function isDeclarationVisible(node) {
- if (node) {
- var links = getNodeLinks(node);
- if (links.isVisible === undefined) {
- links.isVisible = !!determineIfDeclarationIsVisible();
- }
- return links.isVisible;
+ function reportNonDefaultExport(moduleSymbol, node) {
+ var _a, _b;
+ if ((_a = moduleSymbol.exports) === null || _a === void 0 ? void 0 : _a.has(node.symbol.escapedName)) {
+ error(node.name, ts.Diagnostics.Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead, symbolToString(moduleSymbol), symbolToString(node.symbol));
}
- return false;
- function determineIfDeclarationIsVisible() {
- switch (node.kind) {
- case 315:
- case 322:
- case 316:
- return !!(node.parent && node.parent.parent && node.parent.parent.parent && ts.isSourceFile(node.parent.parent.parent));
- case 191:
- return isDeclarationVisible(node.parent.parent);
- case 242:
- if (ts.isBindingPattern(node.name) &&
- !node.name.elements.length) {
- return false;
- }
- case 249:
- case 245:
- case 246:
- case 247:
- case 244:
- case 248:
- case 253:
- if (ts.isExternalModuleAugmentation(node)) {
- return true;
- }
- var parent = getDeclarationContainer(node);
- if (!(ts.getCombinedModifierFlags(node) & 1) &&
- !(node.kind !== 253 && parent.kind !== 290 && parent.flags & 8388608)) {
- return isGlobalSourceFile(parent);
- }
- return isDeclarationVisible(parent);
- case 159:
- case 158:
- case 163:
- case 164:
- case 161:
- case 160:
- if (ts.hasModifier(node, 8 | 16)) {
- return false;
- }
- case 162:
- case 166:
- case 165:
- case 167:
- case 156:
- case 250:
- case 170:
- case 171:
- case 173:
- case 169:
- case 174:
- case 175:
- case 178:
- case 179:
- case 182:
- return isDeclarationVisible(node.parent);
- case 255:
- case 256:
- case 258:
- return false;
- case 155:
- case 290:
- case 252:
- return true;
- case 259:
- return false;
- default:
- return false;
+ else {
+ var diagnostic = error(node.name, ts.Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol));
+ var exportStar = (_b = moduleSymbol.exports) === null || _b === void 0 ? void 0 : _b.get("__export");
+ if (exportStar) {
+ var defaultExport = ts.find(exportStar.declarations, function (decl) {
+ var _a, _b;
+ return !!(ts.isExportDeclaration(decl) && decl.moduleSpecifier && ((_b = (_a = resolveExternalModuleName(decl, decl.moduleSpecifier)) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.has("default")));
+ });
+ if (defaultExport) {
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(defaultExport, ts.Diagnostics.export_Asterisk_does_not_re_export_a_default));
+ }
}
}
}
- function collectLinkedAliases(node, setVisibility) {
- var exportSymbol;
- if (node.parent && node.parent.kind === 259) {
- exportSymbol = resolveName(node, node.escapedText, 111551 | 788968 | 1920 | 2097152, undefined, node, false);
- }
- else if (node.parent.kind === 263) {
- exportSymbol = getTargetOfExportSpecifier(node.parent, 111551 | 788968 | 1920 | 2097152);
+ function getTargetOfNamespaceImport(node, dontResolveAlias) {
+ var moduleSpecifier = node.parent.parent.moduleSpecifier;
+ var immediate = resolveExternalModuleName(node, moduleSpecifier);
+ var resolved = resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false);
+ markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false);
+ return resolved;
+ }
+ function getTargetOfNamespaceExport(node, dontResolveAlias) {
+ var moduleSpecifier = node.parent.moduleSpecifier;
+ var immediate = moduleSpecifier && resolveExternalModuleName(node, moduleSpecifier);
+ var resolved = moduleSpecifier && resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false);
+ markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false);
+ return resolved;
+ }
+ function combineValueAndTypeSymbols(valueSymbol, typeSymbol) {
+ if (valueSymbol === unknownSymbol && typeSymbol === unknownSymbol) {
+ return unknownSymbol;
}
- var result;
- var visited;
- if (exportSymbol) {
- visited = ts.createMap();
- visited.set("" + getSymbolId(exportSymbol), true);
- buildVisibleNodeList(exportSymbol.declarations);
+ if (valueSymbol.flags & (788968 | 1920)) {
+ return valueSymbol;
}
+ var result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.escapedName);
+ result.declarations = ts.deduplicate(ts.concatenate(valueSymbol.declarations, typeSymbol.declarations), ts.equateValues);
+ result.parent = valueSymbol.parent || typeSymbol.parent;
+ if (valueSymbol.valueDeclaration)
+ result.valueDeclaration = valueSymbol.valueDeclaration;
+ if (typeSymbol.members)
+ result.members = new ts.Map(typeSymbol.members);
+ if (valueSymbol.exports)
+ result.exports = new ts.Map(valueSymbol.exports);
return result;
- function buildVisibleNodeList(declarations) {
- ts.forEach(declarations, function (declaration) {
- var resultNode = getAnyImportSyntax(declaration) || declaration;
- if (setVisibility) {
- getNodeLinks(declaration).isVisible = true;
+ }
+ function getExportOfModule(symbol, name, specifier, dontResolveAlias) {
+ if (symbol.flags & 1536) {
+ var exportSymbol = getExportsOfSymbol(symbol).get(name.escapedText);
+ var resolved = resolveSymbol(exportSymbol, dontResolveAlias);
+ markSymbolOfAliasDeclarationIfTypeOnly(specifier, exportSymbol, resolved, false);
+ return resolved;
+ }
+ }
+ function getPropertyOfVariable(symbol, name) {
+ if (symbol.flags & 3) {
+ var typeAnnotation = symbol.valueDeclaration.type;
+ if (typeAnnotation) {
+ return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name));
+ }
+ }
+ }
+ function getExternalModuleMember(node, specifier, dontResolveAlias) {
+ var _a;
+ if (dontResolveAlias === void 0) { dontResolveAlias = false; }
+ var moduleSpecifier = ts.getExternalModuleRequireArgument(node) || node.moduleSpecifier;
+ var moduleSymbol = resolveExternalModuleName(node, moduleSpecifier);
+ var name = !ts.isPropertyAccessExpression(specifier) && specifier.propertyName || specifier.name;
+ if (!ts.isIdentifier(name)) {
+ return undefined;
+ }
+ var suppressInteropError = name.escapedText === "default" && !!(compilerOptions.allowSyntheticDefaultImports || compilerOptions.esModuleInterop);
+ var targetSymbol = resolveESModuleSymbol(moduleSymbol, moduleSpecifier, dontResolveAlias, suppressInteropError);
+ if (targetSymbol) {
+ if (name.escapedText) {
+ if (ts.isShorthandAmbientModuleSymbol(moduleSymbol)) {
+ return moduleSymbol;
+ }
+ var symbolFromVariable = void 0;
+ if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports.get("export=")) {
+ symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name.escapedText);
}
else {
- result = result || [];
- ts.pushIfUnique(result, resultNode);
+ symbolFromVariable = getPropertyOfVariable(targetSymbol, name.escapedText);
}
- if (ts.isInternalModuleImportEqualsDeclaration(declaration)) {
- var internalModuleReference = declaration.moduleReference;
- var firstIdentifier = ts.getFirstIdentifier(internalModuleReference);
- var importSymbol = resolveName(declaration, firstIdentifier.escapedText, 111551 | 788968 | 1920, undefined, undefined, false);
- var id = importSymbol && "" + getSymbolId(importSymbol);
- if (importSymbol && !visited.has(id)) {
- visited.set(id, true);
- buildVisibleNodeList(importSymbol.declarations);
+ symbolFromVariable = resolveSymbol(symbolFromVariable, dontResolveAlias);
+ var symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias);
+ if (symbolFromModule === undefined && name.escapedText === "default") {
+ var file = ts.find(moduleSymbol.declarations, ts.isSourceFile);
+ if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias)) {
+ symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
}
}
- });
- }
- }
- function pushTypeResolution(target, propertyName) {
- var resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName);
- if (resolutionCycleStartIndex >= 0) {
- var length_3 = resolutionTargets.length;
- for (var i = resolutionCycleStartIndex; i < length_3; i++) {
- resolutionResults[i] = false;
+ var symbol = symbolFromModule && symbolFromVariable && symbolFromModule !== symbolFromVariable ?
+ combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
+ symbolFromModule || symbolFromVariable;
+ if (!symbol) {
+ var moduleName = getFullyQualifiedName(moduleSymbol, node);
+ var declarationName = ts.declarationNameToString(name);
+ var suggestion = getSuggestedSymbolForNonexistentModule(name, targetSymbol);
+ if (suggestion !== undefined) {
+ var suggestionName = symbolToString(suggestion);
+ var diagnostic = error(name, ts.Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, moduleName, declarationName, suggestionName);
+ if (suggestion.valueDeclaration) {
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName));
+ }
+ }
+ else {
+ if ((_a = moduleSymbol.exports) === null || _a === void 0 ? void 0 : _a.has("default")) {
+ error(name, ts.Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead, moduleName, declarationName);
+ }
+ else {
+ reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName);
+ }
+ }
+ }
+ return symbol;
}
- return false;
}
- resolutionTargets.push(target);
- resolutionResults.push(true);
- resolutionPropertyNames.push(propertyName);
- return true;
}
- function findResolutionCycleStartIndex(target, propertyName) {
- for (var i = resolutionTargets.length - 1; i >= 0; i--) {
- if (hasType(resolutionTargets[i], resolutionPropertyNames[i])) {
- return -1;
+ function reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName) {
+ var _a;
+ var localSymbol = (_a = moduleSymbol.valueDeclaration.locals) === null || _a === void 0 ? void 0 : _a.get(name.escapedText);
+ var exports = moduleSymbol.exports;
+ if (localSymbol) {
+ var exportedEqualsSymbol = exports === null || exports === void 0 ? void 0 : exports.get("export=");
+ if (exportedEqualsSymbol) {
+ getSymbolIfSameReference(exportedEqualsSymbol, localSymbol) ? reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) :
+ error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName);
}
- if (resolutionTargets[i] === target && resolutionPropertyNames[i] === propertyName) {
- return i;
+ else {
+ var exportedSymbol = exports ? ts.find(symbolsToArray(exports), function (symbol) { return !!getSymbolIfSameReference(symbol, localSymbol); }) : undefined;
+ var diagnostic = exportedSymbol ? error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2, moduleName, declarationName, symbolToString(exportedSymbol)) :
+ error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName);
+ ts.addRelatedInfo.apply(void 0, __spreadArrays([diagnostic], ts.map(localSymbol.declarations, function (decl, index) {
+ return ts.createDiagnosticForNode(decl, index === 0 ? ts.Diagnostics._0_is_declared_here : ts.Diagnostics.and_here, declarationName);
+ })));
}
}
- return -1;
- }
- function hasType(target, propertyName) {
- switch (propertyName) {
- case 0:
- return !!getSymbolLinks(target).type;
- case 5:
- return !!(getNodeLinks(target).resolvedEnumType);
- case 2:
- return !!getSymbolLinks(target).declaredType;
- case 1:
- return !!target.resolvedBaseConstructorType;
- case 3:
- return !!target.resolvedReturnType;
- case 4:
- return !!target.immediateBaseConstraint;
- case 6:
- return !!target.resolvedTypeArguments;
+ else {
+ error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName);
}
- return ts.Debug.assertNever(propertyName);
}
- function popTypeResolution() {
- resolutionTargets.pop();
- resolutionPropertyNames.pop();
- return resolutionResults.pop();
- }
- function getDeclarationContainer(node) {
- return ts.findAncestor(ts.getRootDeclaration(node), function (node) {
- switch (node.kind) {
- case 242:
- case 243:
- case 258:
- case 257:
- case 256:
- case 255:
- return false;
- default:
- return true;
+ function reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) {
+ if (moduleKind >= ts.ModuleKind.ES2015) {
+ var message = compilerOptions.esModuleInterop ? ts.Diagnostics._0_can_only_be_imported_by_using_a_default_import :
+ ts.Diagnostics._0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
+ error(name, message, declarationName);
+ }
+ else {
+ if (ts.isInJSFile(node)) {
+ var message = compilerOptions.esModuleInterop ? ts.Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import :
+ ts.Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
+ error(name, message, declarationName);
}
- }).parent;
+ else {
+ var message = compilerOptions.esModuleInterop ? ts.Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import :
+ ts.Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
+ error(name, message, declarationName, declarationName, moduleName);
+ }
+ }
}
- function getTypeOfPrototypeProperty(prototype) {
- var classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype));
- return classType.typeParameters ? createTypeReference(classType, ts.map(classType.typeParameters, function (_) { return anyType; })) : classType;
+ function getTargetOfImportSpecifier(node, dontResolveAlias) {
+ var root = ts.isBindingElement(node) ? ts.getRootDeclaration(node) : node.parent.parent.parent;
+ var commonJSPropertyAccess = getCommonJSPropertyAccess(root);
+ var resolved = getExternalModuleMember(root, commonJSPropertyAccess || node, dontResolveAlias);
+ var name = node.propertyName || node.name;
+ if (commonJSPropertyAccess && resolved && ts.isIdentifier(name)) {
+ return getPropertyOfType(getTypeOfSymbol(resolved), name.escapedText);
+ }
+ markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false);
+ return resolved;
}
- function getTypeOfPropertyOfType(type, name) {
- var prop = getPropertyOfType(type, name);
- return prop ? getTypeOfSymbol(prop) : undefined;
+ function getCommonJSPropertyAccess(node) {
+ if (ts.isVariableDeclaration(node) && node.initializer && ts.isPropertyAccessExpression(node.initializer)) {
+ return node.initializer;
+ }
}
- function getTypeOfPropertyOrIndexSignature(type, name) {
- return getTypeOfPropertyOfType(type, name) || isNumericLiteralName(name) && getIndexTypeOfType(type, 1) || getIndexTypeOfType(type, 0) || unknownType;
+ function getTargetOfNamespaceExportDeclaration(node, dontResolveAlias) {
+ var resolved = resolveExternalModuleSymbol(node.parent.symbol, dontResolveAlias);
+ markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false);
+ return resolved;
}
- function isTypeAny(type) {
- return type && (type.flags & 1) !== 0;
+ function getTargetOfExportSpecifier(node, meaning, dontResolveAlias) {
+ var resolved = node.parent.parent.moduleSpecifier ?
+ getExternalModuleMember(node.parent.parent, node, dontResolveAlias) :
+ resolveEntityName(node.propertyName || node.name, meaning, false, dontResolveAlias);
+ markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false);
+ return resolved;
}
- function getTypeForBindingElementParent(node) {
- var symbol = getSymbolOfNode(node);
- return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, false);
+ function getTargetOfExportAssignment(node, dontResolveAlias) {
+ var expression = ts.isExportAssignment(node) ? node.expression : node.right;
+ var resolved = getTargetOfAliasLikeExpression(expression, dontResolveAlias);
+ markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false);
+ return resolved;
}
- function getRestType(source, properties, symbol) {
- source = filterType(source, function (t) { return !(t.flags & 98304); });
- if (source.flags & 131072) {
- return emptyObjectType;
- }
- if (source.flags & 1048576) {
- return mapType(source, function (t) { return getRestType(t, properties, symbol); });
+ function getTargetOfAliasLikeExpression(expression, dontResolveAlias) {
+ if (ts.isClassExpression(expression)) {
+ return checkExpressionCached(expression).symbol;
}
- var omitKeyType = getUnionType(ts.map(properties, getLiteralTypeFromPropertyName));
- if (isGenericObjectType(source) || isGenericIndexType(omitKeyType)) {
- if (omitKeyType.flags & 131072) {
- return source;
- }
- var omitTypeAlias = getGlobalOmitSymbol();
- if (!omitTypeAlias) {
- return errorType;
- }
- return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]);
+ if (!ts.isEntityName(expression) && !ts.isEntityNameExpression(expression)) {
+ return undefined;
}
- var members = ts.createSymbolTable();
- for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) {
- var prop = _a[_i];
- if (!isTypeAssignableTo(getLiteralTypeFromProperty(prop, 8576), omitKeyType)
- && !(ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 | 16))
- && isSpreadableProperty(prop)) {
- members.set(prop.escapedName, getSpreadSymbol(prop, false));
- }
+ var aliasLike = resolveEntityName(expression, 111551 | 788968 | 1920, true, dontResolveAlias);
+ if (aliasLike) {
+ return aliasLike;
}
- var stringIndexInfo = getIndexInfoOfType(source, 0);
- var numberIndexInfo = getIndexInfoOfType(source, 1);
- var result = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo);
- result.objectFlags |= 131072;
- return result;
+ checkExpressionCached(expression);
+ return getNodeLinks(expression).resolvedSymbol;
}
- function getFlowTypeOfDestructuring(node, declaredType) {
- var reference = getSyntheticElementAccess(node);
- return reference ? getFlowTypeOfReference(reference, declaredType) : declaredType;
+ function getTargetOfPropertyAssignment(node, dontRecursivelyResolve) {
+ var expression = node.initializer;
+ return getTargetOfAliasLikeExpression(expression, dontRecursivelyResolve);
}
- function getSyntheticElementAccess(node) {
- var parentAccess = getParentElementAccess(node);
- if (parentAccess && parentAccess.flowNode) {
- var propName = getDestructuringPropertyName(node);
- if (propName) {
- var result = ts.createNode(195, node.pos, node.end);
- result.parent = node;
- result.expression = parentAccess;
- var literal = ts.createNode(10, node.pos, node.end);
- literal.parent = result;
- literal.text = propName;
- result.argumentExpression = literal;
- result.flowNode = parentAccess.flowNode;
- return result;
- }
+ function getTargetOfAccessExpression(node, dontRecursivelyResolve) {
+ if (!(ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 62)) {
+ return undefined;
}
+ return getTargetOfAliasLikeExpression(node.parent.right, dontRecursivelyResolve);
}
- function getParentElementAccess(node) {
- var ancestor = node.parent.parent;
- switch (ancestor.kind) {
- case 191:
- case 281:
- return getSyntheticElementAccess(ancestor);
- case 192:
- return getSyntheticElementAccess(node.parent);
- case 242:
- return ancestor.initializer;
- case 209:
- return ancestor.right;
+ function getTargetOfAliasDeclaration(node, dontRecursivelyResolve) {
+ if (dontRecursivelyResolve === void 0) { dontRecursivelyResolve = false; }
+ switch (node.kind) {
+ case 260:
+ case 249:
+ return getTargetOfImportEqualsDeclaration(node, dontRecursivelyResolve);
+ case 262:
+ return getTargetOfImportClause(node, dontRecursivelyResolve);
+ case 263:
+ return getTargetOfNamespaceImport(node, dontRecursivelyResolve);
+ case 269:
+ return getTargetOfNamespaceExport(node, dontRecursivelyResolve);
+ case 265:
+ case 198:
+ return getTargetOfImportSpecifier(node, dontRecursivelyResolve);
+ case 270:
+ return getTargetOfExportSpecifier(node, 111551 | 788968 | 1920, dontRecursivelyResolve);
+ case 266:
+ case 216:
+ return getTargetOfExportAssignment(node, dontRecursivelyResolve);
+ case 259:
+ return getTargetOfNamespaceExportDeclaration(node, dontRecursivelyResolve);
+ case 289:
+ return resolveEntityName(node.name, 111551 | 788968 | 1920, true, dontRecursivelyResolve);
+ case 288:
+ return getTargetOfPropertyAssignment(node, dontRecursivelyResolve);
+ case 202:
+ case 201:
+ return getTargetOfAccessExpression(node, dontRecursivelyResolve);
+ default:
+ return ts.Debug.fail();
}
}
- function getDestructuringPropertyName(node) {
- var parent = node.parent;
- if (node.kind === 191 && parent.kind === 189) {
- return getLiteralPropertyNameText(node.propertyName || node.name);
- }
- if (node.kind === 281 || node.kind === 282) {
- return getLiteralPropertyNameText(node.name);
- }
- return "" + parent.elements.indexOf(node);
+ function isNonLocalAlias(symbol, excludes) {
+ if (excludes === void 0) { excludes = 111551 | 788968 | 1920; }
+ if (!symbol)
+ return false;
+ return (symbol.flags & (2097152 | excludes)) === 2097152 || !!(symbol.flags & 2097152 && symbol.flags & 67108864);
}
- function getLiteralPropertyNameText(name) {
- var type = getLiteralTypeFromPropertyName(name);
- return type.flags & (128 | 256) ? "" + type.value : undefined;
+ function resolveSymbol(symbol, dontResolveAlias) {
+ return !dontResolveAlias && isNonLocalAlias(symbol) ? resolveAlias(symbol) : symbol;
}
- function getTypeForBindingElement(declaration) {
- var pattern = declaration.parent;
- var parentType = getTypeForBindingElementParent(pattern.parent);
- if (!parentType || isTypeAny(parentType)) {
- return parentType;
- }
- if (strictNullChecks && declaration.flags & 8388608 && ts.isParameterDeclaration(declaration)) {
- parentType = getNonNullableType(parentType);
- }
- else if (strictNullChecks && pattern.parent.initializer && !(getTypeFacts(getTypeOfInitializer(pattern.parent.initializer)) & 65536)) {
- parentType = getTypeWithFacts(parentType, 524288);
- }
- var type;
- if (pattern.kind === 189) {
- if (declaration.dotDotDotToken) {
- parentType = getReducedType(parentType);
- if (parentType.flags & 2 || !isValidSpreadType(parentType)) {
- error(declaration, ts.Diagnostics.Rest_types_may_only_be_created_from_object_types);
- return errorType;
- }
- var literalMembers = [];
- for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
- var element = _a[_i];
- if (!element.dotDotDotToken) {
- literalMembers.push(element.propertyName || element.name);
- }
- }
- type = getRestType(parentType, literalMembers, declaration.symbol);
+ function resolveAlias(symbol) {
+ ts.Debug.assert((symbol.flags & 2097152) !== 0, "Should only get Alias here.");
+ var links = getSymbolLinks(symbol);
+ if (!links.target) {
+ links.target = resolvingSymbol;
+ var node = getDeclarationOfAliasSymbol(symbol);
+ if (!node)
+ return ts.Debug.fail();
+ var target = getTargetOfAliasDeclaration(node);
+ if (links.target === resolvingSymbol) {
+ links.target = target || unknownSymbol;
}
else {
- var name = declaration.propertyName || declaration.name;
- var indexType = getLiteralTypeFromPropertyName(name);
- var declaredType = getConstraintForLocation(getIndexedAccessType(parentType, indexType, name), declaration.name);
- type = getFlowTypeOfDestructuring(declaration, declaredType);
+ error(node, ts.Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol));
}
}
- else {
- var elementType = checkIteratedTypeOrElementType(65, parentType, undefinedType, pattern);
- var index_1 = pattern.elements.indexOf(declaration);
- if (declaration.dotDotDotToken) {
- type = everyType(parentType, isTupleType) ?
- mapType(parentType, function (t) { return sliceTupleType(t, index_1); }) :
- createArrayType(elementType);
- }
- else if (isArrayLikeType(parentType)) {
- var indexType = getLiteralType(index_1);
- var accessFlags = hasDefaultValue(declaration) ? 8 : 0;
- var declaredType = getConstraintForLocation(getIndexedAccessTypeOrUndefined(parentType, indexType, declaration.name, accessFlags) || errorType, declaration.name);
- type = getFlowTypeOfDestructuring(declaration, declaredType);
- }
- else {
- type = elementType;
- }
+ else if (links.target === resolvingSymbol) {
+ links.target = unknownSymbol;
}
- if (!declaration.initializer) {
- return type;
+ return links.target;
+ }
+ function tryResolveAlias(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (links.target !== resolvingSymbol) {
+ return resolveAlias(symbol);
}
- if (ts.getEffectiveTypeAnnotationNode(ts.walkUpBindingElementsAndPatterns(declaration))) {
- return strictNullChecks && !(getFalsyFlags(checkDeclarationInitializer(declaration)) & 32768) ?
- getTypeWithFacts(type, 524288) :
- type;
+ return undefined;
+ }
+ function markSymbolOfAliasDeclarationIfTypeOnly(aliasDeclaration, immediateTarget, finalTarget, overwriteEmpty) {
+ if (!aliasDeclaration || ts.isPropertyAccessExpression(aliasDeclaration))
+ return false;
+ var sourceSymbol = getSymbolOfNode(aliasDeclaration);
+ if (ts.isTypeOnlyImportOrExportDeclaration(aliasDeclaration)) {
+ var links_1 = getSymbolLinks(sourceSymbol);
+ links_1.typeOnlyDeclaration = aliasDeclaration;
+ return true;
}
- return widenTypeInferredFromInitializer(declaration, getUnionType([getTypeWithFacts(type, 524288), checkDeclarationInitializer(declaration)], 2));
+ var links = getSymbolLinks(sourceSymbol);
+ return markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, immediateTarget, overwriteEmpty)
+ || markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, finalTarget, overwriteEmpty);
}
- function getTypeForDeclarationFromJSDocComment(declaration) {
- var jsdocType = ts.getJSDocType(declaration);
- if (jsdocType) {
- return getTypeFromTypeNode(jsdocType);
+ function markSymbolOfAliasDeclarationIfTypeOnlyWorker(aliasDeclarationLinks, target, overwriteEmpty) {
+ var _a, _b, _c;
+ if (target && (aliasDeclarationLinks.typeOnlyDeclaration === undefined || overwriteEmpty && aliasDeclarationLinks.typeOnlyDeclaration === false)) {
+ var exportSymbol = (_b = (_a = target.exports) === null || _a === void 0 ? void 0 : _a.get("export=")) !== null && _b !== void 0 ? _b : target;
+ var typeOnly = exportSymbol.declarations && ts.find(exportSymbol.declarations, ts.isTypeOnlyImportOrExportDeclaration);
+ aliasDeclarationLinks.typeOnlyDeclaration = (_c = typeOnly !== null && typeOnly !== void 0 ? typeOnly : getSymbolLinks(exportSymbol).typeOnlyDeclaration) !== null && _c !== void 0 ? _c : false;
}
- return undefined;
+ return !!aliasDeclarationLinks.typeOnlyDeclaration;
}
- function isNullOrUndefined(node) {
- var expr = ts.skipParentheses(node);
- return expr.kind === 100 || expr.kind === 75 && getResolvedSymbol(expr) === undefinedSymbol;
+ function getTypeOnlyAliasDeclaration(symbol) {
+ if (!(symbol.flags & 2097152)) {
+ return undefined;
+ }
+ var links = getSymbolLinks(symbol);
+ return links.typeOnlyDeclaration || undefined;
}
- function isEmptyArrayLiteral(node) {
- var expr = ts.skipParentheses(node);
- return expr.kind === 192 && expr.elements.length === 0;
+ function markExportAsReferenced(node) {
+ var symbol = getSymbolOfNode(node);
+ var target = resolveAlias(symbol);
+ if (target) {
+ var markAlias = target === unknownSymbol ||
+ ((target.flags & 111551) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol));
+ if (markAlias) {
+ markAliasSymbolAsReferenced(symbol);
+ }
+ }
}
- function addOptionality(type, optional) {
- if (optional === void 0) { optional = true; }
- return strictNullChecks && optional ? getOptionalType(type) : type;
+ function markAliasSymbolAsReferenced(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (!links.referenced) {
+ links.referenced = true;
+ var node = getDeclarationOfAliasSymbol(symbol);
+ if (!node)
+ return ts.Debug.fail();
+ if (ts.isInternalModuleImportEqualsDeclaration(node)) {
+ var target = resolveSymbol(symbol);
+ if (target === unknownSymbol || target.flags & 111551) {
+ checkExpressionCached(node.moduleReference);
+ }
+ }
+ }
}
- function getTypeForVariableLikeDeclaration(declaration, includeOptionality) {
- if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 231) {
- var indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression)));
- return indexType.flags & (262144 | 4194304) ? getExtractStringType(indexType) : stringType;
+ function markConstEnumAliasAsReferenced(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (!links.constEnumReferenced) {
+ links.constEnumReferenced = true;
}
- if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 232) {
- var forOfStatement = declaration.parent.parent;
- return checkRightHandSideOfForOf(forOfStatement) || anyType;
+ }
+ function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) {
+ if (entityName.kind === 78 && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
+ entityName = entityName.parent;
}
- if (ts.isBindingPattern(declaration.parent)) {
- return getTypeForBindingElement(declaration);
+ if (entityName.kind === 78 || entityName.parent.kind === 157) {
+ return resolveEntityName(entityName, 1920, false, dontResolveAlias);
}
- var isOptional = includeOptionality && (ts.isParameter(declaration) && isJSDocOptionalParameter(declaration)
- || !ts.isBindingElement(declaration) && !ts.isVariableDeclaration(declaration) && !!declaration.questionToken);
- var declaredType = tryGetTypeFromEffectiveTypeNode(declaration);
- if (declaredType) {
- return addOptionality(declaredType, isOptional);
+ else {
+ ts.Debug.assert(entityName.parent.kind === 260);
+ return resolveEntityName(entityName, 111551 | 788968 | 1920, false, dontResolveAlias);
}
- if ((noImplicitAny || ts.isInJSFile(declaration)) &&
- declaration.kind === 242 && !ts.isBindingPattern(declaration.name) &&
- !(ts.getCombinedModifierFlags(declaration) & 1) && !(declaration.flags & 8388608)) {
- if (!(ts.getCombinedNodeFlags(declaration) & 2) && (!declaration.initializer || isNullOrUndefined(declaration.initializer))) {
- return autoType;
- }
- if (declaration.initializer && isEmptyArrayLiteral(declaration.initializer)) {
- return autoArrayType;
+ }
+ function getFullyQualifiedName(symbol, containingLocation) {
+ return symbol.parent ? getFullyQualifiedName(symbol.parent, containingLocation) + "." + symbolToString(symbol) : symbolToString(symbol, containingLocation, undefined, 16 | 4);
+ }
+ function resolveEntityName(name, meaning, ignoreErrors, dontResolveAlias, location) {
+ if (ts.nodeIsMissing(name)) {
+ return undefined;
+ }
+ var namespaceMeaning = 1920 | (ts.isInJSFile(name) ? meaning & 111551 : 0);
+ var symbol;
+ if (name.kind === 78) {
+ var message = meaning === namespaceMeaning || ts.nodeIsSynthesized(name) ? ts.Diagnostics.Cannot_find_namespace_0 : getCannotFindNameDiagnosticForName(ts.getFirstIdentifier(name));
+ var symbolFromJSPrototype = ts.isInJSFile(name) && !ts.nodeIsSynthesized(name) ? resolveEntityNameFromAssignmentDeclaration(name, meaning) : undefined;
+ symbol = getMergedSymbol(resolveName(location || name, name.escapedText, meaning, ignoreErrors || symbolFromJSPrototype ? undefined : message, name, true));
+ if (!symbol) {
+ return getMergedSymbol(symbolFromJSPrototype);
}
}
- if (declaration.kind === 156) {
- var func = declaration.parent;
- if (func.kind === 164 && !hasNonBindableDynamicName(func)) {
- var getter = ts.getDeclarationOfKind(getSymbolOfNode(declaration.parent), 163);
- if (getter) {
- var getterSignature = getSignatureFromDeclaration(getter);
- var thisParameter = getAccessorThisParameter(func);
- if (thisParameter && declaration === thisParameter) {
- ts.Debug.assert(!thisParameter.type);
- return getTypeOfSymbol(getterSignature.thisParameter);
+ else if (name.kind === 157 || name.kind === 201) {
+ var left = name.kind === 157 ? name.left : name.expression;
+ var right = name.kind === 157 ? name.right : name.name;
+ var namespace = resolveEntityName(left, namespaceMeaning, ignoreErrors, false, location);
+ if (!namespace || ts.nodeIsMissing(right)) {
+ return undefined;
+ }
+ else if (namespace === unknownSymbol) {
+ return namespace;
+ }
+ if (ts.isInJSFile(name)) {
+ if (namespace.valueDeclaration &&
+ ts.isVariableDeclaration(namespace.valueDeclaration) &&
+ namespace.valueDeclaration.initializer &&
+ isCommonJsRequire(namespace.valueDeclaration.initializer)) {
+ var moduleName = namespace.valueDeclaration.initializer.arguments[0];
+ var moduleSym = resolveExternalModuleName(moduleName, moduleName);
+ if (moduleSym) {
+ var resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym);
+ if (resolvedModuleSymbol) {
+ namespace = resolvedModuleSymbol;
+ }
}
- return getReturnTypeOfSignature(getterSignature);
}
}
- if (ts.isInJSFile(declaration)) {
- var typeTag = ts.getJSDocType(func);
- if (typeTag && ts.isFunctionTypeNode(typeTag)) {
- return getTypeAtPosition(getSignatureFromDeclaration(typeTag), func.parameters.indexOf(declaration));
+ symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(namespace), right.escapedText, meaning));
+ if (!symbol) {
+ if (!ignoreErrors) {
+ var namespaceName = getFullyQualifiedName(namespace);
+ var declarationName = ts.declarationNameToString(right);
+ var suggestion = getSuggestedSymbolForNonexistentModule(right, namespace);
+ suggestion ?
+ error(right, ts.Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, namespaceName, declarationName, symbolToString(suggestion)) :
+ error(right, ts.Diagnostics.Namespace_0_has_no_exported_member_1, namespaceName, declarationName);
}
- }
- var type = declaration.symbol.escapedName === "this" ? getContextualThisParameterType(func) : getContextuallyTypedParameterType(declaration);
- if (type) {
- return addOptionality(type, isOptional);
- }
- }
- else if (ts.isInJSFile(declaration)) {
- var containerObjectType = getJSContainerObjectType(declaration, getSymbolOfNode(declaration), ts.getDeclaredExpandoInitializer(declaration));
- if (containerObjectType) {
- return containerObjectType;
+ return undefined;
}
}
- if (declaration.initializer) {
- var type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration));
- return addOptionality(type, isOptional);
- }
- if (ts.isJsxAttribute(declaration)) {
- return trueType;
+ else {
+ throw ts.Debug.assertNever(name, "Unknown entity name kind.");
}
- if (ts.isBindingPattern(declaration.name)) {
- return getTypeFromBindingPattern(declaration.name, false, true);
+ ts.Debug.assert((ts.getCheckFlags(symbol) & 1) === 0, "Should never get an instantiated symbol here.");
+ if (!ts.nodeIsSynthesized(name) && ts.isEntityName(name) && (symbol.flags & 2097152 || name.parent.kind === 266)) {
+ markSymbolOfAliasDeclarationIfTypeOnly(ts.getAliasDeclarationFromName(name), symbol, undefined, true);
}
- return undefined;
+ return (symbol.flags & meaning) || dontResolveAlias ? symbol : resolveAlias(symbol);
}
- function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) {
- var container = ts.getAssignedExpandoInitializer(symbol.valueDeclaration);
- if (container) {
- var tag = ts.getJSDocTypeTag(container);
- if (tag && tag.typeExpression) {
- return getTypeFromTypeNode(tag.typeExpression);
+ function resolveEntityNameFromAssignmentDeclaration(name, meaning) {
+ if (isJSDocTypeReference(name.parent)) {
+ var secondaryLocation = getAssignmentDeclarationLocation(name.parent);
+ if (secondaryLocation) {
+ return resolveName(secondaryLocation, name.escapedText, meaning, undefined, name, true);
}
- var containerObjectType = getJSContainerObjectType(symbol.valueDeclaration, symbol, container);
- return containerObjectType || getWidenedLiteralType(checkExpressionCached(container));
}
- var definedInConstructor = false;
- var definedInMethod = false;
- var jsdocType;
- var types;
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var declaration = _a[_i];
- var expression = (ts.isBinaryExpression(declaration) || ts.isCallExpression(declaration)) ? declaration :
- ts.isAccessExpression(declaration) ? ts.isBinaryExpression(declaration.parent) ? declaration.parent : declaration :
- undefined;
- if (!expression) {
- continue;
- }
- var kind = ts.isAccessExpression(expression)
- ? ts.getAssignmentDeclarationPropertyAccessKind(expression)
- : ts.getAssignmentDeclarationKind(expression);
- if (kind === 4) {
- if (isDeclarationInConstructor(expression)) {
- definedInConstructor = true;
- }
- else {
- definedInMethod = true;
- }
- }
- if (!ts.isCallExpression(expression)) {
- jsdocType = getAnnotatedTypeForAssignmentDeclaration(jsdocType, expression, symbol, declaration);
- }
- if (!jsdocType) {
- (types || (types = [])).push((ts.isBinaryExpression(expression) || ts.isCallExpression(expression)) ? getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) : neverType);
- }
+ }
+ function getAssignmentDeclarationLocation(node) {
+ var typeAlias = ts.findAncestor(node, function (node) { return !(ts.isJSDocNode(node) || node.flags & 4194304) ? "quit" : ts.isJSDocTypeAlias(node); });
+ if (typeAlias) {
+ return;
}
- var type = jsdocType;
- if (!type) {
- if (!ts.length(types)) {
- return errorType;
+ var host = ts.getJSDocHost(node);
+ if (ts.isExpressionStatement(host) &&
+ ts.isBinaryExpression(host.expression) &&
+ ts.getAssignmentDeclarationKind(host.expression) === 3) {
+ var symbol = getSymbolOfNode(host.expression.left);
+ if (symbol) {
+ return getDeclarationOfJSPrototypeContainer(symbol);
}
- var constructorTypes = definedInConstructor ? getConstructorDefinedThisAssignmentTypes(types, symbol.declarations) : undefined;
- if (definedInMethod) {
- var propType = getTypeOfAssignmentDeclarationPropertyOfBaseType(symbol);
- if (propType) {
- (constructorTypes || (constructorTypes = [])).push(propType);
- definedInConstructor = true;
- }
+ }
+ if ((ts.isObjectLiteralMethod(host) || ts.isPropertyAssignment(host)) &&
+ ts.isBinaryExpression(host.parent.parent) &&
+ ts.getAssignmentDeclarationKind(host.parent.parent) === 6) {
+ var symbol = getSymbolOfNode(host.parent.parent.left);
+ if (symbol) {
+ return getDeclarationOfJSPrototypeContainer(symbol);
}
- var sourceTypes = ts.some(constructorTypes, function (t) { return !!(t.flags & ~98304); }) ? constructorTypes : types;
- type = getUnionType(sourceTypes, 2);
}
- var widened = getWidenedType(addOptionality(type, definedInMethod && !definedInConstructor));
- if (filterType(widened, function (t) { return !!(t.flags & ~98304); }) === neverType) {
- reportImplicitAny(symbol.valueDeclaration, anyType);
- return anyType;
+ var sig = ts.getEffectiveJSDocHost(node);
+ if (sig && ts.isFunctionLike(sig)) {
+ var symbol = getSymbolOfNode(sig);
+ return symbol && symbol.valueDeclaration;
+ }
+ }
+ function getDeclarationOfJSPrototypeContainer(symbol) {
+ var decl = symbol.parent.valueDeclaration;
+ if (!decl) {
+ return undefined;
}
- return widened;
+ var initializer = ts.isAssignmentDeclaration(decl) ? ts.getAssignedExpandoInitializer(decl) :
+ ts.hasOnlyExpressionInitializer(decl) ? ts.getDeclaredExpandoInitializer(decl) :
+ undefined;
+ return initializer || decl;
}
- function getJSContainerObjectType(decl, symbol, init) {
- if (!ts.isInJSFile(decl) || !init || !ts.isObjectLiteralExpression(init) || init.properties.length) {
+ function getExpandoSymbol(symbol) {
+ var decl = symbol.valueDeclaration;
+ if (!decl || !ts.isInJSFile(decl) || symbol.flags & 524288 || ts.getExpandoInitializer(decl, false)) {
return undefined;
}
- var exports = ts.createSymbolTable();
- while (ts.isBinaryExpression(decl) || ts.isPropertyAccessExpression(decl)) {
- var s_2 = getSymbolOfNode(decl);
- if (s_2 && ts.hasEntries(s_2.exports)) {
- mergeSymbolTable(exports, s_2.exports);
+ var init = ts.isVariableDeclaration(decl) ? ts.getDeclaredExpandoInitializer(decl) : ts.getAssignedExpandoInitializer(decl);
+ if (init) {
+ var initSymbol = getSymbolOfNode(init);
+ if (initSymbol) {
+ return mergeJSSymbols(initSymbol, symbol);
}
- decl = ts.isBinaryExpression(decl) ? decl.parent : decl.parent.parent;
- }
- var s = getSymbolOfNode(decl);
- if (s && ts.hasEntries(s.exports)) {
- mergeSymbolTable(exports, s.exports);
}
- var type = createAnonymousType(symbol, exports, ts.emptyArray, ts.emptyArray, undefined, undefined);
- type.objectFlags |= 16384;
- return type;
}
- function getAnnotatedTypeForAssignmentDeclaration(declaredType, expression, symbol, declaration) {
- var typeNode = ts.getEffectiveTypeAnnotationNode(expression.parent);
- if (typeNode) {
- var type = getWidenedType(getTypeFromTypeNode(typeNode));
- if (!declaredType) {
- return type;
+ function resolveExternalModuleName(location, moduleReferenceExpression, ignoreErrors) {
+ var isClassic = ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Classic;
+ var errorMessage = isClassic ?
+ ts.Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option
+ : ts.Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
+ return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? undefined : errorMessage);
+ }
+ function resolveExternalModuleNameWorker(location, moduleReferenceExpression, moduleNotFoundError, isForAugmentation) {
+ if (isForAugmentation === void 0) { isForAugmentation = false; }
+ return ts.isStringLiteralLike(moduleReferenceExpression)
+ ? resolveExternalModule(location, moduleReferenceExpression.text, moduleNotFoundError, moduleReferenceExpression, isForAugmentation)
+ : undefined;
+ }
+ function resolveExternalModule(location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
+ if (isForAugmentation === void 0) { isForAugmentation = false; }
+ if (ts.startsWith(moduleReference, "@types/")) {
+ var diag = ts.Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1;
+ var withoutAtTypePrefix = ts.removePrefix(moduleReference, "@types/");
+ error(errorNode, diag, withoutAtTypePrefix, moduleReference);
+ }
+ var ambientModule = tryFindAmbientModule(moduleReference, true);
+ if (ambientModule) {
+ return ambientModule;
+ }
+ var currentSourceFile = ts.getSourceFileOfNode(location);
+ var resolvedModule = ts.getResolvedModule(currentSourceFile, moduleReference);
+ var resolutionDiagnostic = resolvedModule && ts.getResolutionDiagnostic(compilerOptions, resolvedModule);
+ var sourceFile = resolvedModule && !resolutionDiagnostic && host.getSourceFile(resolvedModule.resolvedFileName);
+ if (sourceFile) {
+ if (sourceFile.symbol) {
+ if (resolvedModule.isExternalLibraryImport && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
+ errorOnImplicitAnyModule(false, errorNode, resolvedModule, moduleReference);
+ }
+ return getMergedSymbol(sourceFile.symbol);
}
- else if (declaredType !== errorType && type !== errorType && !isTypeIdenticalTo(declaredType, type)) {
- errorNextVariableOrPropertyDeclarationMustHaveSameType(undefined, declaredType, declaration, type);
+ if (moduleNotFoundError) {
+ error(errorNode, ts.Diagnostics.File_0_is_not_a_module, sourceFile.fileName);
}
+ return undefined;
}
- if (symbol.parent) {
- var typeNode_2 = ts.getEffectiveTypeAnnotationNode(symbol.parent.valueDeclaration);
- if (typeNode_2) {
- return getTypeOfPropertyOfType(getTypeFromTypeNode(typeNode_2), symbol.escapedName);
+ if (patternAmbientModules) {
+ var pattern = ts.findBestPatternMatch(patternAmbientModules, function (_) { return _.pattern; }, moduleReference);
+ if (pattern) {
+ var augmentation = patternAmbientModuleAugmentations && patternAmbientModuleAugmentations.get(moduleReference);
+ if (augmentation) {
+ return getMergedSymbol(augmentation);
+ }
+ return getMergedSymbol(pattern.symbol);
}
}
- return declaredType;
- }
- function getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) {
- if (ts.isCallExpression(expression)) {
- if (resolvedSymbol) {
- return getTypeOfSymbol(resolvedSymbol);
- }
- var objectLitType = checkExpressionCached(expression.arguments[2]);
- var valueType = getTypeOfPropertyOfType(objectLitType, "value");
- if (valueType) {
- return valueType;
+ if (resolvedModule && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension) && resolutionDiagnostic === undefined || resolutionDiagnostic === ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type) {
+ if (isForAugmentation) {
+ var diag = ts.Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented;
+ error(errorNode, diag, moduleReference, resolvedModule.resolvedFileName);
}
- var getFunc = getTypeOfPropertyOfType(objectLitType, "get");
- if (getFunc) {
- var getSig = getSingleCallSignature(getFunc);
- if (getSig) {
- return getReturnTypeOfSignature(getSig);
- }
+ else {
+ errorOnImplicitAnyModule(noImplicitAny && !!moduleNotFoundError, errorNode, resolvedModule, moduleReference);
}
- var setFunc = getTypeOfPropertyOfType(objectLitType, "set");
- if (setFunc) {
- var setSig = getSingleCallSignature(setFunc);
- if (setSig) {
- return getTypeOfFirstParameterOfSignature(setSig);
+ return undefined;
+ }
+ if (moduleNotFoundError) {
+ if (resolvedModule) {
+ var redirect = host.getProjectReferenceRedirect(resolvedModule.resolvedFileName);
+ if (redirect) {
+ error(errorNode, ts.Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, resolvedModule.resolvedFileName);
+ return undefined;
}
}
- return anyType;
- }
- if (containsSameNamedThisProperty(expression.left, expression.right)) {
- return anyType;
- }
- var type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol) : getWidenedLiteralType(checkExpressionCached(expression.right));
- if (type.flags & 524288 &&
- kind === 2 &&
- symbol.escapedName === "export=") {
- var exportedType = resolveStructuredTypeMembers(type);
- var members_4 = ts.createSymbolTable();
- ts.copyEntries(exportedType.members, members_4);
- if (resolvedSymbol && !resolvedSymbol.exports) {
- resolvedSymbol.exports = ts.createSymbolTable();
+ if (resolutionDiagnostic) {
+ error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName);
}
- (resolvedSymbol || symbol).exports.forEach(function (s, name) {
- var _a;
- var exportedMember = members_4.get(name);
- if (exportedMember && exportedMember !== s) {
- if (s.flags & 111551) {
- if (ts.getSourceFileOfNode(s.valueDeclaration) !== ts.getSourceFileOfNode(exportedMember.valueDeclaration)) {
- var unescapedName = ts.unescapeLeadingUnderscores(s.escapedName);
- var exportedMemberName = ((_a = ts.tryCast(exportedMember.valueDeclaration, ts.isNamedDeclaration)) === null || _a === void 0 ? void 0 : _a.name) || exportedMember.valueDeclaration;
- ts.addRelatedInfo(error(s.valueDeclaration, ts.Diagnostics.Duplicate_identifier_0, unescapedName), ts.createDiagnosticForNode(exportedMemberName, ts.Diagnostics._0_was_also_declared_here, unescapedName));
- ts.addRelatedInfo(error(exportedMemberName, ts.Diagnostics.Duplicate_identifier_0, unescapedName), ts.createDiagnosticForNode(s.valueDeclaration, ts.Diagnostics._0_was_also_declared_here, unescapedName));
- }
- var union = createSymbol(s.flags | exportedMember.flags, name);
- union.type = getUnionType([getTypeOfSymbol(s), getTypeOfSymbol(exportedMember)]);
- union.valueDeclaration = exportedMember.valueDeclaration;
- union.declarations = ts.concatenate(exportedMember.declarations, s.declarations);
- members_4.set(name, union);
- }
- else {
- members_4.set(name, mergeSymbol(s, exportedMember));
- }
+ else {
+ var tsExtension = ts.tryExtractTSExtension(moduleReference);
+ if (tsExtension) {
+ var diag = ts.Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
+ error(errorNode, diag, tsExtension, ts.removeExtension(moduleReference, tsExtension));
+ }
+ else if (!compilerOptions.resolveJsonModule &&
+ ts.fileExtensionIs(moduleReference, ".json") &&
+ ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs &&
+ ts.hasJsonModuleEmitEnabled(compilerOptions)) {
+ error(errorNode, ts.Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
}
else {
- members_4.set(name, s);
+ error(errorNode, moduleNotFoundError, moduleReference);
}
- });
- var result = createAnonymousType(exportedType.symbol, members_4, exportedType.callSignatures, exportedType.constructSignatures, exportedType.stringIndexInfo, exportedType.numberIndexInfo);
- result.objectFlags |= (ts.getObjectFlags(type) & 16384);
- return result;
- }
- if (isEmptyArrayLiteralType(type)) {
- reportImplicitAny(expression, anyArrayType);
- return anyArrayType;
+ }
}
- return type;
- }
- function containsSameNamedThisProperty(thisProperty, expression) {
- return ts.isPropertyAccessExpression(thisProperty)
- && thisProperty.expression.kind === 104
- && ts.forEachChildRecursively(expression, function (n) { return isMatchingReference(thisProperty, n); });
+ return undefined;
}
- function isDeclarationInConstructor(expression) {
- var thisContainer = ts.getThisContainer(expression, false);
- return thisContainer.kind === 162 ||
- thisContainer.kind === 244 ||
- (thisContainer.kind === 201 && !ts.isPrototypePropertyAssignment(thisContainer.parent));
+ function errorOnImplicitAnyModule(isError, errorNode, _a, moduleReference) {
+ var packageId = _a.packageId, resolvedFileName = _a.resolvedFileName;
+ var errorInfo = !ts.isExternalModuleNameRelative(moduleReference) && packageId
+ ? typesPackageExists(packageId.name)
+ ? ts.chainDiagnosticMessages(undefined, ts.Diagnostics.If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1, packageId.name, ts.mangleScopedPackageName(packageId.name))
+ : ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0, moduleReference, ts.mangleScopedPackageName(packageId.name))
+ : undefined;
+ errorOrSuggestion(isError, errorNode, ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type, moduleReference, resolvedFileName));
}
- function getConstructorDefinedThisAssignmentTypes(types, declarations) {
- ts.Debug.assert(types.length === declarations.length);
- return types.filter(function (_, i) {
- var declaration = declarations[i];
- var expression = ts.isBinaryExpression(declaration) ? declaration :
- ts.isBinaryExpression(declaration.parent) ? declaration.parent : undefined;
- return expression && isDeclarationInConstructor(expression);
- });
+ function typesPackageExists(packageName) {
+ return getPackagesSet().has(ts.getTypesPackageName(packageName));
}
- function getTypeOfAssignmentDeclarationPropertyOfBaseType(property) {
- var parentDeclaration = ts.forEach(property.declarations, function (d) {
- var parent = ts.getThisContainer(d, false).parent;
- return ts.isClassLike(parent) && parent;
- });
- if (parentDeclaration) {
- var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(parentDeclaration));
- var baseClassType = classType && getBaseTypes(classType)[0];
- if (baseClassType) {
- return getTypeOfPropertyOfType(baseClassType, property.escapedName);
- }
+ function resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) {
+ if (moduleSymbol === null || moduleSymbol === void 0 ? void 0 : moduleSymbol.exports) {
+ var exportEquals = resolveSymbol(moduleSymbol.exports.get("export="), dontResolveAlias);
+ var exported = getCommonJsExportEquals(getMergedSymbol(exportEquals), getMergedSymbol(moduleSymbol));
+ return getMergedSymbol(exported) || moduleSymbol;
}
+ return undefined;
}
- function getTypeFromBindingElement(element, includePatternInType, reportErrors) {
- if (element.initializer) {
- var contextualType = ts.isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, true, false) : unknownType;
- return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, contextualType)));
+ function getCommonJsExportEquals(exported, moduleSymbol) {
+ if (!exported || exported === unknownSymbol || exported === moduleSymbol || moduleSymbol.exports.size === 1 || exported.flags & 2097152) {
+ return exported;
}
- if (ts.isBindingPattern(element.name)) {
- return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors);
+ var links = getSymbolLinks(exported);
+ if (links.cjsExportMerged) {
+ return links.cjsExportMerged;
}
- if (reportErrors && !declarationBelongsToPrivateAmbientMember(element)) {
- reportImplicitAny(element, anyType);
+ var merged = exported.flags & 33554432 ? exported : cloneSymbol(exported);
+ merged.flags = merged.flags | 512;
+ if (merged.exports === undefined) {
+ merged.exports = ts.createSymbolTable();
}
- return includePatternInType ? nonInferrableAnyType : anyType;
- }
- function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) {
- var members = ts.createSymbolTable();
- var stringIndexInfo;
- var objectFlags = 128 | 1048576;
- ts.forEach(pattern.elements, function (e) {
- var name = e.propertyName || e.name;
- if (e.dotDotDotToken) {
- stringIndexInfo = createIndexInfo(anyType, false);
+ moduleSymbol.exports.forEach(function (s, name) {
+ if (name === "export=")
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 symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias);
+ if (!dontResolveAlias && symbol) {
+ if (!suppressInteropError && !(symbol.flags & (1536 | 3)) && !ts.getDeclarationOfKind(symbol, 297)) {
+ var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015
+ ? "allowSyntheticDefaultImports"
+ : "esModuleInterop";
+ error(referencingLocation, ts.Diagnostics.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, compilerOptionName);
+ return symbol;
}
- var exprType = getLiteralTypeFromPropertyName(name);
- if (!isTypeUsableAsPropertyName(exprType)) {
- objectFlags |= 512;
- return;
+ if (compilerOptions.esModuleInterop) {
+ var referenceParent = referencingLocation.parent;
+ if ((ts.isImportDeclaration(referenceParent) && ts.getNamespaceDeclarationNode(referenceParent)) ||
+ ts.isImportCall(referenceParent)) {
+ var type = getTypeOfSymbol(symbol);
+ var sigs = getSignaturesOfStructuredType(type, 0);
+ if (!sigs || !sigs.length) {
+ sigs = getSignaturesOfStructuredType(type, 1);
+ }
+ if (sigs && sigs.length) {
+ var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol);
+ var result = createSymbol(symbol.flags, symbol.escapedName);
+ result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
+ result.parent = symbol.parent;
+ result.target = symbol;
+ result.originatingImport = referenceParent;
+ if (symbol.valueDeclaration)
+ result.valueDeclaration = symbol.valueDeclaration;
+ if (symbol.constEnumOnlyModule)
+ result.constEnumOnlyModule = true;
+ if (symbol.members)
+ result.members = new ts.Map(symbol.members);
+ if (symbol.exports)
+ result.exports = new ts.Map(symbol.exports);
+ var resolvedModuleType = resolveStructuredTypeMembers(moduleType);
+ result.type = createAnonymousType(result, resolvedModuleType.members, ts.emptyArray, ts.emptyArray, resolvedModuleType.stringIndexInfo, resolvedModuleType.numberIndexInfo);
+ return result;
+ }
+ }
}
- var text = getPropertyNameFromType(exprType);
- var flags = 4 | (e.initializer ? 16777216 : 0);
- var symbol = createSymbol(flags, text);
- symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors);
- symbol.bindingElement = e;
- members.set(symbol.escapedName, symbol);
- });
- var result = createAnonymousType(undefined, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, undefined);
- result.objectFlags |= objectFlags;
- if (includePatternInType) {
- result.pattern = pattern;
- result.objectFlags |= 1048576;
}
- return result;
+ return symbol;
}
- function getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors) {
- var elements = pattern.elements;
- var lastElement = ts.lastOrUndefined(elements);
- var hasRestElement = !!(lastElement && lastElement.kind === 191 && lastElement.dotDotDotToken);
- if (elements.length === 0 || elements.length === 1 && hasRestElement) {
- return languageVersion >= 2 ? createIterableType(anyType) : anyArrayType;
- }
- var elementTypes = ts.map(elements, function (e) { return ts.isOmittedExpression(e) ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors); });
- var minLength = ts.findLastIndex(elements, function (e) { return !ts.isOmittedExpression(e) && !hasDefaultValue(e); }, elements.length - (hasRestElement ? 2 : 1)) + 1;
- var result = createTupleType(elementTypes, minLength, hasRestElement);
- if (includePatternInType) {
- result = cloneTypeReference(result);
- result.pattern = pattern;
- result.objectFlags |= 1048576;
- }
- return result;
+ function hasExportAssignmentSymbol(moduleSymbol) {
+ return moduleSymbol.exports.get("export=") !== undefined;
}
- function getTypeFromBindingPattern(pattern, includePatternInType, reportErrors) {
- if (includePatternInType === void 0) { includePatternInType = false; }
- if (reportErrors === void 0) { reportErrors = false; }
- return pattern.kind === 189
- ? getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors)
- : getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors);
+ function getExportsOfModuleAsArray(moduleSymbol) {
+ return symbolsToArray(getExportsOfModule(moduleSymbol));
}
- function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) {
- return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, true), declaration, reportErrors);
+ function getExportsAndPropertiesOfModule(moduleSymbol) {
+ var exports = getExportsOfModuleAsArray(moduleSymbol);
+ var exportEquals = resolveExternalModuleSymbol(moduleSymbol);
+ if (exportEquals !== moduleSymbol) {
+ ts.addRange(exports, getPropertiesOfType(getTypeOfSymbol(exportEquals)));
+ }
+ return exports;
}
- function widenTypeForVariableLikeDeclaration(type, declaration, reportErrors) {
- if (type) {
- if (reportErrors) {
- reportErrorsFromWidening(declaration, type);
- }
- if (type.flags & 8192 && (ts.isBindingElement(declaration) || !declaration.type) && type.symbol !== getSymbolOfNode(declaration)) {
- type = esSymbolType;
- }
- return getWidenedType(type);
+ function tryGetMemberInModuleExports(memberName, moduleSymbol) {
+ var symbolTable = getExportsOfModule(moduleSymbol);
+ if (symbolTable) {
+ return symbolTable.get(memberName);
}
- type = ts.isParameter(declaration) && declaration.dotDotDotToken ? anyArrayType : anyType;
- if (reportErrors) {
- if (!declarationBelongsToPrivateAmbientMember(declaration)) {
- reportImplicitAny(declaration, type);
- }
+ }
+ function tryGetMemberInModuleExportsAndProperties(memberName, moduleSymbol) {
+ var symbol = tryGetMemberInModuleExports(memberName, moduleSymbol);
+ if (symbol) {
+ return symbol;
}
- return type;
+ var exportEquals = resolveExternalModuleSymbol(moduleSymbol);
+ if (exportEquals === moduleSymbol) {
+ return undefined;
+ }
+ var type = getTypeOfSymbol(exportEquals);
+ return type.flags & 131068 ||
+ ts.getObjectFlags(type) & 1 ||
+ isArrayOrTupleLikeType(type)
+ ? undefined
+ : getPropertyOfType(type, memberName);
}
- function declarationBelongsToPrivateAmbientMember(declaration) {
- var root = ts.getRootDeclaration(declaration);
- var memberDeclaration = root.kind === 156 ? root.parent : root;
- return isPrivateWithinAmbient(memberDeclaration);
+ function getExportsOfSymbol(symbol) {
+ return symbol.flags & 6256 ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedExports") :
+ symbol.flags & 1536 ? getExportsOfModule(symbol) :
+ symbol.exports || emptySymbols;
}
- function tryGetTypeFromEffectiveTypeNode(declaration) {
- var typeNode = ts.getEffectiveTypeAnnotationNode(declaration);
- if (typeNode) {
- return getTypeFromTypeNode(typeNode);
- }
+ function getExportsOfModule(moduleSymbol) {
+ var links = getSymbolLinks(moduleSymbol);
+ return links.resolvedExports || (links.resolvedExports = getExportsOfModuleWorker(moduleSymbol));
}
- function getTypeOfVariableOrParameterOrProperty(symbol) {
- var links = getSymbolLinks(symbol);
- if (!links.type) {
- var type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
- if (!links.type) {
- links.type = type;
+ function extendExportSymbols(target, source, lookupTable, exportNode) {
+ if (!source)
+ return;
+ source.forEach(function (sourceSymbol, id) {
+ if (id === "default")
+ return;
+ var targetSymbol = target.get(id);
+ if (!targetSymbol) {
+ target.set(id, sourceSymbol);
+ if (lookupTable && exportNode) {
+ lookupTable.set(id, {
+ specifierText: ts.getTextOfNode(exportNode.moduleSpecifier)
+ });
+ }
}
- }
- return links.type;
+ else if (lookupTable && exportNode && targetSymbol && resolveSymbol(targetSymbol) !== resolveSymbol(sourceSymbol)) {
+ var collisionTracker = lookupTable.get(id);
+ if (!collisionTracker.exportsWithDuplicate) {
+ collisionTracker.exportsWithDuplicate = [exportNode];
+ }
+ else {
+ collisionTracker.exportsWithDuplicate.push(exportNode);
+ }
+ }
+ });
}
- function getTypeOfVariableOrParameterOrPropertyWorker(symbol) {
- if (symbol.flags & 4194304) {
- return getTypeOfPrototypeProperty(symbol);
- }
- if (symbol === requireSymbol) {
- return anyType;
- }
- if (symbol.flags & 134217728) {
- var fileSymbol = getSymbolOfNode(ts.getSourceFileOfNode(symbol.valueDeclaration));
- var members = ts.createSymbolTable();
- members.set("exports", fileSymbol);
- return createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, undefined, undefined);
- }
- var declaration = symbol.valueDeclaration;
- if (ts.isCatchClauseVariableDeclarationOrBindingElement(declaration)) {
- return anyType;
- }
- if (ts.isSourceFile(declaration) && ts.isJsonSourceFile(declaration)) {
- if (!declaration.statements.length) {
- return emptyObjectType;
+ function getExportsOfModuleWorker(moduleSymbol) {
+ var visitedSymbols = [];
+ moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
+ return visit(moduleSymbol) || emptySymbols;
+ function visit(symbol) {
+ if (!(symbol && symbol.exports && ts.pushIfUnique(visitedSymbols, symbol))) {
+ return;
}
- return getWidenedType(getWidenedLiteralType(checkExpression(declaration.statements[0].expression)));
- }
- if (!pushTypeResolution(symbol, 0)) {
- if (symbol.flags & 512 && !(symbol.flags & 67108864)) {
- return getTypeOfFuncClassEnumModule(symbol);
+ var symbols = new ts.Map(symbol.exports);
+ var exportStars = symbol.exports.get("__export");
+ if (exportStars) {
+ var nestedSymbols = ts.createSymbolTable();
+ var lookupTable_1 = new ts.Map();
+ for (var _i = 0, _a = exportStars.declarations; _i < _a.length; _i++) {
+ var node = _a[_i];
+ var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
+ var exportedSymbols = visit(resolvedModule);
+ extendExportSymbols(nestedSymbols, exportedSymbols, lookupTable_1, node);
+ }
+ lookupTable_1.forEach(function (_a, id) {
+ var exportsWithDuplicate = _a.exportsWithDuplicate;
+ if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || symbols.has(id)) {
+ return;
+ }
+ for (var _i = 0, exportsWithDuplicate_1 = exportsWithDuplicate; _i < exportsWithDuplicate_1.length; _i++) {
+ var node = exportsWithDuplicate_1[_i];
+ diagnostics.add(ts.createDiagnosticForNode(node, ts.Diagnostics.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity, lookupTable_1.get(id).specifierText, ts.unescapeLeadingUnderscores(id)));
+ }
+ });
+ extendExportSymbols(symbols, nestedSymbols);
}
- return reportCircularityError(symbol);
- }
- var type;
- if (declaration.kind === 259) {
- type = widenTypeForVariableLikeDeclaration(checkExpressionCached(declaration.expression), declaration);
+ return symbols;
}
- else if (ts.isBinaryExpression(declaration) ||
- (ts.isInJSFile(declaration) &&
- (ts.isCallExpression(declaration) || (ts.isPropertyAccessExpression(declaration) || ts.isBindableStaticElementAccessExpression(declaration)) && ts.isBinaryExpression(declaration.parent)))) {
- type = getWidenedTypeForAssignmentDeclaration(symbol);
+ }
+ function getMergedSymbol(symbol) {
+ var merged;
+ return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol;
+ }
+ function getSymbolOfNode(node) {
+ return getMergedSymbol(node.symbol && getLateBoundSymbol(node.symbol));
+ }
+ function getParentOfSymbol(symbol) {
+ return getMergedSymbol(symbol.parent && getLateBoundSymbol(symbol.parent));
+ }
+ function getAlternativeContainingModules(symbol, enclosingDeclaration) {
+ var containingFile = ts.getSourceFileOfNode(enclosingDeclaration);
+ var id = getNodeId(containingFile);
+ var links = getSymbolLinks(symbol);
+ var results;
+ if (links.extendedContainersByFile && (results = links.extendedContainersByFile.get(id))) {
+ return results;
}
- else if (ts.isJSDocPropertyLikeTag(declaration)
- || ts.isPropertyAccessExpression(declaration)
- || ts.isElementAccessExpression(declaration)
- || ts.isIdentifier(declaration)
- || ts.isStringLiteralLike(declaration)
- || ts.isNumericLiteral(declaration)
- || ts.isClassDeclaration(declaration)
- || ts.isFunctionDeclaration(declaration)
- || (ts.isMethodDeclaration(declaration) && !ts.isObjectLiteralMethod(declaration))
- || ts.isMethodSignature(declaration)
- || ts.isSourceFile(declaration)) {
- if (symbol.flags & (16 | 8192 | 32 | 384 | 512)) {
- return getTypeOfFuncClassEnumModule(symbol);
+ if (containingFile && containingFile.imports) {
+ for (var _i = 0, _a = containingFile.imports; _i < _a.length; _i++) {
+ var importRef = _a[_i];
+ if (ts.nodeIsSynthesized(importRef))
+ continue;
+ var resolvedModule = resolveExternalModuleName(enclosingDeclaration, importRef, true);
+ if (!resolvedModule)
+ continue;
+ var ref = getAliasForSymbolInContainer(resolvedModule, symbol);
+ if (!ref)
+ continue;
+ results = ts.append(results, resolvedModule);
+ }
+ if (ts.length(results)) {
+ (links.extendedContainersByFile || (links.extendedContainersByFile = new ts.Map())).set(id, results);
+ return results;
}
- type = ts.isBinaryExpression(declaration.parent) ?
- getWidenedTypeForAssignmentDeclaration(symbol) :
- tryGetTypeFromEffectiveTypeNode(declaration) || anyType;
}
- else if (ts.isPropertyAssignment(declaration)) {
- type = tryGetTypeFromEffectiveTypeNode(declaration) || checkPropertyAssignment(declaration);
+ if (links.extendedContainers) {
+ return links.extendedContainers;
}
- else if (ts.isJsxAttribute(declaration)) {
- type = tryGetTypeFromEffectiveTypeNode(declaration) || checkJsxAttribute(declaration);
+ var otherFiles = host.getSourceFiles();
+ for (var _b = 0, otherFiles_1 = otherFiles; _b < otherFiles_1.length; _b++) {
+ var file = otherFiles_1[_b];
+ if (!ts.isExternalModule(file))
+ continue;
+ var sym = getSymbolOfNode(file);
+ var ref = getAliasForSymbolInContainer(sym, symbol);
+ if (!ref)
+ continue;
+ results = ts.append(results, sym);
}
- else if (ts.isShorthandPropertyAssignment(declaration)) {
- type = tryGetTypeFromEffectiveTypeNode(declaration) || checkExpressionForMutableLocation(declaration.name, 0);
+ return links.extendedContainers = results || ts.emptyArray;
+ }
+ function getContainersOfSymbol(symbol, enclosingDeclaration, meaning) {
+ var container = getParentOfSymbol(symbol);
+ if (container && !(symbol.flags & 262144)) {
+ var additionalContainers = ts.mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
+ var reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
+ var objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container, meaning);
+ if (enclosingDeclaration && getAccessibleSymbolChain(container, enclosingDeclaration, 1920, false)) {
+ return ts.append(ts.concatenate(ts.concatenate([container], additionalContainers), reexportContainers), objectLiteralContainer);
+ }
+ var res = ts.append(ts.append(additionalContainers, container), objectLiteralContainer);
+ return ts.concatenate(res, reexportContainers);
}
- else if (ts.isObjectLiteralMethod(declaration)) {
- type = tryGetTypeFromEffectiveTypeNode(declaration) || checkObjectLiteralMethod(declaration, 0);
+ var candidates = ts.mapDefined(symbol.declarations, function (d) {
+ if (!ts.isAmbientModule(d) && d.parent && hasNonGlobalAugmentationExternalModuleSymbol(d.parent)) {
+ return getSymbolOfNode(d.parent);
+ }
+ if (ts.isClassExpression(d) && ts.isBinaryExpression(d.parent) && d.parent.operatorToken.kind === 62 && ts.isAccessExpression(d.parent.left) && ts.isEntityNameExpression(d.parent.left.expression)) {
+ if (ts.isModuleExportsAccessExpression(d.parent.left) || ts.isExportsIdentifier(d.parent.left.expression)) {
+ return getSymbolOfNode(ts.getSourceFileOfNode(d));
+ }
+ checkExpressionCached(d.parent.left.expression);
+ return getNodeLinks(d.parent.left.expression).resolvedSymbol;
+ }
+ });
+ if (!ts.length(candidates)) {
+ return undefined;
}
- else if (ts.isParameter(declaration)
- || ts.isPropertyDeclaration(declaration)
- || ts.isPropertySignature(declaration)
- || ts.isVariableDeclaration(declaration)
- || ts.isBindingElement(declaration)) {
- type = getWidenedTypeForVariableLikeDeclaration(declaration, true);
+ return ts.mapDefined(candidates, function (candidate) { return getAliasForSymbolInContainer(candidate, symbol) ? candidate : undefined; });
+ function fileSymbolIfFileSymbolExportEqualsContainer(d) {
+ return container && getFileSymbolIfFileSymbolExportEqualsContainer(d, container);
}
- else if (ts.isEnumDeclaration(declaration)) {
- type = getTypeOfFuncClassEnumModule(symbol);
+ }
+ function getVariableDeclarationOfObjectLiteral(symbol, meaning) {
+ var firstDecl = !!ts.length(symbol.declarations) && ts.first(symbol.declarations);
+ if (meaning & 111551 && firstDecl && firstDecl.parent && ts.isVariableDeclaration(firstDecl.parent)) {
+ if (ts.isObjectLiteralExpression(firstDecl) && firstDecl === firstDecl.parent.initializer || ts.isTypeLiteralNode(firstDecl) && firstDecl === firstDecl.parent.type) {
+ return getSymbolOfNode(firstDecl.parent);
+ }
}
- else if (ts.isEnumMember(declaration)) {
- type = getTypeOfEnumMember(symbol);
+ }
+ function getFileSymbolIfFileSymbolExportEqualsContainer(d, container) {
+ var fileSymbol = getExternalModuleContainer(d);
+ var exported = fileSymbol && fileSymbol.exports && fileSymbol.exports.get("export=");
+ return exported && getSymbolIfSameReference(exported, container) ? fileSymbol : undefined;
+ }
+ function getAliasForSymbolInContainer(container, symbol) {
+ if (container === getParentOfSymbol(symbol)) {
+ return symbol;
}
- else if (ts.isAccessor(declaration)) {
- type = resolveTypeOfAccessors(symbol);
+ var exportEquals = container.exports && container.exports.get("export=");
+ if (exportEquals && getSymbolIfSameReference(exportEquals, symbol)) {
+ return container;
}
- else {
- return ts.Debug.fail("Unhandled declaration kind! " + ts.Debug.formatSyntaxKind(declaration.kind) + " for " + ts.Debug.formatSymbol(symbol));
+ var exports = getExportsOfSymbol(container);
+ var quick = exports.get(symbol.escapedName);
+ if (quick && getSymbolIfSameReference(quick, symbol)) {
+ return quick;
}
- if (!popTypeResolution()) {
- if (symbol.flags & 512 && !(symbol.flags & 67108864)) {
- return getTypeOfFuncClassEnumModule(symbol);
+ return ts.forEachEntry(exports, function (exported) {
+ if (getSymbolIfSameReference(exported, symbol)) {
+ return exported;
}
- return reportCircularityError(symbol);
+ });
+ }
+ function getSymbolIfSameReference(s1, s2) {
+ if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
+ return s1;
}
- return type;
}
- function getAnnotatedAccessorTypeNode(accessor) {
- if (accessor) {
- if (accessor.kind === 163) {
- var getterTypeAnnotation = ts.getEffectiveReturnTypeNode(accessor);
- return getterTypeAnnotation;
- }
- else {
- var setterTypeAnnotation = ts.getEffectiveSetAccessorTypeAnnotationNode(accessor);
- return setterTypeAnnotation;
+ function getExportSymbolOfValueSymbolIfExported(symbol) {
+ return getMergedSymbol(symbol && (symbol.flags & 1048576) !== 0 ? symbol.exportSymbol : symbol);
+ }
+ function symbolIsValue(symbol) {
+ return !!(symbol.flags & 111551 || symbol.flags & 2097152 && resolveAlias(symbol).flags & 111551 && !getTypeOnlyAliasDeclaration(symbol));
+ }
+ function findConstructorDeclaration(node) {
+ var members = node.members;
+ for (var _i = 0, members_3 = members; _i < members_3.length; _i++) {
+ var member = members_3[_i];
+ if (member.kind === 166 && ts.nodeIsPresent(member.body)) {
+ return member;
}
}
- return undefined;
}
- function getAnnotatedAccessorType(accessor) {
- var node = getAnnotatedAccessorTypeNode(accessor);
- return node && getTypeFromTypeNode(node);
+ function createType(flags) {
+ var result = new Type(checker, flags);
+ typeCount++;
+ result.id = typeCount;
+ typeCatalog.push(result);
+ return result;
}
- function getAnnotatedAccessorThisParameter(accessor) {
- var parameter = getAccessorThisParameter(accessor);
- return parameter && parameter.symbol;
+ function createIntrinsicType(kind, intrinsicName, objectFlags) {
+ if (objectFlags === void 0) { objectFlags = 0; }
+ var type = createType(kind);
+ type.intrinsicName = intrinsicName;
+ type.objectFlags = objectFlags;
+ return type;
}
- function getThisTypeOfDeclaration(declaration) {
- return getThisTypeOfSignature(getSignatureFromDeclaration(declaration));
+ function createBooleanType(trueFalseTypes) {
+ var type = getUnionType(trueFalseTypes);
+ type.flags |= 16;
+ type.intrinsicName = "boolean";
+ return type;
}
- function getTypeOfAccessors(symbol) {
- var links = getSymbolLinks(symbol);
- return links.type || (links.type = getTypeOfAccessorsWorker(symbol));
+ function createObjectType(objectFlags, symbol) {
+ var type = createType(524288);
+ type.objectFlags = objectFlags;
+ type.symbol = symbol;
+ type.members = undefined;
+ type.properties = undefined;
+ type.callSignatures = undefined;
+ type.constructSignatures = undefined;
+ type.stringIndexInfo = undefined;
+ type.numberIndexInfo = undefined;
+ return type;
}
- function getTypeOfAccessorsWorker(symbol) {
- if (!pushTypeResolution(symbol, 0)) {
- return errorType;
- }
- var type = resolveTypeOfAccessors(symbol);
- if (!popTypeResolution()) {
- type = anyType;
- if (noImplicitAny) {
- var getter = ts.getDeclarationOfKind(symbol, 163);
- error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
+ function createTypeofType() {
+ return getUnionType(ts.arrayFrom(typeofEQFacts.keys(), getLiteralType));
+ }
+ function createTypeParameter(symbol) {
+ var type = createType(262144);
+ if (symbol)
+ type.symbol = symbol;
+ return type;
+ }
+ function isReservedMemberName(name) {
+ return name.charCodeAt(0) === 95 &&
+ name.charCodeAt(1) === 95 &&
+ name.charCodeAt(2) !== 95 &&
+ name.charCodeAt(2) !== 64 &&
+ name.charCodeAt(2) !== 35;
+ }
+ function getNamedMembers(members) {
+ var result;
+ members.forEach(function (symbol, id) {
+ if (!isReservedMemberName(id) && symbolIsValue(symbol)) {
+ (result || (result = [])).push(symbol);
}
- }
+ });
+ return result || ts.emptyArray;
+ }
+ function setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) {
+ type.members = members;
+ type.properties = members === emptySymbols ? ts.emptyArray : getNamedMembers(members);
+ type.callSignatures = callSignatures;
+ type.constructSignatures = constructSignatures;
+ type.stringIndexInfo = stringIndexInfo;
+ type.numberIndexInfo = numberIndexInfo;
return type;
}
- function resolveTypeOfAccessors(symbol) {
- var getter = ts.getDeclarationOfKind(symbol, 163);
- var setter = ts.getDeclarationOfKind(symbol, 164);
- if (getter && ts.isInJSFile(getter)) {
- var jsDocType = getTypeForDeclarationFromJSDocComment(getter);
- if (jsDocType) {
- return jsDocType;
+ function createAnonymousType(symbol, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo) {
+ return setStructuredTypeMembers(createObjectType(16, symbol), members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+ }
+ function forEachSymbolTableInScope(enclosingDeclaration, callback) {
+ var result;
+ var _loop_8 = function (location) {
+ if (location.locals && !isGlobalSourceFile(location)) {
+ if (result = callback(location.locals)) {
+ return { value: result };
+ }
+ }
+ switch (location.kind) {
+ case 297:
+ if (!ts.isExternalOrCommonJsModule(location)) {
+ break;
+ }
+ case 256:
+ var sym = getSymbolOfNode(location);
+ if (result = callback((sym === null || sym === void 0 ? void 0 : sym.exports) || emptySymbols)) {
+ return { value: result };
+ }
+ break;
+ case 252:
+ case 221:
+ case 253:
+ var table_1;
+ (getSymbolOfNode(location).members || emptySymbols).forEach(function (memberSymbol, key) {
+ if (memberSymbol.flags & (788968 & ~67108864)) {
+ (table_1 || (table_1 = ts.createSymbolTable())).set(key, memberSymbol);
+ }
+ });
+ if (table_1 && (result = callback(table_1))) {
+ return { value: result };
+ }
+ break;
}
+ };
+ for (var location = enclosingDeclaration; location; location = location.parent) {
+ var state_2 = _loop_8(location);
+ if (typeof state_2 === "object")
+ return state_2.value;
}
- var getterReturnType = getAnnotatedAccessorType(getter);
- if (getterReturnType) {
- return getterReturnType;
+ return callback(globals);
+ }
+ function getQualifiedLeftMeaning(rightMeaning) {
+ return rightMeaning === 111551 ? 111551 : 1920;
+ }
+ function getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, useOnlyExternalAliasing, visitedSymbolTablesMap) {
+ if (visitedSymbolTablesMap === void 0) { visitedSymbolTablesMap = new ts.Map(); }
+ if (!(symbol && !isPropertyOrMethodDeclarationSymbol(symbol))) {
+ return undefined;
}
- else {
- var setterParameterType = getAnnotatedAccessorType(setter);
- if (setterParameterType) {
- return setterParameterType;
+ var id = getSymbolId(symbol);
+ var visitedSymbolTables = visitedSymbolTablesMap.get(id);
+ if (!visitedSymbolTables) {
+ visitedSymbolTablesMap.set(id, visitedSymbolTables = []);
+ }
+ return forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable);
+ function getAccessibleSymbolChainFromSymbolTable(symbols, ignoreQualification) {
+ if (!ts.pushIfUnique(visitedSymbolTables, symbols)) {
+ return undefined;
}
- else {
- if (getter && getter.body) {
- return getReturnTypeFromBody(getter);
- }
- else {
- if (setter) {
- if (!isPrivateWithinAmbient(setter)) {
- errorOrSuggestion(noImplicitAny, setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
- }
+ var result = trySymbolTable(symbols, ignoreQualification);
+ visitedSymbolTables.pop();
+ return result;
+ }
+ function canQualifySymbol(symbolFromSymbolTable, meaning) {
+ return !needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning) ||
+ !!getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing, visitedSymbolTablesMap);
+ }
+ function isAccessible(symbolFromSymbolTable, resolvedAliasSymbol, ignoreQualification) {
+ return (symbol === (resolvedAliasSymbol || symbolFromSymbolTable) || getMergedSymbol(symbol) === getMergedSymbol(resolvedAliasSymbol || symbolFromSymbolTable)) &&
+ !ts.some(symbolFromSymbolTable.declarations, hasNonGlobalAugmentationExternalModuleSymbol) &&
+ (ignoreQualification || canQualifySymbol(getMergedSymbol(symbolFromSymbolTable), meaning));
+ }
+ function trySymbolTable(symbols, ignoreQualification) {
+ if (isAccessible(symbols.get(symbol.escapedName), undefined, ignoreQualification)) {
+ return [symbol];
+ }
+ var result = ts.forEachEntry(symbols, function (symbolFromSymbolTable) {
+ if (symbolFromSymbolTable.flags & 2097152
+ && symbolFromSymbolTable.escapedName !== "export="
+ && symbolFromSymbolTable.escapedName !== "default"
+ && !(ts.isUMDExportSymbol(symbolFromSymbolTable) && enclosingDeclaration && ts.isExternalModule(ts.getSourceFileOfNode(enclosingDeclaration)))
+ && (!useOnlyExternalAliasing || ts.some(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration))
+ && (ignoreQualification || !ts.getDeclarationOfKind(symbolFromSymbolTable, 270))) {
+ var resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
+ var candidate = getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification);
+ if (candidate) {
+ return candidate;
}
- else {
- ts.Debug.assert(!!getter, "there must exist a getter as we are current checking either setter or getter in this function");
- if (!isPrivateWithinAmbient(getter)) {
- errorOrSuggestion(noImplicitAny, getter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
- }
+ }
+ if (symbolFromSymbolTable.escapedName === symbol.escapedName && symbolFromSymbolTable.exportSymbol) {
+ if (isAccessible(getMergedSymbol(symbolFromSymbolTable.exportSymbol), undefined, ignoreQualification)) {
+ return [symbol];
}
- return anyType;
}
+ });
+ return result || (symbols === globals ? getCandidateListForSymbol(globalThisSymbol, globalThisSymbol, ignoreQualification) : undefined);
+ }
+ function getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification) {
+ if (isAccessible(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification)) {
+ return [symbolFromSymbolTable];
+ }
+ var candidateTable = getExportsOfSymbol(resolvedImportedSymbol);
+ var accessibleSymbolsFromExports = candidateTable && getAccessibleSymbolChainFromSymbolTable(candidateTable, true);
+ if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
+ return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
}
}
}
- function getBaseTypeVariableOfClass(symbol) {
- var baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol));
- return baseConstructorType.flags & 8650752 ? baseConstructorType :
- baseConstructorType.flags & 2097152 ? ts.find(baseConstructorType.types, function (t) { return !!(t.flags & 8650752); }) :
- undefined;
+ function needsQualification(symbol, enclosingDeclaration, meaning) {
+ var qualify = false;
+ forEachSymbolTableInScope(enclosingDeclaration, function (symbolTable) {
+ var symbolFromSymbolTable = getMergedSymbol(symbolTable.get(symbol.escapedName));
+ if (!symbolFromSymbolTable) {
+ return false;
+ }
+ if (symbolFromSymbolTable === symbol) {
+ return true;
+ }
+ symbolFromSymbolTable = (symbolFromSymbolTable.flags & 2097152 && !ts.getDeclarationOfKind(symbolFromSymbolTable, 270)) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
+ if (symbolFromSymbolTable.flags & meaning) {
+ qualify = true;
+ return true;
+ }
+ return false;
+ });
+ return qualify;
}
- function getTypeOfFuncClassEnumModule(symbol) {
- var links = getSymbolLinks(symbol);
- var originalLinks = links;
- if (!links.type) {
- var jsDeclaration = symbol.valueDeclaration && ts.getDeclarationOfExpando(symbol.valueDeclaration);
- if (jsDeclaration) {
- var merged = mergeJSSymbols(symbol, getSymbolOfNode(jsDeclaration));
- if (merged) {
- symbol = links = merged;
+ function isPropertyOrMethodDeclarationSymbol(symbol) {
+ if (symbol.declarations && symbol.declarations.length) {
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ switch (declaration.kind) {
+ case 163:
+ case 165:
+ case 167:
+ case 168:
+ continue;
+ default:
+ return false;
}
}
- originalLinks.type = links.type = getTypeOfFuncClassEnumModuleWorker(symbol);
+ return true;
}
- return links.type;
+ return false;
}
- function getTypeOfFuncClassEnumModuleWorker(symbol) {
- var declaration = symbol.valueDeclaration;
- if (symbol.flags & 1536 && ts.isShorthandAmbientModuleSymbol(symbol)) {
- return anyType;
- }
- else if (declaration && (declaration.kind === 209 ||
- ts.isAccessExpression(declaration) &&
- declaration.parent.kind === 209)) {
- return getWidenedTypeForAssignmentDeclaration(symbol);
- }
- else if (symbol.flags & 512 && declaration && ts.isSourceFile(declaration) && declaration.commonJsModuleIndicator) {
- var resolvedModule = resolveExternalModuleSymbol(symbol);
- if (resolvedModule !== symbol) {
- if (!pushTypeResolution(symbol, 0)) {
- return errorType;
+ function isTypeSymbolAccessible(typeSymbol, enclosingDeclaration) {
+ var access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, 788968, false, true);
+ return access.accessibility === 0;
+ }
+ function isValueSymbolAccessible(typeSymbol, enclosingDeclaration) {
+ var access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, 111551, false, true);
+ return access.accessibility === 0;
+ }
+ function isSymbolAccessibleByFlags(typeSymbol, enclosingDeclaration, flags) {
+ var access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, flags, false, false);
+ return access.accessibility === 0;
+ }
+ function isAnySymbolAccessible(symbols, enclosingDeclaration, initialSymbol, meaning, shouldComputeAliasesToMakeVisible, allowModules) {
+ if (!ts.length(symbols))
+ return;
+ var hadAccessibleChain;
+ var earlyModuleBail = false;
+ for (var _i = 0, _a = symbols; _i < _a.length; _i++) {
+ var symbol = _a[_i];
+ var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, false);
+ if (accessibleSymbolChain) {
+ hadAccessibleChain = symbol;
+ var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0], shouldComputeAliasesToMakeVisible);
+ if (hasAccessibleDeclarations) {
+ return hasAccessibleDeclarations;
}
- var exportEquals = getMergedSymbol(symbol.exports.get("export="));
- var type_1 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? undefined : resolvedModule);
- if (!popTypeResolution()) {
- return reportCircularityError(symbol);
+ }
+ else if (allowModules) {
+ if (ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
+ if (shouldComputeAliasesToMakeVisible) {
+ earlyModuleBail = true;
+ continue;
+ }
+ return {
+ accessibility: 0
+ };
}
- return type_1;
+ }
+ var containers = getContainersOfSymbol(symbol, enclosingDeclaration, meaning);
+ var parentResult = isAnySymbolAccessible(containers, enclosingDeclaration, initialSymbol, initialSymbol === symbol ? getQualifiedLeftMeaning(meaning) : meaning, shouldComputeAliasesToMakeVisible, allowModules);
+ if (parentResult) {
+ return parentResult;
}
}
- var type = createObjectType(16, symbol);
- if (symbol.flags & 32) {
- var baseTypeVariable = getBaseTypeVariableOfClass(symbol);
- return baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type;
+ if (earlyModuleBail) {
+ return {
+ accessibility: 0
+ };
}
- else {
- return strictNullChecks && symbol.flags & 16777216 ? getOptionalType(type) : type;
+ if (hadAccessibleChain) {
+ return {
+ accessibility: 1,
+ errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
+ errorModuleName: hadAccessibleChain !== initialSymbol ? symbolToString(hadAccessibleChain, enclosingDeclaration, 1920) : undefined,
+ };
}
}
- function getTypeOfEnumMember(symbol) {
- var links = getSymbolLinks(symbol);
- return links.type || (links.type = getDeclaredTypeOfEnumMember(symbol));
- }
- function getTypeOfAlias(symbol) {
- var links = getSymbolLinks(symbol);
- if (!links.type) {
- var targetSymbol = resolveAlias(symbol);
- links.type = targetSymbol.flags & 111551
- ? getTypeOfSymbol(targetSymbol)
- : errorType;
- }
- return links.type;
+ function isSymbolAccessible(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible) {
+ return isSymbolAccessibleWorker(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible, true);
}
- function getTypeOfInstantiatedSymbol(symbol) {
- var links = getSymbolLinks(symbol);
- if (!links.type) {
- if (!pushTypeResolution(symbol, 0)) {
- return links.type = errorType;
+ function isSymbolAccessibleWorker(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible, allowModules) {
+ if (symbol && enclosingDeclaration) {
+ var result = isAnySymbolAccessible([symbol], enclosingDeclaration, symbol, meaning, shouldComputeAliasesToMakeVisible, allowModules);
+ if (result) {
+ return result;
}
- var type = instantiateType(getTypeOfSymbol(links.target), links.mapper);
- if (!popTypeResolution()) {
- type = reportCircularityError(symbol);
+ var symbolExternalModule = ts.forEach(symbol.declarations, getExternalModuleContainer);
+ if (symbolExternalModule) {
+ var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
+ if (symbolExternalModule !== enclosingExternalModule) {
+ return {
+ accessibility: 2,
+ errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning),
+ errorModuleName: symbolToString(symbolExternalModule)
+ };
+ }
}
- links.type = type;
+ return {
+ accessibility: 1,
+ errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning),
+ };
}
- return links.type;
+ return { accessibility: 0 };
}
- function reportCircularityError(symbol) {
- var declaration = symbol.valueDeclaration;
- if (ts.getEffectiveTypeAnnotationNode(declaration)) {
- error(symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
- return errorType;
+ function getExternalModuleContainer(declaration) {
+ var node = ts.findAncestor(declaration, hasExternalModuleSymbol);
+ return node && getSymbolOfNode(node);
+ }
+ function hasExternalModuleSymbol(declaration) {
+ return ts.isAmbientModule(declaration) || (declaration.kind === 297 && ts.isExternalOrCommonJsModule(declaration));
+ }
+ function hasNonGlobalAugmentationExternalModuleSymbol(declaration) {
+ return ts.isModuleWithStringLiteralName(declaration) || (declaration.kind === 297 && ts.isExternalOrCommonJsModule(declaration));
+ }
+ function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) {
+ var aliasesToMakeVisible;
+ if (!ts.every(ts.filter(symbol.declarations, function (d) { return d.kind !== 78; }), getIsDeclarationVisible)) {
+ return undefined;
}
- if (noImplicitAny && (declaration.kind !== 156 || declaration.initializer)) {
- error(symbol.valueDeclaration, ts.Diagnostics._0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer, symbolToString(symbol));
+ return { accessibility: 0, aliasesToMakeVisible: aliasesToMakeVisible };
+ function getIsDeclarationVisible(declaration) {
+ var _a, _b;
+ if (!isDeclarationVisible(declaration)) {
+ var anyImportSyntax = getAnyImportSyntax(declaration);
+ if (anyImportSyntax &&
+ !ts.hasSyntacticModifier(anyImportSyntax, 1) &&
+ isDeclarationVisible(anyImportSyntax.parent)) {
+ return addVisibleAlias(declaration, anyImportSyntax);
+ }
+ else if (ts.isVariableDeclaration(declaration) && ts.isVariableStatement(declaration.parent.parent) &&
+ !ts.hasSyntacticModifier(declaration.parent.parent, 1) &&
+ isDeclarationVisible(declaration.parent.parent.parent)) {
+ return addVisibleAlias(declaration, declaration.parent.parent);
+ }
+ else if (ts.isLateVisibilityPaintedStatement(declaration)
+ && !ts.hasSyntacticModifier(declaration, 1)
+ && isDeclarationVisible(declaration.parent)) {
+ return addVisibleAlias(declaration, declaration);
+ }
+ else if (symbol.flags & 2097152 && ts.isBindingElement(declaration) && ts.isInJSFile(declaration) && ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.parent)
+ && ts.isVariableDeclaration(declaration.parent.parent)
+ && ((_b = declaration.parent.parent.parent) === null || _b === void 0 ? void 0 : _b.parent) && ts.isVariableStatement(declaration.parent.parent.parent.parent)
+ && !ts.hasSyntacticModifier(declaration.parent.parent.parent.parent, 1)
+ && declaration.parent.parent.parent.parent.parent
+ && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
+ return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
+ }
+ return false;
+ }
+ return true;
}
- return anyType;
- }
- function getTypeOfSymbolWithDeferredType(symbol) {
- var links = getSymbolLinks(symbol);
- if (!links.type) {
- ts.Debug.assertIsDefined(links.deferralParent);
- ts.Debug.assertIsDefined(links.deferralConstituents);
- links.type = links.deferralParent.flags & 1048576 ? getUnionType(links.deferralConstituents) : getIntersectionType(links.deferralConstituents);
+ function addVisibleAlias(declaration, aliasingStatement) {
+ if (shouldComputeAliasToMakeVisible) {
+ getNodeLinks(declaration).isVisible = true;
+ aliasesToMakeVisible = ts.appendIfUnique(aliasesToMakeVisible, aliasingStatement);
+ }
+ return true;
}
- return links.type;
}
- function getTypeOfSymbol(symbol) {
- var checkFlags = ts.getCheckFlags(symbol);
- if (checkFlags & 65536) {
- return getTypeOfSymbolWithDeferredType(symbol);
+ function isEntityNameVisible(entityName, enclosingDeclaration) {
+ var meaning;
+ if (entityName.parent.kind === 176 ||
+ ts.isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent) ||
+ entityName.parent.kind === 158) {
+ meaning = 111551 | 1048576;
}
- if (checkFlags & 1) {
- return getTypeOfInstantiatedSymbol(symbol);
+ else if (entityName.kind === 157 || entityName.kind === 201 ||
+ entityName.parent.kind === 260) {
+ meaning = 1920;
}
- if (checkFlags & 262144) {
- return getTypeOfMappedSymbol(symbol);
+ else {
+ meaning = 788968;
}
- if (checkFlags & 8192) {
- return getTypeOfReverseMappedSymbol(symbol);
+ var firstIdentifier = ts.getFirstIdentifier(entityName);
+ var symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, undefined, undefined, false);
+ if (symbol && symbol.flags & 262144 && meaning & 788968) {
+ return { accessibility: 0 };
}
- if (symbol.flags & (3 | 4)) {
- return getTypeOfVariableOrParameterOrProperty(symbol);
+ return (symbol && hasVisibleDeclarations(symbol, true)) || {
+ accessibility: 1,
+ errorSymbolName: ts.getTextOfNode(firstIdentifier),
+ errorNode: firstIdentifier
+ };
+ }
+ function symbolToString(symbol, enclosingDeclaration, meaning, flags, writer) {
+ if (flags === void 0) { flags = 4; }
+ var nodeFlags = 70221824;
+ if (flags & 2) {
+ nodeFlags |= 128;
}
- if (symbol.flags & (16 | 8192 | 32 | 384 | 512)) {
- return getTypeOfFuncClassEnumModule(symbol);
+ if (flags & 1) {
+ nodeFlags |= 512;
}
- if (symbol.flags & 8) {
- return getTypeOfEnumMember(symbol);
+ if (flags & 8) {
+ nodeFlags |= 16384;
}
- if (symbol.flags & 98304) {
- return getTypeOfAccessors(symbol);
+ if (flags & 16) {
+ nodeFlags |= 134217728;
}
- if (symbol.flags & 2097152) {
- return getTypeOfAlias(symbol);
+ var builder = flags & 4 ? nodeBuilder.symbolToExpression : nodeBuilder.symbolToEntityName;
+ return writer ? symbolToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(symbolToStringWorker);
+ function symbolToStringWorker(writer) {
+ var entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags);
+ var printer = (enclosingDeclaration === null || enclosingDeclaration === void 0 ? void 0 : enclosingDeclaration.kind) === 297 ? ts.createPrinter({ removeComments: true, neverAsciiEscape: true }) : ts.createPrinter({ removeComments: true });
+ var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
+ printer.writeNode(4, entity, sourceFile, writer);
+ return writer;
}
- return errorType;
- }
- function isReferenceToType(type, target) {
- return type !== undefined
- && target !== undefined
- && (ts.getObjectFlags(type) & 4) !== 0
- && type.target === target;
- }
- function getTargetType(type) {
- return ts.getObjectFlags(type) & 4 ? type.target : type;
}
- function hasBaseType(type, checkBase) {
- return check(type);
- function check(type) {
- if (ts.getObjectFlags(type) & (3 | 4)) {
- var target = getTargetType(type);
- return target === checkBase || ts.some(getBaseTypes(target), check);
+ function signatureToString(signature, enclosingDeclaration, flags, kind, writer) {
+ if (flags === void 0) { flags = 0; }
+ return writer ? signatureToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(signatureToStringWorker);
+ function signatureToStringWorker(writer) {
+ var sigOutput;
+ if (flags & 262144) {
+ sigOutput = kind === 1 ? 175 : 174;
}
- else if (type.flags & 2097152) {
- return ts.some(type.types, check);
+ else {
+ sigOutput = kind === 1 ? 170 : 169;
}
- return false;
+ var sig = nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | 512);
+ var printer = ts.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+ var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
+ printer.writeNode(4, sig, sourceFile, ts.getTrailingSemicolonDeferringWriter(writer));
+ return writer;
}
}
- function appendTypeParameters(typeParameters, declarations) {
- for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) {
- var declaration = declarations_2[_i];
- typeParameters = ts.appendIfUnique(typeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration)));
+ function typeToString(type, enclosingDeclaration, flags, writer) {
+ if (flags === void 0) { flags = 1048576 | 16384; }
+ if (writer === void 0) { writer = ts.createTextWriter(""); }
+ var noTruncation = compilerOptions.noErrorTruncation || flags & 1;
+ var typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | (noTruncation ? 1 : 0), writer);
+ if (typeNode === undefined)
+ return ts.Debug.fail("should always get typenode");
+ var options = { removeComments: true };
+ var printer = ts.createPrinter(options);
+ var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
+ printer.writeNode(4, typeNode, sourceFile, writer);
+ var result = writer.getText();
+ var maxLength = noTruncation ? ts.noTruncationMaximumTruncationLength * 2 : ts.defaultMaximumTruncationLength * 2;
+ if (maxLength && result && result.length >= maxLength) {
+ return result.substr(0, maxLength - "...".length) + "...";
}
- return typeParameters;
+ return result;
}
- function getOuterTypeParameters(node, includeThisTypes) {
- while (true) {
- node = node.parent;
- if (node && ts.isBinaryExpression(node)) {
- var assignmentKind = ts.getAssignmentDeclarationKind(node);
- if (assignmentKind === 6 || assignmentKind === 3) {
- var symbol = getSymbolOfNode(node.left);
- if (symbol && symbol.parent && !ts.findAncestor(symbol.parent.valueDeclaration, function (d) { return node === d; })) {
- node = symbol.parent.valueDeclaration;
- }
- }
- }
- if (!node) {
- return undefined;
- }
- switch (node.kind) {
- case 225:
- case 245:
- case 214:
- case 246:
- case 165:
- case 166:
- case 160:
- case 170:
- case 171:
- case 300:
- case 244:
- case 161:
- case 201:
- case 202:
- case 247:
- case 321:
- case 322:
- case 316:
- case 315:
- case 186:
- case 180:
- var outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
- if (node.kind === 186) {
- return ts.append(outerTypeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter)));
- }
- else if (node.kind === 180) {
- return ts.concatenate(outerTypeParameters, getInferTypeParameters(node));
- }
- else if (node.kind === 225 && !ts.isInJSFile(node)) {
- break;
- }
- var outerAndOwnTypeParameters = appendTypeParameters(outerTypeParameters, ts.getEffectiveTypeParameterDeclarations(node));
- var thisType = includeThisTypes &&
- (node.kind === 245 || node.kind === 214 || node.kind === 246 || isJSConstructor(node)) &&
- getDeclaredTypeOfClassOrInterface(getSymbolOfNode(node)).thisType;
- return thisType ? ts.append(outerAndOwnTypeParameters, thisType) : outerAndOwnTypeParameters;
- }
+ function getTypeNamesForErrorDisplay(left, right) {
+ var leftStr = symbolValueDeclarationIsContextSensitive(left.symbol) ? typeToString(left, left.symbol.valueDeclaration) : typeToString(left);
+ var rightStr = symbolValueDeclarationIsContextSensitive(right.symbol) ? typeToString(right, right.symbol.valueDeclaration) : typeToString(right);
+ if (leftStr === rightStr) {
+ leftStr = getTypeNameForErrorDisplay(left);
+ rightStr = getTypeNameForErrorDisplay(right);
}
+ return [leftStr, rightStr];
}
- function getOuterTypeParametersOfClassOrInterface(symbol) {
- var declaration = symbol.flags & 32 ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 246);
- ts.Debug.assert(!!declaration, "Class was missing valueDeclaration -OR- non-class had no interface declarations");
- return getOuterTypeParameters(declaration);
+ function getTypeNameForErrorDisplay(type) {
+ return typeToString(type, undefined, 64);
}
- function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) {
- var result;
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var node = _a[_i];
- if (node.kind === 246 ||
- node.kind === 245 ||
- node.kind === 214 ||
- isJSConstructor(node) ||
- ts.isTypeAlias(node)) {
- var declaration = node;
- result = appendTypeParameters(result, ts.getEffectiveTypeParameterDeclarations(declaration));
- }
- }
- return result;
+ function symbolValueDeclarationIsContextSensitive(symbol) {
+ return symbol && symbol.valueDeclaration && ts.isExpression(symbol.valueDeclaration) && !isContextSensitive(symbol.valueDeclaration);
}
- function getTypeParametersOfClassOrInterface(symbol) {
- return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol));
+ function toNodeBuilderFlags(flags) {
+ if (flags === void 0) { flags = 0; }
+ return flags & 814775659;
}
- function isMixinConstructorType(type) {
- var signatures = getSignaturesOfType(type, 1);
- if (signatures.length === 1) {
- var s = signatures[0];
- return !s.typeParameters && s.parameters.length === 1 && signatureHasRestParameter(s) && getElementTypeOfArrayType(getTypeOfParameter(s.parameters[0])) === anyType;
- }
- return false;
+ function isClassInstanceSide(type) {
+ return !!type.symbol && !!(type.symbol.flags & 32) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || !!(ts.getObjectFlags(type) & 1073741824));
}
- function isConstructorType(type) {
- if (getSignaturesOfType(type, 1).length > 0) {
- return true;
+ function createNodeBuilder() {
+ return {
+ typeToTypeNode: function (type, enclosingDeclaration, flags, tracker) {
+ return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeToTypeNodeHelper(type, context); });
+ },
+ indexInfoToIndexSignatureDeclaration: function (indexInfo, kind, enclosingDeclaration, flags, tracker) {
+ return withContext(enclosingDeclaration, flags, tracker, function (context) { return indexInfoToIndexSignatureDeclarationHelper(indexInfo, kind, context, undefined); });
+ },
+ signatureToSignatureDeclaration: function (signature, kind, enclosingDeclaration, flags, tracker) {
+ return withContext(enclosingDeclaration, flags, tracker, function (context) { return signatureToSignatureDeclarationHelper(signature, kind, context); });
+ },
+ symbolToEntityName: function (symbol, meaning, enclosingDeclaration, flags, tracker) {
+ return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToName(symbol, context, meaning, false); });
+ },
+ symbolToExpression: function (symbol, meaning, enclosingDeclaration, flags, tracker) {
+ return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToExpression(symbol, context, meaning); });
+ },
+ symbolToTypeParameterDeclarations: function (symbol, enclosingDeclaration, flags, tracker) {
+ return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeParametersToTypeParameterDeclarations(symbol, context); });
+ },
+ symbolToParameterDeclaration: function (symbol, enclosingDeclaration, flags, tracker) {
+ return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToParameterDeclaration(symbol, context); });
+ },
+ typeParameterToDeclaration: function (parameter, enclosingDeclaration, flags, tracker) {
+ return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeParameterToDeclaration(parameter, context); });
+ },
+ symbolTableToDeclarationStatements: function (symbolTable, enclosingDeclaration, flags, tracker, bundled) {
+ return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolTableToDeclarationStatements(symbolTable, context, bundled); });
+ },
+ };
+ function withContext(enclosingDeclaration, flags, tracker, cb) {
+ var _a, _b;
+ ts.Debug.assert(enclosingDeclaration === undefined || (enclosingDeclaration.flags & 8) === 0);
+ var context = {
+ enclosingDeclaration: enclosingDeclaration,
+ flags: flags || 0,
+ tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: ts.noop, moduleResolverHost: flags & 134217728 ? {
+ getCommonSourceDirectory: !!host.getCommonSourceDirectory ? function () { return host.getCommonSourceDirectory(); } : function () { return ""; },
+ getSourceFiles: function () { return host.getSourceFiles(); },
+ getCurrentDirectory: function () { return host.getCurrentDirectory(); },
+ getSymlinkCache: ts.maybeBind(host, host.getSymlinkCache),
+ useCaseSensitiveFileNames: ts.maybeBind(host, host.useCaseSensitiveFileNames),
+ redirectTargetsMap: host.redirectTargetsMap,
+ getProjectReferenceRedirect: function (fileName) { return host.getProjectReferenceRedirect(fileName); },
+ isSourceOfProjectReferenceRedirect: function (fileName) { return host.isSourceOfProjectReferenceRedirect(fileName); },
+ fileExists: function (fileName) { return host.fileExists(fileName); },
+ } : undefined },
+ encounteredError: false,
+ visitedTypes: undefined,
+ symbolDepth: undefined,
+ inferTypeParameters: undefined,
+ approximateLength: 0
+ };
+ var resultingNode = cb(context);
+ if (context.truncating && context.flags & 1) {
+ (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.reportTruncationError) === null || _b === void 0 ? void 0 : _b.call(_a);
+ }
+ return context.encounteredError ? undefined : resultingNode;
}
- if (type.flags & 8650752) {
- var constraint = getBaseConstraintOfType(type);
- return !!constraint && isMixinConstructorType(constraint);
+ function checkTruncationLength(context) {
+ if (context.truncating)
+ return context.truncating;
+ return context.truncating = context.approximateLength > ((context.flags & 1) ? ts.noTruncationMaximumTruncationLength : ts.defaultMaximumTruncationLength);
}
- return false;
- }
- function getBaseTypeNodeOfClass(type) {
- return ts.getEffectiveBaseTypeNode(type.symbol.valueDeclaration);
- }
- function getConstructorsForTypeArguments(type, typeArgumentNodes, location) {
- var typeArgCount = ts.length(typeArgumentNodes);
- var isJavascript = ts.isInJSFile(location);
- return ts.filter(getSignaturesOfType(type, 1), function (sig) { return (isJavascript || typeArgCount >= getMinTypeArgumentCount(sig.typeParameters)) && typeArgCount <= ts.length(sig.typeParameters); });
- }
- function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes, location) {
- var signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location);
- var typeArguments = ts.map(typeArgumentNodes, getTypeFromTypeNode);
- return ts.sameMap(signatures, function (sig) { return ts.some(sig.typeParameters) ? getSignatureInstantiation(sig, typeArguments, ts.isInJSFile(location)) : sig; });
- }
- function getBaseConstructorTypeOfClass(type) {
- if (!type.resolvedBaseConstructorType) {
- var decl = type.symbol.valueDeclaration;
- var extended = ts.getEffectiveBaseTypeNode(decl);
- var baseTypeNode = getBaseTypeNodeOfClass(type);
- if (!baseTypeNode) {
- return type.resolvedBaseConstructorType = undefinedType;
+ function typeToTypeNodeHelper(type, context) {
+ if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
+ cancellationToken.throwIfCancellationRequested();
}
- if (!pushTypeResolution(type, 1)) {
- return errorType;
+ var inTypeAlias = context.flags & 8388608;
+ context.flags &= ~8388608;
+ if (!type) {
+ if (!(context.flags & 262144)) {
+ context.encounteredError = true;
+ return undefined;
+ }
+ context.approximateLength += 3;
+ return ts.factory.createKeywordTypeNode(128);
}
- var baseConstructorType = checkExpression(baseTypeNode.expression);
- if (extended && baseTypeNode !== extended) {
- ts.Debug.assert(!extended.typeArguments);
- checkExpression(extended.expression);
+ if (!(context.flags & 536870912)) {
+ type = getReducedType(type);
}
- if (baseConstructorType.flags & (524288 | 2097152)) {
- resolveStructuredTypeMembers(baseConstructorType);
+ if (type.flags & 1) {
+ context.approximateLength += 3;
+ return ts.factory.createKeywordTypeNode(type === intrinsicMarkerType ? 136 : 128);
}
- if (!popTypeResolution()) {
- error(type.symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol));
- return type.resolvedBaseConstructorType = errorType;
+ if (type.flags & 2) {
+ return ts.factory.createKeywordTypeNode(152);
}
- if (!(baseConstructorType.flags & 1) && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) {
- var err = error(baseTypeNode.expression, ts.Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType));
- if (baseConstructorType.flags & 262144) {
- var constraint = getConstraintFromTypeParameter(baseConstructorType);
- var ctorReturn = unknownType;
- if (constraint) {
- var ctorSig = getSignaturesOfType(constraint, 1);
- if (ctorSig[0]) {
- ctorReturn = getReturnTypeOfSignature(ctorSig[0]);
- }
- }
- ts.addRelatedInfo(err, ts.createDiagnosticForNode(baseConstructorType.symbol.declarations[0], ts.Diagnostics.Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1, symbolToString(baseConstructorType.symbol), typeToString(ctorReturn)));
+ if (type.flags & 4) {
+ context.approximateLength += 6;
+ return ts.factory.createKeywordTypeNode(147);
+ }
+ if (type.flags & 8) {
+ context.approximateLength += 6;
+ return ts.factory.createKeywordTypeNode(144);
+ }
+ if (type.flags & 64) {
+ context.approximateLength += 6;
+ return ts.factory.createKeywordTypeNode(155);
+ }
+ if (type.flags & 16) {
+ context.approximateLength += 7;
+ return ts.factory.createKeywordTypeNode(131);
+ }
+ if (type.flags & 1024 && !(type.flags & 1048576)) {
+ var parentSymbol = getParentOfSymbol(type.symbol);
+ var parentName = symbolToTypeNode(parentSymbol, context, 788968);
+ if (getDeclaredTypeOfSymbol(parentSymbol) === type) {
+ return parentName;
+ }
+ var memberName = ts.symbolName(type.symbol);
+ if (ts.isIdentifierText(memberName, 0)) {
+ return appendReferenceToType(parentName, ts.factory.createTypeReferenceNode(memberName, undefined));
+ }
+ if (ts.isImportTypeNode(parentName)) {
+ parentName.isTypeOf = true;
+ return ts.factory.createIndexedAccessTypeNode(parentName, ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(memberName)));
+ }
+ else if (ts.isTypeReferenceNode(parentName)) {
+ return ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeQueryNode(parentName.typeName), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(memberName)));
+ }
+ else {
+ return ts.Debug.fail("Unhandled type node kind returned from `symbolToTypeNode`.");
}
- return type.resolvedBaseConstructorType = errorType;
}
- type.resolvedBaseConstructorType = baseConstructorType;
- }
- return type.resolvedBaseConstructorType;
- }
- function getImplementsTypes(type) {
- var resolvedImplementsTypes = ts.emptyArray;
- for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) {
- var declaration = _a[_i];
- var implementsTypeNodes = ts.getEffectiveImplementsTypeNodes(declaration);
- if (!implementsTypeNodes)
- continue;
- for (var _b = 0, implementsTypeNodes_1 = implementsTypeNodes; _b < implementsTypeNodes_1.length; _b++) {
- var node = implementsTypeNodes_1[_b];
- var implementsType = getTypeFromTypeNode(node);
- if (implementsType !== errorType) {
- if (resolvedImplementsTypes === ts.emptyArray) {
- resolvedImplementsTypes = [implementsType];
+ if (type.flags & 1056) {
+ return symbolToTypeNode(type.symbol, context, 788968);
+ }
+ if (type.flags & 128) {
+ context.approximateLength += (type.value.length + 2);
+ return ts.factory.createLiteralTypeNode(ts.setEmitFlags(ts.factory.createStringLiteral(type.value, !!(context.flags & 268435456)), 16777216));
+ }
+ if (type.flags & 256) {
+ var value = type.value;
+ context.approximateLength += ("" + value).length;
+ return ts.factory.createLiteralTypeNode(value < 0 ? ts.factory.createPrefixUnaryExpression(40, ts.factory.createNumericLiteral(-value)) : ts.factory.createNumericLiteral(value));
+ }
+ if (type.flags & 2048) {
+ context.approximateLength += (ts.pseudoBigIntToString(type.value).length) + 1;
+ return ts.factory.createLiteralTypeNode((ts.factory.createBigIntLiteral(type.value)));
+ }
+ if (type.flags & 512) {
+ context.approximateLength += type.intrinsicName.length;
+ return ts.factory.createLiteralTypeNode(type.intrinsicName === "true" ? ts.factory.createTrue() : ts.factory.createFalse());
+ }
+ if (type.flags & 8192) {
+ if (!(context.flags & 1048576)) {
+ if (isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+ context.approximateLength += 6;
+ return symbolToTypeNode(type.symbol, context, 111551);
}
- else {
- resolvedImplementsTypes.push(implementsType);
+ if (context.tracker.reportInaccessibleUniqueSymbolError) {
+ context.tracker.reportInaccessibleUniqueSymbolError();
}
}
+ context.approximateLength += 13;
+ return ts.factory.createTypeOperatorNode(151, ts.factory.createKeywordTypeNode(148));
}
- }
- return resolvedImplementsTypes;
- }
- function getBaseTypes(type) {
- if (!type.resolvedBaseTypes) {
- if (type.objectFlags & 8) {
- type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters || ts.emptyArray), type.readonly)];
+ if (type.flags & 16384) {
+ context.approximateLength += 4;
+ return ts.factory.createKeywordTypeNode(113);
}
- else if (type.symbol.flags & (32 | 64)) {
- if (type.symbol.flags & 32) {
- resolveBaseTypesOfClass(type);
- }
- if (type.symbol.flags & 64) {
- resolveBaseTypesOfInterface(type);
- }
+ if (type.flags & 32768) {
+ context.approximateLength += 9;
+ return ts.factory.createKeywordTypeNode(150);
}
- else {
- ts.Debug.fail("type must be class or interface");
+ if (type.flags & 65536) {
+ context.approximateLength += 4;
+ return ts.factory.createLiteralTypeNode(ts.factory.createNull());
}
- }
- return type.resolvedBaseTypes;
- }
- function resolveBaseTypesOfClass(type) {
- type.resolvedBaseTypes = ts.resolvingEmptyArray;
- var baseConstructorType = getApparentType(getBaseConstructorTypeOfClass(type));
- if (!(baseConstructorType.flags & (524288 | 2097152 | 1))) {
- return type.resolvedBaseTypes = ts.emptyArray;
- }
- var baseTypeNode = getBaseTypeNodeOfClass(type);
- var baseType;
- var originalBaseType = baseConstructorType.symbol ? getDeclaredTypeOfSymbol(baseConstructorType.symbol) : undefined;
- if (baseConstructorType.symbol && baseConstructorType.symbol.flags & 32 &&
- areAllOuterTypeParametersApplied(originalBaseType)) {
- baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol);
- }
- else if (baseConstructorType.flags & 1) {
- baseType = baseConstructorType;
- }
- else {
- var constructors = getInstantiatedConstructorsForTypeArguments(baseConstructorType, baseTypeNode.typeArguments, baseTypeNode);
- if (!constructors.length) {
- error(baseTypeNode.expression, ts.Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments);
- return type.resolvedBaseTypes = ts.emptyArray;
+ if (type.flags & 131072) {
+ context.approximateLength += 5;
+ return ts.factory.createKeywordTypeNode(141);
}
- baseType = getReturnTypeOfSignature(constructors[0]);
- }
- if (baseType === errorType) {
- return type.resolvedBaseTypes = ts.emptyArray;
- }
- var reducedBaseType = getReducedType(baseType);
- if (!isValidBaseType(reducedBaseType)) {
- var elaboration = elaborateNeverIntersection(undefined, baseType);
- var diagnostic = ts.chainDiagnosticMessages(elaboration, ts.Diagnostics.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members, typeToString(reducedBaseType));
- diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(baseTypeNode.expression, diagnostic));
- return type.resolvedBaseTypes = ts.emptyArray;
- }
- if (type === reducedBaseType || hasBaseType(reducedBaseType, type)) {
- error(type.symbol.valueDeclaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 2));
- return type.resolvedBaseTypes = ts.emptyArray;
- }
- if (type.resolvedBaseTypes === ts.resolvingEmptyArray) {
- type.members = undefined;
- }
- return type.resolvedBaseTypes = [reducedBaseType];
- }
- function areAllOuterTypeParametersApplied(type) {
- var outerTypeParameters = type.outerTypeParameters;
- if (outerTypeParameters) {
- var last_1 = outerTypeParameters.length - 1;
- var typeArguments = getTypeArguments(type);
- return outerTypeParameters[last_1].symbol !== typeArguments[last_1].symbol;
- }
- return true;
- }
- function isValidBaseType(type) {
- if (type.flags & 262144) {
- var constraint = getBaseConstraintOfType(type);
- if (constraint) {
- return isValidBaseType(constraint);
+ if (type.flags & 4096) {
+ context.approximateLength += 6;
+ return ts.factory.createKeywordTypeNode(148);
}
- }
- return !!(type.flags & (524288 | 67108864 | 1) && !isGenericMappedType(type) ||
- type.flags & 2097152 && ts.every(type.types, isValidBaseType));
- }
- function resolveBaseTypesOfInterface(type) {
- type.resolvedBaseTypes = type.resolvedBaseTypes || ts.emptyArray;
- for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) {
- var declaration = _a[_i];
- if (declaration.kind === 246 && ts.getInterfaceBaseTypeNodes(declaration)) {
- for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) {
- var node = _c[_b];
- var baseType = getReducedType(getTypeFromTypeNode(node));
- if (baseType !== errorType) {
- if (isValidBaseType(baseType)) {
- if (type !== baseType && !hasBaseType(baseType, type)) {
- if (type.resolvedBaseTypes === ts.emptyArray) {
- type.resolvedBaseTypes = [baseType];
- }
- else {
- type.resolvedBaseTypes.push(baseType);
- }
- }
- else {
- error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 2));
- }
- }
- else {
- error(node, ts.Diagnostics.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members);
- }
+ if (type.flags & 67108864) {
+ context.approximateLength += 6;
+ return ts.factory.createKeywordTypeNode(145);
+ }
+ if (isThisTypeParameter(type)) {
+ if (context.flags & 4194304) {
+ if (!context.encounteredError && !(context.flags & 32768)) {
+ context.encounteredError = true;
+ }
+ if (context.tracker.reportInaccessibleThisError) {
+ context.tracker.reportInaccessibleThisError();
}
}
+ context.approximateLength += 4;
+ return ts.factory.createThisTypeNode();
+ }
+ if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) {
+ var typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
+ if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32))
+ return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""), typeArgumentNodes);
+ return symbolToTypeNode(type.aliasSymbol, context, 788968, typeArgumentNodes);
+ }
+ var objectFlags = ts.getObjectFlags(type);
+ if (objectFlags & 4) {
+ ts.Debug.assert(!!(type.flags & 524288));
+ return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type);
+ }
+ if (type.flags & 262144 || objectFlags & 3) {
+ if (type.flags & 262144 && ts.contains(context.inferTypeParameters, type)) {
+ context.approximateLength += (ts.symbolName(type.symbol).length + 6);
+ return ts.factory.createInferTypeNode(typeParameterToDeclarationWithConstraint(type, context, undefined));
+ }
+ if (context.flags & 4 &&
+ type.flags & 262144 &&
+ !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+ var name = typeParameterToName(type, context);
+ context.approximateLength += ts.idText(name).length;
+ return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(ts.idText(name)), undefined);
+ }
+ return type.symbol
+ ? symbolToTypeNode(type.symbol, context, 788968)
+ : ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("?"), undefined);
}
- }
- }
- function isThislessInterface(symbol) {
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var declaration = _a[_i];
- if (declaration.kind === 246) {
- if (declaration.flags & 128) {
- return false;
+ if (type.flags & (1048576 | 2097152)) {
+ var types = type.flags & 1048576 ? formatUnionTypes(type.types) : type.types;
+ if (ts.length(types) === 1) {
+ return typeToTypeNodeHelper(types[0], context);
}
- var baseTypeNodes = ts.getInterfaceBaseTypeNodes(declaration);
- if (baseTypeNodes) {
- for (var _b = 0, baseTypeNodes_1 = baseTypeNodes; _b < baseTypeNodes_1.length; _b++) {
- var node = baseTypeNodes_1[_b];
- if (ts.isEntityNameExpression(node.expression)) {
- var baseSymbol = resolveEntityName(node.expression, 788968, true);
- if (!baseSymbol || !(baseSymbol.flags & 64) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
- return false;
- }
- }
+ var typeNodes = mapToTypeNodes(types, context, true);
+ if (typeNodes && typeNodes.length > 0) {
+ var unionOrIntersectionTypeNode = type.flags & 1048576 ? ts.factory.createUnionTypeNode(typeNodes) : ts.factory.createIntersectionTypeNode(typeNodes);
+ return unionOrIntersectionTypeNode;
+ }
+ else {
+ if (!context.encounteredError && !(context.flags & 262144)) {
+ context.encounteredError = true;
}
+ return undefined;
}
}
- }
- return true;
- }
- function getDeclaredTypeOfClassOrInterface(symbol) {
- var links = getSymbolLinks(symbol);
- var originalLinks = links;
- if (!links.declaredType) {
- var kind = symbol.flags & 32 ? 1 : 2;
- var merged = mergeJSSymbols(symbol, getAssignedClassSymbol(symbol.valueDeclaration));
- if (merged) {
- symbol = links = merged;
+ if (objectFlags & (16 | 32)) {
+ ts.Debug.assert(!!(type.flags & 524288));
+ return createAnonymousTypeNode(type);
}
- var type = originalLinks.declaredType = links.declaredType = createObjectType(kind, symbol);
- var outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol);
- var localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
- if (outerTypeParameters || localTypeParameters || kind === 1 || !isThislessInterface(symbol)) {
- type.objectFlags |= 4;
- type.typeParameters = ts.concatenate(outerTypeParameters, localTypeParameters);
- type.outerTypeParameters = outerTypeParameters;
- type.localTypeParameters = localTypeParameters;
- type.instantiations = ts.createMap();
- 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;
+ if (type.flags & 4194304) {
+ var indexedType = type.type;
+ context.approximateLength += 6;
+ var indexTypeNode = typeToTypeNodeHelper(indexedType, context);
+ return ts.factory.createTypeOperatorNode(138, indexTypeNode);
}
- }
- return links.declaredType;
- }
- function getDeclaredTypeOfTypeAlias(symbol) {
- var links = getSymbolLinks(symbol);
- if (!links.declaredType) {
- if (!pushTypeResolution(symbol, 2)) {
- return errorType;
+ if (type.flags & 134217728) {
+ var texts_1 = type.texts;
+ var types_1 = type.types;
+ var templateHead = ts.factory.createTemplateHead(texts_1[0]);
+ var templateSpans = ts.factory.createNodeArray(ts.map(types_1, function (t, i) { return ts.factory.createTemplateLiteralTypeSpan(typeToTypeNodeHelper(t, context), (i < types_1.length - 1 ? ts.factory.createTemplateMiddle : ts.factory.createTemplateTail)(texts_1[i + 1])); }));
+ context.approximateLength += 2;
+ return ts.factory.createTemplateLiteralType(templateHead, templateSpans);
}
- var declaration = ts.Debug.checkDefined(ts.find(symbol.declarations, ts.isTypeAlias), "Type alias symbol with no valid declaration found");
- var typeNode = ts.isJSDocTypeAlias(declaration) ? declaration.typeExpression : declaration.type;
- var type = typeNode ? getTypeFromTypeNode(typeNode) : errorType;
- if (popTypeResolution()) {
- var typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
- if (typeParameters) {
- links.typeParameters = typeParameters;
- links.instantiations = ts.createMap();
- links.instantiations.set(getTypeListId(typeParameters), type);
+ if (type.flags & 268435456) {
+ var typeNode = typeToTypeNodeHelper(type.type, context);
+ return symbolToTypeNode(type.symbol, context, 788968, [typeNode]);
+ }
+ if (type.flags & 8388608) {
+ var objectTypeNode = typeToTypeNodeHelper(type.objectType, context);
+ var indexTypeNode = typeToTypeNodeHelper(type.indexType, context);
+ context.approximateLength += 2;
+ return ts.factory.createIndexedAccessTypeNode(objectTypeNode, indexTypeNode);
+ }
+ if (type.flags & 16777216) {
+ var checkTypeNode = typeToTypeNodeHelper(type.checkType, context);
+ var saveInferTypeParameters = context.inferTypeParameters;
+ context.inferTypeParameters = type.root.inferTypeParameters;
+ var extendsTypeNode = typeToTypeNodeHelper(type.extendsType, context);
+ context.inferTypeParameters = saveInferTypeParameters;
+ var trueTypeNode = typeToTypeNodeOrCircularityElision(getTrueTypeFromConditionalType(type));
+ var falseTypeNode = typeToTypeNodeOrCircularityElision(getFalseTypeFromConditionalType(type));
+ context.approximateLength += 15;
+ return ts.factory.createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode);
+ }
+ if (type.flags & 33554432) {
+ return typeToTypeNodeHelper(type.baseType, context);
+ }
+ return ts.Debug.fail("Should be unreachable.");
+ function typeToTypeNodeOrCircularityElision(type) {
+ var _a, _b, _c;
+ if (type.flags & 1048576) {
+ if ((_a = context.visitedTypes) === null || _a === void 0 ? void 0 : _a.has(getTypeId(type))) {
+ if (!(context.flags & 131072)) {
+ context.encounteredError = true;
+ (_c = (_b = context.tracker) === null || _b === void 0 ? void 0 : _b.reportCyclicStructureError) === null || _c === void 0 ? void 0 : _c.call(_b);
+ }
+ return createElidedInformationPlaceholder(context);
+ }
+ return visitAndTransformType(type, function (type) { return typeToTypeNodeHelper(type, context); });
}
+ return typeToTypeNodeHelper(type, context);
}
- else {
- type = errorType;
- error(ts.isNamedDeclaration(declaration) ? declaration.name : declaration || declaration, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
+ function createMappedTypeNodeFromType(type) {
+ ts.Debug.assert(!!(type.flags & 524288));
+ var readonlyToken = type.declaration.readonlyToken ? ts.factory.createToken(type.declaration.readonlyToken.kind) : undefined;
+ var questionToken = type.declaration.questionToken ? ts.factory.createToken(type.declaration.questionToken.kind) : undefined;
+ var appropriateConstraintTypeNode;
+ if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
+ appropriateConstraintTypeNode = ts.factory.createTypeOperatorNode(138, typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context));
+ }
+ else {
+ appropriateConstraintTypeNode = typeToTypeNodeHelper(getConstraintTypeFromMappedType(type), context);
+ }
+ var typeParameterNode = typeParameterToDeclarationWithConstraint(getTypeParameterFromMappedType(type), context, appropriateConstraintTypeNode);
+ var nameTypeNode = type.declaration.nameType ? typeToTypeNodeHelper(getNameTypeFromMappedType(type), context) : undefined;
+ var templateTypeNode = typeToTypeNodeHelper(getTemplateTypeFromMappedType(type), context);
+ var mappedTypeNode = ts.factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode);
+ context.approximateLength += 10;
+ return ts.setEmitFlags(mappedTypeNode, 1);
}
- links.declaredType = type;
- }
- return links.declaredType;
- }
- function isStringConcatExpression(expr) {
- if (ts.isStringLiteralLike(expr)) {
- return true;
- }
- else if (expr.kind === 209) {
- return isStringConcatExpression(expr.left) && isStringConcatExpression(expr.right);
- }
- return false;
- }
- function isLiteralEnumMember(member) {
- var expr = member.initializer;
- if (!expr) {
- return !(member.flags & 8388608);
- }
- switch (expr.kind) {
- case 10:
- case 8:
- case 14:
- return true;
- case 207:
- return expr.operator === 40 &&
- expr.operand.kind === 8;
- case 75:
- return ts.nodeIsMissing(expr) || !!getSymbolOfNode(member.parent).exports.get(expr.escapedText);
- case 209:
- return isStringConcatExpression(expr);
- default:
- return false;
- }
- }
- function getEnumKind(symbol) {
- var links = getSymbolLinks(symbol);
- if (links.enumKind !== undefined) {
- return links.enumKind;
- }
- var hasNonLiteralMember = false;
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var declaration = _a[_i];
- if (declaration.kind === 248) {
- for (var _b = 0, _c = declaration.members; _b < _c.length; _b++) {
- var member = _c[_b];
- if (member.initializer && ts.isStringLiteralLike(member.initializer)) {
- return links.enumKind = 1;
+ function createAnonymousTypeNode(type) {
+ var _a;
+ var typeId = type.id;
+ var symbol = type.symbol;
+ if (symbol) {
+ var isInstanceType = isClassInstanceSide(type) ? 788968 : 111551;
+ if (isJSConstructor(symbol.valueDeclaration)) {
+ return symbolToTypeNode(symbol, context, isInstanceType);
}
- if (!isLiteralEnumMember(member)) {
- hasNonLiteralMember = true;
+ else if (symbol.flags & 32 && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration.kind === 221 && context.flags & 2048) ||
+ symbol.flags & (384 | 512) ||
+ shouldWriteTypeOfFunctionSymbol()) {
+ return symbolToTypeNode(symbol, context, isInstanceType);
+ }
+ else if ((_a = context.visitedTypes) === null || _a === void 0 ? void 0 : _a.has(typeId)) {
+ var typeAlias = getTypeAliasForTypeLiteral(type);
+ if (typeAlias) {
+ return symbolToTypeNode(typeAlias, context, 788968);
+ }
+ else {
+ return createElidedInformationPlaceholder(context);
+ }
+ }
+ else {
+ return visitAndTransformType(type, createTypeNodeFromObjectType);
}
}
- }
- }
- return links.enumKind = hasNonLiteralMember ? 0 : 1;
- }
- function getBaseTypeOfEnumLiteralType(type) {
- return type.flags & 1024 && !(type.flags & 1048576) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
- }
- function getDeclaredTypeOfEnum(symbol) {
- var links = getSymbolLinks(symbol);
- if (links.declaredType) {
- return links.declaredType;
- }
- if (getEnumKind(symbol) === 1) {
- enumCount++;
- var memberTypeList = [];
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var declaration = _a[_i];
- if (declaration.kind === 248) {
- for (var _b = 0, _c = declaration.members; _b < _c.length; _b++) {
- var member = _c[_b];
- var value = getEnumMemberValue(member);
- var memberType = getFreshTypeOfLiteralType(getLiteralType(value !== undefined ? value : 0, enumCount, getSymbolOfNode(member)));
- getSymbolLinks(getSymbolOfNode(member)).declaredType = memberType;
- memberTypeList.push(getRegularTypeOfLiteralType(memberType));
+ else {
+ return createTypeNodeFromObjectType(type);
+ }
+ function shouldWriteTypeOfFunctionSymbol() {
+ var _a;
+ var isStaticMethodSymbol = !!(symbol.flags & 8192) &&
+ ts.some(symbol.declarations, function (declaration) { return ts.hasSyntacticModifier(declaration, 32); });
+ var isNonLocalFunctionSymbol = !!(symbol.flags & 16) &&
+ (symbol.parent ||
+ ts.forEach(symbol.declarations, function (declaration) {
+ return declaration.parent.kind === 297 || declaration.parent.kind === 257;
+ }));
+ if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
+ return (!!(context.flags & 4096) || ((_a = context.visitedTypes) === null || _a === void 0 ? void 0 : _a.has(typeId))) &&
+ (!(context.flags & 8) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
}
}
}
- if (memberTypeList.length) {
- var enumType_1 = getUnionType(memberTypeList, 1, symbol, undefined);
- if (enumType_1.flags & 1048576) {
- enumType_1.flags |= 1024;
- enumType_1.symbol = symbol;
+ function visitAndTransformType(type, transform) {
+ var typeId = type.id;
+ var isConstructorObject = ts.getObjectFlags(type) & 16 && type.symbol && type.symbol.flags & 32;
+ var id = ts.getObjectFlags(type) & 4 && type.node ? "N" + getNodeId(type.node) :
+ type.symbol ? (isConstructorObject ? "+" : "") + getSymbolId(type.symbol) :
+ undefined;
+ if (!context.visitedTypes) {
+ context.visitedTypes = new ts.Set();
}
- return links.declaredType = enumType_1;
- }
- }
- var enumType = createType(32);
- enumType.symbol = symbol;
- return links.declaredType = enumType;
- }
- function getDeclaredTypeOfEnumMember(symbol) {
- var links = getSymbolLinks(symbol);
- if (!links.declaredType) {
- var enumType = getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
- if (!links.declaredType) {
- links.declaredType = enumType;
- }
- }
- return links.declaredType;
- }
- function getDeclaredTypeOfTypeParameter(symbol) {
- var links = getSymbolLinks(symbol);
- return links.declaredType || (links.declaredType = createTypeParameter(symbol));
- }
- function getDeclaredTypeOfAlias(symbol) {
- var links = getSymbolLinks(symbol);
- return links.declaredType || (links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol)));
- }
- function getDeclaredTypeOfSymbol(symbol) {
- return tryGetDeclaredTypeOfSymbol(symbol) || errorType;
- }
- function tryGetDeclaredTypeOfSymbol(symbol) {
- if (symbol.flags & (32 | 64)) {
- return getDeclaredTypeOfClassOrInterface(symbol);
- }
- if (symbol.flags & 524288) {
- return getDeclaredTypeOfTypeAlias(symbol);
- }
- if (symbol.flags & 262144) {
- return getDeclaredTypeOfTypeParameter(symbol);
- }
- if (symbol.flags & 384) {
- return getDeclaredTypeOfEnum(symbol);
- }
- if (symbol.flags & 8) {
- return getDeclaredTypeOfEnumMember(symbol);
- }
- if (symbol.flags & 2097152) {
- return getDeclaredTypeOfAlias(symbol);
- }
- return undefined;
- }
- function isThislessType(node) {
- switch (node.kind) {
- case 125:
- case 148:
- case 143:
- case 140:
- case 151:
- case 128:
- case 144:
- case 141:
- case 110:
- case 146:
- case 100:
- case 137:
- case 187:
- return true;
- case 174:
- return isThislessType(node.elementType);
- case 169:
- return !node.typeArguments || node.typeArguments.every(isThislessType);
- }
- return false;
- }
- function isThislessTypeParameter(node) {
- var constraint = ts.getEffectiveConstraintOfTypeParameter(node);
- return !constraint || isThislessType(constraint);
- }
- function isThislessVariableLikeDeclaration(node) {
- var typeNode = ts.getEffectiveTypeAnnotationNode(node);
- return typeNode ? isThislessType(typeNode) : !ts.hasInitializer(node);
- }
- function isThislessFunctionLikeDeclaration(node) {
- var returnType = ts.getEffectiveReturnTypeNode(node);
- var typeParameters = ts.getEffectiveTypeParameterDeclarations(node);
- return (node.kind === 162 || (!!returnType && isThislessType(returnType))) &&
- node.parameters.every(isThislessVariableLikeDeclaration) &&
- typeParameters.every(isThislessTypeParameter);
- }
- function isThisless(symbol) {
- if (symbol.declarations && symbol.declarations.length === 1) {
- var declaration = symbol.declarations[0];
- if (declaration) {
- switch (declaration.kind) {
- case 159:
- case 158:
- return isThislessVariableLikeDeclaration(declaration);
- case 161:
- case 160:
- case 162:
- case 163:
- case 164:
- return isThislessFunctionLikeDeclaration(declaration);
+ if (id && !context.symbolDepth) {
+ context.symbolDepth = new ts.Map();
}
- }
- }
- return false;
- }
- function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) {
- var result = ts.createSymbolTable();
- for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
- var symbol = symbols_2[_i];
- result.set(symbol.escapedName, mappingThisOnly && isThisless(symbol) ? symbol : instantiateSymbol(symbol, mapper));
- }
- return result;
- }
- function addInheritedMembers(symbols, baseSymbols) {
- for (var _i = 0, baseSymbols_1 = baseSymbols; _i < baseSymbols_1.length; _i++) {
- var s = baseSymbols_1[_i];
- if (!symbols.has(s.escapedName) && !isStaticPrivateIdentifierProperty(s)) {
- symbols.set(s.escapedName, s);
- }
- }
- }
- function isStaticPrivateIdentifierProperty(s) {
- return !!s.valueDeclaration && ts.isPrivateIdentifierPropertyDeclaration(s.valueDeclaration) && ts.hasModifier(s.valueDeclaration, 32);
- }
- function resolveDeclaredMembers(type) {
- if (!type.declaredProperties) {
- var symbol = type.symbol;
- var members = getMembersOfSymbol(symbol);
- type.declaredProperties = getNamedMembers(members);
- type.declaredCallSignatures = ts.emptyArray;
- type.declaredConstructSignatures = ts.emptyArray;
- type.declaredCallSignatures = getSignaturesOfSymbol(members.get("__call"));
- type.declaredConstructSignatures = getSignaturesOfSymbol(members.get("__new"));
- type.declaredStringIndexInfo = getIndexInfoOfSymbol(symbol, 0);
- type.declaredNumberIndexInfo = getIndexInfoOfSymbol(symbol, 1);
- }
- return type;
- }
- function isTypeUsableAsPropertyName(type) {
- return !!(type.flags & 8576);
- }
- function isLateBindableName(node) {
- if (!ts.isComputedPropertyName(node) && !ts.isElementAccessExpression(node)) {
- return false;
- }
- var expr = ts.isComputedPropertyName(node) ? node.expression : node.argumentExpression;
- return ts.isEntityNameExpression(expr)
- && isTypeUsableAsPropertyName(ts.isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr));
- }
- function isLateBoundName(name) {
- return name.charCodeAt(0) === 95 &&
- name.charCodeAt(1) === 95 &&
- name.charCodeAt(2) === 64;
- }
- function hasLateBindableName(node) {
- var name = ts.getNameOfDeclaration(node);
- return !!name && isLateBindableName(name);
- }
- function hasNonBindableDynamicName(node) {
- return ts.hasDynamicName(node) && !hasLateBindableName(node);
- }
- function isNonBindableDynamicName(node) {
- return ts.isDynamicName(node) && !isLateBindableName(node);
- }
- function getPropertyNameFromType(type) {
- if (type.flags & 8192) {
- return type.escapedName;
- }
- if (type.flags & (128 | 256)) {
- return ts.escapeLeadingUnderscores("" + type.value);
- }
- return ts.Debug.fail();
- }
- function addDeclarationToLateBoundSymbol(symbol, member, symbolFlags) {
- ts.Debug.assert(!!(ts.getCheckFlags(symbol) & 4096), "Expected a late-bound symbol.");
- symbol.flags |= symbolFlags;
- getSymbolLinks(member.symbol).lateSymbol = symbol;
- if (!symbol.declarations) {
- symbol.declarations = [member];
- }
- else {
- symbol.declarations.push(member);
- }
- if (symbolFlags & 111551) {
- if (!symbol.valueDeclaration || symbol.valueDeclaration.kind !== member.kind) {
- symbol.valueDeclaration = member;
- }
- }
- }
- function lateBindMember(parent, earlySymbols, lateSymbols, decl) {
- ts.Debug.assert(!!decl.symbol, "The member is expected to have a symbol.");
- var links = getNodeLinks(decl);
- if (!links.resolvedSymbol) {
- links.resolvedSymbol = decl.symbol;
- var declName = ts.isBinaryExpression(decl) ? decl.left : decl.name;
- var type = ts.isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName);
- if (isTypeUsableAsPropertyName(type)) {
- var memberName = getPropertyNameFromType(type);
- var symbolFlags = decl.symbol.flags;
- var lateSymbol = lateSymbols.get(memberName);
- if (!lateSymbol)
- lateSymbols.set(memberName, lateSymbol = createSymbol(0, memberName, 4096));
- var earlySymbol = earlySymbols && earlySymbols.get(memberName);
- if (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol) {
- var declarations = earlySymbol ? ts.concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
- var name_3 = !(type.flags & 8192) && ts.unescapeLeadingUnderscores(memberName) || ts.declarationNameToString(declName);
- ts.forEach(declarations, function (declaration) { return error(ts.getNameOfDeclaration(declaration) || declaration, ts.Diagnostics.Property_0_was_also_declared_here, name_3); });
- error(declName || decl, ts.Diagnostics.Duplicate_property_0, name_3);
- lateSymbol = createSymbol(0, memberName, 4096);
+ var depth;
+ if (id) {
+ depth = context.symbolDepth.get(id) || 0;
+ if (depth > 10) {
+ return createElidedInformationPlaceholder(context);
+ }
+ context.symbolDepth.set(id, depth + 1);
}
- lateSymbol.nameType = type;
- addDeclarationToLateBoundSymbol(lateSymbol, decl, symbolFlags);
- if (lateSymbol.parent) {
- ts.Debug.assert(lateSymbol.parent === parent, "Existing symbol parent should match new one");
+ context.visitedTypes.add(typeId);
+ var result = transform(type);
+ context.visitedTypes.delete(typeId);
+ if (id) {
+ context.symbolDepth.set(id, depth);
}
- else {
- lateSymbol.parent = parent;
+ return result;
+ }
+ function createTypeNodeFromObjectType(type) {
+ if (isGenericMappedType(type) || type.containsError) {
+ return createMappedTypeNodeFromType(type);
}
- return links.resolvedSymbol = lateSymbol;
+ var resolved = resolveStructuredTypeMembers(type);
+ if (!resolved.properties.length && !resolved.stringIndexInfo && !resolved.numberIndexInfo) {
+ if (!resolved.callSignatures.length && !resolved.constructSignatures.length) {
+ context.approximateLength += 2;
+ return ts.setEmitFlags(ts.factory.createTypeLiteralNode(undefined), 1);
+ }
+ if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
+ var signature = resolved.callSignatures[0];
+ var signatureNode = signatureToSignatureDeclarationHelper(signature, 174, context);
+ return signatureNode;
+ }
+ if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
+ var signature = resolved.constructSignatures[0];
+ var signatureNode = signatureToSignatureDeclarationHelper(signature, 175, context);
+ return signatureNode;
+ }
+ }
+ var savedFlags = context.flags;
+ context.flags |= 4194304;
+ var members = createTypeNodesFromResolvedType(resolved);
+ context.flags = savedFlags;
+ var typeLiteralNode = ts.factory.createTypeLiteralNode(members);
+ context.approximateLength += 2;
+ return ts.setEmitFlags(typeLiteralNode, (context.flags & 1024) ? 0 : 1);
}
- }
- return links.resolvedSymbol;
- }
- function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
- var links = getSymbolLinks(symbol);
- if (!links[resolutionKind]) {
- var isStatic = resolutionKind === "resolvedExports";
- var earlySymbols = !isStatic ? symbol.members :
- symbol.flags & 1536 ? getExportsOfModuleWorker(symbol) :
- symbol.exports;
- links[resolutionKind] = earlySymbols || emptySymbols;
- var lateSymbols = ts.createSymbolTable();
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var decl = _a[_i];
- var members = ts.getMembersOfDeclaration(decl);
- if (members) {
- for (var _b = 0, members_5 = members; _b < members_5.length; _b++) {
- var member = members_5[_b];
- if (isStatic === ts.hasStaticModifier(member) && hasLateBindableName(member)) {
- lateBindMember(symbol, earlySymbols, lateSymbols, member);
+ function typeReferenceToTypeNode(type) {
+ var typeArguments = getTypeArguments(type);
+ if (type.target === globalArrayType || type.target === globalReadonlyArrayType) {
+ if (context.flags & 2) {
+ var typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context);
+ return ts.factory.createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]);
+ }
+ var elementType = typeToTypeNodeHelper(typeArguments[0], context);
+ var arrayType = ts.factory.createArrayTypeNode(elementType);
+ return type.target === globalArrayType ? arrayType : ts.factory.createTypeOperatorNode(142, arrayType);
+ }
+ else if (type.target.objectFlags & 8) {
+ if (typeArguments.length > 0) {
+ var arity = getTypeReferenceArity(type);
+ var tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context);
+ if (tupleConstituentNodes) {
+ if (type.target.labeledElementDeclarations) {
+ for (var i = 0; i < tupleConstituentNodes.length; i++) {
+ var flags = type.target.elementFlags[i];
+ tupleConstituentNodes[i] = ts.factory.createNamedTupleMember(flags & 12 ? ts.factory.createToken(25) : undefined, ts.factory.createIdentifier(ts.unescapeLeadingUnderscores(getTupleElementLabel(type.target.labeledElementDeclarations[i]))), flags & 2 ? ts.factory.createToken(57) : undefined, flags & 4 ? ts.factory.createArrayTypeNode(tupleConstituentNodes[i]) :
+ tupleConstituentNodes[i]);
+ }
+ }
+ else {
+ for (var i = 0; i < Math.min(arity, tupleConstituentNodes.length); i++) {
+ var flags = type.target.elementFlags[i];
+ tupleConstituentNodes[i] =
+ flags & 12 ? ts.factory.createRestTypeNode(flags & 4 ? ts.factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]) :
+ flags & 2 ? ts.factory.createOptionalTypeNode(tupleConstituentNodes[i]) :
+ tupleConstituentNodes[i];
+ }
+ }
+ var tupleTypeNode = ts.setEmitFlags(ts.factory.createTupleTypeNode(tupleConstituentNodes), 1);
+ return type.target.readonly ? ts.factory.createTypeOperatorNode(142, tupleTypeNode) : tupleTypeNode;
}
}
+ if (context.encounteredError || (context.flags & 524288)) {
+ var tupleTypeNode = ts.setEmitFlags(ts.factory.createTupleTypeNode([]), 1);
+ return type.target.readonly ? ts.factory.createTypeOperatorNode(142, tupleTypeNode) : tupleTypeNode;
+ }
+ context.encounteredError = true;
+ return undefined;
}
- }
- var assignments = symbol.assignmentDeclarationMembers;
- if (assignments) {
- var decls = ts.arrayFrom(assignments.values());
- for (var _c = 0, decls_1 = decls; _c < decls_1.length; _c++) {
- var member = decls_1[_c];
- var assignmentKind = ts.getAssignmentDeclarationKind(member);
- var isInstanceMember = assignmentKind === 3
- || assignmentKind === 4
- || assignmentKind === 9
- || assignmentKind === 6;
- if (isStatic === !isInstanceMember && hasLateBindableName(member)) {
- lateBindMember(symbol, earlySymbols, lateSymbols, member);
+ else if (context.flags & 2048 &&
+ type.symbol.valueDeclaration &&
+ ts.isClassLike(type.symbol.valueDeclaration) &&
+ !isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
+ return createAnonymousTypeNode(type);
+ }
+ else {
+ var outerTypeParameters = type.target.outerTypeParameters;
+ var i = 0;
+ var resultType = void 0;
+ if (outerTypeParameters) {
+ var length_2 = outerTypeParameters.length;
+ while (i < length_2) {
+ var start = i;
+ var parent = getParentSymbolOfTypeParameter(outerTypeParameters[i]);
+ do {
+ i++;
+ } while (i < length_2 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent);
+ if (!ts.rangeEquals(outerTypeParameters, typeArguments, start, i)) {
+ var typeArgumentSlice = mapToTypeNodes(typeArguments.slice(start, i), context);
+ var flags_3 = context.flags;
+ context.flags |= 16;
+ var ref = symbolToTypeNode(parent, context, 788968, typeArgumentSlice);
+ context.flags = flags_3;
+ resultType = !resultType ? ref : appendReferenceToType(resultType, ref);
+ }
+ }
+ }
+ var typeArgumentNodes = void 0;
+ if (typeArguments.length > 0) {
+ var typeParameterCount = (type.target.typeParameters || ts.emptyArray).length;
+ typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context);
}
+ var flags = context.flags;
+ context.flags |= 16;
+ var finalRef = symbolToTypeNode(type.symbol, context, 788968, typeArgumentNodes);
+ context.flags = flags;
+ return !resultType ? finalRef : appendReferenceToType(resultType, finalRef);
}
}
- links[resolutionKind] = combineSymbolTables(earlySymbols, lateSymbols) || emptySymbols;
- }
- return links[resolutionKind];
- }
- function getMembersOfSymbol(symbol) {
- return symbol.flags & 6256
- ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedMembers")
- : symbol.members || emptySymbols;
- }
- function getLateBoundSymbol(symbol) {
- if (symbol.flags & 106500 && symbol.escapedName === "__computed") {
- var links = getSymbolLinks(symbol);
- if (!links.lateSymbol && ts.some(symbol.declarations, hasLateBindableName)) {
- var parent = getMergedSymbol(symbol.parent);
- if (ts.some(symbol.declarations, ts.hasStaticModifier)) {
- getExportsOfSymbol(parent);
+ function appendReferenceToType(root, ref) {
+ if (ts.isImportTypeNode(root)) {
+ var typeArguments = root.typeArguments;
+ var qualifier = root.qualifier;
+ if (qualifier) {
+ if (ts.isIdentifier(qualifier)) {
+ qualifier = ts.factory.updateIdentifier(qualifier, typeArguments);
+ }
+ else {
+ qualifier = ts.factory.updateQualifiedName(qualifier, qualifier.left, ts.factory.updateIdentifier(qualifier.right, typeArguments));
+ }
+ }
+ typeArguments = ref.typeArguments;
+ var ids = getAccessStack(ref);
+ for (var _i = 0, ids_1 = ids; _i < ids_1.length; _i++) {
+ var id = ids_1[_i];
+ qualifier = qualifier ? ts.factory.createQualifiedName(qualifier, id) : id;
+ }
+ return ts.factory.updateImportTypeNode(root, root.argument, qualifier, typeArguments, root.isTypeOf);
}
else {
- getMembersOfSymbol(parent);
+ var typeArguments = root.typeArguments;
+ var typeName = root.typeName;
+ if (ts.isIdentifier(typeName)) {
+ typeName = ts.factory.updateIdentifier(typeName, typeArguments);
+ }
+ else {
+ typeName = ts.factory.updateQualifiedName(typeName, typeName.left, ts.factory.updateIdentifier(typeName.right, typeArguments));
+ }
+ typeArguments = ref.typeArguments;
+ var ids = getAccessStack(ref);
+ for (var _a = 0, ids_2 = ids; _a < ids_2.length; _a++) {
+ var id = ids_2[_a];
+ typeName = ts.factory.createQualifiedName(typeName, id);
+ }
+ return ts.factory.updateTypeReferenceNode(root, typeName, typeArguments);
}
}
- return links.lateSymbol || (links.lateSymbol = symbol);
- }
- return symbol;
- }
- function getTypeWithThisArgument(type, thisArgument, needApparentType) {
- if (ts.getObjectFlags(type) & 4) {
- var target = type.target;
- var typeArguments = getTypeArguments(type);
- if (ts.length(target.typeParameters) === ts.length(typeArguments)) {
- var ref = createTypeReference(target, ts.concatenate(typeArguments, [thisArgument || target.thisType]));
- return needApparentType ? getApparentType(ref) : ref;
- }
- }
- else if (type.flags & 2097152) {
- return getIntersectionType(ts.map(type.types, function (t) { return getTypeWithThisArgument(t, thisArgument, needApparentType); }));
- }
- return needApparentType ? getApparentType(type) : type;
- }
- function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
- var mapper;
- var members;
- var callSignatures;
- var constructSignatures;
- var stringIndexInfo;
- var numberIndexInfo;
- if (ts.rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
- members = source.symbol ? getMembersOfSymbol(source.symbol) : ts.createSymbolTable(source.declaredProperties);
- callSignatures = source.declaredCallSignatures;
- constructSignatures = source.declaredConstructSignatures;
- stringIndexInfo = source.declaredStringIndexInfo;
- numberIndexInfo = source.declaredNumberIndexInfo;
- }
- else {
- mapper = createTypeMapper(typeParameters, typeArguments);
- members = createInstantiatedSymbolTable(source.declaredProperties, mapper, typeParameters.length === 1);
- callSignatures = instantiateSignatures(source.declaredCallSignatures, mapper);
- constructSignatures = instantiateSignatures(source.declaredConstructSignatures, mapper);
- stringIndexInfo = instantiateIndexInfo(source.declaredStringIndexInfo, mapper);
- numberIndexInfo = instantiateIndexInfo(source.declaredNumberIndexInfo, mapper);
- }
- var baseTypes = getBaseTypes(source);
- if (baseTypes.length) {
- if (source.symbol && members === getMembersOfSymbol(source.symbol)) {
- members = ts.createSymbolTable(source.declaredProperties);
- }
- setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
- var thisArgument = ts.lastOrUndefined(typeArguments);
- for (var _i = 0, baseTypes_1 = baseTypes; _i < baseTypes_1.length; _i++) {
- var baseType = baseTypes_1[_i];
- var instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
- addInheritedMembers(members, getPropertiesOfType(instantiatedBaseType));
- callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0));
- constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1));
- if (!stringIndexInfo) {
- stringIndexInfo = instantiatedBaseType === anyType ?
- createIndexInfo(anyType, false) :
- getIndexInfoOfType(instantiatedBaseType, 0);
+ function getAccessStack(ref) {
+ var state = ref.typeName;
+ var ids = [];
+ while (!ts.isIdentifier(state)) {
+ ids.unshift(state.right);
+ state = state.left;
}
- numberIndexInfo = numberIndexInfo || getIndexInfoOfType(instantiatedBaseType, 1);
- }
- }
- setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
- }
- function resolveClassOrInterfaceMembers(type) {
- resolveObjectTypeMembers(type, resolveDeclaredMembers(type), ts.emptyArray, ts.emptyArray);
- }
- function resolveTypeReferenceMembers(type) {
- var source = resolveDeclaredMembers(type.target);
- var typeParameters = ts.concatenate(source.typeParameters, [source.thisType]);
- var typeArguments = getTypeArguments(type);
- var paddedTypeArguments = typeArguments.length === typeParameters.length ? typeArguments : ts.concatenate(typeArguments, [type]);
- resolveObjectTypeMembers(type, source, typeParameters, paddedTypeArguments);
- }
- function createSignature(declaration, typeParameters, thisParameter, parameters, resolvedReturnType, resolvedTypePredicate, minArgumentCount, flags) {
- var sig = new Signature(checker, flags);
- sig.declaration = declaration;
- sig.typeParameters = typeParameters;
- sig.parameters = parameters;
- sig.thisParameter = thisParameter;
- sig.resolvedReturnType = resolvedReturnType;
- sig.resolvedTypePredicate = resolvedTypePredicate;
- sig.minArgumentCount = minArgumentCount;
- sig.target = undefined;
- sig.mapper = undefined;
- sig.unionSignatures = undefined;
- return sig;
- }
- function cloneSignature(sig) {
- var result = createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, undefined, undefined, sig.minArgumentCount, sig.flags & 3);
- result.target = sig.target;
- result.mapper = sig.mapper;
- result.unionSignatures = sig.unionSignatures;
- return result;
- }
- function createUnionSignature(signature, unionSignatures) {
- var result = cloneSignature(signature);
- result.unionSignatures = unionSignatures;
- result.target = undefined;
- result.mapper = undefined;
- return result;
- }
- function getOptionalCallSignature(signature, callChainFlags) {
- if ((signature.flags & 12) === callChainFlags) {
- return signature;
- }
- if (!signature.optionalCallSignatureCache) {
- signature.optionalCallSignatureCache = {};
- }
- var key = callChainFlags === 4 ? "inner" : "outer";
- return signature.optionalCallSignatureCache[key]
- || (signature.optionalCallSignatureCache[key] = createOptionalCallSignature(signature, callChainFlags));
- }
- function createOptionalCallSignature(signature, callChainFlags) {
- ts.Debug.assert(callChainFlags === 4 || callChainFlags === 8, "An optional call signature can either be for an inner call chain or an outer call chain, but not both.");
- var result = cloneSignature(signature);
- result.flags |= callChainFlags;
- return result;
- }
- function getExpandedParameters(sig) {
- if (signatureHasRestParameter(sig)) {
- var restIndex_1 = sig.parameters.length - 1;
- var restParameter = sig.parameters[restIndex_1];
- var restType = getTypeOfSymbol(restParameter);
- if (isTupleType(restType)) {
- var elementTypes = getTypeArguments(restType);
- var minLength_1 = restType.target.minLength;
- var tupleRestIndex_1 = restType.target.hasRestElement ? elementTypes.length - 1 : -1;
- var restParams = ts.map(elementTypes, function (t, i) {
- var name = getParameterNameAtPosition(sig, restIndex_1 + i);
- var checkFlags = i === tupleRestIndex_1 ? 32768 :
- i >= minLength_1 ? 16384 : 0;
- var symbol = createSymbol(1, name, checkFlags);
- symbol.type = i === tupleRestIndex_1 ? createArrayType(t) : t;
- return symbol;
- });
- return ts.concatenate(sig.parameters.slice(0, restIndex_1), restParams);
- }
- }
- return sig.parameters;
- }
- function getDefaultConstructSignatures(classType) {
- var baseConstructorType = getBaseConstructorTypeOfClass(classType);
- var baseSignatures = getSignaturesOfType(baseConstructorType, 1);
- if (baseSignatures.length === 0) {
- return [createSignature(undefined, classType.localTypeParameters, undefined, ts.emptyArray, classType, undefined, 0, 0)];
- }
- var baseTypeNode = getBaseTypeNodeOfClass(classType);
- var isJavaScript = ts.isInJSFile(baseTypeNode);
- var typeArguments = typeArgumentsFromTypeReferenceNode(baseTypeNode);
- var typeArgCount = ts.length(typeArguments);
- var result = [];
- for (var _i = 0, baseSignatures_1 = baseSignatures; _i < baseSignatures_1.length; _i++) {
- var baseSig = baseSignatures_1[_i];
- var minTypeArgumentCount = getMinTypeArgumentCount(baseSig.typeParameters);
- var typeParamCount = ts.length(baseSig.typeParameters);
- if (isJavaScript || typeArgCount >= minTypeArgumentCount && typeArgCount <= typeParamCount) {
- var sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount, isJavaScript)) : cloneSignature(baseSig);
- sig.typeParameters = classType.localTypeParameters;
- sig.resolvedReturnType = classType;
- result.push(sig);
- }
- }
- return result;
- }
- function findMatchingSignature(signatureList, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes) {
- for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) {
- var s = signatureList_1[_i];
- if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, partialMatch ? compareTypesSubtypeOf : compareTypesIdentical)) {
- return s;
- }
- }
- }
- function findMatchingSignatures(signatureLists, signature, listIndex) {
- if (signature.typeParameters) {
- if (listIndex > 0) {
- return undefined;
+ ids.unshift(state);
+ return ids;
}
- for (var i = 1; i < signatureLists.length; i++) {
- if (!findMatchingSignature(signatureLists[i], signature, false, false, false)) {
- return undefined;
+ function createTypeNodesFromResolvedType(resolvedType) {
+ if (checkTruncationLength(context)) {
+ return [ts.factory.createPropertySignature(undefined, "...", undefined, undefined)];
}
+ var typeElements = [];
+ for (var _i = 0, _a = resolvedType.callSignatures; _i < _a.length; _i++) {
+ var signature = _a[_i];
+ typeElements.push(signatureToSignatureDeclarationHelper(signature, 169, context));
+ }
+ for (var _b = 0, _c = resolvedType.constructSignatures; _b < _c.length; _b++) {
+ var signature = _c[_b];
+ typeElements.push(signatureToSignatureDeclarationHelper(signature, 170, context));
+ }
+ if (resolvedType.stringIndexInfo) {
+ var indexSignature = void 0;
+ if (resolvedType.objectFlags & 2048) {
+ indexSignature = indexInfoToIndexSignatureDeclarationHelper(createIndexInfo(anyType, resolvedType.stringIndexInfo.isReadonly, resolvedType.stringIndexInfo.declaration), 0, context, createElidedInformationPlaceholder(context));
+ }
+ else {
+ indexSignature = indexInfoToIndexSignatureDeclarationHelper(resolvedType.stringIndexInfo, 0, context, undefined);
+ }
+ typeElements.push(indexSignature);
+ }
+ if (resolvedType.numberIndexInfo) {
+ typeElements.push(indexInfoToIndexSignatureDeclarationHelper(resolvedType.numberIndexInfo, 1, context, undefined));
+ }
+ var properties = resolvedType.properties;
+ if (!properties) {
+ return typeElements;
+ }
+ var i = 0;
+ for (var _d = 0, properties_1 = properties; _d < properties_1.length; _d++) {
+ var propertySymbol = properties_1[_d];
+ i++;
+ if (context.flags & 2048) {
+ if (propertySymbol.flags & 4194304) {
+ continue;
+ }
+ if (ts.getDeclarationModifierFlagsFromSymbol(propertySymbol) & (8 | 16) && context.tracker.reportPrivateInBaseOfClassExpression) {
+ context.tracker.reportPrivateInBaseOfClassExpression(ts.unescapeLeadingUnderscores(propertySymbol.escapedName));
+ }
+ }
+ if (checkTruncationLength(context) && (i + 2 < properties.length - 1)) {
+ typeElements.push(ts.factory.createPropertySignature(undefined, "... " + (properties.length - i) + " more ...", undefined, undefined));
+ addPropertyToElementList(properties[properties.length - 1], context, typeElements);
+ break;
+ }
+ addPropertyToElementList(propertySymbol, context, typeElements);
+ }
+ return typeElements.length ? typeElements : undefined;
}
- return [signature];
}
- var result;
- for (var i = 0; i < signatureLists.length; i++) {
- var match = i === listIndex ? signature : findMatchingSignature(signatureLists[i], signature, true, false, true);
- if (!match) {
- return undefined;
+ function createElidedInformationPlaceholder(context) {
+ context.approximateLength += 3;
+ if (!(context.flags & 1)) {
+ return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("..."), undefined);
}
- result = ts.appendIfUnique(result, match);
+ return ts.factory.createKeywordTypeNode(128);
}
- return result;
- }
- function getUnionSignatures(signatureLists) {
- var result;
- var indexWithLengthOverOne;
- for (var i = 0; i < signatureLists.length; i++) {
- if (signatureLists[i].length === 0)
- return ts.emptyArray;
- if (signatureLists[i].length > 1) {
- indexWithLengthOverOne = indexWithLengthOverOne === undefined ? i : -1;
- }
- for (var _i = 0, _a = signatureLists[i]; _i < _a.length; _i++) {
- var signature = _a[_i];
- if (!result || !findMatchingSignature(result, signature, false, false, true)) {
- var unionSignatures = findMatchingSignatures(signatureLists, signature, i);
- if (unionSignatures) {
- var s = signature;
- if (unionSignatures.length > 1) {
- var thisParameter = signature.thisParameter;
- var firstThisParameterOfUnionSignatures = ts.forEach(unionSignatures, function (sig) { return sig.thisParameter; });
- if (firstThisParameterOfUnionSignatures) {
- var thisType = getIntersectionType(ts.mapDefined(unionSignatures, function (sig) { return sig.thisParameter && getTypeOfSymbol(sig.thisParameter); }));
- thisParameter = createSymbolWithType(firstThisParameterOfUnionSignatures, thisType);
- }
- s = createUnionSignature(signature, unionSignatures);
- s.thisParameter = thisParameter;
+ function addPropertyToElementList(propertySymbol, context, typeElements) {
+ var propertyIsReverseMapped = !!(ts.getCheckFlags(propertySymbol) & 8192);
+ var propertyType = propertyIsReverseMapped && context.flags & 33554432 ?
+ anyType : getTypeOfSymbol(propertySymbol);
+ var saveEnclosingDeclaration = context.enclosingDeclaration;
+ context.enclosingDeclaration = undefined;
+ if (context.tracker.trackSymbol && ts.getCheckFlags(propertySymbol) & 4096) {
+ var decl = ts.first(propertySymbol.declarations);
+ if (hasLateBindableName(decl)) {
+ if (ts.isBinaryExpression(decl)) {
+ var name = ts.getNameOfDeclaration(decl);
+ if (name && ts.isElementAccessExpression(name) && ts.isPropertyAccessEntityNameExpression(name.argumentExpression)) {
+ trackComputedName(name.argumentExpression, saveEnclosingDeclaration, context);
}
- (result || (result = [])).push(s);
}
- }
- }
- }
- if (!ts.length(result) && indexWithLengthOverOne !== -1) {
- var masterList = signatureLists[indexWithLengthOverOne !== undefined ? indexWithLengthOverOne : 0];
- var results = masterList.slice();
- var _loop_9 = function (signatures) {
- if (signatures !== masterList) {
- var signature_1 = signatures[0];
- ts.Debug.assert(!!signature_1, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass");
- results = signature_1.typeParameters && ts.some(results, function (s) { return !!s.typeParameters; }) ? undefined : ts.map(results, function (sig) { return combineSignaturesOfUnionMembers(sig, signature_1); });
- if (!results) {
- return "break";
+ else {
+ trackComputedName(decl.name.expression, saveEnclosingDeclaration, context);
}
}
- };
- for (var _b = 0, signatureLists_1 = signatureLists; _b < signatureLists_1.length; _b++) {
- var signatures = signatureLists_1[_b];
- var state_3 = _loop_9(signatures);
- if (state_3 === "break")
- break;
- }
- result = results;
- }
- return result || ts.emptyArray;
- }
- function combineUnionThisParam(left, right) {
- if (!left || !right) {
- return left || right;
- }
- var thisType = getIntersectionType([getTypeOfSymbol(left), getTypeOfSymbol(right)]);
- return createSymbolWithType(left, thisType);
- }
- function combineUnionParameters(left, right) {
- var leftCount = getParameterCount(left);
- var rightCount = getParameterCount(right);
- var longest = leftCount >= rightCount ? left : right;
- var shorter = longest === left ? right : left;
- var longestCount = longest === left ? leftCount : rightCount;
- var eitherHasEffectiveRest = (hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right));
- var needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest);
- var params = new Array(longestCount + (needsExtraRestElement ? 1 : 0));
- for (var i = 0; i < longestCount; i++) {
- var longestParamType = tryGetTypeAtPosition(longest, i);
- var shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType;
- var unionParamType = getIntersectionType([longestParamType, shorterParamType]);
- var isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === (longestCount - 1);
- var isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter);
- var leftName = i >= leftCount ? undefined : getParameterNameAtPosition(left, i);
- var rightName = i >= rightCount ? undefined : getParameterNameAtPosition(right, i);
- var paramName = leftName === rightName ? leftName :
- !leftName ? rightName :
- !rightName ? leftName :
- undefined;
- var paramSymbol = createSymbol(1 | (isOptional && !isRestParam ? 16777216 : 0), paramName || "arg" + i);
- paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
- params[i] = paramSymbol;
- }
- if (needsExtraRestElement) {
- var restParamSymbol = createSymbol(1, "args");
- restParamSymbol.type = createArrayType(getTypeAtPosition(shorter, longestCount));
- params[longestCount] = restParamSymbol;
- }
- return params;
- }
- function combineSignaturesOfUnionMembers(left, right) {
- var declaration = left.declaration;
- var params = combineUnionParameters(left, right);
- var thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter);
- var minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount);
- var result = createSignature(declaration, left.typeParameters || right.typeParameters, thisParam, params, undefined, undefined, minArgCount, (left.flags | right.flags) & 3);
- result.unionSignatures = ts.concatenate(left.unionSignatures || [left], [right]);
- return result;
- }
- function getUnionIndexInfo(types, kind) {
- var indexTypes = [];
- var isAnyReadonly = false;
- for (var _i = 0, types_3 = types; _i < types_3.length; _i++) {
- var type = types_3[_i];
- var indexInfo = getIndexInfoOfType(getApparentType(type), kind);
- if (!indexInfo) {
- return undefined;
}
- indexTypes.push(indexInfo.type);
- isAnyReadonly = isAnyReadonly || indexInfo.isReadonly;
- }
- return createIndexInfo(getUnionType(indexTypes, 2), isAnyReadonly);
- }
- function resolveUnionTypeMembers(type) {
- var callSignatures = getUnionSignatures(ts.map(type.types, function (t) { return t === globalFunctionType ? [unknownSignature] : getSignaturesOfType(t, 0); }));
- var constructSignatures = getUnionSignatures(ts.map(type.types, function (t) { return getSignaturesOfType(t, 1); }));
- var stringIndexInfo = getUnionIndexInfo(type.types, 0);
- var numberIndexInfo = getUnionIndexInfo(type.types, 1);
- setStructuredTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
- }
- function intersectTypes(type1, type2) {
- return !type1 ? type2 : !type2 ? type1 : getIntersectionType([type1, type2]);
- }
- function intersectIndexInfos(info1, info2) {
- return !info1 ? info2 : !info2 ? info1 : createIndexInfo(getIntersectionType([info1.type, info2.type]), info1.isReadonly && info2.isReadonly);
- }
- function unionSpreadIndexInfos(info1, info2) {
- return info1 && info2 && createIndexInfo(getUnionType([info1.type, info2.type]), info1.isReadonly || info2.isReadonly);
- }
- function findMixins(types) {
- var constructorTypeCount = ts.countWhere(types, function (t) { return getSignaturesOfType(t, 1).length > 0; });
- var mixinFlags = ts.map(types, isMixinConstructorType);
- if (constructorTypeCount > 0 && constructorTypeCount === ts.countWhere(mixinFlags, function (b) { return b; })) {
- var firstMixinIndex = mixinFlags.indexOf(true);
- mixinFlags[firstMixinIndex] = false;
- }
- return mixinFlags;
- }
- function includeMixinType(type, types, mixinFlags, index) {
- var mixedTypes = [];
- for (var i = 0; i < types.length; i++) {
- if (i === index) {
- mixedTypes.push(type);
+ context.enclosingDeclaration = saveEnclosingDeclaration;
+ var propertyName = getPropertyNameNodeForSymbol(propertySymbol, context);
+ context.approximateLength += (ts.symbolName(propertySymbol).length + 1);
+ var optionalToken = propertySymbol.flags & 16777216 ? ts.factory.createToken(57) : undefined;
+ if (propertySymbol.flags & (16 | 8192) && !getPropertiesOfObjectType(propertyType).length && !isReadonlySymbol(propertySymbol)) {
+ var signatures = getSignaturesOfType(filterType(propertyType, function (t) { return !(t.flags & 32768); }), 0);
+ for (var _i = 0, signatures_1 = signatures; _i < signatures_1.length; _i++) {
+ var signature = signatures_1[_i];
+ var methodDeclaration = signatureToSignatureDeclarationHelper(signature, 164, context, { name: propertyName, questionToken: optionalToken });
+ typeElements.push(preserveCommentsOn(methodDeclaration));
+ }
}
- else if (mixinFlags[i]) {
- mixedTypes.push(getReturnTypeOfSignature(getSignaturesOfType(types[i], 1)[0]));
+ else {
+ var savedFlags = context.flags;
+ context.flags |= propertyIsReverseMapped ? 33554432 : 0;
+ var propertyTypeNode = void 0;
+ if (propertyIsReverseMapped && !!(savedFlags & 33554432)) {
+ propertyTypeNode = createElidedInformationPlaceholder(context);
+ }
+ else {
+ propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : ts.factory.createKeywordTypeNode(128);
+ }
+ context.flags = savedFlags;
+ var modifiers = isReadonlySymbol(propertySymbol) ? [ts.factory.createToken(142)] : undefined;
+ if (modifiers) {
+ context.approximateLength += 9;
+ }
+ var propertySignature = ts.factory.createPropertySignature(modifiers, propertyName, optionalToken, propertyTypeNode);
+ typeElements.push(preserveCommentsOn(propertySignature));
}
- }
- return getIntersectionType(mixedTypes);
- }
- function resolveIntersectionTypeMembers(type) {
- var callSignatures;
- var constructSignatures;
- var stringIndexInfo;
- var numberIndexInfo;
- var types = type.types;
- var mixinFlags = findMixins(types);
- var mixinCount = ts.countWhere(mixinFlags, function (b) { return b; });
- var _loop_10 = function (i) {
- var t = type.types[i];
- if (!mixinFlags[i]) {
- var signatures = getSignaturesOfType(t, 1);
- if (signatures.length && mixinCount > 0) {
- signatures = ts.map(signatures, function (s) {
- var clone = cloneSignature(s);
- clone.resolvedReturnType = includeMixinType(getReturnTypeOfSignature(s), types, mixinFlags, i);
- return clone;
- });
+ function preserveCommentsOn(node) {
+ if (ts.some(propertySymbol.declarations, function (d) { return d.kind === 333; })) {
+ var d = ts.find(propertySymbol.declarations, function (d) { return d.kind === 333; });
+ var commentText = d.comment;
+ if (commentText) {
+ ts.setSyntheticLeadingComments(node, [{ kind: 3, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]);
+ }
}
- constructSignatures = appendSignatures(constructSignatures, signatures);
+ else if (propertySymbol.valueDeclaration) {
+ ts.setCommentRange(node, propertySymbol.valueDeclaration);
+ }
+ return node;
}
- callSignatures = appendSignatures(callSignatures, getSignaturesOfType(t, 0));
- stringIndexInfo = intersectIndexInfos(stringIndexInfo, getIndexInfoOfType(t, 0));
- numberIndexInfo = intersectIndexInfos(numberIndexInfo, getIndexInfoOfType(t, 1));
- };
- for (var i = 0; i < types.length; i++) {
- _loop_10(i);
}
- setStructuredTypeMembers(type, emptySymbols, callSignatures || ts.emptyArray, constructSignatures || ts.emptyArray, stringIndexInfo, numberIndexInfo);
- }
- function appendSignatures(signatures, newSignatures) {
- var _loop_11 = function (sig) {
- if (!signatures || ts.every(signatures, function (s) { return !compareSignaturesIdentical(s, sig, false, false, false, compareTypesIdentical); })) {
- signatures = ts.append(signatures, sig);
+ function mapToTypeNodes(types, context, isBareList) {
+ if (ts.some(types)) {
+ if (checkTruncationLength(context)) {
+ if (!isBareList) {
+ return [ts.factory.createTypeReferenceNode("...", undefined)];
+ }
+ else if (types.length > 2) {
+ return [
+ typeToTypeNodeHelper(types[0], context),
+ ts.factory.createTypeReferenceNode("... " + (types.length - 2) + " more ...", undefined),
+ typeToTypeNodeHelper(types[types.length - 1], context)
+ ];
+ }
+ }
+ var mayHaveNameCollisions = !(context.flags & 64);
+ var seenNames = mayHaveNameCollisions ? ts.createUnderscoreEscapedMultiMap() : undefined;
+ var result_4 = [];
+ var i = 0;
+ for (var _i = 0, types_2 = types; _i < types_2.length; _i++) {
+ var type = types_2[_i];
+ i++;
+ if (checkTruncationLength(context) && (i + 2 < types.length - 1)) {
+ result_4.push(ts.factory.createTypeReferenceNode("... " + (types.length - i) + " more ...", undefined));
+ var typeNode_1 = typeToTypeNodeHelper(types[types.length - 1], context);
+ if (typeNode_1) {
+ result_4.push(typeNode_1);
+ }
+ break;
+ }
+ context.approximateLength += 2;
+ var typeNode = typeToTypeNodeHelper(type, context);
+ if (typeNode) {
+ result_4.push(typeNode);
+ if (seenNames && ts.isIdentifierTypeReference(typeNode)) {
+ seenNames.add(typeNode.typeName.escapedText, [type, result_4.length - 1]);
+ }
+ }
+ }
+ if (seenNames) {
+ var saveContextFlags = context.flags;
+ context.flags |= 64;
+ seenNames.forEach(function (types) {
+ if (!ts.arrayIsHomogeneous(types, function (_a, _b) {
+ var a = _a[0];
+ var b = _b[0];
+ return typesAreSameReference(a, b);
+ })) {
+ for (var _i = 0, types_3 = types; _i < types_3.length; _i++) {
+ var _a = types_3[_i], type = _a[0], resultIndex = _a[1];
+ result_4[resultIndex] = typeToTypeNodeHelper(type, context);
+ }
+ }
+ });
+ context.flags = saveContextFlags;
+ }
+ return result_4;
}
- };
- for (var _i = 0, newSignatures_1 = newSignatures; _i < newSignatures_1.length; _i++) {
- var sig = newSignatures_1[_i];
- _loop_11(sig);
}
- return signatures;
- }
- function resolveAnonymousTypeMembers(type) {
- var symbol = getMergedSymbol(type.symbol);
- if (type.target) {
- setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- var members = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, false);
- var callSignatures = instantiateSignatures(getSignaturesOfType(type.target, 0), type.mapper);
- var constructSignatures = instantiateSignatures(getSignaturesOfType(type.target, 1), type.mapper);
- var stringIndexInfo = instantiateIndexInfo(getIndexInfoOfType(type.target, 0), type.mapper);
- var numberIndexInfo = instantiateIndexInfo(getIndexInfoOfType(type.target, 1), type.mapper);
- setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+ function typesAreSameReference(a, b) {
+ return a === b
+ || !!a.symbol && a.symbol === b.symbol
+ || !!a.aliasSymbol && a.aliasSymbol === b.aliasSymbol;
}
- else if (symbol.flags & 2048) {
- setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- var members = getMembersOfSymbol(symbol);
- var callSignatures = getSignaturesOfSymbol(members.get("__call"));
- var constructSignatures = getSignaturesOfSymbol(members.get("__new"));
- var stringIndexInfo = getIndexInfoOfSymbol(symbol, 0);
- var numberIndexInfo = getIndexInfoOfSymbol(symbol, 1);
- setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+ function indexInfoToIndexSignatureDeclarationHelper(indexInfo, kind, context, typeNode) {
+ var name = ts.getNameFromIndexInfo(indexInfo) || "x";
+ var indexerTypeNode = ts.factory.createKeywordTypeNode(kind === 0 ? 147 : 144);
+ var indexingParameter = ts.factory.createParameterDeclaration(undefined, undefined, undefined, name, undefined, indexerTypeNode, undefined);
+ if (!typeNode) {
+ typeNode = typeToTypeNodeHelper(indexInfo.type || anyType, context);
+ }
+ if (!indexInfo.type && !(context.flags & 2097152)) {
+ context.encounteredError = true;
+ }
+ context.approximateLength += (name.length + 4);
+ return ts.factory.createIndexSignature(undefined, indexInfo.isReadonly ? [ts.factory.createToken(142)] : undefined, [indexingParameter], typeNode);
}
- else {
- var members = emptySymbols;
- var stringIndexInfo = void 0;
- if (symbol.exports) {
- members = getExportsOfSymbol(symbol);
- if (symbol === globalThisSymbol) {
- var varsOnly_1 = ts.createMap();
- members.forEach(function (p) {
- if (!(p.flags & 418)) {
- varsOnly_1.set(p.escapedName, p);
- }
- });
- members = varsOnly_1;
- }
+ function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
+ var _a, _b, _c, _d;
+ var suppressAny = context.flags & 256;
+ if (suppressAny)
+ context.flags &= ~256;
+ var typeParameters;
+ var typeArguments;
+ if (context.flags & 32 && signature.target && signature.mapper && signature.target.typeParameters) {
+ typeArguments = signature.target.typeParameters.map(function (parameter) { return typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context); });
}
- setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, undefined, undefined);
- if (symbol.flags & 32) {
- var classType = getDeclaredTypeOfClassOrInterface(symbol);
- var baseConstructorType = getBaseConstructorTypeOfClass(classType);
- if (baseConstructorType.flags & (524288 | 2097152 | 8650752)) {
- members = ts.createSymbolTable(getNamedMembers(members));
- addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
- }
- else if (baseConstructorType === anyType) {
- stringIndexInfo = createIndexInfo(anyType, false);
- }
+ else {
+ typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return typeParameterToDeclaration(parameter, context); });
}
- var numberIndexInfo = symbol.flags & 384 && (getDeclaredTypeOfSymbol(symbol).flags & 32 ||
- ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296); })) ? enumNumberIndexInfo : undefined;
- setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo);
- if (symbol.flags & (16 | 8192)) {
- type.callSignatures = getSignaturesOfSymbol(symbol);
+ var expandedParams = getExpandedParameters(signature, true)[0];
+ var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 166, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); });
+ if (signature.thisParameter) {
+ var thisParameter = symbolToParameterDeclaration(signature.thisParameter, context);
+ parameters.unshift(thisParameter);
}
- if (symbol.flags & 32) {
- var classType_1 = getDeclaredTypeOfClassOrInterface(symbol);
- var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor")) : ts.emptyArray;
- if (symbol.flags & 16) {
- constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ?
- createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, undefined, sig.minArgumentCount, sig.flags & 3) :
- undefined; }));
+ var returnTypeNode;
+ var typePredicate = getTypePredicateOfSignature(signature);
+ if (typePredicate) {
+ var assertsModifier = typePredicate.kind === 2 || typePredicate.kind === 3 ?
+ ts.factory.createToken(127) :
+ undefined;
+ var parameterName = typePredicate.kind === 1 || typePredicate.kind === 3 ?
+ ts.setEmitFlags(ts.factory.createIdentifier(typePredicate.parameterName), 16777216) :
+ ts.factory.createThisTypeNode();
+ var typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context);
+ returnTypeNode = ts.factory.createTypePredicateNode(assertsModifier, parameterName, typeNode);
+ }
+ else {
+ var returnType = getReturnTypeOfSignature(signature);
+ if (returnType && !(suppressAny && isTypeAny(returnType))) {
+ returnTypeNode = serializeReturnTypeForSignature(context, returnType, signature, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports);
}
- if (!constructSignatures.length) {
- constructSignatures = getDefaultConstructSignatures(classType_1);
+ else if (!suppressAny) {
+ returnTypeNode = ts.factory.createKeywordTypeNode(128);
}
- type.constructSignatures = constructSignatures;
}
+ context.approximateLength += 3;
+ var node = kind === 169 ? ts.factory.createCallSignature(typeParameters, parameters, returnTypeNode) :
+ kind === 170 ? ts.factory.createConstructSignature(typeParameters, parameters, returnTypeNode) :
+ kind === 164 ? ts.factory.createMethodSignature(options === null || options === void 0 ? void 0 : options.modifiers, (_a = options === null || options === void 0 ? void 0 : options.name) !== null && _a !== void 0 ? _a : ts.factory.createIdentifier(""), options === null || options === void 0 ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) :
+ kind === 165 ? ts.factory.createMethodDeclaration(undefined, options === null || options === void 0 ? void 0 : options.modifiers, undefined, (_b = options === null || options === void 0 ? void 0 : options.name) !== null && _b !== void 0 ? _b : ts.factory.createIdentifier(""), undefined, typeParameters, parameters, returnTypeNode, undefined) :
+ kind === 166 ? ts.factory.createConstructorDeclaration(undefined, options === null || options === void 0 ? void 0 : options.modifiers, parameters, undefined) :
+ kind === 167 ? ts.factory.createGetAccessorDeclaration(undefined, options === null || options === void 0 ? void 0 : options.modifiers, (_c = options === null || options === void 0 ? void 0 : options.name) !== null && _c !== void 0 ? _c : ts.factory.createIdentifier(""), parameters, returnTypeNode, undefined) :
+ kind === 168 ? ts.factory.createSetAccessorDeclaration(undefined, options === null || options === void 0 ? void 0 : options.modifiers, (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : ts.factory.createIdentifier(""), parameters, undefined) :
+ kind === 171 ? ts.factory.createIndexSignature(undefined, options === null || options === void 0 ? void 0 : options.modifiers, parameters, returnTypeNode) :
+ kind === 308 ? ts.factory.createJSDocFunctionType(parameters, returnTypeNode) :
+ kind === 174 ? ts.factory.createFunctionTypeNode(typeParameters, parameters, returnTypeNode !== null && returnTypeNode !== void 0 ? returnTypeNode : ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""))) :
+ kind === 175 ? ts.factory.createConstructorTypeNode(typeParameters, parameters, returnTypeNode !== null && returnTypeNode !== void 0 ? returnTypeNode : ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""))) :
+ kind === 251 ? ts.factory.createFunctionDeclaration(undefined, options === null || options === void 0 ? void 0 : options.modifiers, undefined, (options === null || options === void 0 ? void 0 : options.name) ? ts.cast(options.name, ts.isIdentifier) : ts.factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, undefined) :
+ kind === 208 ? ts.factory.createFunctionExpression(options === null || options === void 0 ? void 0 : options.modifiers, undefined, (options === null || options === void 0 ? void 0 : options.name) ? ts.cast(options.name, ts.isIdentifier) : ts.factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, ts.factory.createBlock([])) :
+ kind === 209 ? ts.factory.createArrowFunction(options === null || options === void 0 ? void 0 : options.modifiers, typeParameters, parameters, returnTypeNode, undefined, ts.factory.createBlock([])) :
+ ts.Debug.assertNever(kind);
+ if (typeArguments) {
+ node.typeArguments = ts.factory.createNodeArray(typeArguments);
+ }
+ return node;
}
- }
- function resolveReverseMappedTypeMembers(type) {
- var indexInfo = getIndexInfoOfType(type.source, 0);
- var modifiers = getMappedTypeModifiers(type.mappedType);
- var readonlyMask = modifiers & 1 ? false : true;
- var optionalMask = modifiers & 4 ? 0 : 16777216;
- var stringIndexInfo = indexInfo && createIndexInfo(inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly);
- var members = ts.createSymbolTable();
- for (var _i = 0, _a = getPropertiesOfType(type.source); _i < _a.length; _i++) {
- var prop = _a[_i];
- var checkFlags = 8192 | (readonlyMask && isReadonlySymbol(prop) ? 8 : 0);
- var inferredProp = createSymbol(4 | prop.flags & optionalMask, prop.escapedName, checkFlags);
- inferredProp.declarations = prop.declarations;
- inferredProp.nameType = getSymbolLinks(prop).nameType;
- inferredProp.propertyType = getTypeOfSymbol(prop);
- inferredProp.mappedType = type.mappedType;
- inferredProp.constraintType = type.constraintType;
- members.set(prop.escapedName, inferredProp);
- }
- setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, undefined);
- }
- function getLowerBoundOfKeyType(type) {
- if (type.flags & (1 | 131068)) {
- return type;
+ function typeParameterToDeclarationWithConstraint(type, context, constraintNode) {
+ var savedContextFlags = context.flags;
+ context.flags &= ~512;
+ var name = typeParameterToName(type, context);
+ var defaultParameter = getDefaultFromTypeParameter(type);
+ var defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context);
+ context.flags = savedContextFlags;
+ return ts.factory.createTypeParameterDeclaration(name, constraintNode, defaultParameterNode);
}
- if (type.flags & 4194304) {
- return getIndexType(getApparentType(type.type));
+ function typeParameterToDeclaration(type, context, constraint) {
+ if (constraint === void 0) { constraint = getConstraintOfTypeParameter(type); }
+ var constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
+ return typeParameterToDeclarationWithConstraint(type, context, constraintNode);
}
- if (type.flags & 16777216) {
- if (type.root.isDistributive) {
- var checkType = type.checkType;
- var constraint = getLowerBoundOfKeyType(checkType);
- if (constraint !== checkType) {
- return getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+ function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
+ var parameterDeclaration = ts.getDeclarationOfKind(parameterSymbol, 160);
+ if (!parameterDeclaration && !ts.isTransientSymbol(parameterSymbol)) {
+ parameterDeclaration = ts.getDeclarationOfKind(parameterSymbol, 326);
+ }
+ var parameterType = getTypeOfSymbol(parameterSymbol);
+ if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
+ parameterType = getOptionalType(parameterType);
+ }
+ if ((context.flags & 1073741824) && parameterDeclaration && !ts.isJSDocParameterTag(parameterDeclaration) && isOptionalUninitializedParameter(parameterDeclaration)) {
+ parameterType = getTypeWithFacts(parameterType, 524288);
+ }
+ var parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports);
+ var modifiers = !(context.flags & 8192) && preserveModifierFlags && parameterDeclaration && parameterDeclaration.modifiers ? parameterDeclaration.modifiers.map(ts.factory.cloneNode) : undefined;
+ var isRest = parameterDeclaration && ts.isRestParameter(parameterDeclaration) || ts.getCheckFlags(parameterSymbol) & 32768;
+ var dotDotDotToken = isRest ? ts.factory.createToken(25) : undefined;
+ var name = parameterDeclaration ? parameterDeclaration.name ?
+ parameterDeclaration.name.kind === 78 ? ts.setEmitFlags(ts.factory.cloneNode(parameterDeclaration.name), 16777216) :
+ parameterDeclaration.name.kind === 157 ? ts.setEmitFlags(ts.factory.cloneNode(parameterDeclaration.name.right), 16777216) :
+ cloneBindingName(parameterDeclaration.name) :
+ ts.symbolName(parameterSymbol) :
+ ts.symbolName(parameterSymbol);
+ var isOptional = parameterDeclaration && isOptionalParameter(parameterDeclaration) || ts.getCheckFlags(parameterSymbol) & 16384;
+ var questionToken = isOptional ? ts.factory.createToken(57) : undefined;
+ var parameterNode = ts.factory.createParameterDeclaration(undefined, modifiers, dotDotDotToken, name, questionToken, parameterTypeNode, undefined);
+ context.approximateLength += ts.symbolName(parameterSymbol).length + 3;
+ return parameterNode;
+ function cloneBindingName(node) {
+ return elideInitializerAndSetEmitFlags(node);
+ function elideInitializerAndSetEmitFlags(node) {
+ if (context.tracker.trackSymbol && ts.isComputedPropertyName(node) && isLateBindableName(node)) {
+ trackComputedName(node.expression, context.enclosingDeclaration, context);
+ }
+ var visited = ts.visitEachChild(node, elideInitializerAndSetEmitFlags, ts.nullTransformationContext, undefined, elideInitializerAndSetEmitFlags);
+ if (ts.isBindingElement(visited)) {
+ visited = ts.factory.updateBindingElement(visited, visited.dotDotDotToken, visited.propertyName, visited.name, undefined);
+ }
+ if (!ts.nodeIsSynthesized(visited)) {
+ visited = ts.factory.cloneNode(visited);
+ }
+ return ts.setEmitFlags(visited, 1 | 16777216);
}
}
- return type;
}
- if (type.flags & 1048576) {
- return getUnionType(ts.sameMap(type.types, getLowerBoundOfKeyType));
+ function trackComputedName(accessExpression, enclosingDeclaration, context) {
+ if (!context.tracker.trackSymbol)
+ return;
+ var firstIdentifier = ts.getFirstIdentifier(accessExpression);
+ var name = resolveName(firstIdentifier, firstIdentifier.escapedText, 111551 | 1048576, undefined, undefined, true);
+ if (name) {
+ context.tracker.trackSymbol(name, enclosingDeclaration, 111551);
+ }
}
- if (type.flags & 2097152) {
- return getIntersectionType(ts.sameMap(type.types, getLowerBoundOfKeyType));
+ function lookupSymbolChain(symbol, context, meaning, yieldModuleSymbol) {
+ context.tracker.trackSymbol(symbol, context.enclosingDeclaration, meaning);
+ return lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol);
}
- return neverType;
- }
- function resolveMappedTypeMembers(type) {
- var members = ts.createSymbolTable();
- var stringIndexInfo;
- var numberIndexInfo;
- setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
- var typeParameter = getTypeParameterFromMappedType(type);
- var constraintType = getConstraintTypeFromMappedType(type);
- var templateType = getTemplateTypeFromMappedType(type.target || type);
- var modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
- var templateModifiers = getMappedTypeModifiers(type);
- var include = keyofStringsOnly ? 128 : 8576;
- if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
- for (var _i = 0, _a = getPropertiesOfType(modifiersType); _i < _a.length; _i++) {
- var prop = _a[_i];
- addMemberForKeyType(getLiteralTypeFromProperty(prop, include));
+ function lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol) {
+ var chain;
+ var isTypeParameter = symbol.flags & 262144;
+ if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64) && !(context.flags & 134217728)) {
+ chain = ts.Debug.checkDefined(getSymbolChain(symbol, meaning, true));
+ ts.Debug.assert(chain && chain.length > 0);
}
- if (modifiersType.flags & 1 || getIndexInfoOfType(modifiersType, 0)) {
- addMemberForKeyType(stringType);
+ else {
+ chain = [symbol];
}
- if (!keyofStringsOnly && getIndexInfoOfType(modifiersType, 1)) {
- addMemberForKeyType(numberType);
+ return chain;
+ function getSymbolChain(symbol, meaning, endOfChain) {
+ var accessibleSymbolChain = getAccessibleSymbolChain(symbol, context.enclosingDeclaration, meaning, !!(context.flags & 128));
+ var parentSpecifiers;
+ if (!accessibleSymbolChain ||
+ needsQualification(accessibleSymbolChain[0], context.enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {
+ var parents_1 = getContainersOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol, context.enclosingDeclaration, meaning);
+ if (ts.length(parents_1)) {
+ parentSpecifiers = parents_1.map(function (symbol) {
+ return ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)
+ ? getSpecifierForModuleSymbol(symbol, context)
+ : undefined;
+ });
+ var indices = parents_1.map(function (_, i) { return i; });
+ indices.sort(sortByBestName);
+ var sortedParents = indices.map(function (i) { return parents_1[i]; });
+ for (var _i = 0, sortedParents_1 = sortedParents; _i < sortedParents_1.length; _i++) {
+ var parent = sortedParents_1[_i];
+ var parentChain = getSymbolChain(parent, getQualifiedLeftMeaning(meaning), false);
+ if (parentChain) {
+ if (parent.exports && parent.exports.get("export=") &&
+ getSymbolIfSameReference(parent.exports.get("export="), symbol)) {
+ accessibleSymbolChain = parentChain;
+ break;
+ }
+ accessibleSymbolChain = parentChain.concat(accessibleSymbolChain || [getAliasForSymbolInContainer(parent, symbol) || symbol]);
+ break;
+ }
+ }
+ }
+ }
+ if (accessibleSymbolChain) {
+ return accessibleSymbolChain;
+ }
+ if (endOfChain ||
+ !(symbol.flags & (2048 | 4096))) {
+ if (!endOfChain && !yieldModuleSymbol && !!ts.forEach(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
+ return;
+ }
+ return [symbol];
+ }
+ function sortByBestName(a, b) {
+ var specifierA = parentSpecifiers[a];
+ var specifierB = parentSpecifiers[b];
+ if (specifierA && specifierB) {
+ var isBRelative = ts.pathIsRelative(specifierB);
+ if (ts.pathIsRelative(specifierA) === isBRelative) {
+ return ts.moduleSpecifiers.countPathComponents(specifierA) - ts.moduleSpecifiers.countPathComponents(specifierB);
+ }
+ if (isBRelative) {
+ return -1;
+ }
+ return 1;
+ }
+ return 0;
+ }
}
}
- else {
- forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
+ function typeParametersToTypeParameterDeclarations(symbol, context) {
+ var typeParameterNodes;
+ var targetSymbol = getTargetSymbol(symbol);
+ if (targetSymbol.flags & (32 | 64 | 524288)) {
+ typeParameterNodes = ts.factory.createNodeArray(ts.map(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), function (tp) { return typeParameterToDeclaration(tp, context); }));
+ }
+ return typeParameterNodes;
}
- setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo);
- function addMemberForKeyType(t) {
- var templateMapper = appendTypeMapping(type.mapper, typeParameter, t);
- if (isTypeUsableAsPropertyName(t)) {
- var propName = getPropertyNameFromType(t);
- var modifiersProp = getPropertyOfType(modifiersType, propName);
- var isOptional = !!(templateModifiers & 4 ||
- !(templateModifiers & 8) && modifiersProp && modifiersProp.flags & 16777216);
- var isReadonly = !!(templateModifiers & 1 ||
- !(templateModifiers & 2) && modifiersProp && isReadonlySymbol(modifiersProp));
- var stripOptional = strictNullChecks && !isOptional && modifiersProp && modifiersProp.flags & 16777216;
- var prop = createSymbol(4 | (isOptional ? 16777216 : 0), propName, 262144 | (isReadonly ? 8 : 0) | (stripOptional ? 524288 : 0));
- prop.mappedType = type;
- prop.mapper = templateMapper;
- if (modifiersProp) {
- prop.syntheticOrigin = modifiersProp;
- prop.declarations = modifiersProp.declarations;
- }
- prop.nameType = t;
- members.set(propName, prop);
- }
- else if (t.flags & (1 | 4 | 8 | 32)) {
- var propType = instantiateType(templateType, templateMapper);
- if (t.flags & (1 | 4)) {
- stringIndexInfo = createIndexInfo(propType, !!(templateModifiers & 1));
+ function lookupTypeParameterNodes(chain, index, context) {
+ var _a;
+ ts.Debug.assert(chain && 0 <= index && index < chain.length);
+ var symbol = chain[index];
+ var symbolId = getSymbolId(symbol);
+ if ((_a = context.typeParameterSymbolList) === null || _a === void 0 ? void 0 : _a.has(symbolId)) {
+ return undefined;
+ }
+ (context.typeParameterSymbolList || (context.typeParameterSymbolList = new ts.Set())).add(symbolId);
+ var typeParameterNodes;
+ if (context.flags & 512 && index < (chain.length - 1)) {
+ var parentSymbol = symbol;
+ var nextSymbol_1 = chain[index + 1];
+ if (ts.getCheckFlags(nextSymbol_1) & 1) {
+ var params = getTypeParametersOfClassOrInterface(parentSymbol.flags & 2097152 ? resolveAlias(parentSymbol) : parentSymbol);
+ typeParameterNodes = mapToTypeNodes(ts.map(params, function (t) { return getMappedType(t, nextSymbol_1.mapper); }), context);
}
else {
- numberIndexInfo = createIndexInfo(numberIndexInfo ? getUnionType([numberIndexInfo.type, propType]) : propType, !!(templateModifiers & 1));
+ typeParameterNodes = typeParametersToTypeParameterDeclarations(symbol, context);
}
}
+ return typeParameterNodes;
}
- }
- function getTypeOfMappedSymbol(symbol) {
- if (!symbol.type) {
- if (!pushTypeResolution(symbol, 0)) {
- return errorType;
+ function getTopmostIndexedAccessType(top) {
+ if (ts.isIndexedAccessTypeNode(top.objectType)) {
+ return getTopmostIndexedAccessType(top.objectType);
}
- var templateType = getTemplateTypeFromMappedType(symbol.mappedType.target || symbol.mappedType);
- var propType = instantiateType(templateType, symbol.mapper);
- var type = strictNullChecks && symbol.flags & 16777216 && !maybeTypeOfKind(propType, 32768 | 16384) ? getOptionalType(propType) :
- symbol.checkFlags & 524288 ? getTypeWithFacts(propType, 524288) :
- propType;
- if (!popTypeResolution()) {
- error(currentNode, ts.Diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1, symbolToString(symbol), typeToString(symbol.mappedType));
- type = errorType;
+ return top;
+ }
+ function getSpecifierForModuleSymbol(symbol, context) {
+ var _a;
+ var file = ts.getDeclarationOfKind(symbol, 297);
+ if (!file) {
+ var equivalentFileSymbol = ts.firstDefined(symbol.declarations, function (d) { return getFileSymbolIfFileSymbolExportEqualsContainer(d, symbol); });
+ if (equivalentFileSymbol) {
+ file = ts.getDeclarationOfKind(equivalentFileSymbol, 297);
+ }
}
- symbol.type = type;
- symbol.mapper = undefined;
+ if (file && file.moduleName !== undefined) {
+ return file.moduleName;
+ }
+ if (!file) {
+ if (context.tracker.trackReferencedAmbientModule) {
+ var ambientDecls = ts.filter(symbol.declarations, ts.isAmbientModule);
+ if (ts.length(ambientDecls)) {
+ for (var _i = 0, ambientDecls_1 = ambientDecls; _i < ambientDecls_1.length; _i++) {
+ var decl = ambientDecls_1[_i];
+ context.tracker.trackReferencedAmbientModule(decl, symbol);
+ }
+ }
+ }
+ if (ambientModuleSymbolRegex.test(symbol.escapedName)) {
+ return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
+ }
+ }
+ if (!context.enclosingDeclaration || !context.tracker.moduleResolverHost) {
+ if (ambientModuleSymbolRegex.test(symbol.escapedName)) {
+ return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
+ }
+ return ts.getSourceFileOfNode(ts.getNonAugmentationDeclaration(symbol)).fileName;
+ }
+ var contextFile = ts.getSourceFileOfNode(ts.getOriginalNode(context.enclosingDeclaration));
+ var links = getSymbolLinks(symbol);
+ var specifier = links.specifierCache && links.specifierCache.get(contextFile.path);
+ if (!specifier) {
+ var isBundle_1 = !!ts.outFile(compilerOptions);
+ var moduleResolverHost = context.tracker.moduleResolverHost;
+ var specifierCompilerOptions = isBundle_1 ? __assign(__assign({}, compilerOptions), { baseUrl: moduleResolverHost.getCommonSourceDirectory() }) : compilerOptions;
+ specifier = ts.first(ts.moduleSpecifiers.getModuleSpecifiers(symbol, specifierCompilerOptions, contextFile, moduleResolverHost, { importModuleSpecifierPreference: isBundle_1 ? "non-relative" : "relative", importModuleSpecifierEnding: isBundle_1 ? "minimal" : undefined }));
+ (_a = links.specifierCache) !== null && _a !== void 0 ? _a : (links.specifierCache = new ts.Map());
+ links.specifierCache.set(contextFile.path, specifier);
+ }
+ return specifier;
}
- 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 getTemplateTypeFromMappedType(type) {
- return type.templateType ||
- (type.templateType = type.declaration.type ?
- instantiateType(addOptionality(getTypeFromTypeNode(type.declaration.type), !!(getMappedTypeModifiers(type) & 4)), type.mapper) :
- errorType);
- }
- function getConstraintDeclarationForMappedType(type) {
- return ts.getEffectiveConstraintOfTypeParameter(type.declaration.typeParameter);
- }
- function isMappedTypeWithKeyofConstraintDeclaration(type) {
- var constraintDeclaration = getConstraintDeclarationForMappedType(type);
- return constraintDeclaration.kind === 184 &&
- constraintDeclaration.operator === 134;
- }
- function getModifiersTypeFromMappedType(type) {
- if (!type.modifiersType) {
- if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
- type.modifiersType = instantiateType(getTypeFromTypeNode(getConstraintDeclarationForMappedType(type).type), type.mapper);
+ function symbolToTypeNode(symbol, context, meaning, overrideTypeArguments) {
+ var chain = lookupSymbolChain(symbol, context, meaning, !(context.flags & 16384));
+ var isTypeOf = meaning === 111551;
+ if (ts.some(chain[0].declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
+ var nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(chain, chain.length - 1, 1) : undefined;
+ var typeParameterNodes = overrideTypeArguments || lookupTypeParameterNodes(chain, 0, context);
+ var specifier = getSpecifierForModuleSymbol(chain[0], context);
+ if (!(context.flags & 67108864) && ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs && specifier.indexOf("/node_modules/") >= 0) {
+ context.encounteredError = true;
+ if (context.tracker.reportLikelyUnsafeImportRequiredError) {
+ context.tracker.reportLikelyUnsafeImportRequiredError(specifier);
+ }
+ }
+ var lit = ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(specifier));
+ if (context.tracker.trackExternalModuleSymbolOfImportTypeNode)
+ context.tracker.trackExternalModuleSymbolOfImportTypeNode(chain[0]);
+ context.approximateLength += specifier.length + 10;
+ if (!nonRootParts || ts.isEntityName(nonRootParts)) {
+ if (nonRootParts) {
+ var lastId = ts.isIdentifier(nonRootParts) ? nonRootParts : nonRootParts.right;
+ lastId.typeArguments = undefined;
+ }
+ return ts.factory.createImportTypeNode(lit, nonRootParts, typeParameterNodes, isTypeOf);
+ }
+ else {
+ var splitNode = getTopmostIndexedAccessType(nonRootParts);
+ var qualifier = splitNode.objectType.typeName;
+ return ts.factory.createIndexedAccessTypeNode(ts.factory.createImportTypeNode(lit, qualifier, typeParameterNodes, isTypeOf), splitNode.indexType);
+ }
+ }
+ var entityName = createAccessFromSymbolChain(chain, chain.length - 1, 0);
+ if (ts.isIndexedAccessTypeNode(entityName)) {
+ return entityName;
+ }
+ if (isTypeOf) {
+ return ts.factory.createTypeQueryNode(entityName);
}
else {
- var declaredType = getTypeFromMappedTypeNode(type.declaration);
- var constraint = getConstraintTypeFromMappedType(declaredType);
- var extendedConstraint = constraint && constraint.flags & 262144 ? getConstraintOfTypeParameter(constraint) : constraint;
- type.modifiersType = extendedConstraint && extendedConstraint.flags & 4194304 ? instantiateType(extendedConstraint.type, type.mapper) : unknownType;
+ var lastId = ts.isIdentifier(entityName) ? entityName : entityName.right;
+ var lastTypeArgs = lastId.typeArguments;
+ lastId.typeArguments = undefined;
+ return ts.factory.createTypeReferenceNode(entityName, lastTypeArgs);
}
- }
- return type.modifiersType;
- }
- function getMappedTypeModifiers(type) {
- var declaration = type.declaration;
- return (declaration.readonlyToken ? declaration.readonlyToken.kind === 40 ? 2 : 1 : 0) |
- (declaration.questionToken ? declaration.questionToken.kind === 40 ? 8 : 4 : 0);
- }
- function getMappedTypeOptionality(type) {
- var modifiers = getMappedTypeModifiers(type);
- return modifiers & 8 ? -1 : modifiers & 4 ? 1 : 0;
- }
- function getCombinedMappedTypeOptionality(type) {
- var optionality = getMappedTypeOptionality(type);
- var modifiersType = getModifiersTypeFromMappedType(type);
- return optionality || (isGenericMappedType(modifiersType) ? getMappedTypeOptionality(modifiersType) : 0);
- }
- function isPartialMappedType(type) {
- return !!(ts.getObjectFlags(type) & 32 && getMappedTypeModifiers(type) & 4);
- }
- function isGenericMappedType(type) {
- return !!(ts.getObjectFlags(type) & 32) && isGenericIndexType(getConstraintTypeFromMappedType(type));
- }
- function resolveStructuredTypeMembers(type) {
- if (!type.members) {
- if (type.flags & 524288) {
- if (type.objectFlags & 4) {
- resolveTypeReferenceMembers(type);
+ function createAccessFromSymbolChain(chain, index, stopper) {
+ var typeParameterNodes = index === (chain.length - 1) ? overrideTypeArguments : lookupTypeParameterNodes(chain, index, context);
+ var symbol = chain[index];
+ var parent = chain[index - 1];
+ var symbolName;
+ if (index === 0) {
+ context.flags |= 16777216;
+ symbolName = getNameOfSymbolAsWritten(symbol, context);
+ context.approximateLength += (symbolName ? symbolName.length : 0) + 1;
+ context.flags ^= 16777216;
}
- else if (type.objectFlags & 3) {
- resolveClassOrInterfaceMembers(type);
+ else {
+ if (parent && getExportsOfSymbol(parent)) {
+ var exports_1 = getExportsOfSymbol(parent);
+ ts.forEachEntry(exports_1, function (ex, name) {
+ if (getSymbolIfSameReference(ex, symbol) && !isLateBoundName(name) && name !== "export=") {
+ symbolName = ts.unescapeLeadingUnderscores(name);
+ return true;
+ }
+ });
+ }
}
- else if (type.objectFlags & 2048) {
- resolveReverseMappedTypeMembers(type);
+ if (!symbolName) {
+ symbolName = getNameOfSymbolAsWritten(symbol, context);
}
- else if (type.objectFlags & 16) {
- resolveAnonymousTypeMembers(type);
+ context.approximateLength += symbolName.length + 1;
+ if (!(context.flags & 16) && parent &&
+ getMembersOfSymbol(parent) && getMembersOfSymbol(parent).get(symbol.escapedName) &&
+ getSymbolIfSameReference(getMembersOfSymbol(parent).get(symbol.escapedName), symbol)) {
+ var LHS = createAccessFromSymbolChain(chain, index - 1, stopper);
+ if (ts.isIndexedAccessTypeNode(LHS)) {
+ return ts.factory.createIndexedAccessTypeNode(LHS, ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(symbolName)));
+ }
+ else {
+ return ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeReferenceNode(LHS, typeParameterNodes), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(symbolName)));
+ }
}
- else if (type.objectFlags & 32) {
- resolveMappedTypeMembers(type);
+ var identifier = ts.setEmitFlags(ts.factory.createIdentifier(symbolName, typeParameterNodes), 16777216);
+ identifier.symbol = symbol;
+ if (index > stopper) {
+ var LHS = createAccessFromSymbolChain(chain, index - 1, stopper);
+ if (!ts.isEntityName(LHS)) {
+ return ts.Debug.fail("Impossible construct - an export of an indexed access cannot be reachable");
+ }
+ return ts.factory.createQualifiedName(LHS, identifier);
}
- }
- else if (type.flags & 1048576) {
- resolveUnionTypeMembers(type);
- }
- else if (type.flags & 2097152) {
- resolveIntersectionTypeMembers(type);
- }
- }
- return type;
- }
- function getPropertiesOfObjectType(type) {
- if (type.flags & 524288) {
- return resolveStructuredTypeMembers(type).properties;
- }
- return ts.emptyArray;
- }
- function getPropertyOfObjectType(type, name) {
- if (type.flags & 524288) {
- var resolved = resolveStructuredTypeMembers(type);
- var symbol = resolved.members.get(name);
- if (symbol && symbolIsValue(symbol)) {
- return symbol;
+ return identifier;
}
}
- }
- function getPropertiesOfUnionOrIntersectionType(type) {
- if (!type.resolvedProperties) {
- var members = ts.createSymbolTable();
- for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
- var current = _a[_i];
- for (var _b = 0, _c = getPropertiesOfType(current); _b < _c.length; _b++) {
- var prop = _c[_b];
- if (!members.has(prop.escapedName)) {
- var combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName);
- if (combinedProp) {
- members.set(prop.escapedName, combinedProp);
- }
- }
- }
- if (type.flags & 1048576 && !getIndexInfoOfType(current, 0) && !getIndexInfoOfType(current, 1)) {
- break;
+ function typeParameterShadowsNameInScope(escapedName, context, type) {
+ var result = resolveName(context.enclosingDeclaration, escapedName, 788968, undefined, escapedName, false);
+ if (result) {
+ if (result.flags & 262144 && result === type.symbol) {
+ return false;
}
+ return true;
}
- type.resolvedProperties = getNamedMembers(members);
- }
- return type.resolvedProperties;
- }
- function getPropertiesOfType(type) {
- type = getReducedApparentType(type);
- return type.flags & 3145728 ?
- getPropertiesOfUnionOrIntersectionType(type) :
- getPropertiesOfObjectType(type);
- }
- function isTypeInvalidDueToUnionDiscriminant(contextualType, obj) {
- var list = obj.properties;
- return list.some(function (property) {
- var nameType = property.name && getLiteralTypeFromPropertyName(property.name);
- var name = nameType && isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined;
- var expected = name === undefined ? undefined : getTypeOfPropertyOfType(contextualType, name);
- return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property), expected);
- });
- }
- function getAllPossiblePropertiesOfTypes(types) {
- var unionType = getUnionType(types);
- if (!(unionType.flags & 1048576)) {
- return getAugmentedPropertiesOfType(unionType);
+ return false;
}
- var props = ts.createSymbolTable();
- for (var _i = 0, types_4 = types; _i < types_4.length; _i++) {
- var memberType = types_4[_i];
- for (var _a = 0, _b = getAugmentedPropertiesOfType(memberType); _a < _b.length; _a++) {
- var escapedName = _b[_a].escapedName;
- if (!props.has(escapedName)) {
- var prop = createUnionOrIntersectionProperty(unionType, escapedName);
- if (prop)
- props.set(escapedName, prop);
+ function typeParameterToName(type, context) {
+ var _a;
+ if (context.flags & 4 && context.typeParameterNames) {
+ var cached = context.typeParameterNames.get(getTypeId(type));
+ if (cached) {
+ return cached;
}
}
- }
- return ts.arrayFrom(props.values());
- }
- function getConstraintOfType(type) {
- return type.flags & 262144 ? getConstraintOfTypeParameter(type) :
- type.flags & 8388608 ? getConstraintOfIndexedAccess(type) :
- type.flags & 16777216 ? getConstraintOfConditionalType(type) :
- getBaseConstraintOfType(type);
- }
- function getConstraintOfTypeParameter(typeParameter) {
- return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : undefined;
- }
- function getConstraintOfIndexedAccess(type) {
- return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : undefined;
- }
- function getSimplifiedTypeOrConstraint(type) {
- var simplified = getSimplifiedType(type, false);
- return simplified !== type ? simplified : getConstraintOfType(type);
- }
- function getConstraintFromIndexedAccess(type) {
- var indexConstraint = getSimplifiedTypeOrConstraint(type.indexType);
- if (indexConstraint && indexConstraint !== type.indexType) {
- var indexedAccess = getIndexedAccessTypeOrUndefined(type.objectType, indexConstraint);
- if (indexedAccess) {
- return indexedAccess;
+ var result = symbolToName(type.symbol, context, 788968, true);
+ if (!(result.kind & 78)) {
+ return ts.factory.createIdentifier("(Missing type parameter)");
}
- }
- var objectConstraint = getSimplifiedTypeOrConstraint(type.objectType);
- if (objectConstraint && objectConstraint !== type.objectType) {
- return getIndexedAccessTypeOrUndefined(objectConstraint, type.indexType);
- }
- return undefined;
- }
- function getDefaultConstraintOfConditionalType(type) {
- if (!type.resolvedDefaultConstraint) {
- var trueConstraint = getInferredTrueTypeFromConditionalType(type);
- var falseConstraint = getFalseTypeFromConditionalType(type);
- type.resolvedDefaultConstraint = isTypeAny(trueConstraint) ? falseConstraint : isTypeAny(falseConstraint) ? trueConstraint : getUnionType([trueConstraint, falseConstraint]);
- }
- return type.resolvedDefaultConstraint;
- }
- function getConstraintOfDistributiveConditionalType(type) {
- if (type.root.isDistributive && type.restrictiveInstantiation !== type) {
- var simplified = getSimplifiedType(type.checkType, false);
- var constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;
- if (constraint && constraint !== type.checkType) {
- var instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
- if (!(instantiated.flags & 131072)) {
- return instantiated;
+ if (context.flags & 4) {
+ var rawtext = result.escapedText;
+ var i = 0;
+ var text = rawtext;
+ while (((_a = context.typeParameterNamesByText) === null || _a === void 0 ? void 0 : _a.has(text)) || typeParameterShadowsNameInScope(text, context, type)) {
+ i++;
+ text = rawtext + "_" + i;
+ }
+ if (text !== rawtext) {
+ result = ts.factory.createIdentifier(text, result.typeArguments);
}
+ (context.typeParameterNames || (context.typeParameterNames = new ts.Map())).set(getTypeId(type), result);
+ (context.typeParameterNamesByText || (context.typeParameterNamesByText = new ts.Set())).add(result.escapedText);
}
+ return result;
}
- return undefined;
- }
- function getConstraintFromConditionalType(type) {
- return getConstraintOfDistributiveConditionalType(type) || getDefaultConstraintOfConditionalType(type);
- }
- function getConstraintOfConditionalType(type) {
- return hasNonCircularBaseConstraint(type) ? getConstraintFromConditionalType(type) : undefined;
- }
- function getEffectiveConstraintOfIntersection(types, targetIsUnion) {
- var constraints;
- var hasDisjointDomainType = false;
- for (var _i = 0, types_5 = types; _i < types_5.length; _i++) {
- var t = types_5[_i];
- if (t.flags & 63176704) {
- var constraint = getConstraintOfType(t);
- while (constraint && constraint.flags & (262144 | 4194304 | 16777216)) {
- constraint = getConstraintOfType(constraint);
+ function symbolToName(symbol, context, meaning, expectsIdentifier) {
+ var chain = lookupSymbolChain(symbol, context, meaning);
+ if (expectsIdentifier && chain.length !== 1
+ && !context.encounteredError
+ && !(context.flags & 65536)) {
+ context.encounteredError = true;
+ }
+ return createEntityNameFromSymbolChain(chain, chain.length - 1);
+ function createEntityNameFromSymbolChain(chain, index) {
+ var typeParameterNodes = lookupTypeParameterNodes(chain, index, context);
+ var symbol = chain[index];
+ if (index === 0) {
+ context.flags |= 16777216;
}
- if (constraint) {
- constraints = ts.append(constraints, constraint);
- if (targetIsUnion) {
- constraints = ts.append(constraints, t);
- }
+ var symbolName = getNameOfSymbolAsWritten(symbol, context);
+ if (index === 0) {
+ context.flags ^= 16777216;
}
- }
- else if (t.flags & 67238908) {
- hasDisjointDomainType = true;
+ var identifier = ts.setEmitFlags(ts.factory.createIdentifier(symbolName, typeParameterNodes), 16777216);
+ identifier.symbol = symbol;
+ return index > 0 ? ts.factory.createQualifiedName(createEntityNameFromSymbolChain(chain, index - 1), identifier) : identifier;
}
}
- if (constraints && (targetIsUnion || hasDisjointDomainType)) {
- if (hasDisjointDomainType) {
- for (var _a = 0, types_6 = types; _a < types_6.length; _a++) {
- var t = types_6[_a];
- if (t.flags & 67238908) {
- constraints = ts.append(constraints, t);
- }
+ function symbolToExpression(symbol, context, meaning) {
+ var chain = lookupSymbolChain(symbol, context, meaning);
+ return createExpressionFromSymbolChain(chain, chain.length - 1);
+ function createExpressionFromSymbolChain(chain, index) {
+ var typeParameterNodes = lookupTypeParameterNodes(chain, index, context);
+ var symbol = chain[index];
+ if (index === 0) {
+ context.flags |= 16777216;
}
- }
- return getIntersectionType(constraints);
- }
- return undefined;
- }
- function getBaseConstraintOfType(type) {
- if (type.flags & (58982400 | 3145728)) {
- var constraint = getResolvedBaseConstraint(type);
- return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : undefined;
- }
- return type.flags & 4194304 ? keyofConstraintType : undefined;
- }
- function getBaseConstraintOrType(type) {
- return getBaseConstraintOfType(type) || type;
- }
- function hasNonCircularBaseConstraint(type) {
- return getResolvedBaseConstraint(type) !== circularConstraintType;
- }
- function getResolvedBaseConstraint(type) {
- var nonTerminating = false;
- return type.resolvedBaseConstraint ||
- (type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type));
- function getImmediateBaseConstraint(t) {
- if (!t.immediateBaseConstraint) {
- if (!pushTypeResolution(t, 4)) {
- return circularConstraintType;
+ var symbolName = getNameOfSymbolAsWritten(symbol, context);
+ if (index === 0) {
+ context.flags ^= 16777216;
}
- if (constraintDepth >= 50) {
- error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
- nonTerminating = true;
- return t.immediateBaseConstraint = noConstraintType;
+ var firstChar = symbolName.charCodeAt(0);
+ if (ts.isSingleOrDoubleQuote(firstChar) && ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
+ return ts.factory.createStringLiteral(getSpecifierForModuleSymbol(symbol, context));
}
- constraintDepth++;
- var result = computeBaseConstraint(getSimplifiedType(t, false));
- constraintDepth--;
- if (!popTypeResolution()) {
- if (t.flags & 262144) {
- var errorNode = getConstraintDeclaration(t);
- if (errorNode) {
- var diagnostic = error(errorNode, ts.Diagnostics.Type_parameter_0_has_a_circular_constraint, typeToString(t));
- if (currentNode && !ts.isNodeDescendantOf(errorNode, currentNode) && !ts.isNodeDescendantOf(currentNode, errorNode)) {
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(currentNode, ts.Diagnostics.Circularity_originates_in_type_at_this_location));
- }
- }
- }
- result = circularConstraintType;
+ var canUsePropertyAccess = firstChar === 35 ?
+ symbolName.length > 1 && ts.isIdentifierStart(symbolName.charCodeAt(1), languageVersion) :
+ ts.isIdentifierStart(firstChar, languageVersion);
+ if (index === 0 || canUsePropertyAccess) {
+ var identifier = ts.setEmitFlags(ts.factory.createIdentifier(symbolName, typeParameterNodes), 16777216);
+ identifier.symbol = symbol;
+ return index > 0 ? ts.factory.createPropertyAccessExpression(createExpressionFromSymbolChain(chain, index - 1), identifier) : identifier;
}
- if (nonTerminating) {
- result = circularConstraintType;
+ else {
+ if (firstChar === 91) {
+ symbolName = symbolName.substring(1, symbolName.length - 1);
+ firstChar = symbolName.charCodeAt(0);
+ }
+ var expression = void 0;
+ if (ts.isSingleOrDoubleQuote(firstChar)) {
+ expression = ts.factory.createStringLiteral(symbolName
+ .substring(1, symbolName.length - 1)
+ .replace(/\\./g, function (s) { return s.substring(1); }), firstChar === 39);
+ }
+ else if (("" + +symbolName) === symbolName) {
+ expression = ts.factory.createNumericLiteral(+symbolName);
+ }
+ if (!expression) {
+ expression = ts.setEmitFlags(ts.factory.createIdentifier(symbolName, typeParameterNodes), 16777216);
+ expression.symbol = symbol;
+ }
+ return ts.factory.createElementAccessExpression(createExpressionFromSymbolChain(chain, index - 1), expression);
}
- t.immediateBaseConstraint = result || noConstraintType;
}
- return t.immediateBaseConstraint;
}
- function getBaseConstraint(t) {
- var c = getImmediateBaseConstraint(t);
- return c !== noConstraintType && c !== circularConstraintType ? c : undefined;
+ function isStringNamed(d) {
+ var name = ts.getNameOfDeclaration(d);
+ return !!name && ts.isStringLiteral(name);
}
- function computeBaseConstraint(t) {
- if (t.flags & 262144) {
- var constraint = getConstraintFromTypeParameter(t);
- return t.isThisType || !constraint ?
- constraint :
- getBaseConstraint(constraint);
+ function isSingleQuotedStringNamed(d) {
+ var name = ts.getNameOfDeclaration(d);
+ return !!(name && ts.isStringLiteral(name) && (name.singleQuote || !ts.nodeIsSynthesized(name) && ts.startsWith(ts.getTextOfNode(name, false), "'")));
+ }
+ function getPropertyNameNodeForSymbol(symbol, context) {
+ var singleQuote = !!ts.length(symbol.declarations) && ts.every(symbol.declarations, isSingleQuotedStringNamed);
+ var fromNameType = getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote);
+ if (fromNameType) {
+ return fromNameType;
}
- if (t.flags & 3145728) {
- var types = t.types;
- var baseTypes = [];
- for (var _i = 0, types_7 = types; _i < types_7.length; _i++) {
- var type_2 = types_7[_i];
- var baseType = getBaseConstraint(type_2);
- if (baseType) {
- baseTypes.push(baseType);
+ if (ts.isKnownSymbol(symbol)) {
+ return ts.factory.createComputedPropertyName(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("Symbol"), symbol.escapedName.substr(3)));
+ }
+ var rawName = ts.unescapeLeadingUnderscores(symbol.escapedName);
+ var stringNamed = !!ts.length(symbol.declarations) && ts.every(symbol.declarations, isStringNamed);
+ return createPropertyNameNodeForIdentifierOrLiteral(rawName, stringNamed, singleQuote);
+ }
+ function getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote) {
+ var nameType = getSymbolLinks(symbol).nameType;
+ if (nameType) {
+ if (nameType.flags & 384) {
+ var name = "" + nameType.value;
+ if (!ts.isIdentifierText(name, compilerOptions.target) && !isNumericLiteralName(name)) {
+ return ts.factory.createStringLiteral(name, !!singleQuote);
+ }
+ if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
+ return ts.factory.createComputedPropertyName(ts.factory.createNumericLiteral(+name));
}
+ return createPropertyNameNodeForIdentifierOrLiteral(name);
+ }
+ if (nameType.flags & 8192) {
+ return ts.factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, 111551));
}
- return t.flags & 1048576 && baseTypes.length === types.length ? getUnionType(baseTypes) :
- t.flags & 2097152 && baseTypes.length ? getIntersectionType(baseTypes) :
- undefined;
- }
- if (t.flags & 4194304) {
- return keyofConstraintType;
}
- if (t.flags & 8388608) {
- var baseObjectType = getBaseConstraint(t.objectType);
- var baseIndexType = getBaseConstraint(t.indexType);
- var baseIndexedAccess = baseObjectType && baseIndexType && getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType);
- return baseIndexedAccess && getBaseConstraint(baseIndexedAccess);
+ }
+ function createPropertyNameNodeForIdentifierOrLiteral(name, stringNamed, singleQuote) {
+ return ts.isIdentifierText(name, compilerOptions.target) ? ts.factory.createIdentifier(name) :
+ !stringNamed && isNumericLiteralName(name) && +name >= 0 ? ts.factory.createNumericLiteral(+name) :
+ ts.factory.createStringLiteral(name, !!singleQuote);
+ }
+ function cloneNodeBuilderContext(context) {
+ var initial = __assign({}, context);
+ if (initial.typeParameterNames) {
+ initial.typeParameterNames = new ts.Map(initial.typeParameterNames);
}
- if (t.flags & 16777216) {
- var constraint = getConstraintFromConditionalType(t);
- constraintDepth++;
- var result = constraint && getBaseConstraint(constraint);
- constraintDepth--;
- return result;
+ if (initial.typeParameterNamesByText) {
+ initial.typeParameterNamesByText = new ts.Set(initial.typeParameterNamesByText);
}
- if (t.flags & 33554432) {
- return getBaseConstraint(t.substitute);
+ if (initial.typeParameterSymbolList) {
+ initial.typeParameterSymbolList = new ts.Set(initial.typeParameterSymbolList);
}
- return t;
+ return initial;
}
- }
- function getApparentTypeOfIntersectionType(type) {
- return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(type, type, true));
- }
- function getResolvedTypeParameterDefault(typeParameter) {
- if (!typeParameter.default) {
- if (typeParameter.target) {
- var targetDefault = getResolvedTypeParameterDefault(typeParameter.target);
- typeParameter.default = targetDefault ? instantiateType(targetDefault, typeParameter.mapper) : noConstraintType;
- }
- else {
- typeParameter.default = resolvingDefaultType;
- var defaultDeclaration = typeParameter.symbol && ts.forEach(typeParameter.symbol.declarations, function (decl) { return ts.isTypeParameterDeclaration(decl) && decl.default; });
- var defaultType = defaultDeclaration ? getTypeFromTypeNode(defaultDeclaration) : noConstraintType;
- if (typeParameter.default === resolvingDefaultType) {
- typeParameter.default = defaultType;
+ function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
+ return symbol.declarations && ts.find(symbol.declarations, function (s) { return !!ts.getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!ts.findAncestor(s, function (n) { return n === enclosingDeclaration; })); });
+ }
+ function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
+ return !(ts.getObjectFlags(type) & 4) || !ts.isTypeReferenceNode(existing) || ts.length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
+ }
+ function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
+ if (type !== errorType && enclosingDeclaration) {
+ var declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration);
+ if (declWithExistingAnnotation && !ts.isFunctionLikeDeclaration(declWithExistingAnnotation)) {
+ var existing = ts.getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
+ if (getTypeFromTypeNode(existing) === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
+ var result_5 = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
+ if (result_5) {
+ return result_5;
+ }
+ }
}
}
+ var oldFlags = context.flags;
+ if (type.flags & 8192 &&
+ type.symbol === symbol && (!context.enclosingDeclaration || ts.some(symbol.declarations, function (d) { return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(context.enclosingDeclaration); }))) {
+ context.flags |= 1048576;
+ }
+ var result = typeToTypeNodeHelper(type, context);
+ context.flags = oldFlags;
+ return result;
}
- else if (typeParameter.default === resolvingDefaultType) {
- typeParameter.default = circularConstraintType;
- }
- return typeParameter.default;
- }
- function getDefaultFromTypeParameter(typeParameter) {
- var defaultType = getResolvedTypeParameterDefault(typeParameter);
- return defaultType !== noConstraintType && defaultType !== circularConstraintType ? defaultType : undefined;
- }
- function hasNonCircularTypeParameterDefault(typeParameter) {
- return getResolvedTypeParameterDefault(typeParameter) !== circularConstraintType;
- }
- function hasTypeParameterDefault(typeParameter) {
- return !!(typeParameter.symbol && ts.forEach(typeParameter.symbol.declarations, function (decl) { return ts.isTypeParameterDeclaration(decl) && decl.default; }));
- }
- function getApparentTypeOfMappedType(type) {
- return type.resolvedApparentType || (type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type));
- }
- function getResolvedApparentTypeOfMappedType(type) {
- var typeVariable = getHomomorphicTypeVariable(type);
- if (typeVariable) {
- var constraint = getConstraintOfTypeParameter(typeVariable);
- if (constraint && (isArrayType(constraint) || isTupleType(constraint))) {
- return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper));
+ function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
+ if (type !== errorType && context.enclosingDeclaration) {
+ var annotation = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration);
+ if (!!ts.findAncestor(annotation, function (n) { return n === context.enclosingDeclaration; }) && annotation && instantiateType(getTypeFromTypeNode(annotation), signature.mapper) === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
+ var result = serializeExistingTypeNode(context, annotation, includePrivateSymbol, bundled);
+ if (result) {
+ return result;
+ }
+ }
}
+ return typeToTypeNodeHelper(type, context);
}
- return type;
- }
- function getApparentType(type) {
- var t = type.flags & 63176704 ? getBaseConstraintOfType(type) || unknownType : type;
- return ts.getObjectFlags(t) & 32 ? getApparentTypeOfMappedType(t) :
- t.flags & 2097152 ? getApparentTypeOfIntersectionType(t) :
- t.flags & 132 ? globalStringType :
- t.flags & 296 ? globalNumberType :
- t.flags & 2112 ? getGlobalBigIntType(languageVersion >= 7) :
- t.flags & 528 ? globalBooleanType :
- t.flags & 12288 ? getGlobalESSymbolType(languageVersion >= 2) :
- t.flags & 67108864 ? emptyObjectType :
- t.flags & 4194304 ? keyofConstraintType :
- t.flags & 2 && !strictNullChecks ? emptyObjectType :
- t;
- }
- function getReducedApparentType(type) {
- return getReducedType(getApparentType(getReducedType(type)));
- }
- function createUnionOrIntersectionProperty(containingType, name) {
- var singleProp;
- var propSet;
- var indexTypes;
- var isUnion = containingType.flags & 1048576;
- var optionalFlag = isUnion ? 0 : 16777216;
- var syntheticFlag = 4;
- var checkFlags = 0;
- for (var _i = 0, _a = containingType.types; _i < _a.length; _i++) {
- var current = _a[_i];
- var type = getApparentType(current);
- if (!(type === errorType || type.flags & 131072)) {
- var prop = getPropertyOfType(type, name);
- var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0;
- if (prop) {
- if (isUnion) {
- optionalFlag |= (prop.flags & 16777216);
+ function serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled) {
+ if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
+ cancellationToken.throwIfCancellationRequested();
+ }
+ var hadError = false;
+ var file = ts.getSourceFileOfNode(existing);
+ var transformed = ts.visitNode(existing, visitExistingNodeTreeSymbols);
+ if (hadError) {
+ return undefined;
+ }
+ return transformed === existing ? ts.setTextRange(ts.factory.cloneNode(existing), existing) : transformed;
+ function visitExistingNodeTreeSymbols(node) {
+ var _a, _b;
+ if (ts.isJSDocAllType(node) || node.kind === 310) {
+ return ts.factory.createKeywordTypeNode(128);
+ }
+ if (ts.isJSDocUnknownType(node)) {
+ return ts.factory.createKeywordTypeNode(152);
+ }
+ if (ts.isJSDocNullableType(node)) {
+ return ts.factory.createUnionTypeNode([ts.visitNode(node.type, visitExistingNodeTreeSymbols), ts.factory.createLiteralTypeNode(ts.factory.createNull())]);
+ }
+ if (ts.isJSDocOptionalType(node)) {
+ return ts.factory.createUnionTypeNode([ts.visitNode(node.type, visitExistingNodeTreeSymbols), ts.factory.createKeywordTypeNode(150)]);
+ }
+ if (ts.isJSDocNonNullableType(node)) {
+ return ts.visitNode(node.type, visitExistingNodeTreeSymbols);
+ }
+ if (ts.isJSDocVariadicType(node)) {
+ return ts.factory.createArrayTypeNode(ts.visitNode(node.type, visitExistingNodeTreeSymbols));
+ }
+ if (ts.isJSDocTypeLiteral(node)) {
+ return ts.factory.createTypeLiteralNode(ts.map(node.jsDocPropertyTags, function (t) {
+ var name = ts.isIdentifier(t.name) ? t.name : t.name.right;
+ var typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode(node), name.escapedText);
+ var overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode(t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : undefined;
+ return ts.factory.createPropertySignature(undefined, name, t.typeExpression && ts.isJSDocOptionalType(t.typeExpression.type) ? ts.factory.createToken(57) : undefined, overrideTypeNode || (t.typeExpression && ts.visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols)) || ts.factory.createKeywordTypeNode(128));
+ }));
+ }
+ if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.escapedText === "") {
+ return ts.setOriginalNode(ts.factory.createKeywordTypeNode(128), node);
+ }
+ if ((ts.isExpressionWithTypeArguments(node) || ts.isTypeReferenceNode(node)) && ts.isJSDocIndexSignature(node)) {
+ return ts.factory.createTypeLiteralNode([ts.factory.createIndexSignature(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, undefined, "x", undefined, ts.visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols))], ts.visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols))]);
+ }
+ if (ts.isJSDocFunctionType(node)) {
+ if (ts.isJSDocConstructSignature(node)) {
+ var newTypeNode_1;
+ return ts.factory.createConstructorTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.mapDefined(node.parameters, function (p, i) { return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode_1 = p.type, undefined) : ts.factory.createParameterDeclaration(undefined, undefined, getEffectiveDotDotDotForParameter(p), getNameForJSDocFunctionParameter(p, i), p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), undefined); }), ts.visitNode(newTypeNode_1 || node.type, visitExistingNodeTreeSymbols) || ts.factory.createKeywordTypeNode(128));
}
else {
- optionalFlag &= prop.flags;
+ return ts.factory.createFunctionTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.map(node.parameters, function (p, i) { return ts.factory.createParameterDeclaration(undefined, undefined, getEffectiveDotDotDotForParameter(p), getNameForJSDocFunctionParameter(p, i), p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), undefined); }), ts.visitNode(node.type, visitExistingNodeTreeSymbols) || ts.factory.createKeywordTypeNode(128));
}
- if (!singleProp) {
- singleProp = prop;
+ }
+ if (ts.isTypeReferenceNode(node) && ts.isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(getTypeReferenceName(node), 788968, true))) {
+ return ts.setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
+ }
+ if (ts.isLiteralImportTypeNode(node)) {
+ return ts.factory.updateImportTypeNode(node, ts.factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier(node, node.argument.literal)), node.qualifier, ts.visitNodes(node.typeArguments, visitExistingNodeTreeSymbols, ts.isTypeNode), node.isTypeOf);
+ }
+ if (ts.isEntityName(node) || ts.isEntityNameExpression(node)) {
+ var leftmost = ts.getFirstIdentifier(node);
+ if (ts.isInJSFile(node) && (ts.isExportsIdentifier(leftmost) || ts.isModuleExportsAccessExpression(leftmost.parent) || (ts.isQualifiedName(leftmost.parent) && ts.isModuleIdentifier(leftmost.parent.left) && ts.isExportsIdentifier(leftmost.parent.right)))) {
+ hadError = true;
+ return node;
}
- else if (prop !== singleProp) {
- if (!propSet) {
- propSet = ts.createMap();
- propSet.set("" + getSymbolId(singleProp), singleProp);
+ var sym = resolveEntityName(leftmost, 67108863, true, true);
+ if (sym) {
+ if (isSymbolAccessible(sym, context.enclosingDeclaration, 67108863, false).accessibility !== 0) {
+ hadError = true;
}
- var id = "" + getSymbolId(prop);
- if (!propSet.has(id)) {
- propSet.set(id, prop);
+ else {
+ (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.trackSymbol) === null || _b === void 0 ? void 0 : _b.call(_a, sym, context.enclosingDeclaration, 67108863);
+ includePrivateSymbol === null || includePrivateSymbol === void 0 ? void 0 : includePrivateSymbol(sym);
+ }
+ if (ts.isIdentifier(node)) {
+ var name = sym.flags & 262144 ? typeParameterToName(getDeclaredTypeOfSymbol(sym), context) : ts.factory.cloneNode(node);
+ name.symbol = sym;
+ return ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216);
}
- }
- checkFlags |= (isReadonlySymbol(prop) ? 8 : 0) |
- (!(modifiers & 24) ? 256 : 0) |
- (modifiers & 16 ? 512 : 0) |
- (modifiers & 8 ? 1024 : 0) |
- (modifiers & 32 ? 2048 : 0);
- if (!isPrototypeProperty(prop)) {
- syntheticFlag = 2;
}
}
- else if (isUnion) {
- var indexInfo = !isLateBoundName(name) && (isNumericLiteralName(name) && getIndexInfoOfType(type, 1) || getIndexInfoOfType(type, 0));
- if (indexInfo) {
- checkFlags |= 32 | (indexInfo.isReadonly ? 8 : 0);
- indexTypes = ts.append(indexTypes, isTupleType(type) ? getRestTypeOfTupleType(type) || undefinedType : indexInfo.type);
- }
- else if (isObjectLiteralType(type)) {
- checkFlags |= 32;
- indexTypes = ts.append(indexTypes, undefinedType);
+ if (file && ts.isTupleTypeNode(node) && (ts.getLineAndCharacterOfPosition(file, node.pos).line === ts.getLineAndCharacterOfPosition(file, node.end).line)) {
+ ts.setEmitFlags(node, 1);
+ }
+ return ts.visitEachChild(node, visitExistingNodeTreeSymbols, ts.nullTransformationContext);
+ function getEffectiveDotDotDotForParameter(p) {
+ return p.dotDotDotToken || (p.type && ts.isJSDocVariadicType(p.type) ? ts.factory.createToken(25) : undefined);
+ }
+ function getNameForJSDocFunctionParameter(p, index) {
+ return p.name && ts.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) {
+ var targetFile = getExternalModuleFileFromDeclaration(parent);
+ if (targetFile) {
+ var getCanonicalFileName = ts.createGetCanonicalFileName(!!host.useCaseSensitiveFileNames);
+ var resolverHost = {
+ getCanonicalFileName: getCanonicalFileName,
+ getCurrentDirectory: function () { return context.tracker.moduleResolverHost.getCurrentDirectory(); },
+ getCommonSourceDirectory: function () { return context.tracker.moduleResolverHost.getCommonSourceDirectory(); }
+ };
+ var newName = ts.getResolvedExternalModuleName(resolverHost, targetFile);
+ return ts.factory.createStringLiteral(newName);
+ }
+ }
}
else {
- checkFlags |= 16;
+ if (context.tracker && context.tracker.trackExternalModuleSymbolOfImportTypeNode) {
+ var moduleSym = resolveExternalModuleNameWorker(lit, lit, undefined);
+ if (moduleSym) {
+ context.tracker.trackExternalModuleSymbolOfImportTypeNode(moduleSym);
+ }
+ }
}
+ return lit;
}
}
}
- if (!singleProp || isUnion && (propSet || checkFlags & 48) && checkFlags & (1024 | 512)) {
- return undefined;
- }
- if (!propSet && !(checkFlags & 16) && !indexTypes) {
- return singleProp;
- }
- var props = propSet ? ts.arrayFrom(propSet.values()) : [singleProp];
- var declarations;
- var firstType;
- var nameType;
- var propTypes = [];
- var firstValueDeclaration;
- var hasNonUniformValueDeclaration = false;
- for (var _b = 0, props_1 = props; _b < props_1.length; _b++) {
- var prop = props_1[_b];
- if (!firstValueDeclaration) {
- firstValueDeclaration = prop.valueDeclaration;
- }
- else if (prop.valueDeclaration && prop.valueDeclaration !== firstValueDeclaration) {
- hasNonUniformValueDeclaration = true;
- }
- declarations = ts.addRange(declarations, prop.declarations);
- var type = getTypeOfSymbol(prop);
- if (!firstType) {
- firstType = type;
- nameType = getSymbolLinks(prop).nameType;
+ function symbolTableToDeclarationStatements(symbolTable, context, bundled) {
+ var serializePropertySymbolForClass = makeSerializePropertySymbol(ts.factory.createPropertyDeclaration, 165, true);
+ var serializePropertySymbolForInterfaceWorker = makeSerializePropertySymbol(function (_decorators, mods, name, question, type) { return ts.factory.createPropertySignature(mods, name, question, type); }, 164, false);
+ var enclosingDeclaration = context.enclosingDeclaration;
+ var results = [];
+ var visitedSymbols = new ts.Set();
+ var deferredPrivatesStack = [];
+ var oldcontext = context;
+ context = __assign(__assign({}, oldcontext), { usedSymbolNames: new ts.Set(oldcontext.usedSymbolNames), remappedSymbolNames: new ts.Map(), tracker: __assign(__assign({}, oldcontext.tracker), { trackSymbol: function (sym, decl, meaning) {
+ var accessibleResult = isSymbolAccessible(sym, decl, meaning, false);
+ if (accessibleResult.accessibility === 0) {
+ var chain = lookupSymbolChainWorker(sym, context, meaning);
+ if (!(sym.flags & 4)) {
+ includePrivateSymbol(chain[0]);
+ }
+ }
+ else if (oldcontext.tracker && oldcontext.tracker.trackSymbol) {
+ oldcontext.tracker.trackSymbol(sym, decl, meaning);
+ }
+ } }) });
+ ts.forEachEntry(symbolTable, function (symbol, name) {
+ var baseName = ts.unescapeLeadingUnderscores(name);
+ void getInternalSymbolName(symbol, baseName);
+ });
+ var addingDeclare = !bundled;
+ var exportEquals = symbolTable.get("export=");
+ if (exportEquals && symbolTable.size > 1 && exportEquals.flags & 2097152) {
+ symbolTable = ts.createSymbolTable();
+ symbolTable.set("export=", exportEquals);
}
- else if (type !== firstType) {
- checkFlags |= 64;
+ visitSymbolTable(symbolTable);
+ return mergeRedundantStatements(results);
+ function isIdentifierAndNotUndefined(node) {
+ return !!node && node.kind === 78;
}
- if (isLiteralType(type)) {
- checkFlags |= 128;
+ function getNamesOfDeclaration(statement) {
+ if (ts.isVariableStatement(statement)) {
+ return ts.filter(ts.map(statement.declarationList.declarations, ts.getNameOfDeclaration), isIdentifierAndNotUndefined);
+ }
+ return ts.filter([ts.getNameOfDeclaration(statement)], isIdentifierAndNotUndefined);
}
- if (type.flags & 131072) {
- checkFlags |= 131072;
+ function flattenExportAssignedNamespace(statements) {
+ var exportAssignment = ts.find(statements, ts.isExportAssignment);
+ var nsIndex = ts.findIndex(statements, ts.isModuleDeclaration);
+ var ns = nsIndex !== -1 ? statements[nsIndex] : undefined;
+ if (ns && exportAssignment && exportAssignment.isExportEquals &&
+ ts.isIdentifier(exportAssignment.expression) && ts.isIdentifier(ns.name) && ts.idText(ns.name) === ts.idText(exportAssignment.expression) &&
+ ns.body && ts.isModuleBlock(ns.body)) {
+ var excessExports = ts.filter(statements, function (s) { return !!(ts.getEffectiveModifierFlags(s) & 1); });
+ var name_2 = ns.name;
+ var body = ns.body;
+ if (ts.length(excessExports)) {
+ ns = ts.factory.updateModuleDeclaration(ns, ns.decorators, ns.modifiers, ns.name, body = ts.factory.updateModuleBlock(body, ts.factory.createNodeArray(__spreadArrays(ns.body.statements, [ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports(ts.map(ts.flatMap(excessExports, function (e) { return getNamesOfDeclaration(e); }), function (id) { return ts.factory.createExportSpecifier(undefined, id); })), undefined)]))));
+ statements = __spreadArrays(statements.slice(0, nsIndex), [ns], statements.slice(nsIndex + 1));
+ }
+ if (!ts.find(statements, function (s) { return s !== ns && ts.nodeHasName(s, name_2); })) {
+ results = [];
+ var mixinExportFlag_1 = !ts.some(body.statements, function (s) { return ts.hasSyntacticModifier(s, 1) || ts.isExportAssignment(s) || ts.isExportDeclaration(s); });
+ ts.forEach(body.statements, function (s) {
+ addResult(s, mixinExportFlag_1 ? 1 : 0);
+ });
+ statements = __spreadArrays(ts.filter(statements, function (s) { return s !== ns && s !== exportAssignment; }), results);
+ }
+ }
+ return statements;
}
- propTypes.push(type);
- }
- ts.addRange(propTypes, indexTypes);
- var result = createSymbol(4 | optionalFlag, name, syntheticFlag | checkFlags);
- result.containingType = containingType;
- if (!hasNonUniformValueDeclaration && firstValueDeclaration) {
- result.valueDeclaration = firstValueDeclaration;
- if (firstValueDeclaration.symbol.parent) {
- result.parent = firstValueDeclaration.symbol.parent;
+ function mergeExportDeclarations(statements) {
+ var exports = ts.filter(statements, function (d) { return ts.isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); });
+ if (ts.length(exports) > 1) {
+ var nonExports = ts.filter(statements, function (d) { return !ts.isExportDeclaration(d) || !!d.moduleSpecifier || !d.exportClause; });
+ statements = __spreadArrays(nonExports, [ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports(ts.flatMap(exports, function (e) { return ts.cast(e.exportClause, ts.isNamedExports).elements; })), undefined)]);
+ }
+ var reexports = ts.filter(statements, function (d) { return ts.isExportDeclaration(d) && !!d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); });
+ if (ts.length(reexports) > 1) {
+ var groups = ts.group(reexports, function (decl) { return ts.isStringLiteral(decl.moduleSpecifier) ? ">" + decl.moduleSpecifier.text : ">"; });
+ if (groups.length !== reexports.length) {
+ var _loop_9 = function (group_1) {
+ if (group_1.length > 1) {
+ statements = __spreadArrays(ts.filter(statements, function (s) { return group_1.indexOf(s) === -1; }), [
+ ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports(ts.flatMap(group_1, function (e) { return ts.cast(e.exportClause, ts.isNamedExports).elements; })), group_1[0].moduleSpecifier)
+ ]);
+ }
+ };
+ for (var _i = 0, groups_1 = groups; _i < groups_1.length; _i++) {
+ var group_1 = groups_1[_i];
+ _loop_9(group_1);
+ }
+ }
+ }
+ return statements;
}
- }
- result.declarations = declarations;
- result.nameType = nameType;
- if (propTypes.length > 2) {
- result.checkFlags |= 65536;
- result.deferralParent = containingType;
- result.deferralConstituents = propTypes;
- }
- else {
- result.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes);
- }
- return result;
- }
- function getUnionOrIntersectionProperty(type, name) {
- var properties = type.propertyCache || (type.propertyCache = ts.createSymbolTable());
- var property = properties.get(name);
- if (!property) {
- property = createUnionOrIntersectionProperty(type, name);
- if (property) {
- properties.set(name, property);
+ function inlineExportModifiers(statements) {
+ var index = ts.findIndex(statements, function (d) { return ts.isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); });
+ if (index >= 0) {
+ var exportDecl = statements[index];
+ var replacements = ts.mapDefined(exportDecl.exportClause.elements, function (e) {
+ if (!e.propertyName) {
+ var indices = ts.indicesOf(statements);
+ var associatedIndices = ts.filter(indices, function (i) { return ts.nodeHasName(statements[i], e.name); });
+ if (ts.length(associatedIndices) && ts.every(associatedIndices, function (i) { return canHaveExportModifier(statements[i]); })) {
+ for (var _i = 0, associatedIndices_1 = associatedIndices; _i < associatedIndices_1.length; _i++) {
+ var index_1 = associatedIndices_1[_i];
+ statements[index_1] = addExportModifier(statements[index_1]);
+ }
+ return undefined;
+ }
+ }
+ return e;
+ });
+ if (!ts.length(replacements)) {
+ ts.orderedRemoveItemAt(statements, index);
+ }
+ else {
+ statements[index] = ts.factory.updateExportDeclaration(exportDecl, exportDecl.decorators, exportDecl.modifiers, exportDecl.isTypeOnly, ts.factory.updateNamedExports(exportDecl.exportClause, replacements), exportDecl.moduleSpecifier);
+ }
+ }
+ return statements;
}
- }
- return property;
- }
- function getPropertyOfUnionOrIntersectionType(type, name) {
- var property = getUnionOrIntersectionProperty(type, name);
- return property && !(ts.getCheckFlags(property) & 16) ? property : undefined;
- }
- function getReducedType(type) {
- if (type.flags & 1048576 && type.objectFlags & 268435456) {
- return type.resolvedReducedType || (type.resolvedReducedType = getReducedUnionType(type));
- }
- else if (type.flags & 2097152) {
- if (!(type.objectFlags & 268435456)) {
- type.objectFlags |= 268435456 |
- (ts.some(getPropertiesOfUnionOrIntersectionType(type), isNeverReducedProperty) ? 536870912 : 0);
+ function mergeRedundantStatements(statements) {
+ statements = flattenExportAssignedNamespace(statements);
+ statements = mergeExportDeclarations(statements);
+ statements = inlineExportModifiers(statements);
+ if (enclosingDeclaration &&
+ ((ts.isSourceFile(enclosingDeclaration) && ts.isExternalOrCommonJsModule(enclosingDeclaration)) || ts.isModuleDeclaration(enclosingDeclaration)) &&
+ (!ts.some(statements, ts.isExternalModuleIndicator) || (!ts.hasScopeMarker(statements) && ts.some(statements, ts.needsScopeMarker)))) {
+ statements.push(ts.createEmptyExports(ts.factory));
+ }
+ return statements;
}
- return type.objectFlags & 536870912 ? neverType : type;
- }
- return type;
- }
- function getReducedUnionType(unionType) {
- var reducedTypes = ts.sameMap(unionType.types, getReducedType);
- if (reducedTypes === unionType.types) {
- return unionType;
- }
- var reduced = getUnionType(reducedTypes);
- if (reduced.flags & 1048576) {
- reduced.resolvedReducedType = reduced;
- }
- return reduced;
- }
- function isNeverReducedProperty(prop) {
- return isDiscriminantWithNeverType(prop) || isConflictingPrivateProperty(prop);
- }
- function isDiscriminantWithNeverType(prop) {
- return !(prop.flags & 16777216) &&
- (ts.getCheckFlags(prop) & (192 | 131072)) === 192 &&
- !!(getTypeOfSymbol(prop).flags & 131072);
- }
- function isConflictingPrivateProperty(prop) {
- return !prop.valueDeclaration && !!(ts.getCheckFlags(prop) & 1024);
- }
- function elaborateNeverIntersection(errorInfo, type) {
- if (ts.getObjectFlags(type) & 536870912) {
- var neverProp = ts.find(getPropertiesOfUnionOrIntersectionType(type), isDiscriminantWithNeverType);
- if (neverProp) {
- return ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents, typeToString(type, undefined, 536870912), symbolToString(neverProp));
+ function canHaveExportModifier(node) {
+ return ts.isEnumDeclaration(node) ||
+ ts.isVariableStatement(node) ||
+ ts.isFunctionDeclaration(node) ||
+ ts.isClassDeclaration(node) ||
+ (ts.isModuleDeclaration(node) && !ts.isExternalModuleAugmentation(node) && !ts.isGlobalScopeAugmentation(node)) ||
+ ts.isInterfaceDeclaration(node) ||
+ isTypeDeclaration(node);
}
- var privateProp = ts.find(getPropertiesOfUnionOrIntersectionType(type), isConflictingPrivateProperty);
- if (privateProp) {
- return ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some, typeToString(type, undefined, 536870912), symbolToString(privateProp));
+ function addExportModifier(node) {
+ var flags = (ts.getEffectiveModifierFlags(node) | 1) & ~2;
+ return ts.factory.updateModifiers(node, flags);
}
- }
- return errorInfo;
- }
- function getPropertyOfType(type, name) {
- type = getReducedApparentType(type);
- if (type.flags & 524288) {
- var resolved = resolveStructuredTypeMembers(type);
- var symbol = resolved.members.get(name);
- if (symbol && symbolIsValue(symbol)) {
- return symbol;
+ function removeExportModifier(node) {
+ var flags = ts.getEffectiveModifierFlags(node) & ~1;
+ return ts.factory.updateModifiers(node, flags);
}
- var functionType = resolved === anyFunctionType ? globalFunctionType :
- resolved.callSignatures.length ? globalCallableFunctionType :
- resolved.constructSignatures.length ? globalNewableFunctionType :
- undefined;
- if (functionType) {
- var symbol_1 = getPropertyOfObjectType(functionType, name);
- if (symbol_1) {
- return symbol_1;
+ function visitSymbolTable(symbolTable, suppressNewPrivateContext, propertyAsAlias) {
+ if (!suppressNewPrivateContext) {
+ deferredPrivatesStack.push(new ts.Map());
+ }
+ symbolTable.forEach(function (symbol) {
+ serializeSymbol(symbol, false, !!propertyAsAlias);
+ });
+ if (!suppressNewPrivateContext) {
+ deferredPrivatesStack[deferredPrivatesStack.length - 1].forEach(function (symbol) {
+ serializeSymbol(symbol, true, !!propertyAsAlias);
+ });
+ deferredPrivatesStack.pop();
}
}
- return getPropertyOfObjectType(globalObjectType, name);
- }
- if (type.flags & 3145728) {
- return getPropertyOfUnionOrIntersectionType(type, name);
- }
- return undefined;
- }
- function getSignaturesOfStructuredType(type, kind) {
- if (type.flags & 3670016) {
- var resolved = resolveStructuredTypeMembers(type);
- return kind === 0 ? resolved.callSignatures : resolved.constructSignatures;
- }
- return ts.emptyArray;
- }
- function getSignaturesOfType(type, kind) {
- return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
- }
- function getIndexInfoOfStructuredType(type, kind) {
- if (type.flags & 3670016) {
- var resolved = resolveStructuredTypeMembers(type);
- return kind === 0 ? resolved.stringIndexInfo : resolved.numberIndexInfo;
- }
- }
- function getIndexTypeOfStructuredType(type, kind) {
- var info = getIndexInfoOfStructuredType(type, kind);
- return info && info.type;
- }
- function getIndexInfoOfType(type, kind) {
- return getIndexInfoOfStructuredType(getReducedApparentType(type), kind);
- }
- function getIndexTypeOfType(type, kind) {
- return getIndexTypeOfStructuredType(getReducedApparentType(type), kind);
- }
- function getImplicitIndexTypeOfType(type, kind) {
- if (isObjectTypeWithInferableIndex(type)) {
- var propTypes = [];
- for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) {
- var prop = _a[_i];
- if (kind === 0 || isNumericLiteralName(prop.escapedName)) {
- propTypes.push(getTypeOfSymbol(prop));
+ function serializeSymbol(symbol, isPrivate, propertyAsAlias) {
+ var visitedSym = getMergedSymbol(symbol);
+ if (visitedSymbols.has(getSymbolId(visitedSym))) {
+ return;
+ }
+ visitedSymbols.add(getSymbolId(visitedSym));
+ var skipMembershipCheck = !isPrivate;
+ if (skipMembershipCheck || (!!ts.length(symbol.declarations) && ts.some(symbol.declarations, function (d) { return !!ts.findAncestor(d, function (n) { return n === enclosingDeclaration; }); }))) {
+ var oldContext = context;
+ context = cloneNodeBuilderContext(context);
+ var result = serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
+ context = oldContext;
+ return result;
}
}
- if (kind === 0) {
- ts.append(propTypes, getIndexTypeOfType(type, 1));
+ function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias) {
+ var symbolName = ts.unescapeLeadingUnderscores(symbol.escapedName);
+ var isDefault = symbol.escapedName === "default";
+ if (isPrivate && !(context.flags & 131072) && ts.isStringANonContextualKeyword(symbolName) && !isDefault) {
+ context.encounteredError = true;
+ return;
+ }
+ var needsPostExportDefault = isDefault && !!(symbol.flags & -113
+ || (symbol.flags & 16 && ts.length(getPropertiesOfType(getTypeOfSymbol(symbol))))) && !(symbol.flags & 2097152);
+ var needsExportDeclaration = !needsPostExportDefault && !isPrivate && ts.isStringANonContextualKeyword(symbolName) && !isDefault;
+ if (needsPostExportDefault || needsExportDeclaration) {
+ isPrivate = true;
+ }
+ var modifierFlags = (!isPrivate ? 1 : 0) | (isDefault && !needsPostExportDefault ? 512 : 0);
+ var isConstMergedWithNS = symbol.flags & 1536 &&
+ symbol.flags & (2 | 1 | 4) &&
+ symbol.escapedName !== "export=";
+ var isConstMergedWithNSPrintableAsSignatureMerge = isConstMergedWithNS && isTypeRepresentableAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol);
+ if (symbol.flags & (16 | 8192) || isConstMergedWithNSPrintableAsSignatureMerge) {
+ serializeAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol, getInternalSymbolName(symbol, symbolName), modifierFlags);
+ }
+ if (symbol.flags & 524288) {
+ serializeTypeAlias(symbol, symbolName, modifierFlags);
+ }
+ if (symbol.flags & (2 | 1 | 4)
+ && symbol.escapedName !== "export="
+ && !(symbol.flags & 4194304)
+ && !(symbol.flags & 32)
+ && !isConstMergedWithNSPrintableAsSignatureMerge) {
+ if (propertyAsAlias) {
+ var createdExport = serializeMaybeAliasAssignment(symbol);
+ if (createdExport) {
+ needsExportDeclaration = false;
+ needsPostExportDefault = false;
+ }
+ }
+ else {
+ var type = getTypeOfSymbol(symbol);
+ var localName = getInternalSymbolName(symbol, symbolName);
+ if (!(symbol.flags & 16) && isTypeRepresentableAsFunctionNamespaceMerge(type, symbol)) {
+ serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags);
+ }
+ else {
+ var flags = !(symbol.flags & 2) ? undefined
+ : isConstVariable(symbol) ? 2
+ : 1;
+ var name = (needsPostExportDefault || !(symbol.flags & 4)) ? localName : getUnusedName(localName, symbol);
+ var textRange = symbol.declarations && ts.find(symbol.declarations, function (d) { return ts.isVariableDeclaration(d); });
+ if (textRange && ts.isVariableDeclarationList(textRange.parent) && textRange.parent.declarations.length === 1) {
+ textRange = textRange.parent.parent;
+ }
+ var propertyAccessRequire = ts.find(symbol.declarations, ts.isPropertyAccessExpression);
+ if (propertyAccessRequire && ts.isBinaryExpression(propertyAccessRequire.parent) && ts.isIdentifier(propertyAccessRequire.parent.right)
+ && type.symbol && ts.isSourceFile(type.symbol.valueDeclaration)) {
+ var alias = localName === propertyAccessRequire.parent.right.escapedText ? undefined : propertyAccessRequire.parent.right;
+ addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(alias, localName)])), 0);
+ context.tracker.trackSymbol(type.symbol, context.enclosingDeclaration, 111551);
+ }
+ else {
+ var statement = ts.setTextRange(ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+ ts.factory.createVariableDeclaration(name, undefined, serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled))
+ ], flags)), textRange);
+ addResult(statement, name !== localName ? modifierFlags & ~1 : modifierFlags);
+ if (name !== localName && !isPrivate) {
+ addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(name, localName)])), 0);
+ needsExportDeclaration = false;
+ needsPostExportDefault = false;
+ }
+ }
+ }
+ }
+ }
+ if (symbol.flags & 384) {
+ serializeEnum(symbol, symbolName, modifierFlags);
+ }
+ if (symbol.flags & 32) {
+ if (symbol.flags & 4 && ts.isBinaryExpression(symbol.valueDeclaration.parent) && ts.isClassExpression(symbol.valueDeclaration.parent.right)) {
+ serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags);
+ }
+ else {
+ serializeAsClass(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags);
+ }
+ }
+ if ((symbol.flags & (512 | 1024) && (!isConstMergedWithNS || isTypeOnlyNamespace(symbol))) || isConstMergedWithNSPrintableAsSignatureMerge) {
+ serializeModule(symbol, symbolName, modifierFlags);
+ }
+ if (symbol.flags & 64 && !(symbol.flags & 32)) {
+ serializeInterface(symbol, symbolName, modifierFlags);
+ }
+ if (symbol.flags & 2097152) {
+ serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags);
+ }
+ if (symbol.flags & 4 && symbol.escapedName === "export=") {
+ serializeMaybeAliasAssignment(symbol);
+ }
+ if (symbol.flags & 8388608) {
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var node = _a[_i];
+ var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
+ if (!resolvedModule)
+ continue;
+ addResult(ts.factory.createExportDeclaration(undefined, undefined, false, undefined, ts.factory.createStringLiteral(getSpecifierForModuleSymbol(resolvedModule, context))), 0);
+ }
+ }
+ if (needsPostExportDefault) {
+ addResult(ts.factory.createExportAssignment(undefined, undefined, false, ts.factory.createIdentifier(getInternalSymbolName(symbol, symbolName))), 0);
+ }
+ else if (needsExportDeclaration) {
+ addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(getInternalSymbolName(symbol, symbolName), symbolName)])), 0);
+ }
}
- if (propTypes.length) {
- return getUnionType(propTypes);
+ function includePrivateSymbol(symbol) {
+ if (ts.some(symbol.declarations, ts.isParameterDeclaration))
+ return;
+ ts.Debug.assertIsDefined(deferredPrivatesStack[deferredPrivatesStack.length - 1]);
+ getUnusedName(ts.unescapeLeadingUnderscores(symbol.escapedName), symbol);
+ var isExternalImportAlias = !!(symbol.flags & 2097152) && !ts.some(symbol.declarations, function (d) {
+ return !!ts.findAncestor(d, ts.isExportDeclaration) ||
+ ts.isNamespaceExport(d) ||
+ (ts.isImportEqualsDeclaration(d) && !ts.isExternalModuleReference(d.moduleReference));
+ });
+ deferredPrivatesStack[isExternalImportAlias ? 0 : (deferredPrivatesStack.length - 1)].set(getSymbolId(symbol), symbol);
}
- }
- return undefined;
- }
- function getTypeParametersFromDeclaration(declaration) {
- var result;
- for (var _i = 0, _a = ts.getEffectiveTypeParameterDeclarations(declaration); _i < _a.length; _i++) {
- var node = _a[_i];
- result = ts.appendIfUnique(result, getDeclaredTypeOfTypeParameter(node.symbol));
- }
- return result;
- }
- function symbolsToArray(symbols) {
- var result = [];
- symbols.forEach(function (symbol, id) {
- if (!isReservedMemberName(id)) {
- result.push(symbol);
+ function isExportingScope(enclosingDeclaration) {
+ return ((ts.isSourceFile(enclosingDeclaration) && (ts.isExternalOrCommonJsModule(enclosingDeclaration) || ts.isJsonSourceFile(enclosingDeclaration))) ||
+ (ts.isAmbientModule(enclosingDeclaration) && !ts.isGlobalScopeAugmentation(enclosingDeclaration)));
}
- });
- return result;
- }
- function isJSDocOptionalParameter(node) {
- return ts.isInJSFile(node) && (node.type && node.type.kind === 299
- || ts.getJSDocParameterTags(node).some(function (_a) {
- var isBracketed = _a.isBracketed, typeExpression = _a.typeExpression;
- return isBracketed || !!typeExpression && typeExpression.type.kind === 299;
- }));
- }
- function tryFindAmbientModule(moduleName, withAugmentations) {
- if (ts.isExternalModuleNameRelative(moduleName)) {
- return undefined;
- }
- var symbol = getSymbol(globals, '"' + moduleName + '"', 512);
- return symbol && withAugmentations ? getMergedSymbol(symbol) : symbol;
- }
- function isOptionalParameter(node) {
- if (ts.hasQuestionToken(node) || isOptionalJSDocParameterTag(node) || isJSDocOptionalParameter(node)) {
- return true;
- }
- if (node.initializer) {
- var signature = getSignatureFromDeclaration(node.parent);
- var parameterIndex = node.parent.parameters.indexOf(node);
- ts.Debug.assert(parameterIndex >= 0);
- return parameterIndex >= getMinArgumentCount(signature, true);
- }
- var iife = ts.getImmediatelyInvokedFunctionExpression(node.parent);
- if (iife) {
- return !node.type &&
- !node.dotDotDotToken &&
- node.parent.parameters.indexOf(node) >= iife.arguments.length;
- }
- return false;
- }
- function isOptionalJSDocParameterTag(node) {
- if (!ts.isJSDocParameterTag(node)) {
- return false;
- }
- var isBracketed = node.isBracketed, typeExpression = node.typeExpression;
- return isBracketed || !!typeExpression && typeExpression.type.kind === 299;
- }
- function createTypePredicate(kind, parameterName, parameterIndex, type) {
- return { kind: kind, parameterName: parameterName, parameterIndex: parameterIndex, type: type };
- }
- function getMinTypeArgumentCount(typeParameters) {
- var minTypeArgumentCount = 0;
- if (typeParameters) {
- for (var i = 0; i < typeParameters.length; i++) {
- if (!hasTypeParameterDefault(typeParameters[i])) {
- minTypeArgumentCount = i + 1;
+ function addResult(node, additionalModifierFlags) {
+ if (ts.canHaveModifiers(node)) {
+ var newModifierFlags = 0;
+ if (additionalModifierFlags & 1 &&
+ context.enclosingDeclaration &&
+ (isExportingScope(context.enclosingDeclaration) || ts.isModuleDeclaration(context.enclosingDeclaration)) &&
+ canHaveExportModifier(node)) {
+ newModifierFlags |= 1;
+ }
+ if (addingDeclare && !(newModifierFlags & 1) &&
+ (!context.enclosingDeclaration || !(context.enclosingDeclaration.flags & 8388608)) &&
+ (ts.isEnumDeclaration(node) || ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isModuleDeclaration(node))) {
+ newModifierFlags |= 2;
+ }
+ if ((additionalModifierFlags & 512) && (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isFunctionDeclaration(node))) {
+ newModifierFlags |= 512;
+ }
+ if (newModifierFlags) {
+ node = ts.factory.updateModifiers(node, newModifierFlags | ts.getEffectiveModifierFlags(node));
+ }
}
+ results.push(node);
}
- }
- return minTypeArgumentCount;
- }
- function fillMissingTypeArguments(typeArguments, typeParameters, minTypeArgumentCount, isJavaScriptImplicitAny) {
- var numTypeParameters = ts.length(typeParameters);
- if (!numTypeParameters) {
- return [];
- }
- var numTypeArguments = ts.length(typeArguments);
- if (isJavaScriptImplicitAny || (numTypeArguments >= minTypeArgumentCount && numTypeArguments <= numTypeParameters)) {
- var result = typeArguments ? typeArguments.slice() : [];
- for (var i = numTypeArguments; i < numTypeParameters; i++) {
- result[i] = errorType;
+ function serializeTypeAlias(symbol, symbolName, modifierFlags) {
+ var aliasType = getDeclaredTypeOfTypeAlias(symbol);
+ var typeParams = getSymbolLinks(symbol).typeParameters;
+ var typeParamDecls = ts.map(typeParams, function (p) { return typeParameterToDeclaration(p, context); });
+ var jsdocAliasDecl = ts.find(symbol.declarations, ts.isJSDocTypeAlias);
+ var commentText = jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : undefined;
+ var oldFlags = context.flags;
+ context.flags |= 8388608;
+ addResult(ts.setSyntheticLeadingComments(ts.factory.createTypeAliasDeclaration(undefined, undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, typeToTypeNodeHelper(aliasType, context)), !commentText ? [] : [{ kind: 3, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]), modifierFlags);
+ context.flags = oldFlags;
+ }
+ function serializeInterface(symbol, symbolName, modifierFlags) {
+ var interfaceType = getDeclaredTypeOfClassOrInterface(symbol);
+ var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
+ var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); });
+ var baseTypes = getBaseTypes(interfaceType);
+ var baseType = ts.length(baseTypes) ? getIntersectionType(baseTypes) : undefined;
+ var members = ts.flatMap(getPropertiesOfType(interfaceType), function (p) { return serializePropertySymbolForInterface(p, baseType); });
+ var callSignatures = serializeSignatures(0, interfaceType, baseType, 169);
+ var constructSignatures = serializeSignatures(1, interfaceType, baseType, 170);
+ var indexSignatures = serializeIndexSignatures(interfaceType, baseType);
+ var heritageClauses = !ts.length(baseTypes) ? undefined : [ts.factory.createHeritageClause(93, ts.mapDefined(baseTypes, function (b) { return trySerializeAsTypeReference(b, 111551); }))];
+ addResult(ts.factory.createInterfaceDeclaration(undefined, undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, heritageClauses, __spreadArrays(indexSignatures, constructSignatures, callSignatures, members)), modifierFlags);
}
- var baseDefaultType = getDefaultTypeArgumentType(isJavaScriptImplicitAny);
- for (var i = numTypeArguments; i < numTypeParameters; i++) {
- var defaultType = getDefaultFromTypeParameter(typeParameters[i]);
- if (isJavaScriptImplicitAny && defaultType && (isTypeIdenticalTo(defaultType, unknownType) || isTypeIdenticalTo(defaultType, emptyObjectType))) {
- defaultType = anyType;
- }
- result[i] = defaultType ? instantiateType(defaultType, createTypeMapper(typeParameters, result)) : baseDefaultType;
+ function getNamespaceMembersForSerialization(symbol) {
+ return !symbol.exports ? [] : ts.filter(ts.arrayFrom(symbol.exports.values()), isNamespaceMember);
}
- result.length = typeParameters.length;
- return result;
- }
- return typeArguments && typeArguments.slice();
- }
- function getSignatureFromDeclaration(declaration) {
- var links = getNodeLinks(declaration);
- if (!links.resolvedSignature) {
- var parameters = [];
- var flags = 0;
- var minArgumentCount = 0;
- var thisParameter = void 0;
- var hasThisParameter = false;
- var iife = ts.getImmediatelyInvokedFunctionExpression(declaration);
- var isJSConstructSignature = ts.isJSDocConstructSignature(declaration);
- var isUntypedSignatureInJSFile = !iife &&
- ts.isInJSFile(declaration) &&
- ts.isValueSignatureDeclaration(declaration) &&
- !ts.hasJSDocParameterTags(declaration) &&
- !ts.getJSDocType(declaration);
- if (isUntypedSignatureInJSFile) {
- flags |= 16;
+ function isTypeOnlyNamespace(symbol) {
+ return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(resolveSymbol(m).flags & 111551); });
}
- for (var i = isJSConstructSignature ? 1 : 0; i < declaration.parameters.length; i++) {
- var param = declaration.parameters[i];
- var paramSymbol = param.symbol;
- var type = ts.isJSDocParameterTag(param) ? (param.typeExpression && param.typeExpression.type) : param.type;
- if (paramSymbol && !!(paramSymbol.flags & 4) && !ts.isBindingPattern(param.name)) {
- var resolvedSymbol = resolveName(param, paramSymbol.escapedName, 111551, undefined, undefined, false);
- paramSymbol = resolvedSymbol;
- }
- if (i === 0 && paramSymbol.escapedName === "this") {
- hasThisParameter = true;
- thisParameter = param.symbol;
+ function serializeModule(symbol, symbolName, modifierFlags) {
+ var members = getNamespaceMembersForSerialization(symbol);
+ var locationMap = ts.arrayToMultiMap(members, function (m) { return m.parent && m.parent === symbol ? "real" : "merged"; });
+ var realMembers = locationMap.get("real") || ts.emptyArray;
+ var mergedMembers = locationMap.get("merged") || ts.emptyArray;
+ if (ts.length(realMembers)) {
+ var localName = getInternalSymbolName(symbol, symbolName);
+ serializeAsNamespaceDeclaration(realMembers, localName, modifierFlags, !!(symbol.flags & (16 | 67108864)));
}
- else {
- parameters.push(paramSymbol);
+ if (ts.length(mergedMembers)) {
+ var containingFile_1 = ts.getSourceFileOfNode(context.enclosingDeclaration);
+ var localName = getInternalSymbolName(symbol, symbolName);
+ var nsBody = ts.factory.createModuleBlock([ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports(ts.mapDefined(ts.filter(mergedMembers, function (n) { return n.escapedName !== "export="; }), function (s) {
+ var _a, _b;
+ var name = ts.unescapeLeadingUnderscores(s.escapedName);
+ var localName = getInternalSymbolName(s, name);
+ var aliasDecl = s.declarations && getDeclarationOfAliasSymbol(s);
+ if (containingFile_1 && (aliasDecl ? containingFile_1 !== ts.getSourceFileOfNode(aliasDecl) : !ts.some(s.declarations, function (d) { return ts.getSourceFileOfNode(d) === containingFile_1; }))) {
+ (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.reportNonlocalAugmentation) === null || _b === void 0 ? void 0 : _b.call(_a, containingFile_1, symbol, s);
+ return undefined;
+ }
+ var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true);
+ includePrivateSymbol(target || s);
+ var targetName = target ? getInternalSymbolName(target, ts.unescapeLeadingUnderscores(target.escapedName)) : localName;
+ return ts.factory.createExportSpecifier(name === targetName ? undefined : targetName, name);
+ })))]);
+ addResult(ts.factory.createModuleDeclaration(undefined, undefined, ts.factory.createIdentifier(localName), nsBody, 16), 0);
}
- if (type && type.kind === 187) {
- flags |= 2;
+ }
+ function serializeEnum(symbol, symbolName, modifierFlags) {
+ addResult(ts.factory.createEnumDeclaration(undefined, ts.factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 2048 : 0), getInternalSymbolName(symbol, symbolName), ts.map(ts.filter(getPropertiesOfType(getTypeOfSymbol(symbol)), function (p) { return !!(p.flags & 8); }), function (p) {
+ var initializedValue = p.declarations && p.declarations[0] && ts.isEnumMember(p.declarations[0]) ? getConstantValue(p.declarations[0]) : undefined;
+ return ts.factory.createEnumMember(ts.unescapeLeadingUnderscores(p.escapedName), initializedValue === undefined ? undefined :
+ typeof initializedValue === "string" ? ts.factory.createStringLiteral(initializedValue) :
+ ts.factory.createNumericLiteral(initializedValue));
+ })), modifierFlags);
+ }
+ function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) {
+ var signatures = getSignaturesOfType(type, 0);
+ for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) {
+ var sig = signatures_2[_i];
+ var decl = signatureToSignatureDeclarationHelper(sig, 251, context, { name: ts.factory.createIdentifier(localName), privateSymbolVisitor: includePrivateSymbol, bundledImports: bundled });
+ addResult(ts.setTextRange(decl, sig.declaration && ts.isVariableDeclaration(sig.declaration.parent) && sig.declaration.parent.parent || sig.declaration), modifierFlags);
}
- var isOptionalParameter_1 = isOptionalJSDocParameterTag(param) ||
- param.initializer || param.questionToken || param.dotDotDotToken ||
- iife && parameters.length > iife.arguments.length && !type ||
- isJSDocOptionalParameter(param);
- if (!isOptionalParameter_1) {
- minArgumentCount = parameters.length;
+ if (!(symbol.flags & (512 | 1024) && !!symbol.exports && !!symbol.exports.size)) {
+ var props = ts.filter(getPropertiesOfType(type), isNamespaceMember);
+ serializeAsNamespaceDeclaration(props, localName, modifierFlags, true);
}
}
- if ((declaration.kind === 163 || declaration.kind === 164) &&
- !hasNonBindableDynamicName(declaration) &&
- (!hasThisParameter || !thisParameter)) {
- var otherKind = declaration.kind === 163 ? 164 : 163;
- var other = ts.getDeclarationOfKind(getSymbolOfNode(declaration), otherKind);
- if (other) {
- thisParameter = getAnnotatedAccessorThisParameter(other);
+ function serializeAsNamespaceDeclaration(props, localName, modifierFlags, suppressNewPrivateContext) {
+ if (ts.length(props)) {
+ var localVsRemoteMap = ts.arrayToMultiMap(props, function (p) {
+ return !ts.length(p.declarations) || ts.some(p.declarations, function (d) {
+ return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(context.enclosingDeclaration);
+ }) ? "local" : "remote";
+ });
+ var localProps = localVsRemoteMap.get("local") || ts.emptyArray;
+ var fakespace = ts.parseNodeFactory.createModuleDeclaration(undefined, undefined, ts.factory.createIdentifier(localName), ts.factory.createModuleBlock([]), 16);
+ ts.setParent(fakespace, enclosingDeclaration);
+ fakespace.locals = ts.createSymbolTable(props);
+ fakespace.symbol = props[0].parent;
+ var oldResults = results;
+ results = [];
+ var oldAddingDeclare = addingDeclare;
+ addingDeclare = false;
+ var subcontext = __assign(__assign({}, context), { enclosingDeclaration: fakespace });
+ var oldContext = context;
+ context = subcontext;
+ visitSymbolTable(ts.createSymbolTable(localProps), suppressNewPrivateContext, true);
+ context = oldContext;
+ addingDeclare = oldAddingDeclare;
+ var declarations = results;
+ results = oldResults;
+ var defaultReplaced = ts.map(declarations, function (d) { return ts.isExportAssignment(d) && !d.isExportEquals && ts.isIdentifier(d.expression) ? ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(d.expression, ts.factory.createIdentifier("default"))])) : d; });
+ var exportModifierStripped = ts.every(defaultReplaced, function (d) { return ts.hasSyntacticModifier(d, 1); }) ? ts.map(defaultReplaced, removeExportModifier) : defaultReplaced;
+ fakespace = ts.factory.updateModuleDeclaration(fakespace, fakespace.decorators, fakespace.modifiers, fakespace.name, ts.factory.createModuleBlock(exportModifierStripped));
+ addResult(fakespace, modifierFlags);
}
}
- var classType = declaration.kind === 162 ?
- getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol))
- : undefined;
- var typeParameters = classType ? classType.localTypeParameters : getTypeParametersFromDeclaration(declaration);
- if (ts.hasRestParameter(declaration) || ts.isInJSFile(declaration) && maybeAddJsSyntheticRestParameter(declaration, parameters)) {
- flags |= 1;
+ function isNamespaceMember(p) {
+ return !!(p.flags & (788968 | 1920 | 2097152)) ||
+ !(p.flags & 4194304 || p.escapedName === "prototype" || p.valueDeclaration && ts.getEffectiveModifierFlags(p.valueDeclaration) & 32 && ts.isClassLike(p.valueDeclaration.parent));
}
- links.resolvedSignature = createSignature(declaration, typeParameters, thisParameter, parameters, undefined, undefined, minArgumentCount, flags);
- }
- return links.resolvedSignature;
- }
- function maybeAddJsSyntheticRestParameter(declaration, parameters) {
- if (ts.isJSDocSignature(declaration) || !containsArgumentsReference(declaration)) {
- return false;
- }
- var lastParam = ts.lastOrUndefined(declaration.parameters);
- var lastParamTags = lastParam ? ts.getJSDocParameterTags(lastParam) : ts.getJSDocTags(declaration).filter(ts.isJSDocParameterTag);
- var lastParamVariadicType = ts.firstDefined(lastParamTags, function (p) {
- return p.typeExpression && ts.isJSDocVariadicType(p.typeExpression.type) ? p.typeExpression.type : undefined;
- });
- var syntheticArgsSymbol = createSymbol(3, "args", 32768);
- syntheticArgsSymbol.type = lastParamVariadicType ? createArrayType(getTypeFromTypeNode(lastParamVariadicType.type)) : anyArrayType;
- if (lastParamVariadicType) {
- parameters.pop();
- }
- parameters.push(syntheticArgsSymbol);
- return true;
- }
- function getSignatureOfTypeTag(node) {
- if (!(ts.isInJSFile(node) && ts.isFunctionLikeDeclaration(node)))
- return undefined;
- var typeTag = ts.getJSDocTypeTag(node);
- var signature = typeTag && typeTag.typeExpression && getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
- return signature && getErasedSignature(signature);
- }
- function getReturnTypeOfTypeTag(node) {
- var signature = getSignatureOfTypeTag(node);
- return signature && getReturnTypeOfSignature(signature);
- }
- function containsArgumentsReference(declaration) {
- var links = getNodeLinks(declaration);
- if (links.containsArgumentsReference === undefined) {
- if (links.flags & 8192) {
- links.containsArgumentsReference = true;
+ function serializeAsClass(symbol, localName, modifierFlags) {
+ var _a;
+ var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
+ var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); });
+ var classType = getDeclaredTypeOfClassOrInterface(symbol);
+ var baseTypes = getBaseTypes(classType);
+ var implementsExpressions = ts.mapDefined(getImplementsTypes(classType), serializeImplementedType);
+ var staticType = getTypeOfSymbol(symbol);
+ var isClass = !!((_a = staticType.symbol) === null || _a === void 0 ? void 0 : _a.valueDeclaration) && ts.isClassLike(staticType.symbol.valueDeclaration);
+ var staticBaseType = isClass
+ ? getBaseConstructorTypeOfClass(staticType)
+ : anyType;
+ var heritageClauses = __spreadArrays(!ts.length(baseTypes) ? [] : [ts.factory.createHeritageClause(93, ts.map(baseTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))], !ts.length(implementsExpressions) ? [] : [ts.factory.createHeritageClause(116, implementsExpressions)]);
+ var symbolProps = getNonInterhitedProperties(classType, baseTypes, getPropertiesOfType(classType));
+ var publicSymbolProps = ts.filter(symbolProps, function (s) {
+ var valueDecl = s.valueDeclaration;
+ return valueDecl && !(ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name));
+ });
+ var hasPrivateIdentifier = ts.some(symbolProps, function (s) {
+ var valueDecl = s.valueDeclaration;
+ return valueDecl && ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name);
+ });
+ var privateProperties = hasPrivateIdentifier ?
+ [ts.factory.createPropertyDeclaration(undefined, undefined, ts.factory.createPrivateIdentifier("#private"), undefined, undefined, undefined)] :
+ ts.emptyArray;
+ var publicProperties = ts.flatMap(publicSymbolProps, function (p) { return serializePropertySymbolForClass(p, false, baseTypes[0]); });
+ var staticMembers = ts.flatMap(ts.filter(getPropertiesOfType(staticType), function (p) { return !(p.flags & 4194304) && p.escapedName !== "prototype" && !isNamespaceMember(p); }), function (p) { return serializePropertySymbolForClass(p, true, staticBaseType); });
+ var isNonConstructableClassLikeInJsFile = !isClass &&
+ !!symbol.valueDeclaration &&
+ ts.isInJSFile(symbol.valueDeclaration) &&
+ !ts.some(getSignaturesOfType(staticType, 1));
+ var constructors = isNonConstructableClassLikeInJsFile ?
+ [ts.factory.createConstructorDeclaration(undefined, ts.factory.createModifiersFromModifierFlags(8), [], undefined)] :
+ serializeSignatures(1, staticType, baseTypes[0], 166);
+ var indexSignatures = serializeIndexSignatures(classType, baseTypes[0]);
+ addResult(ts.setTextRange(ts.factory.createClassDeclaration(undefined, undefined, localName, typeParamDecls, heritageClauses, __spreadArrays(indexSignatures, staticMembers, constructors, publicProperties, privateProperties)), symbol.declarations && ts.filter(symbol.declarations, function (d) { return ts.isClassDeclaration(d) || ts.isClassExpression(d); })[0]), modifierFlags);
}
- else {
- links.containsArgumentsReference = traverse(declaration.body);
+ function serializeAsAlias(symbol, localName, modifierFlags) {
+ var _a, _b, _c, _d, _e;
+ var node = getDeclarationOfAliasSymbol(symbol);
+ if (!node)
+ return ts.Debug.fail();
+ var target = getMergedSymbol(getTargetOfAliasDeclaration(node, true));
+ if (!target) {
+ return;
+ }
+ var verbatimTargetName = ts.unescapeLeadingUnderscores(target.escapedName);
+ if (verbatimTargetName === "export=" && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) {
+ verbatimTargetName = "default";
+ }
+ var targetName = getInternalSymbolName(target, verbatimTargetName);
+ includePrivateSymbol(target);
+ switch (node.kind) {
+ case 198:
+ if (((_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.kind) === 249) {
+ var specifier_1 = getSpecifierForModuleSymbol(target.parent || target, context);
+ var propertyName = node.propertyName;
+ addResult(ts.factory.createImportDeclaration(undefined, undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([ts.factory.createImportSpecifier(propertyName && ts.isIdentifier(propertyName) ? ts.factory.createIdentifier(ts.idText(propertyName)) : undefined, ts.factory.createIdentifier(localName))])), ts.factory.createStringLiteral(specifier_1)), 0);
+ break;
+ }
+ ts.Debug.failBadSyntaxKind(((_c = node.parent) === null || _c === void 0 ? void 0 : _c.parent) || node, "Unhandled binding element grandparent kind in declaration serialization");
+ break;
+ case 289:
+ if (((_e = (_d = node.parent) === null || _d === void 0 ? void 0 : _d.parent) === null || _e === void 0 ? void 0 : _e.kind) === 216) {
+ serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), targetName);
+ }
+ break;
+ case 249:
+ if (ts.isPropertyAccessExpression(node.initializer)) {
+ var initializer = node.initializer;
+ var uniqueName = ts.factory.createUniqueName(localName);
+ var specifier_2 = getSpecifierForModuleSymbol(target.parent || target, context);
+ addResult(ts.factory.createImportEqualsDeclaration(undefined, undefined, uniqueName, ts.factory.createExternalModuleReference(ts.factory.createStringLiteral(specifier_2))), 0);
+ addResult(ts.factory.createImportEqualsDeclaration(undefined, undefined, ts.factory.createIdentifier(localName), ts.factory.createQualifiedName(uniqueName, initializer.name)), modifierFlags);
+ break;
+ }
+ case 260:
+ if (target.escapedName === "export=" && ts.some(target.declarations, ts.isJsonSourceFile)) {
+ serializeMaybeAliasAssignment(symbol);
+ break;
+ }
+ var isLocalImport = !(target.flags & 512) && !ts.isVariableDeclaration(node);
+ addResult(ts.factory.createImportEqualsDeclaration(undefined, undefined, ts.factory.createIdentifier(localName), isLocalImport
+ ? symbolToName(target, context, 67108863, false)
+ : ts.factory.createExternalModuleReference(ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target, context)))), isLocalImport ? modifierFlags : 0);
+ break;
+ case 259:
+ addResult(ts.factory.createNamespaceExportDeclaration(ts.idText(node.name)), 0);
+ break;
+ case 262:
+ addResult(ts.factory.createImportDeclaration(undefined, undefined, ts.factory.createImportClause(false, ts.factory.createIdentifier(localName), undefined), ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context))), 0);
+ break;
+ case 263:
+ addResult(ts.factory.createImportDeclaration(undefined, undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamespaceImport(ts.factory.createIdentifier(localName))), ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target, context))), 0);
+ break;
+ case 269:
+ addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamespaceExport(ts.factory.createIdentifier(localName)), ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target, context))), 0);
+ break;
+ case 265:
+ addResult(ts.factory.createImportDeclaration(undefined, undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+ ts.factory.createImportSpecifier(localName !== verbatimTargetName ? ts.factory.createIdentifier(verbatimTargetName) : undefined, ts.factory.createIdentifier(localName))
+ ])), ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context))), 0);
+ break;
+ case 270:
+ var specifier = node.parent.parent.moduleSpecifier;
+ serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? verbatimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.factory.createStringLiteral(specifier.text) : undefined);
+ break;
+ case 266:
+ serializeMaybeAliasAssignment(symbol);
+ break;
+ case 216:
+ case 201:
+ case 202:
+ if (symbol.escapedName === "default" || symbol.escapedName === "export=") {
+ serializeMaybeAliasAssignment(symbol);
+ }
+ else {
+ serializeExportSpecifier(localName, targetName);
+ }
+ break;
+ default:
+ return ts.Debug.failBadSyntaxKind(node, "Unhandled alias declaration kind in symbol serializer!");
+ }
}
- }
- return links.containsArgumentsReference;
- function traverse(node) {
- if (!node)
- return false;
- switch (node.kind) {
- case 75:
- return node.escapedText === "arguments" && ts.isExpressionNode(node);
- case 159:
- case 161:
- case 163:
- case 164:
- return node.name.kind === 154
- && traverse(node.name);
- default:
- return !ts.nodeStartsNewLexicalEnvironment(node) && !ts.isPartOfTypeNode(node) && !!ts.forEachChild(node, traverse);
+ function serializeExportSpecifier(localName, targetName, specifier) {
+ addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(localName !== targetName ? targetName : undefined, localName)]), specifier), 0);
}
- }
- }
- function getSignaturesOfSymbol(symbol) {
- if (!symbol)
- return ts.emptyArray;
- var result = [];
- for (var i = 0; i < symbol.declarations.length; i++) {
- var decl = symbol.declarations[i];
- if (!ts.isFunctionLike(decl))
- continue;
- if (i > 0 && decl.body) {
- var previous = symbol.declarations[i - 1];
- if (decl.parent === previous.parent && decl.kind === previous.kind && decl.pos === previous.end) {
- continue;
+ function serializeMaybeAliasAssignment(symbol) {
+ if (symbol.flags & 4194304) {
+ return false;
+ }
+ var name = ts.unescapeLeadingUnderscores(symbol.escapedName);
+ var isExportEquals = name === "export=";
+ var isDefault = name === "default";
+ var isExportAssignmentCompatibleSymbolName = isExportEquals || isDefault;
+ var aliasDecl = symbol.declarations && getDeclarationOfAliasSymbol(symbol);
+ var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true);
+ if (target && ts.length(target.declarations) && ts.some(target.declarations, function (d) { return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(enclosingDeclaration); })) {
+ var expr = aliasDecl && ((ts.isExportAssignment(aliasDecl) || ts.isBinaryExpression(aliasDecl)) ? ts.getExportAssignmentExpression(aliasDecl) : ts.getPropertyAssignmentAliasLikeExpression(aliasDecl));
+ var first_1 = expr && ts.isEntityNameExpression(expr) ? getFirstNonModuleExportsIdentifier(expr) : undefined;
+ var referenced = first_1 && resolveEntityName(first_1, 67108863, true, true, enclosingDeclaration);
+ if (referenced || target) {
+ includePrivateSymbol(referenced || target);
+ }
+ var oldTrack = context.tracker.trackSymbol;
+ context.tracker.trackSymbol = ts.noop;
+ if (isExportAssignmentCompatibleSymbolName) {
+ results.push(ts.factory.createExportAssignment(undefined, undefined, isExportEquals, symbolToExpression(target, context, 67108863)));
+ }
+ else {
+ if (first_1 === expr && first_1) {
+ serializeExportSpecifier(name, ts.idText(first_1));
+ }
+ else if (expr && ts.isClassExpression(expr)) {
+ serializeExportSpecifier(name, getInternalSymbolName(target, ts.symbolName(target)));
+ }
+ else {
+ var varName = getUnusedName(name, symbol);
+ addResult(ts.factory.createImportEqualsDeclaration(undefined, undefined, ts.factory.createIdentifier(varName), symbolToName(target, context, 67108863, false)), 0);
+ serializeExportSpecifier(name, varName);
+ }
+ }
+ context.tracker.trackSymbol = oldTrack;
+ return true;
+ }
+ else {
+ var varName = getUnusedName(name, symbol);
+ var typeToSerialize = getWidenedType(getTypeOfSymbol(getMergedSymbol(symbol)));
+ if (isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, symbol)) {
+ serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignmentCompatibleSymbolName ? 0 : 1);
+ }
+ else {
+ var statement = ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+ ts.factory.createVariableDeclaration(varName, undefined, serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration, includePrivateSymbol, bundled))
+ ], 2));
+ addResult(statement, target && target.flags & 4 && target.escapedName === "export=" ? 2
+ : name === varName ? 1
+ : 0);
+ }
+ if (isExportAssignmentCompatibleSymbolName) {
+ results.push(ts.factory.createExportAssignment(undefined, undefined, isExportEquals, ts.factory.createIdentifier(varName)));
+ return true;
+ }
+ else if (name !== varName) {
+ serializeExportSpecifier(name, varName);
+ return true;
+ }
+ return false;
}
}
- result.push(getSignatureFromDeclaration(decl));
- }
- return result;
- }
- function resolveExternalModuleTypeByLiteral(name) {
- var moduleSym = resolveExternalModuleName(name, name);
- if (moduleSym) {
- var resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym);
- if (resolvedModuleSymbol) {
- return getTypeOfSymbol(resolvedModuleSymbol);
+ function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, hostSymbol) {
+ var ctxSrc = ts.getSourceFileOfNode(context.enclosingDeclaration);
+ return ts.getObjectFlags(typeToSerialize) & (16 | 32) &&
+ !getIndexInfoOfType(typeToSerialize, 0) &&
+ !getIndexInfoOfType(typeToSerialize, 1) &&
+ !isClassInstanceSide(typeToSerialize) &&
+ !!(ts.length(ts.filter(getPropertiesOfType(typeToSerialize), isNamespaceMember)) || ts.length(getSignaturesOfType(typeToSerialize, 0))) &&
+ !ts.length(getSignaturesOfType(typeToSerialize, 1)) &&
+ !getDeclarationWithTypeAnnotation(hostSymbol, enclosingDeclaration) &&
+ !(typeToSerialize.symbol && ts.some(typeToSerialize.symbol.declarations, function (d) { return ts.getSourceFileOfNode(d) !== ctxSrc; })) &&
+ !ts.some(getPropertiesOfType(typeToSerialize), function (p) { return isLateBoundName(p.escapedName); }) &&
+ !ts.some(getPropertiesOfType(typeToSerialize), function (p) { return ts.some(p.declarations, function (d) { return ts.getSourceFileOfNode(d) !== ctxSrc; }); }) &&
+ ts.every(getPropertiesOfType(typeToSerialize), function (p) { return ts.isIdentifierText(ts.symbolName(p), languageVersion); });
}
- }
- return anyType;
- }
- function getThisTypeOfSignature(signature) {
- if (signature.thisParameter) {
- return getTypeOfSymbol(signature.thisParameter);
- }
- }
- function getTypePredicateOfSignature(signature) {
- if (!signature.resolvedTypePredicate) {
- if (signature.target) {
- var targetTypePredicate = getTypePredicateOfSignature(signature.target);
- signature.resolvedTypePredicate = targetTypePredicate ? instantiateTypePredicate(targetTypePredicate, signature.mapper) : noTypePredicate;
+ function makeSerializePropertySymbol(createProperty, methodKind, useAccessors) {
+ return function serializePropertySymbol(p, isStatic, baseType) {
+ var modifierFlags = ts.getDeclarationModifierFlagsFromSymbol(p);
+ var isPrivate = !!(modifierFlags & 8);
+ if (isStatic && (p.flags & (788968 | 1920 | 2097152))) {
+ return [];
+ }
+ if (p.flags & 4194304 ||
+ (baseType && getPropertyOfType(baseType, p.escapedName)
+ && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p)
+ && (p.flags & 16777216) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216)
+ && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName)))) {
+ return [];
+ }
+ var flag = (modifierFlags & ~256) | (isStatic ? 32 : 0);
+ var name = getPropertyNameNodeForSymbol(p, context);
+ var firstPropertyLikeDecl = ts.find(p.declarations, ts.or(ts.isPropertyDeclaration, ts.isAccessor, ts.isVariableDeclaration, ts.isPropertySignature, ts.isBinaryExpression, ts.isPropertyAccessExpression));
+ if (p.flags & 98304 && useAccessors) {
+ var result = [];
+ if (p.flags & 65536) {
+ result.push(ts.setTextRange(ts.factory.createSetAccessorDeclaration(undefined, ts.factory.createModifiersFromModifierFlags(flag), name, [ts.factory.createParameterDeclaration(undefined, undefined, undefined, "arg", undefined, isPrivate ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled))], undefined), ts.find(p.declarations, ts.isSetAccessor) || firstPropertyLikeDecl));
+ }
+ if (p.flags & 32768) {
+ var isPrivate_1 = modifierFlags & 8;
+ result.push(ts.setTextRange(ts.factory.createGetAccessorDeclaration(undefined, ts.factory.createModifiersFromModifierFlags(flag), name, [], isPrivate_1 ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled), undefined), ts.find(p.declarations, ts.isGetAccessor) || firstPropertyLikeDecl));
+ }
+ return result;
+ }
+ else if (p.flags & (4 | 3 | 98304)) {
+ return ts.setTextRange(createProperty(undefined, ts.factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 : 0) | flag), name, p.flags & 16777216 ? ts.factory.createToken(57) : undefined, isPrivate ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled), undefined), ts.find(p.declarations, ts.or(ts.isPropertyDeclaration, ts.isVariableDeclaration)) || firstPropertyLikeDecl);
+ }
+ if (p.flags & (8192 | 16)) {
+ var type = getTypeOfSymbol(p);
+ var signatures = getSignaturesOfType(type, 0);
+ if (flag & 8) {
+ return ts.setTextRange(createProperty(undefined, ts.factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 : 0) | flag), name, p.flags & 16777216 ? ts.factory.createToken(57) : undefined, undefined, undefined), ts.find(p.declarations, ts.isFunctionLikeDeclaration) || signatures[0] && signatures[0].declaration || p.declarations[0]);
+ }
+ var results_1 = [];
+ for (var _i = 0, signatures_3 = signatures; _i < signatures_3.length; _i++) {
+ var sig = signatures_3[_i];
+ var decl = signatureToSignatureDeclarationHelper(sig, methodKind, context, {
+ name: name,
+ questionToken: p.flags & 16777216 ? ts.factory.createToken(57) : undefined,
+ modifiers: flag ? ts.factory.createModifiersFromModifierFlags(flag) : undefined
+ });
+ results_1.push(ts.setTextRange(decl, sig.declaration));
+ }
+ return results_1;
+ }
+ return ts.Debug.fail("Unhandled class member kind! " + (p.__debugFlags || p.flags));
+ };
}
- else if (signature.unionSignatures) {
- signature.resolvedTypePredicate = getUnionTypePredicate(signature.unionSignatures) || noTypePredicate;
+ function serializePropertySymbolForInterface(p, baseType) {
+ return serializePropertySymbolForInterfaceWorker(p, false, baseType);
}
- else {
- var type = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration);
- var jsdocPredicate = void 0;
- if (!type && ts.isInJSFile(signature.declaration)) {
- var jsdocSignature = getSignatureOfTypeTag(signature.declaration);
- if (jsdocSignature && signature !== jsdocSignature) {
- jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
+ function serializeSignatures(kind, input, baseType, outputKind) {
+ var signatures = getSignaturesOfType(input, kind);
+ if (kind === 1) {
+ if (!baseType && ts.every(signatures, function (s) { return ts.length(s.parameters) === 0; })) {
+ return [];
+ }
+ if (baseType) {
+ var baseSigs = getSignaturesOfType(baseType, 1);
+ if (!ts.length(baseSigs) && ts.every(signatures, function (s) { return ts.length(s.parameters) === 0; })) {
+ return [];
+ }
+ if (baseSigs.length === signatures.length) {
+ var failed = false;
+ for (var i = 0; i < baseSigs.length; i++) {
+ if (!compareSignaturesIdentical(signatures[i], baseSigs[i], false, false, true, compareTypesIdentical)) {
+ failed = true;
+ break;
+ }
+ }
+ if (!failed) {
+ return [];
+ }
+ }
+ }
+ var privateProtected = 0;
+ for (var _i = 0, signatures_4 = signatures; _i < signatures_4.length; _i++) {
+ var s = signatures_4[_i];
+ if (s.declaration) {
+ privateProtected |= ts.getSelectedEffectiveModifierFlags(s.declaration, 8 | 16);
+ }
+ }
+ if (privateProtected) {
+ return [ts.setTextRange(ts.factory.createConstructorDeclaration(undefined, ts.factory.createModifiersFromModifierFlags(privateProtected), [], undefined), signatures[0].declaration)];
}
}
- signature.resolvedTypePredicate = type && ts.isTypePredicateNode(type) ?
- createTypePredicateFromTypePredicateNode(type, signature) :
- jsdocPredicate || noTypePredicate;
+ var results = [];
+ for (var _a = 0, signatures_5 = signatures; _a < signatures_5.length; _a++) {
+ var sig = signatures_5[_a];
+ var decl = signatureToSignatureDeclarationHelper(sig, outputKind, context);
+ results.push(ts.setTextRange(decl, sig.declaration));
+ }
+ return results;
}
- ts.Debug.assert(!!signature.resolvedTypePredicate);
- }
- return signature.resolvedTypePredicate === noTypePredicate ? undefined : signature.resolvedTypePredicate;
- }
- function createTypePredicateFromTypePredicateNode(node, signature) {
- var parameterName = node.parameterName;
- var type = node.type && getTypeFromTypeNode(node.type);
- return parameterName.kind === 183 ?
- createTypePredicate(node.assertsModifier ? 2 : 0, undefined, undefined, type) :
- createTypePredicate(node.assertsModifier ? 3 : 1, parameterName.escapedText, ts.findIndex(signature.parameters, function (p) { return p.escapedName === parameterName.escapedText; }), type);
- }
- function getReturnTypeOfSignature(signature) {
- if (!signature.resolvedReturnType) {
- if (!pushTypeResolution(signature, 3)) {
- return errorType;
+ function serializeIndexSignatures(input, baseType) {
+ var results = [];
+ for (var _i = 0, _a = [0, 1]; _i < _a.length; _i++) {
+ var type = _a[_i];
+ var info = getIndexInfoOfType(input, type);
+ if (info) {
+ if (baseType) {
+ var baseInfo = getIndexInfoOfType(baseType, type);
+ if (baseInfo) {
+ if (isTypeIdenticalTo(info.type, baseInfo.type)) {
+ continue;
+ }
+ }
+ }
+ results.push(indexInfoToIndexSignatureDeclarationHelper(info, type, context, undefined));
+ }
+ }
+ return results;
}
- var type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper) :
- signature.unionSignatures ? getUnionType(ts.map(signature.unionSignatures, getReturnTypeOfSignature), 2) :
- getReturnTypeFromAnnotation(signature.declaration) ||
- (ts.nodeIsMissing(signature.declaration.body) ? anyType : getReturnTypeFromBody(signature.declaration));
- if (signature.flags & 4) {
- type = addOptionalTypeMarker(type);
+ function serializeBaseType(t, staticType, rootName) {
+ var ref = trySerializeAsTypeReference(t, 111551);
+ if (ref) {
+ return ref;
+ }
+ var tempName = getUnusedName(rootName + "_base");
+ var statement = ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+ ts.factory.createVariableDeclaration(tempName, undefined, typeToTypeNodeHelper(staticType, context))
+ ], 2));
+ addResult(statement, 0);
+ return ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier(tempName), undefined);
}
- else if (signature.flags & 8) {
- type = getOptionalType(type);
+ function trySerializeAsTypeReference(t, flags) {
+ var typeArgs;
+ var reference;
+ if (t.target && isSymbolAccessibleByFlags(t.target.symbol, enclosingDeclaration, flags)) {
+ typeArgs = ts.map(getTypeArguments(t), function (t) { return typeToTypeNodeHelper(t, context); });
+ reference = symbolToExpression(t.target.symbol, context, 788968);
+ }
+ else if (t.symbol && isSymbolAccessibleByFlags(t.symbol, enclosingDeclaration, flags)) {
+ reference = symbolToExpression(t.symbol, context, 788968);
+ }
+ if (reference) {
+ return ts.factory.createExpressionWithTypeArguments(reference, typeArgs);
+ }
}
- if (!popTypeResolution()) {
- if (signature.declaration) {
- var typeNode = ts.getEffectiveReturnTypeNode(signature.declaration);
- if (typeNode) {
- error(typeNode, ts.Diagnostics.Return_type_annotation_circularly_references_itself);
- }
- else if (noImplicitAny) {
- var declaration = signature.declaration;
- var name = ts.getNameOfDeclaration(declaration);
- if (name) {
- error(name, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, ts.declarationNameToString(name));
- }
- else {
- error(declaration, ts.Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions);
- }
+ function serializeImplementedType(t) {
+ var ref = trySerializeAsTypeReference(t, 788968);
+ if (ref) {
+ return ref;
+ }
+ if (t.symbol) {
+ return ts.factory.createExpressionWithTypeArguments(symbolToExpression(t.symbol, context, 788968), undefined);
+ }
+ }
+ function getUnusedName(input, symbol) {
+ var _a, _b;
+ var id = symbol ? getSymbolId(symbol) : undefined;
+ if (id) {
+ if (context.remappedSymbolNames.has(id)) {
+ return context.remappedSymbolNames.get(id);
}
}
- type = anyType;
+ if (symbol) {
+ input = getNameCandidateWorker(symbol, input);
+ }
+ var i = 0;
+ var original = input;
+ while ((_a = context.usedSymbolNames) === null || _a === void 0 ? void 0 : _a.has(input)) {
+ i++;
+ input = original + "_" + i;
+ }
+ (_b = context.usedSymbolNames) === null || _b === void 0 ? void 0 : _b.add(input);
+ if (id) {
+ context.remappedSymbolNames.set(id, input);
+ }
+ return input;
}
- signature.resolvedReturnType = type;
- }
- return signature.resolvedReturnType;
- }
- function getReturnTypeFromAnnotation(declaration) {
- if (declaration.kind === 162) {
- return getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol));
- }
- if (ts.isJSDocConstructSignature(declaration)) {
- return getTypeFromTypeNode(declaration.parameters[0].type);
- }
- var typeNode = ts.getEffectiveReturnTypeNode(declaration);
- if (typeNode) {
- return getTypeFromTypeNode(typeNode);
- }
- if (declaration.kind === 163 && !hasNonBindableDynamicName(declaration)) {
- var jsDocType = ts.isInJSFile(declaration) && getTypeForDeclarationFromJSDocComment(declaration);
- if (jsDocType) {
- return jsDocType;
+ function getNameCandidateWorker(symbol, localName) {
+ if (localName === "default" || localName === "__class" || localName === "__function") {
+ var flags = context.flags;
+ context.flags |= 16777216;
+ var nameCandidate = getNameOfSymbolAsWritten(symbol, context);
+ context.flags = flags;
+ localName = nameCandidate.length > 0 && ts.isSingleOrDoubleQuote(nameCandidate.charCodeAt(0)) ? ts.stripQuotes(nameCandidate) : nameCandidate;
+ }
+ if (localName === "default") {
+ localName = "_default";
+ }
+ else if (localName === "export=") {
+ localName = "_exports";
+ }
+ localName = ts.isIdentifierText(localName, languageVersion) && !ts.isStringANonContextualKeyword(localName) ? localName : "_" + localName.replace(/[^a-zA-Z0-9]/g, "_");
+ return localName;
}
- var setter = ts.getDeclarationOfKind(getSymbolOfNode(declaration), 164);
- var setterType = getAnnotatedAccessorType(setter);
- if (setterType) {
- return setterType;
+ function getInternalSymbolName(symbol, localName) {
+ var id = getSymbolId(symbol);
+ if (context.remappedSymbolNames.has(id)) {
+ return context.remappedSymbolNames.get(id);
+ }
+ localName = getNameCandidateWorker(symbol, localName);
+ context.remappedSymbolNames.set(id, localName);
+ return localName;
}
}
- return getReturnTypeOfTypeTag(declaration);
- }
- function isResolvingReturnTypeOfSignature(signature) {
- return !signature.resolvedReturnType && findResolutionCycleStartIndex(signature, 3) >= 0;
- }
- function getRestTypeOfSignature(signature) {
- return tryGetRestTypeOfSignature(signature) || anyType;
}
- function tryGetRestTypeOfSignature(signature) {
- if (signatureHasRestParameter(signature)) {
- var sigRestType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
- var restType = isTupleType(sigRestType) ? getRestTypeOfTupleType(sigRestType) : sigRestType;
- return restType && getIndexTypeOfType(restType, 1);
+ function typePredicateToString(typePredicate, enclosingDeclaration, flags, writer) {
+ if (flags === void 0) { flags = 16384; }
+ return writer ? typePredicateToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(typePredicateToStringWorker);
+ function typePredicateToStringWorker(writer) {
+ var predicate = ts.factory.createTypePredicateNode(typePredicate.kind === 2 || typePredicate.kind === 3 ? ts.factory.createToken(127) : undefined, typePredicate.kind === 1 || typePredicate.kind === 3 ? ts.factory.createIdentifier(typePredicate.parameterName) : ts.factory.createThisTypeNode(), typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | 512));
+ var printer = ts.createPrinter({ removeComments: true });
+ var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
+ printer.writeNode(4, predicate, sourceFile, writer);
+ return writer;
}
- return undefined;
}
- function getSignatureInstantiation(signature, typeArguments, isJavascript, inferredTypeParameters) {
- var instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, fillMissingTypeArguments(typeArguments, signature.typeParameters, getMinTypeArgumentCount(signature.typeParameters), isJavascript));
- if (inferredTypeParameters) {
- var returnSignature = getSingleCallOrConstructSignature(getReturnTypeOfSignature(instantiatedSignature));
- if (returnSignature) {
- var newReturnSignature = cloneSignature(returnSignature);
- newReturnSignature.typeParameters = inferredTypeParameters;
- var newInstantiatedSignature = cloneSignature(instantiatedSignature);
- newInstantiatedSignature.resolvedReturnType = getOrCreateTypeFromSignature(newReturnSignature);
- return newInstantiatedSignature;
+ function formatUnionTypes(types) {
+ var result = [];
+ var flags = 0;
+ for (var i = 0; i < types.length; i++) {
+ var t = types[i];
+ flags |= t.flags;
+ if (!(t.flags & 98304)) {
+ if (t.flags & (512 | 1024)) {
+ var baseType = t.flags & 512 ? booleanType : getBaseTypeOfEnumLiteralType(t);
+ if (baseType.flags & 1048576) {
+ var count = baseType.types.length;
+ if (i + count <= types.length && getRegularTypeOfLiteralType(types[i + count - 1]) === getRegularTypeOfLiteralType(baseType.types[count - 1])) {
+ result.push(baseType);
+ i += count - 1;
+ continue;
+ }
+ }
+ }
+ result.push(t);
}
}
- return instantiatedSignature;
+ if (flags & 65536)
+ result.push(nullType);
+ if (flags & 32768)
+ result.push(undefinedType);
+ return result || types;
}
- function getSignatureInstantiationWithoutFillingInTypeArguments(signature, typeArguments) {
- var instantiations = signature.instantiations || (signature.instantiations = ts.createMap());
- var id = getTypeListId(typeArguments);
- var instantiation = instantiations.get(id);
- if (!instantiation) {
- instantiations.set(id, instantiation = createSignatureInstantiation(signature, typeArguments));
+ function visibilityToString(flags) {
+ if (flags === 8) {
+ return "private";
}
- 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, ts.map(signature.typeParameters, function (tp) { return tp.target && !getConstraintOfTypeParameter(tp.target) ? tp.target : tp; }), ts.isInJSFile(signature.declaration));
- }
- function getBaseSignature(signature) {
- var typeParameters = signature.typeParameters;
- if (typeParameters) {
- var typeEraser_1 = createTypeEraser(typeParameters);
- var baseConstraints = ts.map(typeParameters, function (tp) { return instantiateType(getBaseConstraintOfType(tp), typeEraser_1) || unknownType; });
- return instantiateSignature(signature, createTypeMapper(typeParameters, baseConstraints), true);
+ if (flags === 16) {
+ return "protected";
}
- return signature;
+ return "public";
}
- function getOrCreateTypeFromSignature(signature) {
- if (!signature.isolatedSignatureType) {
- var kind = signature.declaration ? signature.declaration.kind : 0;
- var isConstructor = kind === 162 || kind === 166 || kind === 171;
- var type = createObjectType(16);
- type.members = emptySymbols;
- type.properties = ts.emptyArray;
- type.callSignatures = !isConstructor ? [signature] : ts.emptyArray;
- type.constructSignatures = isConstructor ? [signature] : ts.emptyArray;
- signature.isolatedSignatureType = type;
+ function getTypeAliasForTypeLiteral(type) {
+ if (type.symbol && type.symbol.flags & 2048) {
+ var node = ts.walkUpParenthesizedTypes(type.symbol.declarations[0].parent);
+ if (node.kind === 254) {
+ return getSymbolOfNode(node);
+ }
}
- return signature.isolatedSignatureType;
+ return undefined;
}
- function getIndexSymbol(symbol) {
- return symbol.members.get("__index");
+ function isTopLevelInExternalModuleAugmentation(node) {
+ return node && node.parent &&
+ node.parent.kind === 257 &&
+ ts.isExternalModuleAugmentation(node.parent.parent);
}
- function getIndexDeclarationOfSymbol(symbol, kind) {
- var syntaxKind = kind === 1 ? 140 : 143;
- var indexSymbol = getIndexSymbol(symbol);
- if (indexSymbol) {
- for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
- var decl = _a[_i];
- var node = ts.cast(decl, ts.isIndexSignatureDeclaration);
- if (node.parameters.length === 1) {
- var parameter = node.parameters[0];
- if (parameter.type && parameter.type.kind === syntaxKind) {
- return node;
- }
+ function isDefaultBindingContext(location) {
+ return location.kind === 297 || ts.isAmbientModule(location);
+ }
+ function getNameOfSymbolFromNameType(symbol, context) {
+ var nameType = getSymbolLinks(symbol).nameType;
+ if (nameType) {
+ if (nameType.flags & 384) {
+ var name = "" + nameType.value;
+ if (!ts.isIdentifierText(name, compilerOptions.target) && !isNumericLiteralName(name)) {
+ return "\"" + ts.escapeString(name, 34) + "\"";
}
+ if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
+ return "[" + name + "]";
+ }
+ return name;
+ }
+ if (nameType.flags & 8192) {
+ return "[" + getNameOfSymbolAsWritten(nameType.symbol, context) + "]";
}
}
- return undefined;
}
- function createIndexInfo(type, isReadonly, declaration) {
- return { type: type, isReadonly: isReadonly, declaration: declaration };
- }
- function getIndexInfoOfSymbol(symbol, kind) {
- var declaration = getIndexDeclarationOfSymbol(symbol, kind);
- if (declaration) {
- return createIndexInfo(declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasModifier(declaration, 64), declaration);
+ function getNameOfSymbolAsWritten(symbol, context) {
+ if (context && symbol.escapedName === "default" && !(context.flags & 16384) &&
+ (!(context.flags & 16777216) ||
+ !symbol.declarations ||
+ (context.enclosingDeclaration && ts.findAncestor(symbol.declarations[0], isDefaultBindingContext) !== ts.findAncestor(context.enclosingDeclaration, isDefaultBindingContext)))) {
+ return "default";
}
- return undefined;
- }
- function getConstraintDeclaration(type) {
- return ts.mapDefined(ts.filter(type.symbol && type.symbol.declarations, ts.isTypeParameterDeclaration), ts.getEffectiveConstraintOfTypeParameter)[0];
- }
- function getInferredTypeParameterConstraint(typeParameter) {
- var inferences;
- if (typeParameter.symbol) {
- for (var _i = 0, _a = typeParameter.symbol.declarations; _i < _a.length; _i++) {
- var declaration = _a[_i];
- if (declaration.parent.kind === 181) {
- var grandParent = declaration.parent.parent;
- if (grandParent.kind === 169) {
- var typeReference = grandParent;
- var typeParameters = getTypeParametersForTypeReference(typeReference);
- if (typeParameters) {
- var index = typeReference.typeArguments.indexOf(declaration.parent);
- if (index < typeParameters.length) {
- var declaredConstraint = getConstraintOfTypeParameter(typeParameters[index]);
- if (declaredConstraint) {
- var mapper = createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReference, typeParameters));
- var constraint = instantiateType(declaredConstraint, mapper);
- if (constraint !== typeParameter) {
- inferences = ts.append(inferences, constraint);
- }
- }
- }
+ if (symbol.declarations && symbol.declarations.length) {
+ var declaration = ts.firstDefined(symbol.declarations, function (d) { return ts.getNameOfDeclaration(d) ? d : undefined; });
+ var name_3 = declaration && ts.getNameOfDeclaration(declaration);
+ if (declaration && name_3) {
+ if (ts.isCallExpression(declaration) && ts.isBindableObjectDefinePropertyCall(declaration)) {
+ return ts.symbolName(symbol);
+ }
+ if (ts.isComputedPropertyName(name_3) && !(ts.getCheckFlags(symbol) & 4096)) {
+ var nameType = getSymbolLinks(symbol).nameType;
+ if (nameType && nameType.flags & 384) {
+ var result = getNameOfSymbolFromNameType(symbol, context);
+ if (result !== undefined) {
+ return result;
}
}
- else if (grandParent.kind === 156 && grandParent.dotDotDotToken) {
- inferences = ts.append(inferences, createArrayType(unknownType));
- }
}
+ return ts.declarationNameToString(name_3);
+ }
+ if (!declaration) {
+ declaration = symbol.declarations[0];
+ }
+ if (declaration.parent && declaration.parent.kind === 249) {
+ return ts.declarationNameToString(declaration.parent.name);
+ }
+ switch (declaration.kind) {
+ case 221:
+ case 208:
+ case 209:
+ if (context && !context.encounteredError && !(context.flags & 131072)) {
+ context.encounteredError = true;
+ }
+ return declaration.kind === 221 ? "(Anonymous class)" : "(Anonymous function)";
}
}
- return inferences && getIntersectionType(inferences);
+ var name = getNameOfSymbolFromNameType(symbol, context);
+ return name !== undefined ? name : ts.symbolName(symbol);
}
- function getConstraintFromTypeParameter(typeParameter) {
- if (!typeParameter.constraint) {
- if (typeParameter.target) {
- var targetConstraint = getConstraintOfTypeParameter(typeParameter.target);
- typeParameter.constraint = targetConstraint ? instantiateType(targetConstraint, typeParameter.mapper) : noConstraintType;
+ function isDeclarationVisible(node) {
+ if (node) {
+ var links = getNodeLinks(node);
+ if (links.isVisible === undefined) {
+ links.isVisible = !!determineIfDeclarationIsVisible();
}
- else {
- var constraintDeclaration = getConstraintDeclaration(typeParameter);
- if (!constraintDeclaration) {
- typeParameter.constraint = getInferredTypeParameterConstraint(typeParameter) || noConstraintType;
- }
- else {
- var type = getTypeFromTypeNode(constraintDeclaration);
- if (type.flags & 1 && type !== errorType) {
- type = constraintDeclaration.parent.parent.kind === 186 ? keyofConstraintType : unknownType;
+ return links.isVisible;
+ }
+ return false;
+ function determineIfDeclarationIsVisible() {
+ switch (node.kind) {
+ case 324:
+ case 331:
+ case 325:
+ return !!(node.parent && node.parent.parent && node.parent.parent.parent && ts.isSourceFile(node.parent.parent.parent));
+ case 198:
+ return isDeclarationVisible(node.parent.parent);
+ case 249:
+ if (ts.isBindingPattern(node.name) &&
+ !node.name.elements.length) {
+ return false;
}
- typeParameter.constraint = type;
- }
+ case 256:
+ case 252:
+ case 253:
+ case 254:
+ case 251:
+ case 255:
+ case 260:
+ if (ts.isExternalModuleAugmentation(node)) {
+ return true;
+ }
+ var parent = getDeclarationContainer(node);
+ if (!(ts.getCombinedModifierFlags(node) & 1) &&
+ !(node.kind !== 260 && parent.kind !== 297 && parent.flags & 8388608)) {
+ return isGlobalSourceFile(parent);
+ }
+ return isDeclarationVisible(parent);
+ case 163:
+ case 162:
+ case 167:
+ case 168:
+ case 165:
+ case 164:
+ if (ts.hasEffectiveModifier(node, 8 | 16)) {
+ return false;
+ }
+ case 166:
+ case 170:
+ case 169:
+ case 171:
+ case 160:
+ case 257:
+ case 174:
+ case 175:
+ case 177:
+ case 173:
+ case 178:
+ case 179:
+ case 182:
+ case 183:
+ case 186:
+ case 192:
+ return isDeclarationVisible(node.parent);
+ case 262:
+ case 263:
+ case 265:
+ return false;
+ case 159:
+ case 297:
+ case 259:
+ return true;
+ case 266:
+ return false;
+ default:
+ return false;
}
}
- return typeParameter.constraint === noConstraintType ? undefined : typeParameter.constraint;
}
- function getParentSymbolOfTypeParameter(typeParameter) {
- var tp = ts.getDeclarationOfKind(typeParameter.symbol, 155);
- var host = ts.isJSDocTemplateTag(tp.parent) ? ts.getHostSignatureFromJSDoc(tp.parent) : tp.parent;
- return host && getSymbolOfNode(host);
- }
- function getTypeListId(types) {
- var result = "";
- if (types) {
- var length_4 = types.length;
- var i = 0;
- while (i < length_4) {
- var startId = types[i].id;
- var count = 1;
- while (i + count < length_4 && types[i + count].id === startId + count) {
- count++;
+ function collectLinkedAliases(node, setVisibility) {
+ var exportSymbol;
+ if (node.parent && node.parent.kind === 266) {
+ exportSymbol = resolveName(node, node.escapedText, 111551 | 788968 | 1920 | 2097152, undefined, node, false);
+ }
+ else if (node.parent.kind === 270) {
+ exportSymbol = getTargetOfExportSpecifier(node.parent, 111551 | 788968 | 1920 | 2097152);
+ }
+ var result;
+ var visited;
+ if (exportSymbol) {
+ visited = new ts.Set();
+ visited.add(getSymbolId(exportSymbol));
+ buildVisibleNodeList(exportSymbol.declarations);
+ }
+ return result;
+ function buildVisibleNodeList(declarations) {
+ ts.forEach(declarations, function (declaration) {
+ var resultNode = getAnyImportSyntax(declaration) || declaration;
+ if (setVisibility) {
+ getNodeLinks(declaration).isVisible = true;
}
- if (result.length) {
- result += ",";
+ else {
+ result = result || [];
+ ts.pushIfUnique(result, resultNode);
}
- result += startId;
- if (count > 1) {
- result += ":" + count;
+ if (ts.isInternalModuleImportEqualsDeclaration(declaration)) {
+ var internalModuleReference = declaration.moduleReference;
+ var firstIdentifier = ts.getFirstIdentifier(internalModuleReference);
+ var importSymbol = resolveName(declaration, firstIdentifier.escapedText, 111551 | 788968 | 1920, undefined, undefined, false);
+ if (importSymbol && visited) {
+ if (ts.tryAddToSet(visited, getSymbolId(importSymbol))) {
+ buildVisibleNodeList(importSymbol.declarations);
+ }
+ }
}
- i += count;
- }
+ });
}
- return result;
}
- function getPropagatingFlagsOfTypes(types, excludeKinds) {
- var result = 0;
- for (var _i = 0, types_8 = types; _i < types_8.length; _i++) {
- var type = types_8[_i];
- if (!(type.flags & excludeKinds)) {
- result |= ts.getObjectFlags(type);
+ function pushTypeResolution(target, propertyName) {
+ var resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName);
+ if (resolutionCycleStartIndex >= 0) {
+ var length_3 = resolutionTargets.length;
+ for (var i = resolutionCycleStartIndex; i < length_3; i++) {
+ resolutionResults[i] = false;
}
+ return false;
}
- return result & 3670016;
- }
- function createTypeReference(target, typeArguments) {
- var id = getTypeListId(typeArguments);
- var type = target.instantiations.get(id);
- if (!type) {
- type = createObjectType(4, target.symbol);
- target.instantiations.set(id, type);
- type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, 0) : 0;
- type.target = target;
- type.resolvedTypeArguments = typeArguments;
- }
- return type;
- }
- function cloneTypeReference(source) {
- var type = createType(source.flags);
- type.symbol = source.symbol;
- type.objectFlags = source.objectFlags;
- type.target = source.target;
- type.resolvedTypeArguments = source.resolvedTypeArguments;
- return type;
- }
- function createDeferredTypeReference(target, node, mapper) {
- var aliasSymbol = getAliasSymbolForTypeNode(node);
- var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
- var type = createObjectType(4, target.symbol);
- type.target = target;
- type.node = node;
- type.mapper = mapper;
- type.aliasSymbol = aliasSymbol;
- type.aliasTypeArguments = mapper ? instantiateTypes(aliasTypeArguments, mapper) : aliasTypeArguments;
- return type;
+ resolutionTargets.push(target);
+ resolutionResults.push(true);
+ resolutionPropertyNames.push(propertyName);
+ return true;
}
- function getTypeArguments(type) {
- var _a, _b;
- if (!type.resolvedTypeArguments) {
- if (!pushTypeResolution(type, 6)) {
- return ((_a = type.target.localTypeParameters) === null || _a === void 0 ? void 0 : _a.map(function () { return errorType; })) || ts.emptyArray;
- }
- var node = type.node;
- var typeArguments = !node ? ts.emptyArray :
- node.kind === 169 ? ts.concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments(node, type.target.localTypeParameters)) :
- node.kind === 174 ? [getTypeFromTypeNode(node.elementType)] :
- ts.map(node.elementTypes, getTypeFromTypeNode);
- if (popTypeResolution()) {
- type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments;
+ function findResolutionCycleStartIndex(target, propertyName) {
+ for (var i = resolutionTargets.length - 1; i >= 0; i--) {
+ if (hasType(resolutionTargets[i], resolutionPropertyNames[i])) {
+ return -1;
}
- else {
- type.resolvedTypeArguments = ((_b = type.target.localTypeParameters) === null || _b === void 0 ? void 0 : _b.map(function () { return errorType; })) || ts.emptyArray;
- error(type.node || currentNode, type.target.symbol
- ? ts.Diagnostics.Type_arguments_for_0_circularly_reference_themselves
- : ts.Diagnostics.Tuple_type_arguments_circularly_reference_themselves, type.target.symbol && symbolToString(type.target.symbol));
+ if (resolutionTargets[i] === target && resolutionPropertyNames[i] === propertyName) {
+ return i;
}
}
- return type.resolvedTypeArguments;
- }
- function getTypeReferenceArity(type) {
- return ts.length(type.target.typeParameters);
+ return -1;
}
- function getTypeFromClassOrInterfaceReference(node, symbol) {
- var type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
- var typeParameters = type.localTypeParameters;
- if (typeParameters) {
- var numTypeArguments = ts.length(node.typeArguments);
- var minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
- var isJs = ts.isInJSFile(node);
- var isJsImplicitAny = !noImplicitAny && isJs;
- if (!isJsImplicitAny && (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length)) {
- var missingAugmentsTag = isJs && ts.isExpressionWithTypeArguments(node) && !ts.isJSDocAugmentsTag(node.parent);
- var diag = minTypeArgumentCount === typeParameters.length ?
- missingAugmentsTag ?
- ts.Diagnostics.Expected_0_type_arguments_provide_these_with_an_extends_tag :
- ts.Diagnostics.Generic_type_0_requires_1_type_argument_s :
- missingAugmentsTag ?
- ts.Diagnostics.Expected_0_1_type_arguments_provide_these_with_an_extends_tag :
- ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments;
- var typeStr = typeToString(type, undefined, 2);
- error(node, diag, typeStr, minTypeArgumentCount, typeParameters.length);
- if (!isJs) {
- return errorType;
- }
- }
- if (node.kind === 169 && isDeferredTypeReferenceNode(node, ts.length(node.typeArguments) !== typeParameters.length)) {
- return createDeferredTypeReference(type, node, undefined);
- }
- var typeArguments = ts.concatenate(type.outerTypeParameters, fillMissingTypeArguments(typeArgumentsFromTypeReferenceNode(node), typeParameters, minTypeArgumentCount, isJs));
- return createTypeReference(type, typeArguments);
+ function hasType(target, propertyName) {
+ switch (propertyName) {
+ case 0:
+ return !!getSymbolLinks(target).type;
+ case 5:
+ return !!(getNodeLinks(target).resolvedEnumType);
+ case 2:
+ return !!getSymbolLinks(target).declaredType;
+ case 1:
+ return !!target.resolvedBaseConstructorType;
+ case 3:
+ return !!target.resolvedReturnType;
+ case 4:
+ return !!target.immediateBaseConstraint;
+ case 6:
+ return !!target.resolvedTypeArguments;
+ case 7:
+ return !!target.baseTypesResolved;
}
- return checkNoTypeArguments(node, symbol) ? type : errorType;
+ return ts.Debug.assertNever(propertyName);
}
- function getTypeAliasInstantiation(symbol, typeArguments) {
- var type = getDeclaredTypeOfSymbol(symbol);
- var links = getSymbolLinks(symbol);
- var typeParameters = links.typeParameters;
- var id = getTypeListId(typeArguments);
- var instantiation = links.instantiations.get(id);
- if (!instantiation) {
- links.instantiations.set(id, instantiation = instantiateType(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(symbol.valueDeclaration)))));
- }
- return instantiation;
+ function popTypeResolution() {
+ resolutionTargets.pop();
+ resolutionPropertyNames.pop();
+ return resolutionResults.pop();
}
- function getTypeFromTypeAliasReference(node, symbol) {
- var type = getDeclaredTypeOfSymbol(symbol);
- var typeParameters = getSymbolLinks(symbol).typeParameters;
- if (typeParameters) {
- var numTypeArguments = ts.length(node.typeArguments);
- var minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
- if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) {
- error(node, minTypeArgumentCount === typeParameters.length ?
- ts.Diagnostics.Generic_type_0_requires_1_type_argument_s :
- ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments, symbolToString(symbol), minTypeArgumentCount, typeParameters.length);
- return errorType;
+ function getDeclarationContainer(node) {
+ return ts.findAncestor(ts.getRootDeclaration(node), function (node) {
+ switch (node.kind) {
+ case 249:
+ case 250:
+ case 265:
+ case 264:
+ case 263:
+ case 262:
+ return false;
+ default:
+ return true;
}
- return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node));
- }
- return checkNoTypeArguments(node, symbol) ? type : errorType;
+ }).parent;
}
- function getTypeReferenceName(node) {
- switch (node.kind) {
- case 169:
- return node.typeName;
- case 216:
- var expr = node.expression;
- if (ts.isEntityNameExpression(expr)) {
- return expr;
- }
- }
- return undefined;
+ function getTypeOfPrototypeProperty(prototype) {
+ var classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype));
+ return classType.typeParameters ? createTypeReference(classType, ts.map(classType.typeParameters, function (_) { return anyType; })) : classType;
}
- function resolveTypeReferenceName(typeReferenceName, meaning, ignoreErrors) {
- if (!typeReferenceName) {
- return unknownSymbol;
- }
- return resolveEntityName(typeReferenceName, meaning, ignoreErrors) || unknownSymbol;
+ function getTypeOfPropertyOfType(type, name) {
+ var prop = getPropertyOfType(type, name);
+ return prop ? getTypeOfSymbol(prop) : undefined;
}
- function getTypeReferenceType(node, symbol) {
- if (symbol === unknownSymbol) {
- return errorType;
- }
- symbol = getExpandoSymbol(symbol) || symbol;
- if (symbol.flags & (32 | 64)) {
- return getTypeFromClassOrInterfaceReference(node, symbol);
- }
- if (symbol.flags & 524288) {
- return getTypeFromTypeAliasReference(node, symbol);
+ function getTypeOfPropertyOrIndexSignature(type, name) {
+ return getTypeOfPropertyOfType(type, name) || isNumericLiteralName(name) && getIndexTypeOfType(type, 1) || getIndexTypeOfType(type, 0) || unknownType;
+ }
+ function isTypeAny(type) {
+ return type && (type.flags & 1) !== 0;
+ }
+ function getTypeForBindingElementParent(node) {
+ var symbol = getSymbolOfNode(node);
+ return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, false);
+ }
+ function getRestType(source, properties, symbol) {
+ source = filterType(source, function (t) { return !(t.flags & 98304); });
+ if (source.flags & 131072) {
+ return emptyObjectType;
}
- var res = tryGetDeclaredTypeOfSymbol(symbol);
- if (res) {
- return checkNoTypeArguments(node, symbol) ? getRegularTypeOfLiteralType(res) : errorType;
+ if (source.flags & 1048576) {
+ return mapType(source, function (t) { return getRestType(t, properties, symbol); });
}
- if (symbol.flags & 111551 && isJSDocTypeReference(node)) {
- var jsdocType = getTypeFromJSDocValueReference(node, symbol);
- if (jsdocType) {
- return jsdocType;
+ var omitKeyType = getUnionType(ts.map(properties, getLiteralTypeFromPropertyName));
+ if (isGenericObjectType(source) || isGenericIndexType(omitKeyType)) {
+ if (omitKeyType.flags & 131072) {
+ return source;
}
- else {
- resolveTypeReferenceName(getTypeReferenceName(node), 788968);
- return getTypeOfSymbol(symbol);
+ var omitTypeAlias = getGlobalOmitSymbol();
+ if (!omitTypeAlias) {
+ return errorType;
}
+ return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]);
}
- return errorType;
- }
- function getTypeFromJSDocValueReference(node, symbol) {
- var links = getNodeLinks(node);
- if (!links.resolvedJSDocType) {
- var valueType = getTypeOfSymbol(symbol);
- var typeType = valueType;
- if (symbol.valueDeclaration) {
- var decl = ts.getRootDeclaration(symbol.valueDeclaration);
- var isRequireAlias = false;
- if (ts.isVariableDeclaration(decl) && decl.initializer) {
- var expr = decl.initializer;
- while (ts.isPropertyAccessExpression(expr)) {
- expr = expr.expression;
- }
- isRequireAlias = ts.isCallExpression(expr) && ts.isRequireCall(expr, true) && !!valueType.symbol;
- }
- var isImportTypeWithQualifier = node.kind === 188 && node.qualifier;
- if (valueType.symbol && (isRequireAlias || isImportTypeWithQualifier)) {
- typeType = getTypeReferenceType(node, valueType.symbol);
- }
+ var members = ts.createSymbolTable();
+ for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) {
+ var prop = _a[_i];
+ if (!isTypeAssignableTo(getLiteralTypeFromProperty(prop, 8576), omitKeyType)
+ && !(ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 | 16))
+ && isSpreadableProperty(prop)) {
+ members.set(prop.escapedName, getSpreadSymbol(prop, false));
}
- links.resolvedJSDocType = typeType;
- }
- return links.resolvedJSDocType;
- }
- function getSubstitutionType(baseType, substitute) {
- if (substitute.flags & 3 || substitute === baseType) {
- return baseType;
- }
- var id = getTypeId(baseType) + ">" + getTypeId(substitute);
- var cached = substitutionTypes.get(id);
- if (cached) {
- return cached;
}
- var result = createType(33554432);
- result.baseType = baseType;
- result.substitute = substitute;
- substitutionTypes.set(id, result);
+ var stringIndexInfo = getIndexInfoOfType(source, 0);
+ var numberIndexInfo = getIndexInfoOfType(source, 1);
+ var result = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo);
+ result.objectFlags |= 131072;
return result;
}
- function isUnaryTupleTypeNode(node) {
- return node.kind === 175 && node.elementTypes.length === 1;
- }
- function getImpliedConstraint(type, checkNode, extendsNode) {
- return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(type, checkNode.elementTypes[0], extendsNode.elementTypes[0]) :
- getActualTypeVariable(getTypeFromTypeNode(checkNode)) === type ? getTypeFromTypeNode(extendsNode) :
- undefined;
+ function getFlowTypeOfDestructuring(node, declaredType) {
+ var reference = getSyntheticElementAccess(node);
+ return reference ? getFlowTypeOfReference(reference, declaredType) : declaredType;
}
- function getConditionalFlowTypeOfType(type, node) {
- var constraints;
- while (node && !ts.isStatement(node) && node.kind !== 303) {
- var parent = node.parent;
- if (parent.kind === 180 && node === parent.trueType) {
- var constraint = getImpliedConstraint(type, parent.checkType, parent.extendsType);
- if (constraint) {
- constraints = ts.append(constraints, constraint);
+ function getSyntheticElementAccess(node) {
+ var parentAccess = getParentElementAccess(node);
+ if (parentAccess && parentAccess.flowNode) {
+ var propName = getDestructuringPropertyName(node);
+ if (propName) {
+ var literal = ts.setTextRange(ts.parseNodeFactory.createStringLiteral(propName), node);
+ var lhsExpr = ts.isLeftHandSideExpression(parentAccess) ? parentAccess : ts.parseNodeFactory.createParenthesizedExpression(parentAccess);
+ var result = ts.setTextRange(ts.parseNodeFactory.createElementAccessExpression(lhsExpr, literal), node);
+ ts.setParent(literal, result);
+ ts.setParent(result, node);
+ if (lhsExpr !== parentAccess) {
+ ts.setParent(lhsExpr, result);
}
+ result.flowNode = parentAccess.flowNode;
+ return result;
}
- node = parent;
}
- return constraints ? getSubstitutionType(type, getIntersectionType(ts.append(constraints, type))) : type;
- }
- function isJSDocTypeReference(node) {
- return !!(node.flags & 4194304) && (node.kind === 169 || node.kind === 188);
}
- function checkNoTypeArguments(node, symbol) {
- if (node.typeArguments) {
- error(node, ts.Diagnostics.Type_0_is_not_generic, symbol ? symbolToString(symbol) : node.typeName ? ts.declarationNameToString(node.typeName) : anon);
- return false;
+ function getParentElementAccess(node) {
+ var ancestor = node.parent.parent;
+ switch (ancestor.kind) {
+ case 198:
+ case 288:
+ return getSyntheticElementAccess(ancestor);
+ case 199:
+ return getSyntheticElementAccess(node.parent);
+ case 249:
+ return ancestor.initializer;
+ case 216:
+ return ancestor.right;
}
- return true;
}
- function getIntendedTypeFromJSDocTypeReference(node) {
- if (ts.isIdentifier(node.typeName)) {
- var typeArgs = node.typeArguments;
- switch (node.typeName.escapedText) {
- case "String":
- checkNoTypeArguments(node);
- return stringType;
- case "Number":
- checkNoTypeArguments(node);
- return numberType;
- case "Boolean":
- checkNoTypeArguments(node);
- return booleanType;
- case "Void":
- checkNoTypeArguments(node);
- return voidType;
- case "Undefined":
- checkNoTypeArguments(node);
- return undefinedType;
- case "Null":
- checkNoTypeArguments(node);
- return nullType;
- case "Function":
- case "function":
- checkNoTypeArguments(node);
- return globalFunctionType;
- case "array":
- return (!typeArgs || !typeArgs.length) && !noImplicitAny ? anyArrayType : undefined;
- case "promise":
- return (!typeArgs || !typeArgs.length) && !noImplicitAny ? createPromiseType(anyType) : undefined;
- case "Object":
- if (typeArgs && typeArgs.length === 2) {
- if (ts.isJSDocIndexSignature(node)) {
- var indexed = getTypeFromTypeNode(typeArgs[0]);
- var target = getTypeFromTypeNode(typeArgs[1]);
- var index = createIndexInfo(target, false);
- return createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, indexed === stringType ? index : undefined, indexed === numberType ? index : undefined);
- }
- return anyType;
- }
- checkNoTypeArguments(node);
- return !noImplicitAny ? anyType : undefined;
- }
+ function getDestructuringPropertyName(node) {
+ var parent = node.parent;
+ if (node.kind === 198 && parent.kind === 196) {
+ return getLiteralPropertyNameText(node.propertyName || node.name);
+ }
+ if (node.kind === 288 || node.kind === 289) {
+ return getLiteralPropertyNameText(node.name);
}
+ return "" + parent.elements.indexOf(node);
}
- function getTypeFromJSDocNullableTypeNode(node) {
- var type = getTypeFromTypeNode(node.type);
- return strictNullChecks ? getNullableType(type, 65536) : type;
+ function getLiteralPropertyNameText(name) {
+ var type = getLiteralTypeFromPropertyName(name);
+ return type.flags & (128 | 256) ? "" + type.value : undefined;
}
- function getTypeFromTypeReference(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- if (ts.isConstTypeReference(node) && ts.isAssertionExpression(node.parent)) {
- links.resolvedSymbol = unknownSymbol;
- return links.resolvedType = checkExpressionCached(node.parent.expression);
- }
- var symbol = void 0;
- var type = void 0;
- var meaning = 788968;
- if (isJSDocTypeReference(node)) {
- type = getIntendedTypeFromJSDocTypeReference(node);
- if (!type) {
- symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning, true);
- if (symbol === unknownSymbol) {
- symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning | 111551);
- }
- else {
- resolveTypeReferenceName(getTypeReferenceName(node), meaning);
+ function getTypeForBindingElement(declaration) {
+ var pattern = declaration.parent;
+ var parentType = getTypeForBindingElementParent(pattern.parent);
+ if (!parentType || isTypeAny(parentType)) {
+ return parentType;
+ }
+ if (strictNullChecks && declaration.flags & 8388608 && ts.isParameterDeclaration(declaration)) {
+ parentType = getNonNullableType(parentType);
+ }
+ else if (strictNullChecks && pattern.parent.initializer && !(getTypeFacts(getTypeOfInitializer(pattern.parent.initializer)) & 65536)) {
+ parentType = getTypeWithFacts(parentType, 524288);
+ }
+ var type;
+ if (pattern.kind === 196) {
+ if (declaration.dotDotDotToken) {
+ parentType = getReducedType(parentType);
+ if (parentType.flags & 2 || !isValidSpreadType(parentType)) {
+ error(declaration, ts.Diagnostics.Rest_types_may_only_be_created_from_object_types);
+ return errorType;
+ }
+ var literalMembers = [];
+ for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
+ var element = _a[_i];
+ if (!element.dotDotDotToken) {
+ literalMembers.push(element.propertyName || element.name);
}
- type = getTypeReferenceType(node, symbol);
}
+ type = getRestType(parentType, literalMembers, declaration.symbol);
}
- if (!type) {
- symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning);
- type = getTypeReferenceType(node, symbol);
+ else {
+ var name = declaration.propertyName || declaration.name;
+ var indexType = getLiteralTypeFromPropertyName(name);
+ var declaredType = getConstraintForLocation(getIndexedAccessType(parentType, indexType, undefined, name, undefined, undefined, 16), declaration.name);
+ type = getFlowTypeOfDestructuring(declaration, declaredType);
}
- links.resolvedSymbol = symbol;
- links.resolvedType = type;
- }
- return links.resolvedType;
- }
- function typeArgumentsFromTypeReferenceNode(node) {
- return ts.map(node.typeArguments, getTypeFromTypeNode);
- }
- function getTypeFromTypeQueryNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- links.resolvedType = getRegularTypeOfLiteralType(getWidenedType(checkExpression(node.exprName)));
}
- return links.resolvedType;
- }
- function getTypeOfGlobalSymbol(symbol, arity) {
- function getTypeDeclaration(symbol) {
- var declarations = symbol.declarations;
- for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) {
- var declaration = declarations_3[_i];
- switch (declaration.kind) {
- case 245:
- case 246:
- case 248:
- return declaration;
- }
+ else {
+ var elementType = checkIteratedTypeOrElementType(65 | (declaration.dotDotDotToken ? 0 : 128), parentType, undefinedType, pattern);
+ var index_2 = pattern.elements.indexOf(declaration);
+ if (declaration.dotDotDotToken) {
+ type = everyType(parentType, isTupleType) ?
+ mapType(parentType, function (t) { return sliceTupleType(t, index_2); }) :
+ createArrayType(elementType);
+ }
+ else if (isArrayLikeType(parentType)) {
+ var indexType = getLiteralType(index_2);
+ var accessFlags = hasDefaultValue(declaration) ? 8 : 0;
+ var declaredType = getConstraintForLocation(getIndexedAccessTypeOrUndefined(parentType, indexType, undefined, declaration.name, accessFlags | 16) || errorType, declaration.name);
+ type = getFlowTypeOfDestructuring(declaration, declaredType);
+ }
+ else {
+ type = elementType;
}
}
- if (!symbol) {
- return arity ? emptyGenericType : emptyObjectType;
- }
- var type = getDeclaredTypeOfSymbol(symbol);
- if (!(type.flags & 524288)) {
- error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_be_a_class_or_interface_type, ts.symbolName(symbol));
- return arity ? emptyGenericType : emptyObjectType;
+ if (!declaration.initializer) {
+ return type;
}
- if (ts.length(type.typeParameters) !== arity) {
- error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_have_1_type_parameter_s, ts.symbolName(symbol), arity);
- return arity ? emptyGenericType : emptyObjectType;
+ if (ts.getEffectiveTypeAnnotationNode(ts.walkUpBindingElementsAndPatterns(declaration))) {
+ return strictNullChecks && !(getFalsyFlags(checkDeclarationInitializer(declaration)) & 32768) ?
+ getTypeWithFacts(type, 524288) :
+ type;
}
- return type;
- }
- function getGlobalValueSymbol(name, reportErrors) {
- return getGlobalSymbol(name, 111551, reportErrors ? ts.Diagnostics.Cannot_find_global_value_0 : undefined);
- }
- function getGlobalTypeSymbol(name, reportErrors) {
- return getGlobalSymbol(name, 788968, reportErrors ? ts.Diagnostics.Cannot_find_global_type_0 : undefined);
- }
- function getGlobalSymbol(name, meaning, diagnostic) {
- return resolveName(undefined, name, meaning, diagnostic, name, false);
- }
- function getGlobalType(name, arity, reportErrors) {
- var symbol = getGlobalTypeSymbol(name, reportErrors);
- return symbol || reportErrors ? getTypeOfGlobalSymbol(symbol, arity) : undefined;
- }
- 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 getGlobalESSymbolConstructorSymbol(reportErrors) {
- return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors));
- }
- function getGlobalESSymbolType(reportErrors) {
- return deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol", 0, reportErrors)) || emptyObjectType;
- }
- function getGlobalPromiseType(reportErrors) {
- return deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise", 1, reportErrors)) || emptyGenericType;
- }
- function getGlobalPromiseLikeType(reportErrors) {
- return deferredGlobalPromiseLikeType || (deferredGlobalPromiseLikeType = getGlobalType("PromiseLike", 1, reportErrors)) || emptyGenericType;
- }
- function getGlobalPromiseConstructorSymbol(reportErrors) {
- return deferredGlobalPromiseConstructorSymbol || (deferredGlobalPromiseConstructorSymbol = getGlobalValueSymbol("Promise", reportErrors));
- }
- function getGlobalPromiseConstructorLikeType(reportErrors) {
- return deferredGlobalPromiseConstructorLikeType || (deferredGlobalPromiseConstructorLikeType = getGlobalType("PromiseConstructorLike", 0, reportErrors)) || emptyObjectType;
- }
- function getGlobalAsyncIterableType(reportErrors) {
- return deferredGlobalAsyncIterableType || (deferredGlobalAsyncIterableType = getGlobalType("AsyncIterable", 1, reportErrors)) || emptyGenericType;
- }
- function getGlobalAsyncIteratorType(reportErrors) {
- return deferredGlobalAsyncIteratorType || (deferredGlobalAsyncIteratorType = getGlobalType("AsyncIterator", 3, reportErrors)) || emptyGenericType;
- }
- function getGlobalAsyncIterableIteratorType(reportErrors) {
- return deferredGlobalAsyncIterableIteratorType || (deferredGlobalAsyncIterableIteratorType = getGlobalType("AsyncIterableIterator", 1, reportErrors)) || emptyGenericType;
- }
- function getGlobalAsyncGeneratorType(reportErrors) {
- return deferredGlobalAsyncGeneratorType || (deferredGlobalAsyncGeneratorType = getGlobalType("AsyncGenerator", 3, reportErrors)) || emptyGenericType;
- }
- function getGlobalIterableType(reportErrors) {
- return deferredGlobalIterableType || (deferredGlobalIterableType = getGlobalType("Iterable", 1, reportErrors)) || emptyGenericType;
- }
- function getGlobalIteratorType(reportErrors) {
- return deferredGlobalIteratorType || (deferredGlobalIteratorType = getGlobalType("Iterator", 3, reportErrors)) || emptyGenericType;
- }
- function getGlobalIterableIteratorType(reportErrors) {
- return deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType("IterableIterator", 1, reportErrors)) || emptyGenericType;
- }
- function getGlobalGeneratorType(reportErrors) {
- return deferredGlobalGeneratorType || (deferredGlobalGeneratorType = getGlobalType("Generator", 3, reportErrors)) || emptyGenericType;
- }
- function getGlobalIteratorYieldResultType(reportErrors) {
- return deferredGlobalIteratorYieldResultType || (deferredGlobalIteratorYieldResultType = getGlobalType("IteratorYieldResult", 1, reportErrors)) || emptyGenericType;
- }
- function getGlobalIteratorReturnResultType(reportErrors) {
- return deferredGlobalIteratorReturnResultType || (deferredGlobalIteratorReturnResultType = getGlobalType("IteratorReturnResult", 1, reportErrors)) || emptyGenericType;
- }
- function getGlobalTypeOrUndefined(name, arity) {
- if (arity === void 0) { arity = 0; }
- var symbol = getGlobalSymbol(name, 788968, undefined);
- return symbol && getTypeOfGlobalSymbol(symbol, arity);
- }
- function getGlobalExtractSymbol() {
- return deferredGlobalExtractSymbol || (deferredGlobalExtractSymbol = getGlobalSymbol("Extract", 524288, ts.Diagnostics.Cannot_find_global_type_0));
- }
- function getGlobalOmitSymbol() {
- return deferredGlobalOmitSymbol || (deferredGlobalOmitSymbol = getGlobalSymbol("Omit", 524288, ts.Diagnostics.Cannot_find_global_type_0));
- }
- function getGlobalBigIntType(reportErrors) {
- return deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", 0, reportErrors)) || emptyObjectType;
+ return widenTypeInferredFromInitializer(declaration, getUnionType([getTypeWithFacts(type, 524288), checkDeclarationInitializer(declaration)], 2));
}
- function createTypeFromGenericGlobalType(genericGlobalType, typeArguments) {
- return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType;
+ function getTypeForDeclarationFromJSDocComment(declaration) {
+ var jsdocType = ts.getJSDocType(declaration);
+ if (jsdocType) {
+ return getTypeFromTypeNode(jsdocType);
+ }
+ return undefined;
}
- function createTypedPropertyDescriptorType(propertyType) {
- return createTypeFromGenericGlobalType(getGlobalTypedPropertyDescriptorType(), [propertyType]);
+ function isNullOrUndefined(node) {
+ var expr = ts.skipParentheses(node);
+ return expr.kind === 103 || expr.kind === 78 && getResolvedSymbol(expr) === undefinedSymbol;
}
- function createIterableType(iteratedType) {
- return createTypeFromGenericGlobalType(getGlobalIterableType(true), [iteratedType]);
+ function isEmptyArrayLiteral(node) {
+ var expr = ts.skipParentheses(node);
+ return expr.kind === 199 && expr.elements.length === 0;
}
- function createArrayType(elementType, readonly) {
- return createTypeFromGenericGlobalType(readonly ? globalReadonlyArrayType : globalArrayType, [elementType]);
+ function addOptionality(type, optional) {
+ if (optional === void 0) { optional = true; }
+ return strictNullChecks && optional ? getOptionalType(type) : type;
}
- function getArrayOrTupleTargetType(node) {
- var readonly = isReadonlyTypeOperator(node.parent);
- if (node.kind === 174 || node.elementTypes.length === 1 && node.elementTypes[0].kind === 177) {
- return readonly ? globalReadonlyArrayType : globalArrayType;
+ function getTypeForVariableLikeDeclaration(declaration, includeOptionality) {
+ if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 238) {
+ var indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression)));
+ return indexType.flags & (262144 | 4194304) ? getExtractStringType(indexType) : stringType;
}
- var lastElement = ts.lastOrUndefined(node.elementTypes);
- var restElement = lastElement && lastElement.kind === 177 ? lastElement : undefined;
- var minLength = ts.findLastIndex(node.elementTypes, function (n) { return n.kind !== 176 && n !== restElement; }) + 1;
- return getTupleTypeOfArity(node.elementTypes.length, minLength, !!restElement, readonly, undefined);
- }
- function isDeferredTypeReferenceNode(node, hasDefaultTypeArguments) {
- return !!getAliasSymbolForTypeNode(node) || isResolvedByTypeAlias(node) && (node.kind === 174 ? mayResolveTypeAlias(node.elementType) :
- node.kind === 175 ? ts.some(node.elementTypes, mayResolveTypeAlias) :
- hasDefaultTypeArguments || ts.some(node.typeArguments, mayResolveTypeAlias));
- }
- function isResolvedByTypeAlias(node) {
- var parent = node.parent;
- switch (parent.kind) {
- case 182:
- case 169:
- case 178:
- case 179:
- case 185:
- case 180:
- case 184:
- case 174:
- case 175:
- return isResolvedByTypeAlias(parent);
- case 247:
- return true;
+ if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 239) {
+ var forOfStatement = declaration.parent.parent;
+ return checkRightHandSideOfForOf(forOfStatement) || anyType;
}
- return false;
- }
- function mayResolveTypeAlias(node) {
- switch (node.kind) {
- case 169:
- return isJSDocTypeReference(node) || !!(resolveTypeReferenceName(node.typeName, 788968).flags & 524288);
- case 172:
- return true;
- case 184:
- return node.operator !== 147 && mayResolveTypeAlias(node.type);
- case 182:
- case 176:
- case 299:
- case 297:
- case 298:
- case 294:
- return mayResolveTypeAlias(node.type);
- case 177:
- return node.type.kind !== 174 || mayResolveTypeAlias(node.type.elementType);
- case 178:
- case 179:
- return ts.some(node.types, mayResolveTypeAlias);
- case 185:
- return mayResolveTypeAlias(node.objectType) || mayResolveTypeAlias(node.indexType);
- case 180:
- return mayResolveTypeAlias(node.checkType) || mayResolveTypeAlias(node.extendsType) ||
- mayResolveTypeAlias(node.trueType) || mayResolveTypeAlias(node.falseType);
+ if (ts.isBindingPattern(declaration.parent)) {
+ return getTypeForBindingElement(declaration);
+ }
+ var isOptional = includeOptionality && (ts.isParameter(declaration) && isJSDocOptionalParameter(declaration)
+ || isOptionalJSDocPropertyLikeTag(declaration)
+ || !ts.isBindingElement(declaration) && !ts.isVariableDeclaration(declaration) && !!declaration.questionToken);
+ var declaredType = tryGetTypeFromEffectiveTypeNode(declaration);
+ if (declaredType) {
+ return addOptionality(declaredType, isOptional);
}
- return false;
- }
- function getTypeFromArrayOrTupleTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- var target = getArrayOrTupleTargetType(node);
- if (target === emptyGenericType) {
- links.resolvedType = emptyObjectType;
+ if ((noImplicitAny || ts.isInJSFile(declaration)) &&
+ ts.isVariableDeclaration(declaration) && !ts.isBindingPattern(declaration.name) &&
+ !(ts.getCombinedModifierFlags(declaration) & 1) && !(declaration.flags & 8388608)) {
+ if (!(ts.getCombinedNodeFlags(declaration) & 2) && (!declaration.initializer || isNullOrUndefined(declaration.initializer))) {
+ return autoType;
}
- else if (isDeferredTypeReferenceNode(node)) {
- links.resolvedType = node.kind === 175 && node.elementTypes.length === 0 ? target :
- createDeferredTypeReference(target, node, undefined);
+ if (declaration.initializer && isEmptyArrayLiteral(declaration.initializer)) {
+ return autoArrayType;
}
- else {
- var elementTypes = node.kind === 174 ? [getTypeFromTypeNode(node.elementType)] : ts.map(node.elementTypes, getTypeFromTypeNode);
- links.resolvedType = createTypeReference(target, elementTypes);
+ }
+ if (ts.isParameter(declaration)) {
+ var func = declaration.parent;
+ if (func.kind === 168 && !hasNonBindableDynamicName(func)) {
+ var getter = ts.getDeclarationOfKind(getSymbolOfNode(declaration.parent), 167);
+ if (getter) {
+ var getterSignature = getSignatureFromDeclaration(getter);
+ var thisParameter = getAccessorThisParameter(func);
+ if (thisParameter && declaration === thisParameter) {
+ ts.Debug.assert(!thisParameter.type);
+ return getTypeOfSymbol(getterSignature.thisParameter);
+ }
+ return getReturnTypeOfSignature(getterSignature);
+ }
+ }
+ if (ts.isInJSFile(declaration)) {
+ var typeTag = ts.getJSDocType(func);
+ if (typeTag && ts.isFunctionTypeNode(typeTag)) {
+ var signature = getSignatureFromDeclaration(typeTag);
+ var pos = func.parameters.indexOf(declaration);
+ return declaration.dotDotDotToken ? getRestTypeAtPosition(signature, pos) : getTypeAtPosition(signature, pos);
+ }
+ }
+ var type = declaration.symbol.escapedName === "this" ? getContextualThisParameterType(func) : getContextuallyTypedParameterType(declaration);
+ if (type) {
+ return addOptionality(type, isOptional);
}
}
- return links.resolvedType;
- }
- function isReadonlyTypeOperator(node) {
- return ts.isTypeOperatorNode(node) && node.operator === 138;
- }
- function createTupleTypeOfArity(arity, minLength, hasRestElement, readonly, associatedNames) {
- var typeParameters;
- var properties = [];
- var maxLength = hasRestElement ? arity - 1 : arity;
- if (arity) {
- typeParameters = new Array(arity);
- for (var i = 0; i < arity; i++) {
- var typeParameter = typeParameters[i] = createTypeParameter();
- if (i < maxLength) {
- var property = createSymbol(4 | (i >= minLength ? 16777216 : 0), "" + i, readonly ? 8 : 0);
- property.type = typeParameter;
- properties.push(property);
+ if (ts.hasOnlyExpressionInitializer(declaration) && !!declaration.initializer) {
+ if (ts.isInJSFile(declaration) && !ts.isParameter(declaration)) {
+ var containerObjectType = getJSContainerObjectType(declaration, getSymbolOfNode(declaration), ts.getDeclaredExpandoInitializer(declaration));
+ if (containerObjectType) {
+ return containerObjectType;
}
}
+ var type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration));
+ return addOptionality(type, isOptional);
}
- var literalTypes = [];
- for (var i = minLength; i <= maxLength; i++)
- literalTypes.push(getLiteralType(i));
- var lengthSymbol = createSymbol(4, "length");
- lengthSymbol.type = hasRestElement ? numberType : getUnionType(literalTypes);
- properties.push(lengthSymbol);
- var type = createObjectType(8 | 4);
- type.typeParameters = typeParameters;
- type.outerTypeParameters = undefined;
- type.localTypeParameters = typeParameters;
- type.instantiations = ts.createMap();
- type.instantiations.set(getTypeListId(type.typeParameters), type);
- type.target = type;
- type.resolvedTypeArguments = type.typeParameters;
- type.thisType = createTypeParameter();
- type.thisType.isThisType = true;
- type.thisType.constraint = type;
- type.declaredProperties = properties;
- type.declaredCallSignatures = ts.emptyArray;
- type.declaredConstructSignatures = ts.emptyArray;
- type.declaredStringIndexInfo = undefined;
- type.declaredNumberIndexInfo = undefined;
- type.minLength = minLength;
- type.hasRestElement = hasRestElement;
- type.readonly = readonly;
- type.associatedNames = associatedNames;
- return type;
- }
- function getTupleTypeOfArity(arity, minLength, hasRestElement, readonly, associatedNames) {
- var key = arity + (hasRestElement ? "+" : ",") + minLength + (readonly ? "R" : "") + (associatedNames && associatedNames.length ? "," + associatedNames.join(",") : "");
- var type = tupleTypes.get(key);
- if (!type) {
- tupleTypes.set(key, type = createTupleTypeOfArity(arity, minLength, hasRestElement, readonly, associatedNames));
+ if (ts.isPropertyDeclaration(declaration) && !ts.hasStaticModifier(declaration) && (noImplicitAny || ts.isInJSFile(declaration))) {
+ var constructor = findConstructorDeclaration(declaration.parent);
+ var type = constructor ? getFlowTypeInConstructor(declaration.symbol, constructor) :
+ ts.getEffectiveModifierFlags(declaration) & 2 ? getTypeOfPropertyInBaseClass(declaration.symbol) :
+ undefined;
+ return type && addOptionality(type, isOptional);
}
- return type;
- }
- function createTupleType(elementTypes, minLength, hasRestElement, readonly, associatedNames) {
- if (minLength === void 0) { minLength = elementTypes.length; }
- if (hasRestElement === void 0) { hasRestElement = false; }
- if (readonly === void 0) { readonly = false; }
- var arity = elementTypes.length;
- if (arity === 1 && hasRestElement) {
- return createArrayType(elementTypes[0], readonly);
+ if (ts.isJsxAttribute(declaration)) {
+ return trueType;
}
- var tupleType = getTupleTypeOfArity(arity, minLength, arity > 0 && hasRestElement, readonly, associatedNames);
- return elementTypes.length ? createTypeReference(tupleType, elementTypes) : tupleType;
- }
- function sliceTupleType(type, index) {
- var tuple = type.target;
- if (tuple.hasRestElement) {
- index = Math.min(index, getTypeReferenceArity(type) - 1);
+ if (ts.isBindingPattern(declaration.name)) {
+ return getTypeFromBindingPattern(declaration.name, false, true);
}
- return createTupleType(getTypeArguments(type).slice(index), Math.max(0, tuple.minLength - index), tuple.hasRestElement, tuple.readonly, tuple.associatedNames && tuple.associatedNames.slice(index));
- }
- function getTypeFromOptionalTypeNode(node) {
- var type = getTypeFromTypeNode(node.type);
- return strictNullChecks ? getOptionalType(type) : type;
- }
- function getTypeId(type) {
- return type.id;
- }
- function containsType(types, type) {
- return ts.binarySearch(types, type, getTypeId, ts.compareValues) >= 0;
+ return undefined;
}
- function insertType(types, type) {
- var index = ts.binarySearch(types, type, getTypeId, ts.compareValues);
- if (index < 0) {
- types.splice(~index, 0, type);
- return true;
+ function isConstructorDeclaredProperty(symbol) {
+ if (symbol.valueDeclaration && ts.isBinaryExpression(symbol.valueDeclaration)) {
+ var links = getSymbolLinks(symbol);
+ if (links.isConstructorDeclaredProperty === undefined) {
+ links.isConstructorDeclaredProperty = false;
+ links.isConstructorDeclaredProperty = !!getDeclaringConstructor(symbol) && ts.every(symbol.declarations, function (declaration) {
+ return ts.isBinaryExpression(declaration) &&
+ isPossiblyAliasedThisProperty(declaration) &&
+ (declaration.left.kind !== 202 || ts.isStringOrNumericLiteralLike(declaration.left.argumentExpression)) &&
+ !getAnnotatedTypeForAssignmentDeclaration(undefined, declaration, symbol, declaration);
+ });
+ }
+ return links.isConstructorDeclaredProperty;
}
return false;
}
- function addTypeToUnion(typeSet, includes, type) {
- var flags = type.flags;
- if (flags & 1048576) {
- return addTypesToUnion(typeSet, includes, type.types);
- }
- if (!(flags & 131072)) {
- includes |= flags & 71041023;
- if (flags & 66846720)
- includes |= 262144;
- if (type === wildcardType)
- includes |= 8388608;
- if (!strictNullChecks && flags & 98304) {
- if (!(ts.getObjectFlags(type) & 524288))
- includes |= 4194304;
- }
- else {
- var len = typeSet.length;
- var index = len && type.id > typeSet[len - 1].id ? ~len : ts.binarySearch(typeSet, type, getTypeId, ts.compareValues);
- if (index < 0) {
- typeSet.splice(~index, 0, type);
- }
+ function isAutoTypedProperty(symbol) {
+ var declaration = symbol.valueDeclaration;
+ return declaration && ts.isPropertyDeclaration(declaration) && !ts.getEffectiveTypeAnnotationNode(declaration) &&
+ !declaration.initializer && (noImplicitAny || ts.isInJSFile(declaration));
+ }
+ function getDeclaringConstructor(symbol) {
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ var container = ts.getThisContainer(declaration, false);
+ if (container && (container.kind === 166 || isJSConstructor(container))) {
+ return container;
}
}
- return includes;
}
- function addTypesToUnion(typeSet, includes, types) {
- for (var _i = 0, types_9 = types; _i < types_9.length; _i++) {
- var type = types_9[_i];
- includes = addTypeToUnion(typeSet, includes, type);
+ function getFlowTypeInConstructor(symbol, constructor) {
+ var accessName = ts.startsWith(symbol.escapedName, "__#")
+ ? ts.factory.createPrivateIdentifier(symbol.escapedName.split("@")[1])
+ : ts.unescapeLeadingUnderscores(symbol.escapedName);
+ var reference = ts.factory.createPropertyAccessExpression(ts.factory.createThis(), accessName);
+ ts.setParent(reference.expression, reference);
+ ts.setParent(reference, constructor);
+ reference.flowNode = constructor.returnFlowNode;
+ var flowType = getFlowTypeOfProperty(reference, symbol);
+ if (noImplicitAny && (flowType === autoType || flowType === autoArrayType)) {
+ error(symbol.valueDeclaration, ts.Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType));
}
- return includes;
+ return everyType(flowType, isNullableType) ? undefined : convertAutoToAny(flowType);
}
- function isSetOfLiteralsFromSameEnum(types) {
- var first = types[0];
- if (first.flags & 1024) {
- var firstEnum = getParentOfSymbol(first.symbol);
- for (var i = 1; i < types.length; i++) {
- var other = types[i];
- if (!(other.flags & 1024) || (firstEnum !== getParentOfSymbol(other.symbol))) {
- return false;
- }
+ function getFlowTypeOfProperty(reference, prop) {
+ var initialType = prop && (!isAutoTypedProperty(prop) || ts.getEffectiveModifierFlags(prop.valueDeclaration) & 2) && getTypeOfPropertyInBaseClass(prop) || undefinedType;
+ return getFlowTypeOfReference(reference, autoType, initialType);
+ }
+ function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) {
+ var container = ts.getAssignedExpandoInitializer(symbol.valueDeclaration);
+ if (container) {
+ var tag = ts.getJSDocTypeTag(container);
+ if (tag && tag.typeExpression) {
+ return getTypeFromTypeNode(tag.typeExpression);
}
- return true;
+ var containerObjectType = getJSContainerObjectType(symbol.valueDeclaration, symbol, container);
+ return containerObjectType || getWidenedLiteralType(checkExpressionCached(container));
}
- return false;
- }
- function removeSubtypes(types, primitivesOnly) {
- var len = types.length;
- if (len === 0 || isSetOfLiteralsFromSameEnum(types)) {
- return true;
+ var type;
+ var definedInConstructor = false;
+ var definedInMethod = false;
+ if (isConstructorDeclaredProperty(symbol)) {
+ type = getFlowTypeInConstructor(symbol, getDeclaringConstructor(symbol));
}
- var i = len;
- var count = 0;
- while (i > 0) {
- i--;
- var source = types[i];
- for (var _i = 0, types_10 = types; _i < types_10.length; _i++) {
- var target = types_10[_i];
- if (source !== target) {
- if (count === 100000) {
- var estimatedCount = (count / (len - i)) * len;
- if (estimatedCount > (primitivesOnly ? 25000000 : 1000000)) {
- error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
- return false;
- }
+ if (!type) {
+ var jsdocType = void 0;
+ var types = void 0;
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ var expression = (ts.isBinaryExpression(declaration) || ts.isCallExpression(declaration)) ? declaration :
+ ts.isAccessExpression(declaration) ? ts.isBinaryExpression(declaration.parent) ? declaration.parent : declaration :
+ undefined;
+ if (!expression) {
+ continue;
+ }
+ var kind = ts.isAccessExpression(expression)
+ ? ts.getAssignmentDeclarationPropertyAccessKind(expression)
+ : ts.getAssignmentDeclarationKind(expression);
+ if (kind === 4 || ts.isBinaryExpression(expression) && isPossiblyAliasedThisProperty(expression, kind)) {
+ if (isDeclarationInConstructor(expression)) {
+ definedInConstructor = true;
}
- count++;
- if (isTypeRelatedTo(source, target, strictSubtypeRelation) && (!(ts.getObjectFlags(getTargetType(source)) & 1) ||
- !(ts.getObjectFlags(getTargetType(target)) & 1) ||
- isTypeDerivedFrom(source, target))) {
- ts.orderedRemoveItemAt(types, i);
- break;
+ else {
+ definedInMethod = true;
}
}
+ if (!ts.isCallExpression(expression)) {
+ jsdocType = getAnnotatedTypeForAssignmentDeclaration(jsdocType, expression, symbol, declaration);
+ }
+ if (!jsdocType) {
+ (types || (types = [])).push((ts.isBinaryExpression(expression) || ts.isCallExpression(expression)) ? getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) : neverType);
+ }
}
- }
- return true;
- }
- function removeRedundantLiteralTypes(types, includes) {
- var i = types.length;
- while (i > 0) {
- i--;
- var t = types[i];
- var remove = t.flags & 128 && includes & 4 ||
- t.flags & 256 && includes & 8 ||
- t.flags & 2048 && includes & 64 ||
- t.flags & 8192 && includes & 4096 ||
- isFreshLiteralType(t) && containsType(types, t.regularType);
- if (remove) {
- ts.orderedRemoveItemAt(types, i);
+ type = jsdocType;
+ if (!type) {
+ if (!ts.length(types)) {
+ return errorType;
+ }
+ var constructorTypes = definedInConstructor ? getConstructorDefinedThisAssignmentTypes(types, symbol.declarations) : undefined;
+ if (definedInMethod) {
+ var propType = getTypeOfPropertyInBaseClass(symbol);
+ if (propType) {
+ (constructorTypes || (constructorTypes = [])).push(propType);
+ definedInConstructor = true;
+ }
+ }
+ var sourceTypes = ts.some(constructorTypes, function (t) { return !!(t.flags & ~98304); }) ? constructorTypes : types;
+ type = getUnionType(sourceTypes, 2);
}
}
+ var widened = getWidenedType(addOptionality(type, definedInMethod && !definedInConstructor));
+ if (filterType(widened, function (t) { return !!(t.flags & ~98304); }) === neverType) {
+ reportImplicitAny(symbol.valueDeclaration, anyType);
+ return anyType;
+ }
+ return widened;
}
- function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments) {
- if (unionReduction === void 0) { unionReduction = 1; }
- if (types.length === 0) {
- return neverType;
+ function getJSContainerObjectType(decl, symbol, init) {
+ var _a, _b;
+ if (!ts.isInJSFile(decl) || !init || !ts.isObjectLiteralExpression(init) || init.properties.length) {
+ return undefined;
}
- if (types.length === 1) {
- return types[0];
+ var exports = ts.createSymbolTable();
+ while (ts.isBinaryExpression(decl) || ts.isPropertyAccessExpression(decl)) {
+ var s_2 = getSymbolOfNode(decl);
+ if ((_a = s_2 === null || s_2 === void 0 ? void 0 : s_2.exports) === null || _a === void 0 ? void 0 : _a.size) {
+ mergeSymbolTable(exports, s_2.exports);
+ }
+ decl = ts.isBinaryExpression(decl) ? decl.parent : decl.parent.parent;
}
- var typeSet = [];
- var includes = addTypesToUnion(typeSet, 0, types);
- if (unionReduction !== 0) {
- if (includes & 3) {
- return includes & 1 ? includes & 8388608 ? wildcardType : anyType : unknownType;
+ var s = getSymbolOfNode(decl);
+ if ((_b = s === null || s === void 0 ? void 0 : s.exports) === null || _b === void 0 ? void 0 : _b.size) {
+ mergeSymbolTable(exports, s.exports);
+ }
+ var type = createAnonymousType(symbol, exports, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ type.objectFlags |= 16384;
+ return type;
+ }
+ function getAnnotatedTypeForAssignmentDeclaration(declaredType, expression, symbol, declaration) {
+ var typeNode = ts.getEffectiveTypeAnnotationNode(expression.parent);
+ if (typeNode) {
+ var type = getWidenedType(getTypeFromTypeNode(typeNode));
+ if (!declaredType) {
+ return type;
}
- switch (unionReduction) {
- case 1:
- if (includes & (2944 | 8192)) {
- removeRedundantLiteralTypes(typeSet, includes);
- }
- break;
- case 2:
- if (!removeSubtypes(typeSet, !(includes & 262144))) {
- return errorType;
- }
- break;
+ else if (declaredType !== errorType && type !== errorType && !isTypeIdenticalTo(declaredType, type)) {
+ errorNextVariableOrPropertyDeclarationMustHaveSameType(undefined, declaredType, declaration, type);
}
- if (typeSet.length === 0) {
- return includes & 65536 ? includes & 4194304 ? nullType : nullWideningType :
- includes & 32768 ? includes & 4194304 ? undefinedType : undefinedWideningType :
- neverType;
+ }
+ if (symbol.parent) {
+ var typeNode_2 = ts.getEffectiveTypeAnnotationNode(symbol.parent.valueDeclaration);
+ if (typeNode_2) {
+ return getTypeOfPropertyOfType(getTypeFromTypeNode(typeNode_2), symbol.escapedName);
}
}
- var objectFlags = (includes & 66994211 ? 0 : 262144) |
- (includes & 2097152 ? 268435456 : 0);
- return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments);
+ return declaredType;
}
- function getUnionTypePredicate(signatures) {
- var first;
- var types = [];
- for (var _i = 0, signatures_6 = signatures; _i < signatures_6.length; _i++) {
- var sig = signatures_6[_i];
- var pred = getTypePredicateOfSignature(sig);
- if (!pred || pred.kind === 2 || pred.kind === 3) {
- continue;
+ function getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) {
+ if (ts.isCallExpression(expression)) {
+ if (resolvedSymbol) {
+ return getTypeOfSymbol(resolvedSymbol);
}
- if (first) {
- if (!typePredicateKindsMatch(first, pred)) {
- return undefined;
+ var objectLitType = checkExpressionCached(expression.arguments[2]);
+ var valueType = getTypeOfPropertyOfType(objectLitType, "value");
+ if (valueType) {
+ return valueType;
+ }
+ var getFunc = getTypeOfPropertyOfType(objectLitType, "get");
+ if (getFunc) {
+ var getSig = getSingleCallSignature(getFunc);
+ if (getSig) {
+ return getReturnTypeOfSignature(getSig);
}
}
- else {
- first = pred;
+ var setFunc = getTypeOfPropertyOfType(objectLitType, "set");
+ if (setFunc) {
+ var setSig = getSingleCallSignature(setFunc);
+ if (setSig) {
+ return getTypeOfFirstParameterOfSignature(setSig);
+ }
}
- types.push(pred.type);
- }
- if (!first) {
- return undefined;
+ return anyType;
}
- var unionType = getUnionType(types);
- return createTypePredicate(first.kind, first.parameterName, first.parameterIndex, unionType);
- }
- function typePredicateKindsMatch(a, b) {
- return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
- }
- function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments) {
- if (types.length === 0) {
- return neverType;
+ if (containsSameNamedThisProperty(expression.left, expression.right)) {
+ return anyType;
}
- if (types.length === 1) {
- return types[0];
+ var type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol) : getWidenedLiteralType(checkExpressionCached(expression.right));
+ if (type.flags & 524288 &&
+ kind === 2 &&
+ symbol.escapedName === "export=") {
+ var exportedType = resolveStructuredTypeMembers(type);
+ var members_4 = ts.createSymbolTable();
+ ts.copyEntries(exportedType.members, members_4);
+ var initialSize = members_4.size;
+ if (resolvedSymbol && !resolvedSymbol.exports) {
+ resolvedSymbol.exports = ts.createSymbolTable();
+ }
+ (resolvedSymbol || symbol).exports.forEach(function (s, name) {
+ var _a;
+ var exportedMember = members_4.get(name);
+ if (exportedMember && exportedMember !== s) {
+ if (s.flags & 111551 && exportedMember.flags & 111551) {
+ if (ts.getSourceFileOfNode(s.valueDeclaration) !== ts.getSourceFileOfNode(exportedMember.valueDeclaration)) {
+ var unescapedName = ts.unescapeLeadingUnderscores(s.escapedName);
+ var exportedMemberName = ((_a = ts.tryCast(exportedMember.valueDeclaration, ts.isNamedDeclaration)) === null || _a === void 0 ? void 0 : _a.name) || exportedMember.valueDeclaration;
+ ts.addRelatedInfo(error(s.valueDeclaration, ts.Diagnostics.Duplicate_identifier_0, unescapedName), ts.createDiagnosticForNode(exportedMemberName, ts.Diagnostics._0_was_also_declared_here, unescapedName));
+ ts.addRelatedInfo(error(exportedMemberName, ts.Diagnostics.Duplicate_identifier_0, unescapedName), ts.createDiagnosticForNode(s.valueDeclaration, ts.Diagnostics._0_was_also_declared_here, unescapedName));
+ }
+ var union = createSymbol(s.flags | exportedMember.flags, name);
+ union.type = getUnionType([getTypeOfSymbol(s), getTypeOfSymbol(exportedMember)]);
+ union.valueDeclaration = exportedMember.valueDeclaration;
+ union.declarations = ts.concatenate(exportedMember.declarations, s.declarations);
+ members_4.set(name, union);
+ }
+ else {
+ members_4.set(name, mergeSymbol(s, exportedMember));
+ }
+ }
+ else {
+ members_4.set(name, s);
+ }
+ });
+ var result = createAnonymousType(initialSize !== members_4.size ? undefined : exportedType.symbol, members_4, exportedType.callSignatures, exportedType.constructSignatures, exportedType.stringIndexInfo, exportedType.numberIndexInfo);
+ result.objectFlags |= (ts.getObjectFlags(type) & 16384);
+ if (result.symbol && result.symbol.flags & 32 && type === getDeclaredTypeOfClassOrInterface(result.symbol)) {
+ result.objectFlags |= 1073741824;
+ }
+ return result;
}
- var id = getTypeListId(types);
- var type = unionTypes.get(id);
- if (!type) {
- type = createType(1048576);
- unionTypes.set(id, type);
- type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(types, 98304);
- type.types = types;
- type.aliasSymbol = aliasSymbol;
- type.aliasTypeArguments = aliasTypeArguments;
+ if (isEmptyArrayLiteralType(type)) {
+ reportImplicitAny(expression, anyArrayType);
+ return anyArrayType;
}
return type;
}
- function getTypeFromUnionTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- var aliasSymbol = getAliasSymbolForTypeNode(node);
- links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), 1, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
- }
- return links.resolvedType;
+ function containsSameNamedThisProperty(thisProperty, expression) {
+ return ts.isPropertyAccessExpression(thisProperty)
+ && thisProperty.expression.kind === 107
+ && ts.forEachChildRecursively(expression, function (n) { return isMatchingReference(thisProperty, n); });
}
- function addTypeToIntersection(typeSet, includes, type) {
- var flags = type.flags;
- if (flags & 2097152) {
- return addTypesToIntersection(typeSet, includes, type.types);
+ function isDeclarationInConstructor(expression) {
+ var thisContainer = ts.getThisContainer(expression, false);
+ return thisContainer.kind === 166 ||
+ thisContainer.kind === 251 ||
+ (thisContainer.kind === 208 && !ts.isPrototypePropertyAssignment(thisContainer.parent));
+ }
+ function getConstructorDefinedThisAssignmentTypes(types, declarations) {
+ ts.Debug.assert(types.length === declarations.length);
+ return types.filter(function (_, i) {
+ var declaration = declarations[i];
+ var expression = ts.isBinaryExpression(declaration) ? declaration :
+ ts.isBinaryExpression(declaration.parent) ? declaration.parent : undefined;
+ return expression && isDeclarationInConstructor(expression);
+ });
+ }
+ function getTypeFromBindingElement(element, includePatternInType, reportErrors) {
+ if (element.initializer) {
+ var contextualType = ts.isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, true, false) : unknownType;
+ return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, contextualType)));
}
- if (isEmptyAnonymousObjectType(type)) {
- if (!(includes & 16777216)) {
- includes |= 16777216;
- typeSet.set(type.id.toString(), type);
- }
+ if (ts.isBindingPattern(element.name)) {
+ return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors);
}
- else {
- if (flags & 3) {
- if (type === wildcardType)
- includes |= 8388608;
+ if (reportErrors && !declarationBelongsToPrivateAmbientMember(element)) {
+ reportImplicitAny(element, anyType);
+ }
+ return includePatternInType ? nonInferrableAnyType : anyType;
+ }
+ function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) {
+ var members = ts.createSymbolTable();
+ var stringIndexInfo;
+ var objectFlags = 128 | 1048576;
+ ts.forEach(pattern.elements, function (e) {
+ var name = e.propertyName || e.name;
+ if (e.dotDotDotToken) {
+ stringIndexInfo = createIndexInfo(anyType, false);
+ return;
}
- else if ((strictNullChecks || !(flags & 98304)) && !typeSet.has(type.id.toString())) {
- if (type.flags & 109440 && includes & 109440) {
- includes |= 67108864;
- }
- typeSet.set(type.id.toString(), type);
+ var exprType = getLiteralTypeFromPropertyName(name);
+ if (!isTypeUsableAsPropertyName(exprType)) {
+ objectFlags |= 512;
+ return;
}
- includes |= flags & 71041023;
+ var text = getPropertyNameFromType(exprType);
+ var flags = 4 | (e.initializer ? 16777216 : 0);
+ var symbol = createSymbol(flags, text);
+ symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors);
+ symbol.bindingElement = e;
+ members.set(symbol.escapedName, symbol);
+ });
+ var result = createAnonymousType(undefined, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, undefined);
+ result.objectFlags |= objectFlags;
+ if (includePatternInType) {
+ result.pattern = pattern;
+ result.objectFlags |= 1048576;
}
- return includes;
+ return result;
}
- function addTypesToIntersection(typeSet, includes, types) {
- for (var _i = 0, types_11 = types; _i < types_11.length; _i++) {
- var type = types_11[_i];
- includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type));
+ function getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors) {
+ var elements = pattern.elements;
+ var lastElement = ts.lastOrUndefined(elements);
+ var restElement = lastElement && lastElement.kind === 198 && lastElement.dotDotDotToken ? lastElement : undefined;
+ if (elements.length === 0 || elements.length === 1 && restElement) {
+ return languageVersion >= 2 ? createIterableType(anyType) : anyArrayType;
}
- return includes;
+ var elementTypes = ts.map(elements, function (e) { return ts.isOmittedExpression(e) ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors); });
+ var minLength = ts.findLastIndex(elements, function (e) { return !(e === restElement || ts.isOmittedExpression(e) || hasDefaultValue(e)); }, elements.length - 1) + 1;
+ var elementFlags = ts.map(elements, function (e, i) { return e === restElement ? 4 : i >= minLength ? 2 : 1; });
+ var result = createTupleType(elementTypes, elementFlags);
+ if (includePatternInType) {
+ result = cloneTypeReference(result);
+ result.pattern = pattern;
+ result.objectFlags |= 1048576;
+ }
+ return result;
}
- function removeRedundantPrimitiveTypes(types, includes) {
- var i = types.length;
- while (i > 0) {
- i--;
- var t = types[i];
- var remove = t.flags & 4 && includes & 128 ||
- t.flags & 8 && includes & 256 ||
- t.flags & 64 && includes & 2048 ||
- t.flags & 4096 && includes & 8192;
- if (remove) {
- ts.orderedRemoveItemAt(types, i);
+ function getTypeFromBindingPattern(pattern, includePatternInType, reportErrors) {
+ if (includePatternInType === void 0) { includePatternInType = false; }
+ if (reportErrors === void 0) { reportErrors = false; }
+ return pattern.kind === 196
+ ? getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors)
+ : getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors);
+ }
+ function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) {
+ return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, true), declaration, reportErrors);
+ }
+ function widenTypeForVariableLikeDeclaration(type, declaration, reportErrors) {
+ if (type) {
+ if (reportErrors) {
+ reportErrorsFromWidening(declaration, type);
+ }
+ if (type.flags & 8192 && (ts.isBindingElement(declaration) || !declaration.type) && type.symbol !== getSymbolOfNode(declaration)) {
+ type = esSymbolType;
}
+ return getWidenedType(type);
}
- }
- function eachUnionContains(unionTypes, type) {
- for (var _i = 0, unionTypes_1 = unionTypes; _i < unionTypes_1.length; _i++) {
- var u = unionTypes_1[_i];
- if (!containsType(u.types, type)) {
- var primitive = type.flags & 128 ? stringType :
- type.flags & 256 ? numberType :
- type.flags & 2048 ? bigintType :
- type.flags & 8192 ? esSymbolType :
- undefined;
- if (!primitive || !containsType(u.types, primitive)) {
- return false;
- }
+ type = ts.isParameter(declaration) && declaration.dotDotDotToken ? anyArrayType : anyType;
+ if (reportErrors) {
+ if (!declarationBelongsToPrivateAmbientMember(declaration)) {
+ reportImplicitAny(declaration, type);
}
}
- return true;
+ return type;
+ }
+ function declarationBelongsToPrivateAmbientMember(declaration) {
+ var root = ts.getRootDeclaration(declaration);
+ var memberDeclaration = root.kind === 160 ? root.parent : root;
+ return isPrivateWithinAmbient(memberDeclaration);
+ }
+ function tryGetTypeFromEffectiveTypeNode(declaration) {
+ var typeNode = ts.getEffectiveTypeAnnotationNode(declaration);
+ if (typeNode) {
+ return getTypeFromTypeNode(typeNode);
+ }
}
- function extractIrreducible(types, flag) {
- if (ts.every(types, function (t) { return !!(t.flags & 1048576) && ts.some(t.types, function (tt) { return !!(tt.flags & flag); }); })) {
- for (var i = 0; i < types.length; i++) {
- types[i] = filterType(types[i], function (t) { return !(t.flags & flag); });
+ function getTypeOfVariableOrParameterOrProperty(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (!links.type) {
+ var type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
+ if (!links.type) {
+ links.type = type;
}
- return true;
}
- return false;
+ return links.type;
}
- function intersectUnionsOfPrimitiveTypes(types) {
- var unionTypes;
- var index = ts.findIndex(types, function (t) { return !!(ts.getObjectFlags(t) & 262144); });
- if (index < 0) {
- return false;
+ function getTypeOfVariableOrParameterOrPropertyWorker(symbol) {
+ if (symbol.flags & 4194304) {
+ return getTypeOfPrototypeProperty(symbol);
}
- var i = index + 1;
- while (i < types.length) {
- var t = types[i];
- if (ts.getObjectFlags(t) & 262144) {
- (unionTypes || (unionTypes = [types[index]])).push(t);
- ts.orderedRemoveItemAt(types, i);
+ if (symbol === requireSymbol) {
+ return anyType;
+ }
+ if (symbol.flags & 134217728) {
+ var fileSymbol = getSymbolOfNode(ts.getSourceFileOfNode(symbol.valueDeclaration));
+ var members = ts.createSymbolTable();
+ members.set("exports", fileSymbol);
+ return createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ }
+ var declaration = symbol.valueDeclaration;
+ if (ts.isCatchClauseVariableDeclarationOrBindingElement(declaration)) {
+ var decl = declaration;
+ if (!decl.type)
+ return anyType;
+ var type_1 = getTypeOfNode(decl.type);
+ return isTypeAny(type_1) || type_1 === unknownType ? type_1 : errorType;
+ }
+ if (ts.isSourceFile(declaration) && ts.isJsonSourceFile(declaration)) {
+ if (!declaration.statements.length) {
+ return emptyObjectType;
}
- else {
- i++;
+ return getWidenedType(getWidenedLiteralType(checkExpression(declaration.statements[0].expression)));
+ }
+ if (!pushTypeResolution(symbol, 0)) {
+ if (symbol.flags & 512 && !(symbol.flags & 67108864)) {
+ return getTypeOfFuncClassEnumModule(symbol);
}
+ return reportCircularityError(symbol);
}
- if (!unionTypes) {
- return false;
+ var type;
+ if (declaration.kind === 266) {
+ type = widenTypeForVariableLikeDeclaration(checkExpressionCached(declaration.expression), declaration);
}
- var checked = [];
- var result = [];
- for (var _i = 0, unionTypes_2 = unionTypes; _i < unionTypes_2.length; _i++) {
- var u = unionTypes_2[_i];
- for (var _a = 0, _b = u.types; _a < _b.length; _a++) {
- var t = _b[_a];
- if (insertType(checked, t)) {
- if (eachUnionContains(unionTypes, t)) {
- insertType(result, t);
- }
- }
+ else if (ts.isBinaryExpression(declaration) ||
+ (ts.isInJSFile(declaration) &&
+ (ts.isCallExpression(declaration) || (ts.isPropertyAccessExpression(declaration) || ts.isBindableStaticElementAccessExpression(declaration)) && ts.isBinaryExpression(declaration.parent)))) {
+ type = getWidenedTypeForAssignmentDeclaration(symbol);
+ }
+ else if (ts.isPropertyAccessExpression(declaration)
+ || ts.isElementAccessExpression(declaration)
+ || ts.isIdentifier(declaration)
+ || ts.isStringLiteralLike(declaration)
+ || ts.isNumericLiteral(declaration)
+ || ts.isClassDeclaration(declaration)
+ || ts.isFunctionDeclaration(declaration)
+ || (ts.isMethodDeclaration(declaration) && !ts.isObjectLiteralMethod(declaration))
+ || ts.isMethodSignature(declaration)
+ || ts.isSourceFile(declaration)) {
+ if (symbol.flags & (16 | 8192 | 32 | 384 | 512)) {
+ return getTypeOfFuncClassEnumModule(symbol);
}
+ type = ts.isBinaryExpression(declaration.parent) ?
+ getWidenedTypeForAssignmentDeclaration(symbol) :
+ tryGetTypeFromEffectiveTypeNode(declaration) || anyType;
}
- types[index] = getUnionTypeFromSortedList(result, 262144);
- return true;
- }
- function createIntersectionType(types, aliasSymbol, aliasTypeArguments) {
- var result = createType(2097152);
- result.objectFlags = getPropagatingFlagsOfTypes(types, 98304);
- result.types = types;
- result.aliasSymbol = aliasSymbol;
- result.aliasTypeArguments = aliasTypeArguments;
- return result;
- }
- function getIntersectionType(types, aliasSymbol, aliasTypeArguments) {
- var typeMembershipMap = ts.createMap();
- var includes = addTypesToIntersection(typeMembershipMap, 0, types);
- var typeSet = ts.arrayFrom(typeMembershipMap.values());
- if (includes & 131072 ||
- strictNullChecks && includes & 98304 && includes & (524288 | 67108864 | 16777216) ||
- includes & 67108864 && includes & (67238908 & ~67108864) ||
- includes & 132 && includes & (67238908 & ~132) ||
- includes & 296 && includes & (67238908 & ~296) ||
- includes & 2112 && includes & (67238908 & ~2112) ||
- includes & 12288 && includes & (67238908 & ~12288) ||
- includes & 49152 && includes & (67238908 & ~49152)) {
- return neverType;
+ else if (ts.isPropertyAssignment(declaration)) {
+ type = tryGetTypeFromEffectiveTypeNode(declaration) || checkPropertyAssignment(declaration);
}
- if (includes & 1) {
- return includes & 8388608 ? wildcardType : anyType;
+ else if (ts.isJsxAttribute(declaration)) {
+ type = tryGetTypeFromEffectiveTypeNode(declaration) || checkJsxAttribute(declaration);
}
- if (!strictNullChecks && includes & 98304) {
- return includes & 32768 ? undefinedType : nullType;
+ else if (ts.isShorthandPropertyAssignment(declaration)) {
+ type = tryGetTypeFromEffectiveTypeNode(declaration) || checkExpressionForMutableLocation(declaration.name, 0);
}
- if (includes & 4 && includes & 128 ||
- includes & 8 && includes & 256 ||
- includes & 64 && includes & 2048 ||
- includes & 4096 && includes & 8192) {
- removeRedundantPrimitiveTypes(typeSet, includes);
+ else if (ts.isObjectLiteralMethod(declaration)) {
+ type = tryGetTypeFromEffectiveTypeNode(declaration) || checkObjectLiteralMethod(declaration, 0);
}
- if (includes & 16777216 && includes & 524288) {
- ts.orderedRemoveItemAt(typeSet, ts.findIndex(typeSet, isEmptyAnonymousObjectType));
+ else if (ts.isParameter(declaration)
+ || ts.isPropertyDeclaration(declaration)
+ || ts.isPropertySignature(declaration)
+ || ts.isVariableDeclaration(declaration)
+ || ts.isBindingElement(declaration)
+ || ts.isJSDocPropertyLikeTag(declaration)) {
+ type = getWidenedTypeForVariableLikeDeclaration(declaration, true);
}
- if (typeSet.length === 0) {
- return unknownType;
+ else if (ts.isEnumDeclaration(declaration)) {
+ type = getTypeOfFuncClassEnumModule(symbol);
}
- if (typeSet.length === 1) {
- return typeSet[0];
+ else if (ts.isEnumMember(declaration)) {
+ type = getTypeOfEnumMember(symbol);
}
- var id = getTypeListId(typeSet);
- var result = intersectionTypes.get(id);
- if (!result) {
- if (includes & 1048576) {
- if (intersectUnionsOfPrimitiveTypes(typeSet)) {
- result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
- }
- else if (extractIrreducible(typeSet, 32768)) {
- result = getUnionType([getIntersectionType(typeSet), undefinedType], 1, aliasSymbol, aliasTypeArguments);
- }
- else if (extractIrreducible(typeSet, 65536)) {
- result = getUnionType([getIntersectionType(typeSet), nullType], 1, aliasSymbol, aliasTypeArguments);
- }
- else {
- var size = ts.reduceLeft(typeSet, function (n, t) { return n * (t.flags & 1048576 ? t.types.length : 1); }, 1);
- if (size >= 100000) {
- error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
- return errorType;
- }
- var unionIndex_1 = ts.findIndex(typeSet, function (t) { return (t.flags & 1048576) !== 0; });
- var unionType = typeSet[unionIndex_1];
- result = getUnionType(ts.map(unionType.types, function (t) { return getIntersectionType(ts.replaceElement(typeSet, unionIndex_1, t)); }), 1, aliasSymbol, aliasTypeArguments);
- }
- }
- else {
- result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
- }
- intersectionTypes.set(id, result);
+ else if (ts.isAccessor(declaration)) {
+ type = resolveTypeOfAccessors(symbol);
}
- return result;
- }
- function getTypeFromIntersectionTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- var aliasSymbol = getAliasSymbolForTypeNode(node);
- links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
+ else {
+ return ts.Debug.fail("Unhandled declaration kind! " + ts.Debug.formatSyntaxKind(declaration.kind) + " for " + ts.Debug.formatSymbol(symbol));
}
- return links.resolvedType;
- }
- function createIndexType(type, stringsOnly) {
- var result = createType(4194304);
- result.type = type;
- result.stringsOnly = stringsOnly;
- return result;
- }
- function getIndexTypeForGenericType(type, stringsOnly) {
- return stringsOnly ?
- type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, true)) :
- type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, false));
- }
- function getLiteralTypeFromPropertyName(name) {
- if (ts.isPrivateIdentifier(name)) {
- return neverType;
+ if (!popTypeResolution()) {
+ if (symbol.flags & 512 && !(symbol.flags & 67108864)) {
+ return getTypeOfFuncClassEnumModule(symbol);
+ }
+ return reportCircularityError(symbol);
}
- return ts.isIdentifier(name) ? getLiteralType(ts.unescapeLeadingUnderscores(name.escapedText)) :
- getRegularTypeOfLiteralType(ts.isComputedPropertyName(name) ? checkComputedPropertyName(name) : checkExpression(name));
- }
- function getBigIntLiteralType(node) {
- return getLiteralType({
- negative: false,
- base10Value: ts.parsePseudoBigInt(node.text)
- });
+ return type;
}
- function getLiteralTypeFromProperty(prop, include) {
- if (!(ts.getDeclarationModifierFlagsFromSymbol(prop) & 24)) {
- var type = getSymbolLinks(getLateBoundSymbol(prop)).nameType;
- if (!type && !ts.isKnownSymbol(prop)) {
- if (prop.escapedName === "default") {
- type = getLiteralType("default");
- }
- else {
- var name = prop.valueDeclaration && ts.getNameOfDeclaration(prop.valueDeclaration);
- type = name && getLiteralTypeFromPropertyName(name) || getLiteralType(ts.symbolName(prop));
- }
+ function getAnnotatedAccessorTypeNode(accessor) {
+ if (accessor) {
+ if (accessor.kind === 167) {
+ var getterTypeAnnotation = ts.getEffectiveReturnTypeNode(accessor);
+ return getterTypeAnnotation;
}
- if (type && type.flags & include) {
- return type;
+ else {
+ var setterTypeAnnotation = ts.getEffectiveSetAccessorTypeAnnotationNode(accessor);
+ return setterTypeAnnotation;
}
}
- return neverType;
- }
- function getLiteralTypeFromProperties(type, include) {
- return getUnionType(ts.map(getPropertiesOfType(type), function (p) { return getLiteralTypeFromProperty(p, include); }));
+ return undefined;
}
- function getNonEnumNumberIndexInfo(type) {
- var numberIndexInfo = getIndexInfoOfType(type, 1);
- return numberIndexInfo !== enumNumberIndexInfo ? numberIndexInfo : undefined;
+ function getAnnotatedAccessorType(accessor) {
+ var node = getAnnotatedAccessorTypeNode(accessor);
+ return node && getTypeFromTypeNode(node);
}
- function getIndexType(type, stringsOnly, noIndexSignatures) {
- if (stringsOnly === void 0) { stringsOnly = keyofStringsOnly; }
- type = getReducedType(type);
- return type.flags & 1048576 ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
- type.flags & 2097152 ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
- maybeTypeOfKind(type, 58982400) ? getIndexTypeForGenericType(type, stringsOnly) :
- ts.getObjectFlags(type) & 32 ? filterType(getConstraintTypeFromMappedType(type), function (t) { return !(noIndexSignatures && t.flags & (1 | 4)); }) :
- type === wildcardType ? wildcardType :
- type.flags & 2 ? neverType :
- type.flags & (1 | 131072) ? keyofConstraintType :
- stringsOnly ? !noIndexSignatures && getIndexInfoOfType(type, 0) ? stringType : getLiteralTypeFromProperties(type, 128) :
- !noIndexSignatures && getIndexInfoOfType(type, 0) ? getUnionType([stringType, numberType, getLiteralTypeFromProperties(type, 8192)]) :
- getNonEnumNumberIndexInfo(type) ? getUnionType([numberType, getLiteralTypeFromProperties(type, 128 | 8192)]) :
- getLiteralTypeFromProperties(type, 8576);
+ function getAnnotatedAccessorThisParameter(accessor) {
+ var parameter = getAccessorThisParameter(accessor);
+ return parameter && parameter.symbol;
}
- function getExtractStringType(type) {
- if (keyofStringsOnly) {
- return type;
- }
- var extractTypeAlias = getGlobalExtractSymbol();
- return extractTypeAlias ? getTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType;
+ function getThisTypeOfDeclaration(declaration) {
+ return getThisTypeOfSignature(getSignatureFromDeclaration(declaration));
}
- function getIndexTypeOrString(type) {
- var indexType = getExtractStringType(getIndexType(type));
- return indexType.flags & 131072 ? stringType : indexType;
+ function getTypeOfAccessors(symbol) {
+ var links = getSymbolLinks(symbol);
+ return links.type || (links.type = getTypeOfAccessorsWorker(symbol));
}
- function getTypeFromTypeOperatorNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- switch (node.operator) {
- case 134:
- links.resolvedType = getIndexType(getTypeFromTypeNode(node.type));
- break;
- case 147:
- links.resolvedType = node.type.kind === 144
- ? getESSymbolLikeTypeForNode(ts.walkUpParenthesizedTypes(node.parent))
- : errorType;
- break;
- case 138:
- links.resolvedType = getTypeFromTypeNode(node.type);
- break;
- default:
- throw ts.Debug.assertNever(node.operator);
+ function getTypeOfAccessorsWorker(symbol) {
+ if (!pushTypeResolution(symbol, 0)) {
+ return errorType;
+ }
+ var type = resolveTypeOfAccessors(symbol);
+ if (!popTypeResolution()) {
+ type = anyType;
+ if (noImplicitAny) {
+ var getter = ts.getDeclarationOfKind(symbol, 167);
+ error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
}
}
- return links.resolvedType;
- }
- function createIndexedAccessType(objectType, indexType) {
- var type = createType(8388608);
- type.objectType = objectType;
- type.indexType = indexType;
return type;
}
- function isJSLiteralType(type) {
- if (noImplicitAny) {
- return false;
- }
- if (ts.getObjectFlags(type) & 16384) {
- return true;
- }
- if (type.flags & 1048576) {
- return ts.every(type.types, isJSLiteralType);
- }
- if (type.flags & 2097152) {
- return ts.some(type.types, isJSLiteralType);
- }
- if (type.flags & 63176704) {
- return isJSLiteralType(getResolvedBaseConstraint(type));
- }
- return false;
- }
- function getPropertyNameFromIndex(indexType, accessNode) {
- var accessExpression = accessNode && accessNode.kind === 195 ? accessNode : undefined;
- return isTypeUsableAsPropertyName(indexType) ?
- getPropertyNameFromType(indexType) :
- accessExpression && checkThatExpressionIsProperSymbolReference(accessExpression.argumentExpression, indexType, false) ?
- ts.getPropertyNameForKnownSymbolName(ts.idText(accessExpression.argumentExpression.name)) :
- accessNode && ts.isPropertyName(accessNode) ?
- ts.getPropertyNameForPropertyNameNode(accessNode) :
- undefined;
- }
- function getPropertyTypeForIndexType(originalObjectType, objectType, indexType, fullIndexType, suppressNoImplicitAnyError, accessNode, accessFlags) {
- var accessExpression = accessNode && accessNode.kind === 195 ? accessNode : undefined;
- var propName = accessNode && ts.isPrivateIdentifier(accessNode) ? undefined : getPropertyNameFromIndex(indexType, accessNode);
- if (propName !== undefined) {
- var prop = getPropertyOfType(objectType, propName);
- if (prop) {
- if (accessExpression) {
- markPropertyAsReferenced(prop, accessExpression, accessExpression.expression.kind === 104);
- if (isAssignmentToReadonlyEntity(accessExpression, prop, ts.getAssignmentTargetKind(accessExpression))) {
- error(accessExpression.argumentExpression, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(prop));
- return undefined;
- }
- if (accessFlags & 4) {
- getNodeLinks(accessNode).resolvedSymbol = prop;
- }
- }
- var propType = getTypeOfSymbol(prop);
- return accessExpression && ts.getAssignmentTargetKind(accessExpression) !== 1 ?
- getFlowTypeOfReference(accessExpression, propType) :
- propType;
- }
- if (everyType(objectType, isTupleType) && isNumericLiteralName(propName) && +propName >= 0) {
- if (accessNode && everyType(objectType, function (t) { return !t.target.hasRestElement; }) && !(accessFlags & 8)) {
- var indexNode = getIndexNodeForAccessExpression(accessNode);
- if (isTupleType(objectType)) {
- error(indexNode, ts.Diagnostics.Tuple_type_0_of_length_1_has_no_element_at_index_2, typeToString(objectType), getTypeReferenceArity(objectType), ts.unescapeLeadingUnderscores(propName));
- }
- else {
- error(indexNode, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType));
- }
- }
- errorIfWritingToReadonlyIndex(getIndexInfoOfType(objectType, 1));
- return mapType(objectType, function (t) { return getRestTypeOfTupleType(t) || undefinedType; });
+ function resolveTypeOfAccessors(symbol) {
+ var getter = ts.getDeclarationOfKind(symbol, 167);
+ var setter = ts.getDeclarationOfKind(symbol, 168);
+ if (getter && ts.isInJSFile(getter)) {
+ var jsDocType = getTypeForDeclarationFromJSDocComment(getter);
+ if (jsDocType) {
+ return jsDocType;
}
}
- if (!(indexType.flags & 98304) && isTypeAssignableToKind(indexType, 132 | 296 | 12288)) {
- if (objectType.flags & (1 | 131072)) {
- return objectType;
- }
- var stringIndexInfo = getIndexInfoOfType(objectType, 0);
- var indexInfo = isTypeAssignableToKind(indexType, 296) && getIndexInfoOfType(objectType, 1) || stringIndexInfo;
- if (indexInfo) {
- if (accessFlags & 1 && indexInfo === stringIndexInfo) {
- if (accessExpression) {
- error(accessExpression, ts.Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(originalObjectType));
- }
- return undefined;
- }
- if (accessNode && !isTypeAssignableToKind(indexType, 4 | 8)) {
- var indexNode = getIndexNodeForAccessExpression(accessNode);
- error(indexNode, ts.Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
- return indexInfo.type;
- }
- errorIfWritingToReadonlyIndex(indexInfo);
- return indexInfo.type;
- }
- if (indexType.flags & 131072) {
- return neverType;
- }
- if (isJSLiteralType(objectType)) {
- return anyType;
+ var getterReturnType = getAnnotatedAccessorType(getter);
+ if (getterReturnType) {
+ return getterReturnType;
+ }
+ else {
+ var setterParameterType = getAnnotatedAccessorType(setter);
+ if (setterParameterType) {
+ return setterParameterType;
}
- if (accessExpression && !isConstEnumObjectType(objectType)) {
- if (objectType.symbol === globalThisSymbol && propName !== undefined && globalThisSymbol.exports.has(propName) && (globalThisSymbol.exports.get(propName).flags & 418)) {
- error(accessExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType));
+ else {
+ if (getter && getter.body) {
+ return getReturnTypeFromBody(getter);
}
- else if (noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !suppressNoImplicitAnyError) {
- if (propName !== undefined && typeHasStaticProperty(propName, objectType)) {
- error(accessExpression, ts.Diagnostics.Property_0_is_a_static_member_of_type_1, propName, typeToString(objectType));
- }
- else if (getIndexTypeOfType(objectType, 1)) {
- error(accessExpression.argumentExpression, ts.Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number);
+ else {
+ if (setter) {
+ if (!isPrivateWithinAmbient(setter)) {
+ errorOrSuggestion(noImplicitAny, setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
+ }
}
else {
- var suggestion = void 0;
- if (propName !== undefined && (suggestion = getSuggestionForNonexistentProperty(propName, objectType))) {
- if (suggestion !== undefined) {
- error(accessExpression.argumentExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(objectType), suggestion);
- }
- }
- else {
- var suggestion_1 = getSuggestionForNonexistentIndexSignature(objectType, accessExpression, indexType);
- if (suggestion_1 !== undefined) {
- error(accessExpression, ts.Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1, typeToString(objectType), suggestion_1);
- }
- else {
- var errorInfo = void 0;
- if (indexType.flags & 1024) {
- errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "[" + typeToString(indexType) + "]", typeToString(objectType));
- }
- else if (indexType.flags & 8192) {
- var symbolName_2 = getFullyQualifiedName(indexType.symbol, accessExpression);
- errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "[" + symbolName_2 + "]", typeToString(objectType));
- }
- else if (indexType.flags & 128) {
- errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType));
- }
- else if (indexType.flags & 256) {
- errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType));
- }
- else if (indexType.flags & (8 | 4)) {
- errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1, typeToString(indexType), typeToString(objectType));
- }
- errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1, typeToString(fullIndexType), typeToString(objectType));
- diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(accessExpression, errorInfo));
- }
+ ts.Debug.assert(!!getter, "there must exist a getter as we are current checking either setter or getter in this function");
+ if (!isPrivateWithinAmbient(getter)) {
+ errorOrSuggestion(noImplicitAny, getter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
}
}
+ return anyType;
}
- return undefined;
- }
- }
- if (isJSLiteralType(objectType)) {
- return anyType;
- }
- if (accessNode) {
- var indexNode = getIndexNodeForAccessExpression(accessNode);
- if (indexType.flags & (128 | 256)) {
- error(indexNode, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "" + indexType.value, typeToString(objectType));
- }
- else if (indexType.flags & (4 | 8)) {
- error(indexNode, ts.Diagnostics.Type_0_has_no_matching_index_signature_for_type_1, typeToString(objectType), typeToString(indexType));
- }
- else {
- error(indexNode, ts.Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
- }
- }
- if (isTypeAny(indexType)) {
- return indexType;
- }
- return undefined;
- function errorIfWritingToReadonlyIndex(indexInfo) {
- if (indexInfo && indexInfo.isReadonly && accessExpression && (ts.isAssignmentTarget(accessExpression) || ts.isDeleteTarget(accessExpression))) {
- error(accessExpression, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
}
}
}
- function getIndexNodeForAccessExpression(accessNode) {
- return accessNode.kind === 195 ? accessNode.argumentExpression :
- accessNode.kind === 185 ? accessNode.indexType :
- accessNode.kind === 154 ? accessNode.expression :
- accessNode;
+ function getBaseTypeVariableOfClass(symbol) {
+ var baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol));
+ return baseConstructorType.flags & 8650752 ? baseConstructorType :
+ baseConstructorType.flags & 2097152 ? ts.find(baseConstructorType.types, function (t) { return !!(t.flags & 8650752); }) :
+ undefined;
}
- function isGenericObjectType(type) {
- if (type.flags & 3145728) {
- if (!(type.objectFlags & 4194304)) {
- type.objectFlags |= 4194304 |
- (ts.some(type.types, isGenericObjectType) ? 8388608 : 0);
+ function getTypeOfFuncClassEnumModule(symbol) {
+ var links = getSymbolLinks(symbol);
+ var originalLinks = links;
+ if (!links.type) {
+ var expando = symbol.valueDeclaration && getSymbolOfExpando(symbol.valueDeclaration, false);
+ if (expando) {
+ var merged = mergeJSSymbols(symbol, expando);
+ if (merged) {
+ symbol = links = merged;
+ }
}
- return !!(type.objectFlags & 8388608);
+ originalLinks.type = links.type = getTypeOfFuncClassEnumModuleWorker(symbol);
}
- return !!(type.flags & 58982400) || isGenericMappedType(type);
+ return links.type;
}
- function isGenericIndexType(type) {
- if (type.flags & 3145728) {
- if (!(type.objectFlags & 16777216)) {
- type.objectFlags |= 16777216 |
- (ts.some(type.types, isGenericIndexType) ? 33554432 : 0);
+ function getTypeOfFuncClassEnumModuleWorker(symbol) {
+ var declaration = symbol.valueDeclaration;
+ if (symbol.flags & 1536 && ts.isShorthandAmbientModuleSymbol(symbol)) {
+ return anyType;
+ }
+ else if (declaration && (declaration.kind === 216 ||
+ ts.isAccessExpression(declaration) &&
+ declaration.parent.kind === 216)) {
+ return getWidenedTypeForAssignmentDeclaration(symbol);
+ }
+ else if (symbol.flags & 512 && declaration && ts.isSourceFile(declaration) && declaration.commonJsModuleIndicator) {
+ var resolvedModule = resolveExternalModuleSymbol(symbol);
+ if (resolvedModule !== symbol) {
+ if (!pushTypeResolution(symbol, 0)) {
+ return errorType;
+ }
+ var exportEquals = getMergedSymbol(symbol.exports.get("export="));
+ var type_2 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? undefined : resolvedModule);
+ if (!popTypeResolution()) {
+ return reportCircularityError(symbol);
+ }
+ return type_2;
}
- return !!(type.objectFlags & 33554432);
}
- return !!(type.flags & (58982400 | 4194304));
- }
- function isThisTypeParameter(type) {
- return !!(type.flags & 262144 && type.isThisType);
+ var type = createObjectType(16, symbol);
+ if (symbol.flags & 32) {
+ var baseTypeVariable = getBaseTypeVariableOfClass(symbol);
+ return baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type;
+ }
+ else {
+ return strictNullChecks && symbol.flags & 16777216 ? getOptionalType(type) : type;
+ }
}
- function getSimplifiedType(type, writing) {
- return type.flags & 8388608 ? getSimplifiedIndexedAccessType(type, writing) :
- type.flags & 16777216 ? getSimplifiedConditionalType(type, writing) :
- type;
+ function getTypeOfEnumMember(symbol) {
+ var links = getSymbolLinks(symbol);
+ return links.type || (links.type = getDeclaredTypeOfEnumMember(symbol));
}
- function distributeIndexOverObjectType(objectType, indexType, writing) {
- if (objectType.flags & 3145728) {
- var types = ts.map(objectType.types, function (t) { return getSimplifiedType(getIndexedAccessType(t, indexType), writing); });
- return objectType.flags & 2097152 || writing ? getIntersectionType(types) : getUnionType(types);
+ function getTypeOfAlias(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (!links.type) {
+ var targetSymbol = resolveAlias(symbol);
+ links.type = targetSymbol.flags & 111551
+ ? getTypeOfSymbol(targetSymbol)
+ : errorType;
}
+ return links.type;
}
- function distributeObjectOverIndexType(objectType, indexType, writing) {
- if (indexType.flags & 1048576) {
- var types = ts.map(indexType.types, function (t) { return getSimplifiedType(getIndexedAccessType(objectType, t), writing); });
- return writing ? getIntersectionType(types) : getUnionType(types);
+ function getTypeOfInstantiatedSymbol(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (!links.type) {
+ if (!pushTypeResolution(symbol, 0)) {
+ return links.type = errorType;
+ }
+ var type = instantiateType(getTypeOfSymbol(links.target), links.mapper);
+ if (!popTypeResolution()) {
+ type = reportCircularityError(symbol);
+ }
+ links.type = type;
}
+ return links.type;
}
- function unwrapSubstitution(type) {
- if (type.flags & 33554432) {
- return type.substitute;
+ function reportCircularityError(symbol) {
+ var declaration = symbol.valueDeclaration;
+ if (ts.getEffectiveTypeAnnotationNode(declaration)) {
+ error(symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+ return errorType;
}
- return type;
+ if (noImplicitAny && (declaration.kind !== 160 || declaration.initializer)) {
+ error(symbol.valueDeclaration, ts.Diagnostics._0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer, symbolToString(symbol));
+ }
+ return anyType;
}
- function getSimplifiedIndexedAccessType(type, writing) {
- var cache = writing ? "simplifiedForWriting" : "simplifiedForReading";
- if (type[cache]) {
- return type[cache] === circularConstraintType ? type : type[cache];
+ function getTypeOfSymbolWithDeferredType(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (!links.type) {
+ ts.Debug.assertIsDefined(links.deferralParent);
+ ts.Debug.assertIsDefined(links.deferralConstituents);
+ links.type = links.deferralParent.flags & 1048576 ? getUnionType(links.deferralConstituents) : getIntersectionType(links.deferralConstituents);
}
- type[cache] = circularConstraintType;
- var objectType = unwrapSubstitution(getSimplifiedType(type.objectType, writing));
- var indexType = getSimplifiedType(type.indexType, writing);
- var distributedOverIndex = distributeObjectOverIndexType(objectType, indexType, writing);
- if (distributedOverIndex) {
- return type[cache] = distributedOverIndex;
+ return links.type;
+ }
+ function getTypeOfSymbol(symbol) {
+ var checkFlags = ts.getCheckFlags(symbol);
+ if (checkFlags & 65536) {
+ return getTypeOfSymbolWithDeferredType(symbol);
}
- if (!(indexType.flags & 63176704)) {
- var distributedOverObject = distributeIndexOverObjectType(objectType, indexType, writing);
- if (distributedOverObject) {
- return type[cache] = distributedOverObject;
- }
+ if (checkFlags & 1) {
+ return getTypeOfInstantiatedSymbol(symbol);
}
- if (isGenericMappedType(objectType)) {
- return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+ if (checkFlags & 262144) {
+ return getTypeOfMappedSymbol(symbol);
}
- return type[cache] = type;
- }
- function getSimplifiedConditionalType(type, writing) {
- var checkType = type.checkType;
- var extendsType = type.extendsType;
- var trueType = getTrueTypeFromConditionalType(type);
- var falseType = getFalseTypeFromConditionalType(type);
- if (falseType.flags & 131072 && getActualTypeVariable(trueType) === getActualTypeVariable(checkType)) {
- if (checkType.flags & 1 || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {
- return getSimplifiedType(trueType, writing);
- }
- else if (isIntersectionEmpty(checkType, extendsType)) {
- return neverType;
- }
+ if (checkFlags & 8192) {
+ return getTypeOfReverseMappedSymbol(symbol);
}
- else if (trueType.flags & 131072 && getActualTypeVariable(falseType) === getActualTypeVariable(checkType)) {
- if (!(checkType.flags & 1) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {
- return neverType;
- }
- else if (checkType.flags & 1 || isIntersectionEmpty(checkType, extendsType)) {
- return getSimplifiedType(falseType, writing);
- }
+ if (symbol.flags & (3 | 4)) {
+ return getTypeOfVariableOrParameterOrProperty(symbol);
}
- return type;
- }
- function isIntersectionEmpty(type1, type2) {
- return !!(getUnionType([intersectTypes(type1, type2), neverType]).flags & 131072);
- }
- function substituteIndexedMappedType(objectType, index) {
- var mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
- var templateMapper = combineTypeMappers(objectType.mapper, mapper);
- return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper);
- }
- function getIndexedAccessType(objectType, indexType, accessNode) {
- return getIndexedAccessTypeOrUndefined(objectType, indexType, accessNode, 0) || (accessNode ? errorType : unknownType);
- }
- function getIndexedAccessTypeOrUndefined(objectType, indexType, accessNode, accessFlags) {
- if (accessFlags === void 0) { accessFlags = 0; }
- if (objectType === wildcardType || indexType === wildcardType) {
- return wildcardType;
+ if (symbol.flags & (16 | 8192 | 32 | 384 | 512)) {
+ return getTypeOfFuncClassEnumModule(symbol);
}
- if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304) && isTypeAssignableToKind(indexType, 4 | 8)) {
- indexType = stringType;
+ if (symbol.flags & 8) {
+ return getTypeOfEnumMember(symbol);
}
- if (isGenericIndexType(indexType) || !(accessNode && accessNode.kind !== 185) && isGenericObjectType(objectType)) {
- if (objectType.flags & 3) {
- return objectType;
- }
- var id = objectType.id + "," + indexType.id;
- var type = indexedAccessTypes.get(id);
- if (!type) {
- indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType));
- }
- return type;
+ if (symbol.flags & 98304) {
+ return getTypeOfAccessors(symbol);
}
- var apparentObjectType = getReducedApparentType(objectType);
- if (indexType.flags & 1048576 && !(indexType.flags & 16)) {
- var propTypes = [];
- var wasMissingProp = false;
- for (var _i = 0, _a = indexType.types; _i < _a.length; _i++) {
- var t = _a[_i];
- var propType = getPropertyTypeForIndexType(objectType, apparentObjectType, t, indexType, wasMissingProp, accessNode, accessFlags);
- if (propType) {
- propTypes.push(propType);
- }
- else if (!accessNode) {
- return undefined;
- }
- else {
- wasMissingProp = true;
- }
- }
- if (wasMissingProp) {
- return undefined;
- }
- return accessFlags & 2 ? getIntersectionType(propTypes) : getUnionType(propTypes);
+ if (symbol.flags & 2097152) {
+ return getTypeOfAlias(symbol);
}
- return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, false, accessNode, accessFlags | 4);
+ return errorType;
}
- function getTypeFromIndexedAccessTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- var objectType = getTypeFromTypeNode(node.objectType);
- var indexType = getTypeFromTypeNode(node.indexType);
- var resolved = getIndexedAccessType(objectType, indexType, node);
- links.resolvedType = resolved.flags & 8388608 &&
- resolved.objectType === objectType &&
- resolved.indexType === indexType ?
- getConditionalFlowTypeOfType(resolved, node) : resolved;
- }
- return links.resolvedType;
+ function isReferenceToType(type, target) {
+ return type !== undefined
+ && target !== undefined
+ && (ts.getObjectFlags(type) & 4) !== 0
+ && type.target === target;
}
- function getTypeFromMappedTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- var type = createObjectType(32, node.symbol);
- type.declaration = node;
- type.aliasSymbol = getAliasSymbolForTypeNode(node);
- type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(type.aliasSymbol);
- links.resolvedType = type;
- getConstraintTypeFromMappedType(type);
- }
- return links.resolvedType;
+ function getTargetType(type) {
+ return ts.getObjectFlags(type) & 4 ? type.target : type;
}
- function getActualTypeVariable(type) {
- if (type.flags & 33554432) {
- return type.baseType;
+ function hasBaseType(type, checkBase) {
+ return check(type);
+ function check(type) {
+ if (ts.getObjectFlags(type) & (3 | 4)) {
+ var target = getTargetType(type);
+ return target === checkBase || ts.some(getBaseTypes(target), check);
+ }
+ else if (type.flags & 2097152) {
+ return ts.some(type.types, check);
+ }
+ return false;
}
- if (type.flags & 8388608 && (type.objectType.flags & 33554432 ||
- type.indexType.flags & 33554432)) {
- return getIndexedAccessType(getActualTypeVariable(type.objectType), getActualTypeVariable(type.indexType));
+ }
+ function appendTypeParameters(typeParameters, declarations) {
+ for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) {
+ var declaration = declarations_2[_i];
+ typeParameters = ts.appendIfUnique(typeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration)));
}
- return type;
+ return typeParameters;
}
- function getConditionalType(root, mapper) {
- var result;
- var extraTypes;
- var _loop_12 = function () {
- var checkType = instantiateType(root.checkType, mapper);
- var checkTypeInstantiable = isGenericObjectType(checkType) || isGenericIndexType(checkType);
- var extendsType = instantiateType(root.extendsType, mapper);
- if (checkType === wildcardType || extendsType === wildcardType) {
- return { value: wildcardType };
- }
- var combinedMapper = void 0;
- if (root.inferTypeParameters) {
- var context = createInferenceContext(root.inferTypeParameters, undefined, 0);
- if (!checkTypeInstantiable || !ts.some(root.inferTypeParameters, function (t) { return t === extendsType; })) {
- inferTypes(context.inferences, checkType, extendsType, 128 | 256);
+ function getOuterTypeParameters(node, includeThisTypes) {
+ while (true) {
+ node = node.parent;
+ if (node && ts.isBinaryExpression(node)) {
+ var assignmentKind = ts.getAssignmentDeclarationKind(node);
+ if (assignmentKind === 6 || assignmentKind === 3) {
+ var symbol = getSymbolOfNode(node.left);
+ if (symbol && symbol.parent && !ts.findAncestor(symbol.parent.valueDeclaration, function (d) { return node === d; })) {
+ node = symbol.parent.valueDeclaration;
+ }
}
- combinedMapper = mergeTypeMappers(mapper, context.mapper);
}
- var inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
- if (!checkTypeInstantiable && !isGenericObjectType(inferredExtendsType) && !isGenericIndexType(inferredExtendsType)) {
- if (!(inferredExtendsType.flags & 3) && (checkType.flags & 1 || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
- if (checkType.flags & 1) {
- (extraTypes || (extraTypes = [])).push(instantiateTypeWithoutDepthIncrease(root.trueType, combinedMapper || mapper));
+ if (!node) {
+ return undefined;
+ }
+ switch (node.kind) {
+ case 232:
+ case 252:
+ case 221:
+ case 253:
+ case 169:
+ case 170:
+ case 164:
+ case 174:
+ case 175:
+ case 308:
+ case 251:
+ case 165:
+ case 208:
+ case 209:
+ case 254:
+ case 330:
+ case 331:
+ case 325:
+ case 324:
+ case 190:
+ case 184:
+ var outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
+ if (node.kind === 190) {
+ return ts.append(outerTypeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter)));
}
- var falseType_1 = root.falseType;
- if (falseType_1.flags & 16777216) {
- var newRoot = falseType_1.root;
- if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
- root = newRoot;
- return "continue";
- }
+ else if (node.kind === 184) {
+ return ts.concatenate(outerTypeParameters, getInferTypeParameters(node));
}
- result = instantiateTypeWithoutDepthIncrease(falseType_1, mapper);
- return "break";
- }
- if (inferredExtendsType.flags & 3 || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
- result = instantiateTypeWithoutDepthIncrease(root.trueType, combinedMapper || mapper);
- return "break";
- }
+ else if (node.kind === 232 && !ts.isInJSFile(node)) {
+ break;
+ }
+ var outerAndOwnTypeParameters = appendTypeParameters(outerTypeParameters, ts.getEffectiveTypeParameterDeclarations(node));
+ var thisType = includeThisTypes &&
+ (node.kind === 252 || node.kind === 221 || node.kind === 253 || isJSConstructor(node)) &&
+ getDeclaredTypeOfClassOrInterface(getSymbolOfNode(node)).thisType;
+ return thisType ? ts.append(outerAndOwnTypeParameters, thisType) : outerAndOwnTypeParameters;
+ case 326:
+ var paramSymbol = ts.getParameterSymbolFromJSDoc(node);
+ if (paramSymbol) {
+ node = paramSymbol.valueDeclaration;
+ }
+ break;
}
- var erasedCheckType = getActualTypeVariable(checkType);
- result = createType(16777216);
- result.root = root;
- result.checkType = erasedCheckType;
- result.extendsType = extendsType;
- result.mapper = mapper;
- result.combinedMapper = combinedMapper;
- result.aliasSymbol = root.aliasSymbol;
- result.aliasTypeArguments = instantiateTypes(root.aliasTypeArguments, mapper);
- return "break";
- };
- while (true) {
- var state_4 = _loop_12();
- if (typeof state_4 === "object")
- return state_4.value;
- if (state_4 === "break")
- break;
}
- return extraTypes ? getUnionType(ts.append(extraTypes, result)) : result;
- }
- function getTrueTypeFromConditionalType(type) {
- return type.resolvedTrueType || (type.resolvedTrueType = instantiateType(type.root.trueType, type.mapper));
}
- function getFalseTypeFromConditionalType(type) {
- return type.resolvedFalseType || (type.resolvedFalseType = instantiateType(type.root.falseType, type.mapper));
- }
- function getInferredTrueTypeFromConditionalType(type) {
- return type.resolvedInferredTrueType || (type.resolvedInferredTrueType = type.combinedMapper ? instantiateType(type.root.trueType, type.combinedMapper) : getTrueTypeFromConditionalType(type));
+ function getOuterTypeParametersOfClassOrInterface(symbol) {
+ var declaration = symbol.flags & 32 ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 253);
+ ts.Debug.assert(!!declaration, "Class was missing valueDeclaration -OR- non-class had no interface declarations");
+ return getOuterTypeParameters(declaration);
}
- function getInferTypeParameters(node) {
+ function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) {
var result;
- if (node.locals) {
- node.locals.forEach(function (symbol) {
- if (symbol.flags & 262144) {
- result = ts.append(result, getDeclaredTypeOfSymbol(symbol));
- }
- });
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var node = _a[_i];
+ if (node.kind === 253 ||
+ node.kind === 252 ||
+ node.kind === 221 ||
+ isJSConstructor(node) ||
+ ts.isTypeAlias(node)) {
+ var declaration = node;
+ result = appendTypeParameters(result, ts.getEffectiveTypeParameterDeclarations(declaration));
+ }
}
return result;
}
- function getTypeFromConditionalTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- var checkType = getTypeFromTypeNode(node.checkType);
- var aliasSymbol = getAliasSymbolForTypeNode(node);
- var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
- var allOuterTypeParameters = getOuterTypeParameters(node, true);
- var outerTypeParameters = aliasTypeArguments ? allOuterTypeParameters : ts.filter(allOuterTypeParameters, function (tp) { return isTypeParameterPossiblyReferenced(tp, node); });
- var root = {
- node: node,
- checkType: checkType,
- extendsType: getTypeFromTypeNode(node.extendsType),
- trueType: getTypeFromTypeNode(node.trueType),
- falseType: getTypeFromTypeNode(node.falseType),
- isDistributive: !!(checkType.flags & 262144),
- inferTypeParameters: getInferTypeParameters(node),
- outerTypeParameters: outerTypeParameters,
- instantiations: undefined,
- aliasSymbol: aliasSymbol,
- aliasTypeArguments: aliasTypeArguments
- };
- links.resolvedType = getConditionalType(root, undefined);
- if (outerTypeParameters) {
- root.instantiations = ts.createMap();
- root.instantiations.set(getTypeListId(outerTypeParameters), links.resolvedType);
- }
- }
- return links.resolvedType;
+ function getTypeParametersOfClassOrInterface(symbol) {
+ return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol));
}
- function getTypeFromInferTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- links.resolvedType = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter));
+ function isMixinConstructorType(type) {
+ var signatures = getSignaturesOfType(type, 1);
+ if (signatures.length === 1) {
+ var s = signatures[0];
+ return !s.typeParameters && s.parameters.length === 1 && signatureHasRestParameter(s) && getElementTypeOfArrayType(getTypeOfParameter(s.parameters[0])) === anyType;
}
- return links.resolvedType;
+ return false;
}
- function getIdentifierChain(node) {
- if (ts.isIdentifier(node)) {
- return [node];
+ function isConstructorType(type) {
+ if (getSignaturesOfType(type, 1).length > 0) {
+ return true;
}
- else {
- return ts.append(getIdentifierChain(node.left), node.right);
+ if (type.flags & 8650752) {
+ var constraint = getBaseConstraintOfType(type);
+ return !!constraint && isMixinConstructorType(constraint);
}
+ return false;
}
- function getTypeFromImportTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- if (node.isTypeOf && node.typeArguments) {
- error(node, ts.Diagnostics.Type_arguments_cannot_be_used_here);
- links.resolvedSymbol = unknownSymbol;
- return links.resolvedType = errorType;
+ function getBaseTypeNodeOfClass(type) {
+ return ts.getEffectiveBaseTypeNode(type.symbol.valueDeclaration);
+ }
+ function getConstructorsForTypeArguments(type, typeArgumentNodes, location) {
+ var typeArgCount = ts.length(typeArgumentNodes);
+ var isJavascript = ts.isInJSFile(location);
+ return ts.filter(getSignaturesOfType(type, 1), function (sig) { return (isJavascript || typeArgCount >= getMinTypeArgumentCount(sig.typeParameters)) && typeArgCount <= ts.length(sig.typeParameters); });
+ }
+ function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes, location) {
+ var signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location);
+ var typeArguments = ts.map(typeArgumentNodes, getTypeFromTypeNode);
+ return ts.sameMap(signatures, function (sig) { return ts.some(sig.typeParameters) ? getSignatureInstantiation(sig, typeArguments, ts.isInJSFile(location)) : sig; });
+ }
+ function getBaseConstructorTypeOfClass(type) {
+ if (!type.resolvedBaseConstructorType) {
+ var decl = type.symbol.valueDeclaration;
+ var extended = ts.getEffectiveBaseTypeNode(decl);
+ var baseTypeNode = getBaseTypeNodeOfClass(type);
+ if (!baseTypeNode) {
+ return type.resolvedBaseConstructorType = undefinedType;
}
- if (!ts.isLiteralImportTypeNode(node)) {
- error(node.argument, ts.Diagnostics.String_literal_expected);
- links.resolvedSymbol = unknownSymbol;
- return links.resolvedType = errorType;
+ if (!pushTypeResolution(type, 1)) {
+ return errorType;
}
- var targetMeaning = node.isTypeOf ? 111551 : node.flags & 4194304 ? 111551 | 788968 : 788968;
- var innerModuleSymbol = resolveExternalModuleName(node, node.argument.literal);
- if (!innerModuleSymbol) {
- links.resolvedSymbol = unknownSymbol;
- return links.resolvedType = errorType;
+ var baseConstructorType = checkExpression(baseTypeNode.expression);
+ if (extended && baseTypeNode !== extended) {
+ ts.Debug.assert(!extended.typeArguments);
+ checkExpression(extended.expression);
}
- var moduleSymbol = resolveExternalModuleSymbol(innerModuleSymbol, false);
- if (!ts.nodeIsMissing(node.qualifier)) {
- var nameStack = getIdentifierChain(node.qualifier);
- var currentNamespace = moduleSymbol;
- var current = void 0;
- while (current = nameStack.shift()) {
- var meaning = nameStack.length ? 1920 : targetMeaning;
- var next = getSymbol(getExportsOfSymbol(getMergedSymbol(resolveSymbol(currentNamespace))), current.escapedText, meaning);
- if (!next) {
- error(current, ts.Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(currentNamespace), ts.declarationNameToString(current));
- return links.resolvedType = errorType;
- }
- getNodeLinks(current).resolvedSymbol = next;
- getNodeLinks(current.parent).resolvedSymbol = next;
- currentNamespace = next;
- }
- links.resolvedType = resolveImportSymbolType(node, links, currentNamespace, targetMeaning);
+ if (baseConstructorType.flags & (524288 | 2097152)) {
+ resolveStructuredTypeMembers(baseConstructorType);
}
- else {
- if (moduleSymbol.flags & targetMeaning) {
- links.resolvedType = resolveImportSymbolType(node, links, moduleSymbol, targetMeaning);
- }
- else {
- var errorMessage = targetMeaning === 111551
- ? ts.Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here
- : ts.Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0;
- error(node, errorMessage, node.argument.literal.text);
- links.resolvedSymbol = unknownSymbol;
- links.resolvedType = errorType;
+ if (!popTypeResolution()) {
+ error(type.symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol));
+ return type.resolvedBaseConstructorType = errorType;
+ }
+ if (!(baseConstructorType.flags & 1) && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) {
+ var err = error(baseTypeNode.expression, ts.Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType));
+ if (baseConstructorType.flags & 262144) {
+ var constraint = getConstraintFromTypeParameter(baseConstructorType);
+ var ctorReturn = unknownType;
+ if (constraint) {
+ var ctorSig = getSignaturesOfType(constraint, 1);
+ if (ctorSig[0]) {
+ ctorReturn = getReturnTypeOfSignature(ctorSig[0]);
+ }
+ }
+ ts.addRelatedInfo(err, ts.createDiagnosticForNode(baseConstructorType.symbol.declarations[0], ts.Diagnostics.Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1, symbolToString(baseConstructorType.symbol), typeToString(ctorReturn)));
}
+ return type.resolvedBaseConstructorType = errorType;
}
+ type.resolvedBaseConstructorType = baseConstructorType;
}
- return links.resolvedType;
- }
- function resolveImportSymbolType(node, links, symbol, meaning) {
- var resolvedSymbol = resolveSymbol(symbol);
- links.resolvedSymbol = resolvedSymbol;
- if (meaning === 111551) {
- return getTypeOfSymbol(symbol);
- }
- else {
- return getTypeReferenceType(node, resolvedSymbol);
- }
+ return type.resolvedBaseConstructorType;
}
- function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- var aliasSymbol = getAliasSymbolForTypeNode(node);
- if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) {
- links.resolvedType = emptyTypeLiteralType;
- }
- else {
- var type = createObjectType(16, node.symbol);
- type.aliasSymbol = aliasSymbol;
- type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
- if (ts.isJSDocTypeLiteral(node) && node.isArrayType) {
- type = createArrayType(type);
+ function getImplementsTypes(type) {
+ var resolvedImplementsTypes = ts.emptyArray;
+ for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ var implementsTypeNodes = ts.getEffectiveImplementsTypeNodes(declaration);
+ if (!implementsTypeNodes)
+ continue;
+ for (var _b = 0, implementsTypeNodes_1 = implementsTypeNodes; _b < implementsTypeNodes_1.length; _b++) {
+ var node = implementsTypeNodes_1[_b];
+ var implementsType = getTypeFromTypeNode(node);
+ if (implementsType !== errorType) {
+ if (resolvedImplementsTypes === ts.emptyArray) {
+ resolvedImplementsTypes = [implementsType];
+ }
+ else {
+ resolvedImplementsTypes.push(implementsType);
+ }
}
- links.resolvedType = type;
}
}
- return links.resolvedType;
- }
- function getAliasSymbolForTypeNode(node) {
- var host = node.parent;
- while (ts.isParenthesizedTypeNode(host) || ts.isTypeOperatorNode(host) && host.operator === 138) {
- host = host.parent;
- }
- return ts.isTypeAlias(host) ? getSymbolOfNode(host) : undefined;
- }
- function getTypeArgumentsForAliasSymbol(symbol) {
- return symbol ? getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) : undefined;
- }
- function isNonGenericObjectType(type) {
- return !!(type.flags & 524288) && !isGenericMappedType(type);
- }
- function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type) {
- return isEmptyObjectType(type) || !!(type.flags & (65536 | 32768 | 528 | 296 | 2112 | 132 | 1056 | 67108864 | 4194304));
+ return resolvedImplementsTypes;
}
- function isSinglePropertyAnonymousObjectType(type) {
- return !!(type.flags & 524288) &&
- !!(ts.getObjectFlags(type) & 16) &&
- (ts.length(getPropertiesOfType(type)) === 1 || ts.every(getPropertiesOfType(type), function (p) { return !!(p.flags & 16777216); }));
+ function reportCircularBaseType(node, type) {
+ error(node, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 2));
}
- function tryMergeUnionOfObjectTypeAndEmptyObject(type, readonly) {
- if (type.types.length === 2) {
- var firstType = type.types[0];
- var secondType = type.types[1];
- if (ts.every(type.types, isEmptyObjectTypeOrSpreadsIntoEmptyObject)) {
- return isEmptyObjectType(firstType) ? firstType : isEmptyObjectType(secondType) ? secondType : emptyObjectType;
- }
- if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(firstType) && isSinglePropertyAnonymousObjectType(secondType)) {
- return getAnonymousPartialType(secondType);
- }
- if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(secondType) && isSinglePropertyAnonymousObjectType(firstType)) {
- return getAnonymousPartialType(firstType);
- }
- }
- function getAnonymousPartialType(type) {
- var members = ts.createSymbolTable();
- for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) {
- var prop = _a[_i];
- if (ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 | 16)) {
+ function getBaseTypes(type) {
+ if (!type.baseTypesResolved) {
+ if (pushTypeResolution(type, 7)) {
+ if (type.objectFlags & 8) {
+ type.resolvedBaseTypes = [getTupleBaseType(type)];
}
- else if (isSpreadableProperty(prop)) {
- var isSetonlyAccessor = prop.flags & 65536 && !(prop.flags & 32768);
- var flags = 4 | 16777216;
- var result = createSymbol(flags, prop.escapedName, readonly ? 8 : 0);
- result.type = isSetonlyAccessor ? undefinedType : getTypeOfSymbol(prop);
- result.declarations = prop.declarations;
- result.nameType = getSymbolLinks(prop).nameType;
- result.syntheticOrigin = prop;
- members.set(prop.escapedName, result);
+ else if (type.symbol.flags & (32 | 64)) {
+ if (type.symbol.flags & 32) {
+ resolveBaseTypesOfClass(type);
+ }
+ if (type.symbol.flags & 64) {
+ resolveBaseTypesOfInterface(type);
+ }
+ }
+ else {
+ ts.Debug.fail("type must be class or interface");
+ }
+ if (!popTypeResolution()) {
+ for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ if (declaration.kind === 252 || declaration.kind === 253) {
+ reportCircularBaseType(declaration, type);
+ }
+ }
}
}
- var spread = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, getIndexInfoOfType(type, 0), getIndexInfoOfType(type, 1));
- spread.objectFlags |= 128 | 1048576;
- return spread;
+ type.baseTypesResolved = true;
}
+ return type.resolvedBaseTypes;
}
- function getSpreadType(left, right, symbol, objectFlags, readonly) {
- if (left.flags & 1 || right.flags & 1) {
- return anyType;
- }
- if (left.flags & 2 || right.flags & 2) {
- return unknownType;
+ function getTupleBaseType(type) {
+ var elementTypes = ts.sameMap(type.typeParameters, function (t, i) { return type.elementFlags[i] & 8 ? getIndexedAccessType(t, numberType) : t; });
+ return createArrayType(getUnionType(elementTypes || ts.emptyArray), type.readonly);
+ }
+ function resolveBaseTypesOfClass(type) {
+ type.resolvedBaseTypes = ts.resolvingEmptyArray;
+ var baseConstructorType = getApparentType(getBaseConstructorTypeOfClass(type));
+ if (!(baseConstructorType.flags & (524288 | 2097152 | 1))) {
+ return type.resolvedBaseTypes = ts.emptyArray;
}
- if (left.flags & 131072) {
- return right;
+ var baseTypeNode = getBaseTypeNodeOfClass(type);
+ var baseType;
+ var originalBaseType = baseConstructorType.symbol ? getDeclaredTypeOfSymbol(baseConstructorType.symbol) : undefined;
+ if (baseConstructorType.symbol && baseConstructorType.symbol.flags & 32 &&
+ areAllOuterTypeParametersApplied(originalBaseType)) {
+ baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol);
}
- if (right.flags & 131072) {
- return left;
+ else if (baseConstructorType.flags & 1) {
+ baseType = baseConstructorType;
}
- if (left.flags & 1048576) {
- var merged = tryMergeUnionOfObjectTypeAndEmptyObject(left, readonly);
- if (merged) {
- return getSpreadType(merged, right, symbol, objectFlags, readonly);
+ else {
+ var constructors = getInstantiatedConstructorsForTypeArguments(baseConstructorType, baseTypeNode.typeArguments, baseTypeNode);
+ if (!constructors.length) {
+ error(baseTypeNode.expression, ts.Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments);
+ return type.resolvedBaseTypes = ts.emptyArray;
}
- return mapType(left, function (t) { return getSpreadType(t, right, symbol, objectFlags, readonly); });
+ baseType = getReturnTypeOfSignature(constructors[0]);
}
- if (right.flags & 1048576) {
- var merged = tryMergeUnionOfObjectTypeAndEmptyObject(right, readonly);
- if (merged) {
- return getSpreadType(left, merged, symbol, objectFlags, readonly);
- }
- return mapType(right, function (t) { return getSpreadType(left, t, symbol, objectFlags, readonly); });
+ if (baseType === errorType) {
+ return type.resolvedBaseTypes = ts.emptyArray;
}
- if (right.flags & (528 | 296 | 2112 | 132 | 1056 | 67108864 | 4194304)) {
- return left;
+ var reducedBaseType = getReducedType(baseType);
+ if (!isValidBaseType(reducedBaseType)) {
+ var elaboration = elaborateNeverIntersection(undefined, baseType);
+ var diagnostic = ts.chainDiagnosticMessages(elaboration, ts.Diagnostics.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members, typeToString(reducedBaseType));
+ diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(baseTypeNode.expression, diagnostic));
+ return type.resolvedBaseTypes = ts.emptyArray;
}
- if (isGenericObjectType(left) || isGenericObjectType(right)) {
- if (isEmptyObjectType(left)) {
- return right;
+ if (type === reducedBaseType || hasBaseType(reducedBaseType, type)) {
+ error(type.symbol.valueDeclaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 2));
+ return type.resolvedBaseTypes = ts.emptyArray;
+ }
+ if (type.resolvedBaseTypes === ts.resolvingEmptyArray) {
+ type.members = undefined;
+ }
+ return type.resolvedBaseTypes = [reducedBaseType];
+ }
+ function areAllOuterTypeParametersApplied(type) {
+ var outerTypeParameters = type.outerTypeParameters;
+ if (outerTypeParameters) {
+ var last_1 = outerTypeParameters.length - 1;
+ var typeArguments = getTypeArguments(type);
+ return outerTypeParameters[last_1].symbol !== typeArguments[last_1].symbol;
+ }
+ return true;
+ }
+ function isValidBaseType(type) {
+ if (type.flags & 262144) {
+ var constraint = getBaseConstraintOfType(type);
+ if (constraint) {
+ return isValidBaseType(constraint);
}
- if (left.flags & 2097152) {
- var types = left.types;
- var lastLeft = types[types.length - 1];
- if (isNonGenericObjectType(lastLeft) && isNonGenericObjectType(right)) {
- return getIntersectionType(ts.concatenate(types.slice(0, types.length - 1), [getSpreadType(lastLeft, right, symbol, objectFlags, readonly)]));
+ }
+ return !!(type.flags & (524288 | 67108864 | 1) && !isGenericMappedType(type) ||
+ type.flags & 2097152 && ts.every(type.types, isValidBaseType));
+ }
+ function resolveBaseTypesOfInterface(type) {
+ type.resolvedBaseTypes = type.resolvedBaseTypes || ts.emptyArray;
+ for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ if (declaration.kind === 253 && ts.getInterfaceBaseTypeNodes(declaration)) {
+ for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) {
+ var node = _c[_b];
+ var baseType = getReducedType(getTypeFromTypeNode(node));
+ if (baseType !== errorType) {
+ if (isValidBaseType(baseType)) {
+ if (type !== baseType && !hasBaseType(baseType, type)) {
+ if (type.resolvedBaseTypes === ts.emptyArray) {
+ type.resolvedBaseTypes = [baseType];
+ }
+ else {
+ type.resolvedBaseTypes.push(baseType);
+ }
+ }
+ else {
+ reportCircularBaseType(declaration, type);
+ }
+ }
+ else {
+ error(node, ts.Diagnostics.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members);
+ }
+ }
}
}
- return getIntersectionType([left, right]);
- }
- var members = ts.createSymbolTable();
- var skippedPrivateMembers = ts.createUnderscoreEscapedMap();
- var stringIndexInfo;
- var numberIndexInfo;
- if (left === emptyObjectType) {
- stringIndexInfo = getIndexInfoOfType(right, 0);
- numberIndexInfo = getIndexInfoOfType(right, 1);
}
- else {
- stringIndexInfo = unionSpreadIndexInfos(getIndexInfoOfType(left, 0), getIndexInfoOfType(right, 0));
- numberIndexInfo = unionSpreadIndexInfos(getIndexInfoOfType(left, 1), getIndexInfoOfType(right, 1));
+ }
+ function isThislessInterface(symbol) {
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ if (declaration.kind === 253) {
+ if (declaration.flags & 128) {
+ return false;
+ }
+ var baseTypeNodes = ts.getInterfaceBaseTypeNodes(declaration);
+ if (baseTypeNodes) {
+ for (var _b = 0, baseTypeNodes_1 = baseTypeNodes; _b < baseTypeNodes_1.length; _b++) {
+ var node = baseTypeNodes_1[_b];
+ if (ts.isEntityNameExpression(node.expression)) {
+ var baseSymbol = resolveEntityName(node.expression, 788968, true);
+ if (!baseSymbol || !(baseSymbol.flags & 64) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
+ return false;
+ }
+ }
+ }
+ }
+ }
}
- for (var _i = 0, _a = getPropertiesOfType(right); _i < _a.length; _i++) {
- var rightProp = _a[_i];
- if (ts.getDeclarationModifierFlagsFromSymbol(rightProp) & (8 | 16)) {
- skippedPrivateMembers.set(rightProp.escapedName, true);
+ return true;
+ }
+ function getDeclaredTypeOfClassOrInterface(symbol) {
+ var links = getSymbolLinks(symbol);
+ var originalLinks = links;
+ if (!links.declaredType) {
+ var kind = symbol.flags & 32 ? 1 : 2;
+ var merged = mergeJSSymbols(symbol, getAssignedClassSymbol(symbol.valueDeclaration));
+ if (merged) {
+ symbol = links = merged;
}
- else if (isSpreadableProperty(rightProp)) {
- members.set(rightProp.escapedName, getSpreadSymbol(rightProp, readonly));
+ var type = originalLinks.declaredType = links.declaredType = createObjectType(kind, symbol);
+ var outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol);
+ var localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
+ if (outerTypeParameters || localTypeParameters || kind === 1 || !isThislessInterface(symbol)) {
+ type.objectFlags |= 4;
+ type.typeParameters = ts.concatenate(outerTypeParameters, localTypeParameters);
+ type.outerTypeParameters = outerTypeParameters;
+ type.localTypeParameters = localTypeParameters;
+ type.instantiations = new ts.Map();
+ type.instantiations.set(getTypeListId(type.typeParameters), type);
+ type.target = type;
+ type.resolvedTypeArguments = type.typeParameters;
+ type.thisType = createTypeParameter(symbol);
+ type.thisType.isThisType = true;
+ type.thisType.constraint = type;
}
}
- for (var _b = 0, _c = getPropertiesOfType(left); _b < _c.length; _b++) {
- var leftProp = _c[_b];
- if (skippedPrivateMembers.has(leftProp.escapedName) || !isSpreadableProperty(leftProp)) {
- continue;
+ return links.declaredType;
+ }
+ function getDeclaredTypeOfTypeAlias(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (!links.declaredType) {
+ if (!pushTypeResolution(symbol, 2)) {
+ return errorType;
}
- if (members.has(leftProp.escapedName)) {
- var rightProp = members.get(leftProp.escapedName);
- var rightType = getTypeOfSymbol(rightProp);
- if (rightProp.flags & 16777216) {
- var declarations = ts.concatenate(leftProp.declarations, rightProp.declarations);
- var flags = 4 | (leftProp.flags & 16777216);
- var result = createSymbol(flags, leftProp.escapedName);
- result.type = getUnionType([getTypeOfSymbol(leftProp), getTypeWithFacts(rightType, 524288)]);
- result.leftSpread = leftProp;
- result.rightSpread = rightProp;
- result.declarations = declarations;
- result.nameType = getSymbolLinks(leftProp).nameType;
- members.set(leftProp.escapedName, result);
+ var declaration = ts.Debug.checkDefined(ts.find(symbol.declarations, ts.isTypeAlias), "Type alias symbol with no valid declaration found");
+ var typeNode = ts.isJSDocTypeAlias(declaration) ? declaration.typeExpression : declaration.type;
+ var type = typeNode ? getTypeFromTypeNode(typeNode) : errorType;
+ if (popTypeResolution()) {
+ var typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
+ if (typeParameters) {
+ links.typeParameters = typeParameters;
+ links.instantiations = new ts.Map();
+ links.instantiations.set(getTypeListId(typeParameters), type);
}
}
else {
- members.set(leftProp.escapedName, getSpreadSymbol(leftProp, readonly));
+ type = errorType;
+ error(ts.isNamedDeclaration(declaration) ? declaration.name : declaration || declaration, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
}
+ links.declaredType = type;
}
- var spread = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, getIndexInfoWithReadonly(stringIndexInfo, readonly), getIndexInfoWithReadonly(numberIndexInfo, readonly));
- spread.objectFlags |= 128 | 1048576 | 1024 | objectFlags;
- return spread;
- }
- function isSpreadableProperty(prop) {
- return !ts.some(prop.declarations, ts.isPrivateIdentifierPropertyDeclaration) &&
- (!(prop.flags & (8192 | 32768 | 65536)) ||
- !prop.declarations.some(function (decl) { return ts.isClassLike(decl.parent); }));
+ return links.declaredType;
}
- function getSpreadSymbol(prop, readonly) {
- var isSetonlyAccessor = prop.flags & 65536 && !(prop.flags & 32768);
- if (!isSetonlyAccessor && readonly === isReadonlySymbol(prop)) {
- return prop;
+ function isStringConcatExpression(expr) {
+ if (ts.isStringLiteralLike(expr)) {
+ return true;
}
- var flags = 4 | (prop.flags & 16777216);
- var result = createSymbol(flags, prop.escapedName, readonly ? 8 : 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 && info.isReadonly !== readonly ? createIndexInfo(info.type, readonly, info.declaration) : info;
- }
- function createLiteralType(flags, value, symbol) {
- var type = createType(flags);
- type.symbol = symbol;
- type.value = value;
- return type;
- }
- function getFreshTypeOfLiteralType(type) {
- if (type.flags & 2944) {
- if (!type.freshType) {
- var freshType = createLiteralType(type.flags, type.value, type.symbol);
- freshType.regularType = type;
- freshType.freshType = freshType;
- type.freshType = freshType;
- }
- return type.freshType;
+ else if (expr.kind === 216) {
+ return isStringConcatExpression(expr.left) && isStringConcatExpression(expr.right);
}
- return type;
- }
- function getRegularTypeOfLiteralType(type) {
- return type.flags & 2944 ? type.regularType :
- type.flags & 1048576 ? (type.regularType || (type.regularType = getUnionType(ts.sameMap(type.types, getRegularTypeOfLiteralType)))) :
- type;
- }
- function isFreshLiteralType(type) {
- return !!(type.flags & 2944) && type.freshType === type;
+ return false;
}
- function getLiteralType(value, enumId, symbol) {
- var qualifier = typeof value === "number" ? "#" : typeof value === "string" ? "@" : "n";
- var key = (enumId ? enumId : "") + qualifier + (typeof value === "object" ? ts.pseudoBigIntToString(value) : value);
- var type = literalTypes.get(key);
- if (!type) {
- var flags = (typeof value === "number" ? 256 :
- typeof value === "string" ? 128 : 2048) |
- (enumId ? 1024 : 0);
- literalTypes.set(key, type = createLiteralType(flags, value, symbol));
- type.regularType = type;
+ function isLiteralEnumMember(member) {
+ var expr = member.initializer;
+ if (!expr) {
+ return !(member.flags & 8388608);
}
- return type;
- }
- function getTypeFromLiteralTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- links.resolvedType = getRegularTypeOfLiteralType(checkExpression(node.literal));
+ switch (expr.kind) {
+ case 10:
+ case 8:
+ case 14:
+ return true;
+ case 214:
+ return expr.operator === 40 &&
+ expr.operand.kind === 8;
+ case 78:
+ return ts.nodeIsMissing(expr) || !!getSymbolOfNode(member.parent).exports.get(expr.escapedText);
+ case 216:
+ return isStringConcatExpression(expr);
+ default:
+ return false;
}
- return links.resolvedType;
- }
- function createUniqueESSymbolType(symbol) {
- var type = createType(8192);
- type.symbol = symbol;
- type.escapedName = "__@" + type.symbol.escapedName + "@" + getSymbolId(type.symbol);
- return type;
}
- function getESSymbolLikeTypeForNode(node) {
- if (ts.isValidESSymbolDeclaration(node)) {
- var symbol = getSymbolOfNode(node);
- var links = getSymbolLinks(symbol);
- return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol));
+ function getEnumKind(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (links.enumKind !== undefined) {
+ return links.enumKind;
}
- return esSymbolType;
- }
- function getThisType(node) {
- var container = ts.getThisContainer(node, false);
- var parent = container && container.parent;
- if (parent && (ts.isClassLike(parent) || parent.kind === 246)) {
- if (!ts.hasModifier(container, 32) &&
- (!ts.isConstructorDeclaration(container) || ts.isNodeDescendantOf(node, container.body))) {
- return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
+ var hasNonLiteralMember = false;
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ if (declaration.kind === 255) {
+ for (var _b = 0, _c = declaration.members; _b < _c.length; _b++) {
+ var member = _c[_b];
+ if (member.initializer && ts.isStringLiteralLike(member.initializer)) {
+ return links.enumKind = 1;
+ }
+ if (!isLiteralEnumMember(member)) {
+ hasNonLiteralMember = true;
+ }
+ }
}
}
- if (parent && ts.isObjectLiteralExpression(parent) && ts.isBinaryExpression(parent.parent) && ts.getAssignmentDeclarationKind(parent.parent) === 6) {
- return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent.parent.left).parent).thisType;
- }
- var host = node.flags & 4194304 ? ts.getHostSignatureFromJSDoc(node) : undefined;
- if (host && ts.isFunctionExpression(host) && ts.isBinaryExpression(host.parent) && ts.getAssignmentDeclarationKind(host.parent) === 3) {
- return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(host.parent.left).parent).thisType;
- }
- if (isJSConstructor(container) && ts.isNodeDescendantOf(node, container.body)) {
- return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(container)).thisType;
- }
- error(node, ts.Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface);
- return errorType;
- }
- function getTypeFromThisTypeNode(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- links.resolvedType = getThisType(node);
- }
- return links.resolvedType;
+ return links.enumKind = hasNonLiteralMember ? 0 : 1;
}
- function getTypeFromTypeNode(node) {
- return getConditionalFlowTypeOfType(getTypeFromTypeNodeWorker(node), node);
+ function getBaseTypeOfEnumLiteralType(type) {
+ return type.flags & 1024 && !(type.flags & 1048576) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
}
- function getTypeFromTypeNodeWorker(node) {
- switch (node.kind) {
- case 125:
- case 295:
- case 296:
- return anyType;
- case 148:
- return unknownType;
- case 143:
- return stringType;
- case 140:
- return numberType;
- case 151:
- return bigintType;
- case 128:
- return booleanType;
- case 144:
- return esSymbolType;
- case 110:
- return voidType;
- case 146:
- return undefinedType;
- case 100:
- return nullType;
- case 137:
- return neverType;
- case 141:
- return node.flags & 131072 && !noImplicitAny ? anyType : nonPrimitiveType;
- case 183:
- case 104:
- return getTypeFromThisTypeNode(node);
- case 187:
- return getTypeFromLiteralTypeNode(node);
- case 169:
- return getTypeFromTypeReference(node);
- case 168:
- return node.assertsModifier ? voidType : booleanType;
- case 216:
- return getTypeFromTypeReference(node);
- case 172:
- return getTypeFromTypeQueryNode(node);
- case 174:
- case 175:
- return getTypeFromArrayOrTupleTypeNode(node);
- case 176:
- return getTypeFromOptionalTypeNode(node);
- case 178:
- return getTypeFromUnionTypeNode(node);
- case 179:
- return getTypeFromIntersectionTypeNode(node);
- case 297:
- return getTypeFromJSDocNullableTypeNode(node);
- case 299:
- return addOptionality(getTypeFromTypeNode(node.type));
- case 182:
- case 298:
- case 294:
- return getTypeFromTypeNode(node.type);
- case 177:
- return getElementTypeOfArrayType(getTypeFromTypeNode(node.type)) || errorType;
- case 301:
- return getTypeFromJSDocVariadicType(node);
- case 170:
- case 171:
- case 173:
- case 304:
- case 300:
- case 305:
- return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
- case 184:
- return getTypeFromTypeOperatorNode(node);
- case 185:
- return getTypeFromIndexedAccessTypeNode(node);
- case 186:
- return getTypeFromMappedTypeNode(node);
- case 180:
- return getTypeFromConditionalTypeNode(node);
- case 181:
- return getTypeFromInferTypeNode(node);
- case 188:
- return getTypeFromImportTypeNode(node);
- case 75:
- case 153:
- var symbol = getSymbolAtLocation(node);
- return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
- default:
- return errorType;
+ function getDeclaredTypeOfEnum(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (links.declaredType) {
+ return links.declaredType;
}
- }
- function instantiateList(items, mapper, instantiator) {
- if (items && items.length) {
- for (var i = 0; i < items.length; i++) {
- var item = items[i];
- var mapped = instantiator(item, mapper);
- if (item !== mapped) {
- var result = i === 0 ? [] : items.slice(0, i);
- result.push(mapped);
- for (i++; i < items.length; i++) {
- result.push(instantiator(items[i], mapper));
+ if (getEnumKind(symbol) === 1) {
+ enumCount++;
+ var memberTypeList = [];
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ if (declaration.kind === 255) {
+ for (var _b = 0, _c = declaration.members; _b < _c.length; _b++) {
+ var member = _c[_b];
+ var value = getEnumMemberValue(member);
+ var memberType = getFreshTypeOfLiteralType(getLiteralType(value !== undefined ? value : 0, enumCount, getSymbolOfNode(member)));
+ getSymbolLinks(getSymbolOfNode(member)).declaredType = memberType;
+ memberTypeList.push(getRegularTypeOfLiteralType(memberType));
}
- return result;
}
}
+ if (memberTypeList.length) {
+ var enumType_1 = getUnionType(memberTypeList, 1, symbol, undefined);
+ if (enumType_1.flags & 1048576) {
+ enumType_1.flags |= 1024;
+ enumType_1.symbol = symbol;
+ }
+ return links.declaredType = enumType_1;
+ }
}
- return items;
+ var enumType = createType(32);
+ enumType.symbol = symbol;
+ return links.declaredType = enumType;
}
- function instantiateTypes(types, mapper) {
- return instantiateList(types, mapper, instantiateType);
+ function getDeclaredTypeOfEnumMember(symbol) {
+ var links = getSymbolLinks(symbol);
+ if (!links.declaredType) {
+ var enumType = getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
+ if (!links.declaredType) {
+ links.declaredType = enumType;
+ }
+ }
+ return links.declaredType;
}
- function instantiateSignatures(signatures, mapper) {
- return instantiateList(signatures, mapper, instantiateSignature);
+ function getDeclaredTypeOfTypeParameter(symbol) {
+ var links = getSymbolLinks(symbol);
+ return links.declaredType || (links.declaredType = createTypeParameter(symbol));
}
- function createTypeMapper(sources, targets) {
- return sources.length === 1 ? makeUnaryTypeMapper(sources[0], targets ? targets[0] : anyType) : makeArrayTypeMapper(sources, targets);
+ function getDeclaredTypeOfAlias(symbol) {
+ var links = getSymbolLinks(symbol);
+ return links.declaredType || (links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol)));
}
- function getMappedType(type, mapper) {
- switch (mapper.kind) {
- case 0:
- return type === mapper.source ? mapper.target : type;
- case 1:
- var sources = mapper.sources;
- var targets = mapper.targets;
- for (var i = 0; i < sources.length; i++) {
- if (type === sources[i]) {
- return targets ? targets[i] : anyType;
- }
- }
- return type;
- case 2:
- return mapper.func(type);
- case 3:
- case 4:
- var t1 = getMappedType(type, mapper.mapper1);
- return t1 !== type && mapper.kind === 3 ? instantiateType(t1, mapper.mapper2) : getMappedType(t1, mapper.mapper2);
+ function getDeclaredTypeOfSymbol(symbol) {
+ return tryGetDeclaredTypeOfSymbol(symbol) || errorType;
+ }
+ function tryGetDeclaredTypeOfSymbol(symbol) {
+ if (symbol.flags & (32 | 64)) {
+ return getDeclaredTypeOfClassOrInterface(symbol);
+ }
+ if (symbol.flags & 524288) {
+ return getDeclaredTypeOfTypeAlias(symbol);
+ }
+ if (symbol.flags & 262144) {
+ return getDeclaredTypeOfTypeParameter(symbol);
+ }
+ if (symbol.flags & 384) {
+ return getDeclaredTypeOfEnum(symbol);
+ }
+ if (symbol.flags & 8) {
+ return getDeclaredTypeOfEnumMember(symbol);
}
+ if (symbol.flags & 2097152) {
+ return getDeclaredTypeOfAlias(symbol);
+ }
+ return undefined;
}
- function makeUnaryTypeMapper(source, target) {
- return { kind: 0, source: source, target: target };
+ function isThislessType(node) {
+ switch (node.kind) {
+ case 128:
+ case 152:
+ case 147:
+ case 144:
+ case 155:
+ case 131:
+ case 148:
+ case 145:
+ case 113:
+ case 150:
+ case 141:
+ case 191:
+ return true;
+ case 178:
+ return isThislessType(node.elementType);
+ case 173:
+ return !node.typeArguments || node.typeArguments.every(isThislessType);
+ }
+ return false;
}
- function makeArrayTypeMapper(sources, targets) {
- return { kind: 1, sources: sources, targets: targets };
+ function isThislessTypeParameter(node) {
+ var constraint = ts.getEffectiveConstraintOfTypeParameter(node);
+ return !constraint || isThislessType(constraint);
}
- function makeFunctionTypeMapper(func) {
- return { kind: 2, func: func };
+ function isThislessVariableLikeDeclaration(node) {
+ var typeNode = ts.getEffectiveTypeAnnotationNode(node);
+ return typeNode ? isThislessType(typeNode) : !ts.hasInitializer(node);
}
- function makeCompositeTypeMapper(kind, mapper1, mapper2) {
- return { kind: kind, mapper1: mapper1, mapper2: mapper2 };
+ function isThislessFunctionLikeDeclaration(node) {
+ var returnType = ts.getEffectiveReturnTypeNode(node);
+ var typeParameters = ts.getEffectiveTypeParameterDeclarations(node);
+ return (node.kind === 166 || (!!returnType && isThislessType(returnType))) &&
+ node.parameters.every(isThislessVariableLikeDeclaration) &&
+ typeParameters.every(isThislessTypeParameter);
}
- function createTypeEraser(sources) {
- return createTypeMapper(sources, undefined);
+ function isThisless(symbol) {
+ if (symbol.declarations && symbol.declarations.length === 1) {
+ var declaration = symbol.declarations[0];
+ if (declaration) {
+ switch (declaration.kind) {
+ case 163:
+ case 162:
+ return isThislessVariableLikeDeclaration(declaration);
+ case 165:
+ case 164:
+ case 166:
+ case 167:
+ case 168:
+ return isThislessFunctionLikeDeclaration(declaration);
+ }
+ }
+ }
+ return false;
}
- function createBackreferenceMapper(context, index) {
- return makeFunctionTypeMapper(function (t) { return ts.findIndex(context.inferences, function (info) { return info.typeParameter === t; }) >= index ? unknownType : t; });
+ function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) {
+ var result = ts.createSymbolTable();
+ for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
+ var symbol = symbols_2[_i];
+ result.set(symbol.escapedName, mappingThisOnly && isThisless(symbol) ? symbol : instantiateSymbol(symbol, mapper));
+ }
+ return result;
}
- function combineTypeMappers(mapper1, mapper2) {
- return mapper1 ? makeCompositeTypeMapper(3, mapper1, mapper2) : mapper2;
+ function addInheritedMembers(symbols, baseSymbols) {
+ for (var _i = 0, baseSymbols_1 = baseSymbols; _i < baseSymbols_1.length; _i++) {
+ var s = baseSymbols_1[_i];
+ if (!symbols.has(s.escapedName) && !isStaticPrivateIdentifierProperty(s)) {
+ symbols.set(s.escapedName, s);
+ }
+ }
}
- function mergeTypeMappers(mapper1, mapper2) {
- return mapper1 ? makeCompositeTypeMapper(4, mapper1, mapper2) : mapper2;
+ function isStaticPrivateIdentifierProperty(s) {
+ return !!s.valueDeclaration && ts.isPrivateIdentifierPropertyDeclaration(s.valueDeclaration) && ts.hasSyntacticModifier(s.valueDeclaration, 32);
}
- function prependTypeMapping(source, target, mapper) {
- return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(4, makeUnaryTypeMapper(source, target), mapper);
+ function resolveDeclaredMembers(type) {
+ if (!type.declaredProperties) {
+ var symbol = type.symbol;
+ var members = getMembersOfSymbol(symbol);
+ type.declaredProperties = getNamedMembers(members);
+ type.declaredCallSignatures = ts.emptyArray;
+ type.declaredConstructSignatures = ts.emptyArray;
+ type.declaredCallSignatures = getSignaturesOfSymbol(members.get("__call"));
+ type.declaredConstructSignatures = getSignaturesOfSymbol(members.get("__new"));
+ type.declaredStringIndexInfo = getIndexInfoOfSymbol(symbol, 0);
+ type.declaredNumberIndexInfo = getIndexInfoOfSymbol(symbol, 1);
+ }
+ return type;
}
- function appendTypeMapping(mapper, source, target) {
- return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(4, mapper, makeUnaryTypeMapper(source, target));
+ function isTypeUsableAsPropertyName(type) {
+ return !!(type.flags & 8576);
}
- function getRestrictiveTypeParameter(tp) {
- return tp.constraint === unknownType ? tp : tp.restrictiveInstantiation || (tp.restrictiveInstantiation = createTypeParameter(tp.symbol),
- tp.restrictiveInstantiation.constraint = unknownType,
- tp.restrictiveInstantiation);
+ function isLateBindableName(node) {
+ if (!ts.isComputedPropertyName(node) && !ts.isElementAccessExpression(node)) {
+ return false;
+ }
+ var expr = ts.isComputedPropertyName(node) ? node.expression : node.argumentExpression;
+ return ts.isEntityNameExpression(expr)
+ && isTypeUsableAsPropertyName(ts.isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr));
}
- function cloneTypeParameter(typeParameter) {
- var result = createTypeParameter(typeParameter.symbol);
- result.target = typeParameter;
- return result;
+ function isLateBoundName(name) {
+ return name.charCodeAt(0) === 95 &&
+ name.charCodeAt(1) === 95 &&
+ name.charCodeAt(2) === 64;
}
- function instantiateTypePredicate(predicate, mapper) {
- return createTypePredicate(predicate.kind, predicate.parameterName, predicate.parameterIndex, instantiateType(predicate.type, mapper));
+ function hasLateBindableName(node) {
+ var name = ts.getNameOfDeclaration(node);
+ return !!name && isLateBindableName(name);
}
- function instantiateSignature(signature, mapper, eraseTypeParameters) {
- var freshTypeParameters;
- if (signature.typeParameters && !eraseTypeParameters) {
- freshTypeParameters = ts.map(signature.typeParameters, cloneTypeParameter);
- mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper);
- for (var _i = 0, freshTypeParameters_1 = freshTypeParameters; _i < freshTypeParameters_1.length; _i++) {
- var tp = freshTypeParameters_1[_i];
- tp.mapper = mapper;
- }
+ function hasNonBindableDynamicName(node) {
+ return ts.hasDynamicName(node) && !hasLateBindableName(node);
+ }
+ function isNonBindableDynamicName(node) {
+ return ts.isDynamicName(node) && !isLateBindableName(node);
+ }
+ function getPropertyNameFromType(type) {
+ if (type.flags & 8192) {
+ return type.escapedName;
}
- var result = createSignature(signature.declaration, freshTypeParameters, signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper), instantiateList(signature.parameters, mapper, instantiateSymbol), undefined, undefined, signature.minArgumentCount, signature.flags & 3);
- result.target = signature;
- result.mapper = mapper;
- return result;
+ if (type.flags & (128 | 256)) {
+ return ts.escapeLeadingUnderscores("" + type.value);
+ }
+ return ts.Debug.fail();
}
- function instantiateSymbol(symbol, mapper) {
- var links = getSymbolLinks(symbol);
- if (links.type && !couldContainTypeVariables(links.type)) {
- return symbol;
+ function addDeclarationToLateBoundSymbol(symbol, member, symbolFlags) {
+ ts.Debug.assert(!!(ts.getCheckFlags(symbol) & 4096), "Expected a late-bound symbol.");
+ symbol.flags |= symbolFlags;
+ getSymbolLinks(member.symbol).lateSymbol = symbol;
+ if (!symbol.declarations) {
+ symbol.declarations = [member];
}
- if (ts.getCheckFlags(symbol) & 1) {
- symbol = links.target;
- mapper = combineTypeMappers(links.mapper, mapper);
+ else {
+ symbol.declarations.push(member);
}
- var result = createSymbol(symbol.flags, symbol.escapedName, 1 | ts.getCheckFlags(symbol) & (8 | 4096 | 16384 | 32768));
- result.declarations = symbol.declarations;
- result.parent = symbol.parent;
- result.target = symbol;
- result.mapper = mapper;
- if (symbol.valueDeclaration) {
- result.valueDeclaration = symbol.valueDeclaration;
+ if (symbolFlags & 111551) {
+ if (!symbol.valueDeclaration || symbol.valueDeclaration.kind !== member.kind) {
+ symbol.valueDeclaration = member;
+ }
}
- if (links.nameType) {
- result.nameType = links.nameType;
+ }
+ function lateBindMember(parent, earlySymbols, lateSymbols, decl) {
+ ts.Debug.assert(!!decl.symbol, "The member is expected to have a symbol.");
+ var links = getNodeLinks(decl);
+ if (!links.resolvedSymbol) {
+ links.resolvedSymbol = decl.symbol;
+ var declName = ts.isBinaryExpression(decl) ? decl.left : decl.name;
+ var type = ts.isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName);
+ if (isTypeUsableAsPropertyName(type)) {
+ var memberName = getPropertyNameFromType(type);
+ var symbolFlags = decl.symbol.flags;
+ var lateSymbol = lateSymbols.get(memberName);
+ if (!lateSymbol)
+ lateSymbols.set(memberName, lateSymbol = createSymbol(0, memberName, 4096));
+ var earlySymbol = earlySymbols && earlySymbols.get(memberName);
+ if (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol) {
+ var declarations = earlySymbol ? ts.concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
+ var name_4 = !(type.flags & 8192) && ts.unescapeLeadingUnderscores(memberName) || ts.declarationNameToString(declName);
+ ts.forEach(declarations, function (declaration) { return error(ts.getNameOfDeclaration(declaration) || declaration, ts.Diagnostics.Property_0_was_also_declared_here, name_4); });
+ error(declName || decl, ts.Diagnostics.Duplicate_property_0, name_4);
+ lateSymbol = createSymbol(0, memberName, 4096);
+ }
+ lateSymbol.nameType = type;
+ addDeclarationToLateBoundSymbol(lateSymbol, decl, symbolFlags);
+ if (lateSymbol.parent) {
+ ts.Debug.assert(lateSymbol.parent === parent, "Existing symbol parent should match new one");
+ }
+ else {
+ lateSymbol.parent = parent;
+ }
+ return links.resolvedSymbol = lateSymbol;
+ }
}
- return result;
+ return links.resolvedSymbol;
}
- function getObjectTypeInstantiation(type, mapper) {
- var target = type.objectFlags & 64 ? type.target : type;
- var node = type.objectFlags & 4 ? type.node : type.symbol.declarations[0];
- var links = getNodeLinks(node);
- var typeParameters = links.outerTypeParameters;
- if (!typeParameters) {
- var declaration_1 = node;
- if (ts.isInJSFile(declaration_1)) {
- var paramTag = ts.findAncestor(declaration_1, ts.isJSDocParameterTag);
- if (paramTag) {
- var paramSymbol = ts.getParameterSymbolFromJSDoc(paramTag);
- if (paramSymbol) {
- declaration_1 = paramSymbol.valueDeclaration;
+ function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
+ var links = getSymbolLinks(symbol);
+ if (!links[resolutionKind]) {
+ var isStatic = resolutionKind === "resolvedExports";
+ var earlySymbols = !isStatic ? symbol.members :
+ symbol.flags & 1536 ? getExportsOfModuleWorker(symbol) :
+ symbol.exports;
+ links[resolutionKind] = earlySymbols || emptySymbols;
+ var lateSymbols = ts.createSymbolTable();
+ for (var _i = 0, _a = symbol.declarations || ts.emptyArray; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ var members = ts.getMembersOfDeclaration(decl);
+ if (members) {
+ for (var _b = 0, members_5 = members; _b < members_5.length; _b++) {
+ var member = members_5[_b];
+ if (isStatic === ts.hasStaticModifier(member) && hasLateBindableName(member)) {
+ lateBindMember(symbol, earlySymbols, lateSymbols, member);
+ }
}
}
}
- var outerTypeParameters = getOuterTypeParameters(declaration_1, true);
- if (isJSConstructor(declaration_1)) {
- var templateTagParameters = getTypeParametersFromDeclaration(declaration_1);
- outerTypeParameters = ts.addRange(outerTypeParameters, templateTagParameters);
- }
- typeParameters = outerTypeParameters || ts.emptyArray;
- typeParameters = (target.objectFlags & 4 || target.symbol.flags & 2048) && !target.aliasTypeArguments ?
- ts.filter(typeParameters, function (tp) { return isTypeParameterPossiblyReferenced(tp, declaration_1); }) :
- typeParameters;
- links.outerTypeParameters = typeParameters;
- if (typeParameters.length) {
- links.instantiations = ts.createMap();
- links.instantiations.set(getTypeListId(typeParameters), target);
- }
- }
- if (typeParameters.length) {
- var combinedMapper_1 = combineTypeMappers(type.mapper, mapper);
- var typeArguments = ts.map(typeParameters, function (t) { return getMappedType(t, combinedMapper_1); });
- var id = getTypeListId(typeArguments);
- var result = links.instantiations.get(id);
- if (!result) {
- var newMapper = createTypeMapper(typeParameters, typeArguments);
- result = target.objectFlags & 4 ? createDeferredTypeReference(type.target, type.node, newMapper) :
- target.objectFlags & 32 ? instantiateMappedType(target, newMapper) :
- instantiateAnonymousType(target, newMapper);
- links.instantiations.set(id, result);
+ var assignments = symbol.assignmentDeclarationMembers;
+ if (assignments) {
+ var decls = ts.arrayFrom(assignments.values());
+ for (var _c = 0, decls_1 = decls; _c < decls_1.length; _c++) {
+ var member = decls_1[_c];
+ var assignmentKind = ts.getAssignmentDeclarationKind(member);
+ var isInstanceMember = assignmentKind === 3
+ || ts.isBinaryExpression(member) && isPossiblyAliasedThisProperty(member, assignmentKind)
+ || assignmentKind === 9
+ || assignmentKind === 6;
+ if (isStatic === !isInstanceMember && hasLateBindableName(member)) {
+ lateBindMember(symbol, earlySymbols, lateSymbols, member);
+ }
+ }
}
- return result;
+ links[resolutionKind] = combineSymbolTables(earlySymbols, lateSymbols) || emptySymbols;
}
- return type;
+ return links[resolutionKind];
}
- function maybeTypeParameterReference(node) {
- return !(node.kind === 153 ||
- node.parent.kind === 169 && node.parent.typeArguments && node === node.parent.typeName ||
- node.parent.kind === 188 && node.parent.typeArguments && node === node.parent.qualifier);
+ function getMembersOfSymbol(symbol) {
+ return symbol.flags & 6256
+ ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedMembers")
+ : symbol.members || emptySymbols;
}
- function isTypeParameterPossiblyReferenced(tp, node) {
- if (tp.symbol && tp.symbol.declarations && tp.symbol.declarations.length === 1) {
- var container = tp.symbol.declarations[0].parent;
- for (var n = node; n !== container; n = n.parent) {
- if (!n || n.kind === 223 || n.kind === 180 && ts.forEachChild(n.extendsType, containsReference)) {
- return true;
+ function getLateBoundSymbol(symbol) {
+ if (symbol.flags & 106500 && symbol.escapedName === "__computed") {
+ var links = getSymbolLinks(symbol);
+ if (!links.lateSymbol && ts.some(symbol.declarations, hasLateBindableName)) {
+ var parent = getMergedSymbol(symbol.parent);
+ if (ts.some(symbol.declarations, ts.hasStaticModifier)) {
+ getExportsOfSymbol(parent);
+ }
+ else {
+ getMembersOfSymbol(parent);
}
}
- return !!ts.forEachChild(node, containsReference);
- }
- return true;
- function containsReference(node) {
- switch (node.kind) {
- case 183:
- return !!tp.isThisType;
- case 75:
- return !tp.isThisType && ts.isPartOfTypeNode(node) && maybeTypeParameterReference(node) &&
- getTypeFromTypeNodeWorker(node) === tp;
- case 172:
- return true;
- }
- return !!ts.forEachChild(node, containsReference);
+ return links.lateSymbol || (links.lateSymbol = symbol);
}
+ return symbol;
}
- function getHomomorphicTypeVariable(type) {
- var constraintType = getConstraintTypeFromMappedType(type);
- if (constraintType.flags & 4194304) {
- var typeVariable = getActualTypeVariable(constraintType.type);
- if (typeVariable.flags & 262144) {
- return typeVariable;
+ function getTypeWithThisArgument(type, thisArgument, needApparentType) {
+ if (ts.getObjectFlags(type) & 4) {
+ var target = type.target;
+ var typeArguments = getTypeArguments(type);
+ if (ts.length(target.typeParameters) === ts.length(typeArguments)) {
+ var ref = createTypeReference(target, ts.concatenate(typeArguments, [thisArgument || target.thisType]));
+ return needApparentType ? getApparentType(ref) : ref;
}
}
- return undefined;
+ else if (type.flags & 2097152) {
+ return getIntersectionType(ts.map(type.types, function (t) { return getTypeWithThisArgument(t, thisArgument, needApparentType); }));
+ }
+ return needApparentType ? getApparentType(type) : type;
}
- function instantiateMappedType(type, mapper) {
- var typeVariable = getHomomorphicTypeVariable(type);
- if (typeVariable) {
- var mappedTypeVariable = instantiateType(typeVariable, mapper);
- if (typeVariable !== mappedTypeVariable) {
- return mapType(getReducedType(mappedTypeVariable), function (t) {
- if (t.flags & (3 | 58982400 | 524288 | 2097152) && t !== wildcardType && t !== errorType) {
- var replacementMapper = prependTypeMapping(typeVariable, t, mapper);
- return isArrayType(t) ? instantiateMappedArrayType(t, type, replacementMapper) :
- isTupleType(t) ? instantiateMappedTupleType(t, type, replacementMapper) :
- instantiateAnonymousType(type, replacementMapper);
- }
- return t;
- });
+ function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
+ var mapper;
+ var members;
+ var callSignatures;
+ var constructSignatures;
+ var stringIndexInfo;
+ var numberIndexInfo;
+ if (ts.rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+ members = source.symbol ? getMembersOfSymbol(source.symbol) : ts.createSymbolTable(source.declaredProperties);
+ callSignatures = source.declaredCallSignatures;
+ constructSignatures = source.declaredConstructSignatures;
+ stringIndexInfo = source.declaredStringIndexInfo;
+ numberIndexInfo = source.declaredNumberIndexInfo;
+ }
+ else {
+ mapper = createTypeMapper(typeParameters, typeArguments);
+ members = createInstantiatedSymbolTable(source.declaredProperties, mapper, typeParameters.length === 1);
+ callSignatures = instantiateSignatures(source.declaredCallSignatures, mapper);
+ constructSignatures = instantiateSignatures(source.declaredConstructSignatures, mapper);
+ stringIndexInfo = instantiateIndexInfo(source.declaredStringIndexInfo, mapper);
+ numberIndexInfo = instantiateIndexInfo(source.declaredNumberIndexInfo, mapper);
+ }
+ var baseTypes = getBaseTypes(source);
+ if (baseTypes.length) {
+ if (source.symbol && members === getMembersOfSymbol(source.symbol)) {
+ members = ts.createSymbolTable(source.declaredProperties);
+ }
+ setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+ var thisArgument = ts.lastOrUndefined(typeArguments);
+ for (var _i = 0, baseTypes_1 = baseTypes; _i < baseTypes_1.length; _i++) {
+ var baseType = baseTypes_1[_i];
+ var instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
+ addInheritedMembers(members, getPropertiesOfType(instantiatedBaseType));
+ callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0));
+ constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1));
+ if (!stringIndexInfo) {
+ stringIndexInfo = instantiatedBaseType === anyType ?
+ createIndexInfo(anyType, false) :
+ getIndexInfoOfType(instantiatedBaseType, 0);
+ }
+ numberIndexInfo = numberIndexInfo || getIndexInfoOfType(instantiatedBaseType, 1);
}
}
- return instantiateAnonymousType(type, mapper);
- }
- function getModifiedReadonlyState(state, modifiers) {
- return modifiers & 1 ? true : modifiers & 2 ? false : state;
- }
- function instantiateMappedArrayType(arrayType, mappedType, mapper) {
- var elementType = instantiateMappedTypeTemplate(mappedType, numberType, true, mapper);
- return elementType === errorType ? errorType :
- createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType)));
+ setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
}
- function instantiateMappedTupleType(tupleType, mappedType, mapper) {
- var minLength = tupleType.target.minLength;
- var elementTypes = ts.map(getTypeArguments(tupleType), function (_, i) {
- return instantiateMappedTypeTemplate(mappedType, getLiteralType("" + i), i >= minLength, mapper);
- });
- var modifiers = getMappedTypeModifiers(mappedType);
- var newMinLength = modifiers & 4 ? 0 :
- modifiers & 8 ? getTypeReferenceArity(tupleType) - (tupleType.target.hasRestElement ? 1 : 0) :
- minLength;
- var newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers);
- return ts.contains(elementTypes, errorType) ? errorType :
- createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.associatedNames);
+ function resolveClassOrInterfaceMembers(type) {
+ resolveObjectTypeMembers(type, resolveDeclaredMembers(type), ts.emptyArray, ts.emptyArray);
}
- function instantiateMappedTypeTemplate(type, key, isOptional, mapper) {
- var templateMapper = appendTypeMapping(mapper, getTypeParameterFromMappedType(type), key);
- var propType = instantiateType(getTemplateTypeFromMappedType(type.target || type), templateMapper);
- var modifiers = getMappedTypeModifiers(type);
- return strictNullChecks && modifiers & 4 && !maybeTypeOfKind(propType, 32768 | 16384) ? getOptionalType(propType) :
- strictNullChecks && modifiers & 8 && isOptional ? getTypeWithFacts(propType, 524288) :
- propType;
+ function resolveTypeReferenceMembers(type) {
+ var source = resolveDeclaredMembers(type.target);
+ var typeParameters = ts.concatenate(source.typeParameters, [source.thisType]);
+ var typeArguments = getTypeArguments(type);
+ var paddedTypeArguments = typeArguments.length === typeParameters.length ? typeArguments : ts.concatenate(typeArguments, [type]);
+ resolveObjectTypeMembers(type, source, typeParameters, paddedTypeArguments);
}
- function instantiateAnonymousType(type, mapper) {
- var result = createObjectType(type.objectFlags | 64, type.symbol);
- if (type.objectFlags & 32) {
- result.declaration = type.declaration;
- var origTypeParameter = getTypeParameterFromMappedType(type);
- var freshTypeParameter = cloneTypeParameter(origTypeParameter);
- result.typeParameter = freshTypeParameter;
- mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper);
- freshTypeParameter.mapper = mapper;
- }
- result.target = type;
- result.mapper = mapper;
- result.aliasSymbol = type.aliasSymbol;
- result.aliasTypeArguments = instantiateTypes(type.aliasTypeArguments, mapper);
- return result;
+ function createSignature(declaration, typeParameters, thisParameter, parameters, resolvedReturnType, resolvedTypePredicate, minArgumentCount, flags) {
+ var sig = new Signature(checker, flags);
+ sig.declaration = declaration;
+ sig.typeParameters = typeParameters;
+ sig.parameters = parameters;
+ sig.thisParameter = thisParameter;
+ sig.resolvedReturnType = resolvedReturnType;
+ sig.resolvedTypePredicate = resolvedTypePredicate;
+ sig.minArgumentCount = minArgumentCount;
+ sig.resolvedMinArgumentCount = undefined;
+ sig.target = undefined;
+ sig.mapper = undefined;
+ sig.unionSignatures = undefined;
+ return sig;
}
- function getConditionalTypeInstantiation(type, mapper) {
- var root = type.root;
- if (root.outerTypeParameters) {
- var typeArguments = ts.map(root.outerTypeParameters, function (t) { return getMappedType(t, mapper); });
- var id = getTypeListId(typeArguments);
- var result = root.instantiations.get(id);
- if (!result) {
- var newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
- result = instantiateConditionalType(root, newMapper);
- root.instantiations.set(id, result);
- }
- return result;
- }
- return type;
+ function cloneSignature(sig) {
+ var result = createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, undefined, undefined, sig.minArgumentCount, sig.flags & 19);
+ result.target = sig.target;
+ result.mapper = sig.mapper;
+ result.unionSignatures = sig.unionSignatures;
+ return result;
}
- function instantiateConditionalType(root, mapper) {
- if (root.isDistributive) {
- var checkType_1 = root.checkType;
- var instantiatedType = getMappedType(checkType_1, mapper);
- if (checkType_1 !== instantiatedType && instantiatedType.flags & (1048576 | 131072)) {
- return mapType(instantiatedType, function (t) { return getConditionalType(root, prependTypeMapping(checkType_1, t, mapper)); });
- }
- }
- return getConditionalType(root, mapper);
+ function createUnionSignature(signature, unionSignatures) {
+ var result = cloneSignature(signature);
+ result.unionSignatures = unionSignatures;
+ result.target = undefined;
+ result.mapper = undefined;
+ return result;
}
- function instantiateType(type, mapper) {
- if (!type || !mapper) {
- return type;
+ function getOptionalCallSignature(signature, callChainFlags) {
+ if ((signature.flags & 12) === callChainFlags) {
+ return signature;
}
- if (instantiationDepth === 50 || instantiationCount >= 5000000) {
- error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
- return errorType;
+ if (!signature.optionalCallSignatureCache) {
+ signature.optionalCallSignatureCache = {};
}
- totalInstantiationCount++;
- instantiationCount++;
- instantiationDepth++;
- var result = instantiateTypeWorker(type, mapper);
- instantiationDepth--;
- return result;
+ var key = callChainFlags === 4 ? "inner" : "outer";
+ return signature.optionalCallSignatureCache[key]
+ || (signature.optionalCallSignatureCache[key] = createOptionalCallSignature(signature, callChainFlags));
}
- function instantiateTypeWithoutDepthIncrease(type, mapper) {
- instantiationDepth--;
- var result = instantiateType(type, mapper);
- instantiationDepth++;
+ function createOptionalCallSignature(signature, callChainFlags) {
+ ts.Debug.assert(callChainFlags === 4 || callChainFlags === 8, "An optional call signature can either be for an inner call chain or an outer call chain, but not both.");
+ var result = cloneSignature(signature);
+ result.flags |= callChainFlags;
return result;
}
- function instantiateTypeWorker(type, mapper) {
- var flags = type.flags;
- if (flags & 262144) {
- return getMappedType(type, mapper);
+ function getExpandedParameters(sig, skipUnionExpanding) {
+ if (signatureHasRestParameter(sig)) {
+ var restIndex_1 = sig.parameters.length - 1;
+ var restType = getTypeOfSymbol(sig.parameters[restIndex_1]);
+ if (isTupleType(restType)) {
+ return [expandSignatureParametersWithTupleMembers(restType, restIndex_1)];
+ }
+ else if (!skipUnionExpanding && restType.flags & 1048576 && ts.every(restType.types, isTupleType)) {
+ return ts.map(restType.types, function (t) { return expandSignatureParametersWithTupleMembers(t, restIndex_1); });
+ }
+ }
+ return [sig.parameters];
+ function expandSignatureParametersWithTupleMembers(restType, restIndex) {
+ var elementTypes = getTypeArguments(restType);
+ var associatedNames = restType.target.labeledElementDeclarations;
+ var restParams = ts.map(elementTypes, function (t, i) {
+ var tupleLabelName = !!associatedNames && getTupleElementLabel(associatedNames[i]);
+ var name = tupleLabelName || getParameterNameAtPosition(sig, restIndex + i, restType);
+ var flags = restType.target.elementFlags[i];
+ var checkFlags = flags & 12 ? 32768 :
+ flags & 2 ? 16384 : 0;
+ var symbol = createSymbol(1, name, checkFlags);
+ symbol.type = flags & 4 ? createArrayType(t) : t;
+ return symbol;
+ });
+ return ts.concatenate(sig.parameters.slice(0, restIndex), restParams);
}
- if (flags & 524288) {
- var objectFlags = type.objectFlags;
- if (objectFlags & 16) {
- return couldContainTypeVariables(type) ?
- getObjectTypeInstantiation(type, mapper) : type;
- }
- if (objectFlags & 32) {
- return getObjectTypeInstantiation(type, mapper);
- }
- if (objectFlags & 4) {
- if (type.node) {
- return getObjectTypeInstantiation(type, mapper);
- }
- var resolvedTypeArguments = type.resolvedTypeArguments;
- var newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper);
- return newTypeArguments !== resolvedTypeArguments ? createTypeReference(type.target, newTypeArguments) : type;
- }
- return type;
+ }
+ function getDefaultConstructSignatures(classType) {
+ var baseConstructorType = getBaseConstructorTypeOfClass(classType);
+ var baseSignatures = getSignaturesOfType(baseConstructorType, 1);
+ if (baseSignatures.length === 0) {
+ return [createSignature(undefined, classType.localTypeParameters, undefined, ts.emptyArray, classType, undefined, 0, 0)];
}
- if ((flags & 2097152) || (flags & 1048576 && !(flags & 131068))) {
- if (!couldContainTypeVariables(type)) {
- return type;
+ var baseTypeNode = getBaseTypeNodeOfClass(classType);
+ var isJavaScript = ts.isInJSFile(baseTypeNode);
+ var typeArguments = typeArgumentsFromTypeReferenceNode(baseTypeNode);
+ var typeArgCount = ts.length(typeArguments);
+ var result = [];
+ for (var _i = 0, baseSignatures_1 = baseSignatures; _i < baseSignatures_1.length; _i++) {
+ var baseSig = baseSignatures_1[_i];
+ var minTypeArgumentCount = getMinTypeArgumentCount(baseSig.typeParameters);
+ var typeParamCount = ts.length(baseSig.typeParameters);
+ if (isJavaScript || typeArgCount >= minTypeArgumentCount && typeArgCount <= typeParamCount) {
+ var sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount, isJavaScript)) : cloneSignature(baseSig);
+ sig.typeParameters = classType.localTypeParameters;
+ sig.resolvedReturnType = classType;
+ result.push(sig);
}
- var types = type.types;
- var newTypes = instantiateTypes(types, mapper);
- return newTypes === types
- ? type
- : (flags & 2097152)
- ? getIntersectionType(newTypes, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper))
- : getUnionType(newTypes, 1, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper));
- }
- if (flags & 4194304) {
- return getIndexType(instantiateType(type.type, mapper));
- }
- if (flags & 8388608) {
- return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper));
}
- if (flags & 16777216) {
- return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper));
+ return result;
+ }
+ function findMatchingSignature(signatureList, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes) {
+ for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) {
+ var s = signatureList_1[_i];
+ if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, partialMatch ? compareTypesSubtypeOf : compareTypesIdentical)) {
+ return s;
+ }
}
- if (flags & 33554432) {
- var maybeVariable = instantiateType(type.baseType, mapper);
- if (maybeVariable.flags & 8650752) {
- return getSubstitutionType(maybeVariable, instantiateType(type.substitute, mapper));
+ }
+ function findMatchingSignatures(signatureLists, signature, listIndex) {
+ if (signature.typeParameters) {
+ if (listIndex > 0) {
+ return undefined;
}
- else {
- var sub = instantiateType(type.substitute, mapper);
- if (sub.flags & 3 || isTypeAssignableTo(getRestrictiveInstantiation(maybeVariable), getRestrictiveInstantiation(sub))) {
- return maybeVariable;
+ for (var i = 1; i < signatureLists.length; i++) {
+ if (!findMatchingSignature(signatureLists[i], signature, false, false, false)) {
+ return undefined;
}
- return sub;
}
+ return [signature];
}
- return type;
- }
- function getPermissiveInstantiation(type) {
- return type.flags & (131068 | 3 | 131072) ? type :
- type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
- }
- function getRestrictiveInstantiation(type) {
- if (type.flags & (131068 | 3 | 131072)) {
- return type;
- }
- if (type.restrictiveInstantiation) {
- return type.restrictiveInstantiation;
+ var result;
+ for (var i = 0; i < signatureLists.length; i++) {
+ var match = i === listIndex ? signature : findMatchingSignature(signatureLists[i], signature, true, false, true);
+ if (!match) {
+ return undefined;
+ }
+ result = ts.appendIfUnique(result, match);
}
- type.restrictiveInstantiation = instantiateType(type, restrictiveMapper);
- type.restrictiveInstantiation.restrictiveInstantiation = type.restrictiveInstantiation;
- return type.restrictiveInstantiation;
- }
- function instantiateIndexInfo(info, mapper) {
- return info && createIndexInfo(instantiateType(info.type, mapper), info.isReadonly, info.declaration);
+ return result;
}
- function isContextSensitive(node) {
- ts.Debug.assert(node.kind !== 161 || ts.isObjectLiteralMethod(node));
- switch (node.kind) {
- case 201:
- case 202:
- case 161:
- case 244:
- return isContextSensitiveFunctionLikeDeclaration(node);
- case 193:
- return ts.some(node.properties, isContextSensitive);
- case 192:
- return ts.some(node.elements, isContextSensitive);
- case 210:
- return isContextSensitive(node.whenTrue) ||
- isContextSensitive(node.whenFalse);
- case 209:
- return (node.operatorToken.kind === 56 || node.operatorToken.kind === 60) &&
- (isContextSensitive(node.left) || isContextSensitive(node.right));
- case 281:
- return isContextSensitive(node.initializer);
- case 200:
- return isContextSensitive(node.expression);
- case 274:
- return ts.some(node.properties, isContextSensitive) || ts.isJsxOpeningElement(node.parent) && ts.some(node.parent.parent.children, isContextSensitive);
- case 273: {
- var initializer = node.initializer;
- return !!initializer && isContextSensitive(initializer);
+ function getUnionSignatures(signatureLists) {
+ var result;
+ var indexWithLengthOverOne;
+ for (var i = 0; i < signatureLists.length; i++) {
+ if (signatureLists[i].length === 0)
+ return ts.emptyArray;
+ if (signatureLists[i].length > 1) {
+ indexWithLengthOverOne = indexWithLengthOverOne === undefined ? i : -1;
}
- case 276: {
- var expression = node.expression;
- return !!expression && isContextSensitive(expression);
+ for (var _i = 0, _a = signatureLists[i]; _i < _a.length; _i++) {
+ var signature = _a[_i];
+ if (!result || !findMatchingSignature(result, signature, false, false, true)) {
+ var unionSignatures = findMatchingSignatures(signatureLists, signature, i);
+ if (unionSignatures) {
+ var s = signature;
+ if (unionSignatures.length > 1) {
+ var thisParameter = signature.thisParameter;
+ var firstThisParameterOfUnionSignatures = ts.forEach(unionSignatures, function (sig) { return sig.thisParameter; });
+ if (firstThisParameterOfUnionSignatures) {
+ var thisType = getIntersectionType(ts.mapDefined(unionSignatures, function (sig) { return sig.thisParameter && getTypeOfSymbol(sig.thisParameter); }));
+ thisParameter = createSymbolWithType(firstThisParameterOfUnionSignatures, thisType);
+ }
+ s = createUnionSignature(signature, unionSignatures);
+ s.thisParameter = thisParameter;
+ }
+ (result || (result = [])).push(s);
+ }
+ }
}
}
- return false;
- }
- function isContextSensitiveFunctionLikeDeclaration(node) {
- return (!ts.isFunctionDeclaration(node) || ts.isInJSFile(node) && !!getTypeForDeclarationFromJSDocComment(node)) &&
- (hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node));
- }
- function hasContextSensitiveParameters(node) {
- if (!node.typeParameters) {
- if (ts.some(node.parameters, function (p) { return !ts.getEffectiveTypeAnnotationNode(p); })) {
- return true;
- }
- if (node.kind !== 202) {
- var parameter = ts.firstOrUndefined(node.parameters);
- if (!(parameter && ts.parameterIsThisKeyword(parameter))) {
- return true;
+ if (!ts.length(result) && indexWithLengthOverOne !== -1) {
+ var masterList = signatureLists[indexWithLengthOverOne !== undefined ? indexWithLengthOverOne : 0];
+ var results = masterList.slice();
+ var _loop_10 = function (signatures) {
+ if (signatures !== masterList) {
+ var signature_1 = signatures[0];
+ ts.Debug.assert(!!signature_1, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass");
+ results = signature_1.typeParameters && ts.some(results, function (s) { return !!s.typeParameters; }) ? undefined : ts.map(results, function (sig) { return combineSignaturesOfUnionMembers(sig, signature_1); });
+ if (!results) {
+ return "break";
+ }
}
+ };
+ for (var _b = 0, signatureLists_1 = signatureLists; _b < signatureLists_1.length; _b++) {
+ var signatures = signatureLists_1[_b];
+ var state_3 = _loop_10(signatures);
+ if (state_3 === "break")
+ break;
}
+ result = results;
}
- return false;
- }
- function hasContextSensitiveReturnExpression(node) {
- return !node.typeParameters && !ts.getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 223 && isContextSensitive(node.body);
+ return result || ts.emptyArray;
}
- function isContextSensitiveFunctionOrObjectLiteralMethod(func) {
- return (ts.isInJSFile(func) && ts.isFunctionDeclaration(func) || isFunctionExpressionOrArrowFunction(func) || ts.isObjectLiteralMethod(func)) &&
- isContextSensitiveFunctionLikeDeclaration(func);
+ function combineUnionThisParam(left, right) {
+ if (!left || !right) {
+ return left || right;
+ }
+ var thisType = getIntersectionType([getTypeOfSymbol(left), getTypeOfSymbol(right)]);
+ return createSymbolWithType(left, thisType);
}
- function getTypeWithoutSignatures(type) {
- if (type.flags & 524288) {
- var resolved = resolveStructuredTypeMembers(type);
- if (resolved.constructSignatures.length || resolved.callSignatures.length) {
- var result = createObjectType(16, type.symbol);
- result.members = resolved.members;
- result.properties = resolved.properties;
- result.callSignatures = ts.emptyArray;
- result.constructSignatures = ts.emptyArray;
- return result;
- }
+ function combineUnionParameters(left, right) {
+ var leftCount = getParameterCount(left);
+ var rightCount = getParameterCount(right);
+ var longest = leftCount >= rightCount ? left : right;
+ var shorter = longest === left ? right : left;
+ var longestCount = longest === left ? leftCount : rightCount;
+ var eitherHasEffectiveRest = (hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right));
+ var needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest);
+ var params = new Array(longestCount + (needsExtraRestElement ? 1 : 0));
+ for (var i = 0; i < longestCount; i++) {
+ var longestParamType = tryGetTypeAtPosition(longest, i);
+ var shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType;
+ var unionParamType = getIntersectionType([longestParamType, shorterParamType]);
+ var isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === (longestCount - 1);
+ var isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter);
+ var leftName = i >= leftCount ? undefined : getParameterNameAtPosition(left, i);
+ var rightName = i >= rightCount ? undefined : getParameterNameAtPosition(right, i);
+ var paramName = leftName === rightName ? leftName :
+ !leftName ? rightName :
+ !rightName ? leftName :
+ undefined;
+ var paramSymbol = createSymbol(1 | (isOptional && !isRestParam ? 16777216 : 0), paramName || "arg" + i);
+ paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
+ params[i] = paramSymbol;
}
- else if (type.flags & 2097152) {
- return getIntersectionType(ts.map(type.types, getTypeWithoutSignatures));
+ if (needsExtraRestElement) {
+ var restParamSymbol = createSymbol(1, "args");
+ restParamSymbol.type = createArrayType(getTypeAtPosition(shorter, longestCount));
+ params[longestCount] = restParamSymbol;
}
- return type;
- }
- function isTypeIdenticalTo(source, target) {
- return isTypeRelatedTo(source, target, identityRelation);
- }
- function compareTypesIdentical(source, target) {
- return isTypeRelatedTo(source, target, identityRelation) ? -1 : 0;
- }
- function compareTypesAssignable(source, target) {
- return isTypeRelatedTo(source, target, assignableRelation) ? -1 : 0;
- }
- function compareTypesSubtypeOf(source, target) {
- return isTypeRelatedTo(source, target, subtypeRelation) ? -1 : 0;
- }
- function isTypeSubtypeOf(source, target) {
- return isTypeRelatedTo(source, target, subtypeRelation);
+ return params;
}
- function isTypeAssignableTo(source, target) {
- return isTypeRelatedTo(source, target, assignableRelation);
+ function combineSignaturesOfUnionMembers(left, right) {
+ var declaration = left.declaration;
+ var params = combineUnionParameters(left, right);
+ var thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter);
+ var minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount);
+ var result = createSignature(declaration, left.typeParameters || right.typeParameters, thisParam, params, undefined, undefined, minArgCount, (left.flags | right.flags) & 19);
+ result.unionSignatures = ts.concatenate(left.unionSignatures || [left], [right]);
+ return result;
}
- function isTypeDerivedFrom(source, target) {
- return source.flags & 1048576 ? ts.every(source.types, function (t) { return isTypeDerivedFrom(t, target); }) :
- target.flags & 1048576 ? ts.some(target.types, function (t) { return isTypeDerivedFrom(source, t); }) :
- source.flags & 58982400 ? isTypeDerivedFrom(getBaseConstraintOfType(source) || unknownType, target) :
- target === globalObjectType ? !!(source.flags & (524288 | 67108864)) :
- target === globalFunctionType ? !!(source.flags & 524288) && isFunctionObjectType(source) :
- hasBaseType(source, getTargetType(target));
+ function getUnionIndexInfo(types, kind) {
+ var indexTypes = [];
+ var isAnyReadonly = false;
+ for (var _i = 0, types_4 = types; _i < types_4.length; _i++) {
+ var type = types_4[_i];
+ var indexInfo = getIndexInfoOfType(getApparentType(type), kind);
+ if (!indexInfo) {
+ return undefined;
+ }
+ indexTypes.push(indexInfo.type);
+ isAnyReadonly = isAnyReadonly || indexInfo.isReadonly;
+ }
+ return createIndexInfo(getUnionType(indexTypes, 2), isAnyReadonly);
}
- function isTypeComparableTo(source, target) {
- return isTypeRelatedTo(source, target, comparableRelation);
+ function resolveUnionTypeMembers(type) {
+ var callSignatures = getUnionSignatures(ts.map(type.types, function (t) { return t === globalFunctionType ? [unknownSignature] : getSignaturesOfType(t, 0); }));
+ var constructSignatures = getUnionSignatures(ts.map(type.types, function (t) { return getSignaturesOfType(t, 1); }));
+ var stringIndexInfo = getUnionIndexInfo(type.types, 0);
+ var numberIndexInfo = getUnionIndexInfo(type.types, 1);
+ setStructuredTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
}
- function areTypesComparable(type1, type2) {
- return isTypeComparableTo(type1, type2) || isTypeComparableTo(type2, type1);
+ function intersectTypes(type1, type2) {
+ return !type1 ? type2 : !type2 ? type1 : getIntersectionType([type1, type2]);
}
- function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain, errorOutputObject) {
- return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain, errorOutputObject);
+ function intersectIndexInfos(info1, info2) {
+ return !info1 ? info2 : !info2 ? info1 : createIndexInfo(getIntersectionType([info1.type, info2.type]), info1.isReadonly && info2.isReadonly);
}
- function checkTypeAssignableToAndOptionallyElaborate(source, target, errorNode, expr, headMessage, containingMessageChain) {
- return checkTypeRelatedToAndOptionallyElaborate(source, target, assignableRelation, errorNode, expr, headMessage, containingMessageChain, undefined);
+ function unionSpreadIndexInfos(info1, info2) {
+ return info1 && info2 && createIndexInfo(getUnionType([info1.type, info2.type]), info1.isReadonly || info2.isReadonly);
}
- 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);
+ function findMixins(types) {
+ var constructorTypeCount = ts.countWhere(types, function (t) { return getSignaturesOfType(t, 1).length > 0; });
+ var mixinFlags = ts.map(types, isMixinConstructorType);
+ if (constructorTypeCount > 0 && constructorTypeCount === ts.countWhere(mixinFlags, function (b) { return b; })) {
+ var firstMixinIndex = mixinFlags.indexOf(true);
+ mixinFlags[firstMixinIndex] = false;
}
- return false;
- }
- function isOrHasGenericConditional(type) {
- return !!(type.flags & 16777216 || (type.flags & 2097152 && ts.some(type.types, isOrHasGenericConditional)));
+ return mixinFlags;
}
- function elaborateError(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) {
- if (!node || isOrHasGenericConditional(target))
- return false;
- if (!checkTypeRelatedTo(source, target, relation, undefined)
- && elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer)) {
- return true;
+ function includeMixinType(type, types, mixinFlags, index) {
+ var mixedTypes = [];
+ for (var i = 0; i < types.length; i++) {
+ if (i === index) {
+ mixedTypes.push(type);
+ }
+ else if (mixinFlags[i]) {
+ mixedTypes.push(getReturnTypeOfSignature(getSignaturesOfType(types[i], 1)[0]));
+ }
}
- switch (node.kind) {
- case 276:
- case 200:
- return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
- case 209:
- switch (node.operatorToken.kind) {
- case 62:
- case 27:
- return elaborateError(node.right, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
+ return getIntersectionType(mixedTypes);
+ }
+ function resolveIntersectionTypeMembers(type) {
+ var callSignatures;
+ var constructSignatures;
+ var stringIndexInfo;
+ var numberIndexInfo;
+ var types = type.types;
+ var mixinFlags = findMixins(types);
+ var mixinCount = ts.countWhere(mixinFlags, function (b) { return b; });
+ var _loop_11 = function (i) {
+ var t = type.types[i];
+ if (!mixinFlags[i]) {
+ var signatures = getSignaturesOfType(t, 1);
+ if (signatures.length && mixinCount > 0) {
+ signatures = ts.map(signatures, function (s) {
+ var clone = cloneSignature(s);
+ clone.resolvedReturnType = includeMixinType(getReturnTypeOfSignature(s), types, mixinFlags, i);
+ return clone;
+ });
}
- break;
- case 193:
- return elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer);
- case 192:
- return elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer);
- case 274:
- return elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer);
- case 202:
- return elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer);
+ constructSignatures = appendSignatures(constructSignatures, signatures);
+ }
+ callSignatures = appendSignatures(callSignatures, getSignaturesOfType(t, 0));
+ stringIndexInfo = intersectIndexInfos(stringIndexInfo, getIndexInfoOfType(t, 0));
+ numberIndexInfo = intersectIndexInfos(numberIndexInfo, getIndexInfoOfType(t, 1));
+ };
+ for (var i = 0; i < types.length; i++) {
+ _loop_11(i);
}
- return false;
+ setStructuredTypeMembers(type, emptySymbols, callSignatures || ts.emptyArray, constructSignatures || ts.emptyArray, stringIndexInfo, numberIndexInfo);
}
- function elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) {
- var callSignatures = getSignaturesOfType(source, 0);
- var constructSignatures = getSignaturesOfType(source, 1);
- for (var _i = 0, _a = [constructSignatures, callSignatures]; _i < _a.length; _i++) {
- var signatures = _a[_i];
- if (ts.some(signatures, function (s) {
- var returnType = getReturnTypeOfSignature(s);
- return !(returnType.flags & (1 | 131072)) && checkTypeRelatedTo(returnType, target, relation, undefined);
- })) {
- var resultObj = errorOutputContainer || {};
- checkTypeAssignableTo(source, target, node, headMessage, containingMessageChain, resultObj);
- var diagnostic = resultObj.errors[resultObj.errors.length - 1];
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(node, signatures === constructSignatures ? ts.Diagnostics.Did_you_mean_to_use_new_with_this_expression : ts.Diagnostics.Did_you_mean_to_call_this_expression));
- return true;
+ function appendSignatures(signatures, newSignatures) {
+ var _loop_12 = function (sig) {
+ if (!signatures || ts.every(signatures, function (s) { return !compareSignaturesIdentical(s, sig, false, false, false, compareTypesIdentical); })) {
+ signatures = ts.append(signatures, sig);
}
+ };
+ for (var _i = 0, newSignatures_1 = newSignatures; _i < newSignatures_1.length; _i++) {
+ var sig = newSignatures_1[_i];
+ _loop_12(sig);
}
- return false;
+ return signatures;
}
- function elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer) {
- if (ts.isBlock(node.body)) {
- return false;
- }
- if (ts.some(node.parameters, ts.hasType)) {
- return false;
- }
- var sourceSig = getSingleCallSignature(source);
- if (!sourceSig) {
- return false;
+ function resolveAnonymousTypeMembers(type) {
+ var symbol = getMergedSymbol(type.symbol);
+ if (type.target) {
+ setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ var members = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, false);
+ var callSignatures = instantiateSignatures(getSignaturesOfType(type.target, 0), type.mapper);
+ var constructSignatures = instantiateSignatures(getSignaturesOfType(type.target, 1), type.mapper);
+ var stringIndexInfo = instantiateIndexInfo(getIndexInfoOfType(type.target, 0), type.mapper);
+ var numberIndexInfo = instantiateIndexInfo(getIndexInfoOfType(type.target, 1), type.mapper);
+ setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
}
- var targetSignatures = getSignaturesOfType(target, 0);
- if (!ts.length(targetSignatures)) {
- return false;
+ else if (symbol.flags & 2048) {
+ setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ var members = getMembersOfSymbol(symbol);
+ var callSignatures = getSignaturesOfSymbol(members.get("__call"));
+ var constructSignatures = getSignaturesOfSymbol(members.get("__new"));
+ var stringIndexInfo = getIndexInfoOfSymbol(symbol, 0);
+ var numberIndexInfo = getIndexInfoOfSymbol(symbol, 1);
+ setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
}
- var returnExpression = node.body;
- var sourceReturn = getReturnTypeOfSignature(sourceSig);
- var targetReturn = getUnionType(ts.map(targetSignatures, getReturnTypeOfSignature));
- if (!checkTypeRelatedTo(sourceReturn, targetReturn, relation, undefined)) {
- var elaborated = returnExpression && elaborateError(returnExpression, sourceReturn, targetReturn, relation, undefined, containingMessageChain, errorOutputContainer);
- if (elaborated) {
- return elaborated;
+ else {
+ var members = emptySymbols;
+ var stringIndexInfo = void 0;
+ if (symbol.exports) {
+ members = getExportsOfSymbol(symbol);
+ if (symbol === globalThisSymbol) {
+ var varsOnly_1 = new ts.Map();
+ members.forEach(function (p) {
+ if (!(p.flags & 418)) {
+ varsOnly_1.set(p.escapedName, p);
+ }
+ });
+ members = varsOnly_1;
+ }
+ }
+ setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ if (symbol.flags & 32) {
+ var classType = getDeclaredTypeOfClassOrInterface(symbol);
+ var baseConstructorType = getBaseConstructorTypeOfClass(classType);
+ if (baseConstructorType.flags & (524288 | 2097152 | 8650752)) {
+ members = ts.createSymbolTable(getNamedMembers(members));
+ addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
+ }
+ else if (baseConstructorType === anyType) {
+ stringIndexInfo = createIndexInfo(anyType, false);
+ }
+ }
+ var numberIndexInfo = symbol.flags & 384 && (getDeclaredTypeOfSymbol(symbol).flags & 32 ||
+ ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296); })) ? enumNumberIndexInfo : undefined;
+ setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo);
+ if (symbol.flags & (16 | 8192)) {
+ type.callSignatures = getSignaturesOfSymbol(symbol);
}
- var resultObj = errorOutputContainer || {};
- checkTypeRelatedTo(sourceReturn, targetReturn, relation, returnExpression, undefined, containingMessageChain, resultObj);
- if (resultObj.errors) {
- if (target.symbol && ts.length(target.symbol.declarations)) {
- ts.addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], ts.createDiagnosticForNode(target.symbol.declarations[0], ts.Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature));
+ if (symbol.flags & 32) {
+ var classType_1 = getDeclaredTypeOfClassOrInterface(symbol);
+ var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor")) : ts.emptyArray;
+ if (symbol.flags & 16) {
+ constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ?
+ createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, undefined, sig.minArgumentCount, sig.flags & 19) :
+ undefined; }));
}
- if ((ts.getFunctionFlags(node) & 2) === 0
- && !getTypeOfPropertyOfType(sourceReturn, "then")
- && checkTypeRelatedTo(createPromiseType(sourceReturn), targetReturn, relation, undefined)) {
- ts.addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], ts.createDiagnosticForNode(node, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async));
+ if (!constructSignatures.length) {
+ constructSignatures = getDefaultConstructSignatures(classType_1);
}
- return true;
+ type.constructSignatures = constructSignatures;
}
}
- return false;
}
- function getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType) {
- var idx = getIndexedAccessTypeOrUndefined(target, nameType);
- if (idx) {
- return idx;
+ function resolveReverseMappedTypeMembers(type) {
+ var indexInfo = getIndexInfoOfType(type.source, 0);
+ var modifiers = getMappedTypeModifiers(type.mappedType);
+ var readonlyMask = modifiers & 1 ? false : true;
+ var optionalMask = modifiers & 4 ? 0 : 16777216;
+ var stringIndexInfo = indexInfo && createIndexInfo(inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly);
+ var members = ts.createSymbolTable();
+ for (var _i = 0, _a = getPropertiesOfType(type.source); _i < _a.length; _i++) {
+ var prop = _a[_i];
+ var checkFlags = 8192 | (readonlyMask && isReadonlySymbol(prop) ? 8 : 0);
+ var inferredProp = createSymbol(4 | prop.flags & optionalMask, prop.escapedName, checkFlags);
+ inferredProp.declarations = prop.declarations;
+ inferredProp.nameType = getSymbolLinks(prop).nameType;
+ inferredProp.propertyType = getTypeOfSymbol(prop);
+ inferredProp.mappedType = type.mappedType;
+ inferredProp.constraintType = type.constraintType;
+ members.set(prop.escapedName, inferredProp);
}
- if (target.flags & 1048576) {
- var best = getBestMatchingType(source, target);
- if (best) {
- return getIndexedAccessTypeOrUndefined(best, nameType);
+ setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, undefined);
+ }
+ function getLowerBoundOfKeyType(type) {
+ if (type.flags & 4194304) {
+ var t = getApparentType(type.type);
+ return isGenericTupleType(t) ? getKnownKeysOfTupleType(t) : getIndexType(t);
+ }
+ if (type.flags & 16777216) {
+ if (type.root.isDistributive) {
+ var checkType = type.checkType;
+ var constraint = getLowerBoundOfKeyType(checkType);
+ if (constraint !== checkType) {
+ return getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+ }
}
+ return type;
}
- }
- function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
- next.contextualType = sourcePropType;
- try {
- return checkExpressionForMutableLocation(next, 1, sourcePropType);
+ if (type.flags & 1048576) {
+ return getUnionType(ts.sameMap(type.types, getLowerBoundOfKeyType));
}
- finally {
- next.contextualType = undefined;
+ if (type.flags & 2097152) {
+ return getIntersectionType(ts.sameMap(type.types, getLowerBoundOfKeyType));
}
+ return type;
}
- function elaborateElementwise(iterator, source, target, relation, containingMessageChain, errorOutputContainer) {
- var reportedError = false;
- for (var status = iterator.next(); !status.done; status = iterator.next()) {
- var _a = status.value, prop = _a.errorNode, next = _a.innerExpression, nameType = _a.nameType, errorMessage = _a.errorMessage;
- var targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType);
- if (!targetPropType || targetPropType.flags & 8388608)
- continue;
- var sourcePropType = getIndexedAccessTypeOrUndefined(source, nameType);
- if (sourcePropType && !checkTypeRelatedTo(sourcePropType, targetPropType, relation, undefined)) {
- var elaborated = next && elaborateError(next, sourcePropType, targetPropType, relation, undefined, containingMessageChain, errorOutputContainer);
- if (elaborated) {
- reportedError = true;
+ function resolveMappedTypeMembers(type) {
+ var members = ts.createSymbolTable();
+ var stringIndexInfo;
+ var numberIndexInfo;
+ setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ var typeParameter = getTypeParameterFromMappedType(type);
+ var constraintType = getConstraintTypeFromMappedType(type);
+ var nameType = getNameTypeFromMappedType(type.target || type);
+ var templateType = getTemplateTypeFromMappedType(type.target || type);
+ var modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
+ var templateModifiers = getMappedTypeModifiers(type);
+ var include = keyofStringsOnly ? 128 : 8576;
+ if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
+ for (var _i = 0, _a = getPropertiesOfType(modifiersType); _i < _a.length; _i++) {
+ var prop = _a[_i];
+ addMemberForKeyType(getLiteralTypeFromProperty(prop, include));
+ }
+ if (modifiersType.flags & 1 || getIndexInfoOfType(modifiersType, 0)) {
+ addMemberForKeyType(stringType);
+ }
+ if (!keyofStringsOnly && getIndexInfoOfType(modifiersType, 1)) {
+ addMemberForKeyType(numberType);
+ }
+ }
+ else {
+ forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
+ }
+ setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo);
+ function addMemberForKeyType(keyType) {
+ var propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType;
+ forEachType(propNameType, function (t) { return addMemberForKeyTypeWorker(keyType, t); });
+ }
+ function addMemberForKeyTypeWorker(keyType, propNameType) {
+ if (isTypeUsableAsPropertyName(propNameType)) {
+ var propName = getPropertyNameFromType(propNameType);
+ var existingProp = members.get(propName);
+ if (existingProp) {
+ existingProp.nameType = getUnionType([existingProp.nameType, propNameType]);
+ existingProp.keyType = getUnionType([existingProp.keyType, keyType]);
}
else {
- var resultObj = errorOutputContainer || {};
- var specificSource = next ? checkExpressionForMutableLocationWithContextualType(next, sourcePropType) : sourcePropType;
- var result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
- if (result && specificSource !== sourcePropType) {
- checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
- }
- if (resultObj.errors) {
- var reportedDiag = resultObj.errors[resultObj.errors.length - 1];
- var propertyName = isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined;
- var targetProp = propertyName !== undefined ? getPropertyOfType(target, propertyName) : undefined;
- var issuedElaboration = false;
- if (!targetProp) {
- var indexInfo = isTypeAssignableToKind(nameType, 296) && getIndexInfoOfType(target, 1) ||
- getIndexInfoOfType(target, 0) ||
- undefined;
- if (indexInfo && indexInfo.declaration && !ts.getSourceFileOfNode(indexInfo.declaration).hasNoDefaultLib) {
- issuedElaboration = true;
- ts.addRelatedInfo(reportedDiag, ts.createDiagnosticForNode(indexInfo.declaration, ts.Diagnostics.The_expected_type_comes_from_this_index_signature));
- }
- }
- if (!issuedElaboration && (targetProp && ts.length(targetProp.declarations) || target.symbol && ts.length(target.symbol.declarations))) {
- var targetNode = targetProp && ts.length(targetProp.declarations) ? targetProp.declarations[0] : target.symbol.declarations[0];
- if (!ts.getSourceFileOfNode(targetNode).hasNoDefaultLib) {
- ts.addRelatedInfo(reportedDiag, ts.createDiagnosticForNode(targetNode, ts.Diagnostics.The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1, propertyName && !(nameType.flags & 8192) ? ts.unescapeLeadingUnderscores(propertyName) : typeToString(nameType), typeToString(target)));
- }
- }
- }
- reportedError = true;
+ var modifiersProp = isTypeUsableAsPropertyName(keyType) ? getPropertyOfType(modifiersType, getPropertyNameFromType(keyType)) : undefined;
+ var isOptional = !!(templateModifiers & 4 ||
+ !(templateModifiers & 8) && modifiersProp && modifiersProp.flags & 16777216);
+ var isReadonly = !!(templateModifiers & 1 ||
+ !(templateModifiers & 2) && modifiersProp && isReadonlySymbol(modifiersProp));
+ var stripOptional = strictNullChecks && !isOptional && modifiersProp && modifiersProp.flags & 16777216;
+ var prop = createSymbol(4 | (isOptional ? 16777216 : 0), propName, 262144 | (isReadonly ? 8 : 0) | (stripOptional ? 524288 : 0));
+ prop.mappedType = type;
+ prop.nameType = propNameType;
+ prop.keyType = keyType;
+ if (modifiersProp) {
+ prop.syntheticOrigin = modifiersProp;
+ prop.declarations = modifiersProp.declarations;
+ }
+ members.set(propName, prop);
+ }
+ }
+ else if (propNameType.flags & (1 | 4 | 8 | 32)) {
+ var propType = instantiateType(templateType, appendTypeMapping(type.mapper, typeParameter, keyType));
+ if (propNameType.flags & (1 | 4)) {
+ stringIndexInfo = createIndexInfo(stringIndexInfo ? getUnionType([stringIndexInfo.type, propType]) : propType, !!(templateModifiers & 1));
+ }
+ else {
+ numberIndexInfo = createIndexInfo(numberIndexInfo ? getUnionType([numberIndexInfo.type, propType]) : propType, !!(templateModifiers & 1));
}
}
}
- return reportedError;
}
- function generateJsxAttributes(node) {
- var _i, _a, prop;
- return __generator(this, function (_b) {
- switch (_b.label) {
- case 0:
- if (!ts.length(node.properties))
- return [2];
- _i = 0, _a = node.properties;
- _b.label = 1;
- case 1:
- if (!(_i < _a.length)) return [3, 4];
- prop = _a[_i];
- if (ts.isJsxSpreadAttribute(prop))
- return [3, 3];
- return [4, { errorNode: prop.name, innerExpression: prop.initializer, nameType: getLiteralType(ts.idText(prop.name)) }];
- case 2:
- _b.sent();
- _b.label = 3;
- case 3:
- _i++;
- return [3, 1];
- case 4: return [2];
+ function getTypeOfMappedSymbol(symbol) {
+ if (!symbol.type) {
+ var mappedType = symbol.mappedType;
+ if (!pushTypeResolution(symbol, 0)) {
+ mappedType.containsError = true;
+ return errorType;
}
- });
- }
- function generateJsxChildren(node, getInvalidTextDiagnostic) {
- var memberOffset, i, child, nameType, elem;
- return __generator(this, function (_a) {
- switch (_a.label) {
- case 0:
- if (!ts.length(node.children))
- return [2];
- memberOffset = 0;
- i = 0;
- _a.label = 1;
- case 1:
- if (!(i < node.children.length)) return [3, 5];
- child = node.children[i];
- nameType = getLiteralType(i - memberOffset);
- elem = getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic);
- if (!elem) return [3, 3];
- return [4, elem];
- case 2:
- _a.sent();
- return [3, 4];
- case 3:
- memberOffset++;
- _a.label = 4;
- case 4:
- i++;
- return [3, 1];
- case 5: return [2];
+ var templateType = getTemplateTypeFromMappedType(mappedType.target || mappedType);
+ var mapper = appendTypeMapping(mappedType.mapper, getTypeParameterFromMappedType(mappedType), symbol.keyType);
+ var propType = instantiateType(templateType, mapper);
+ var type = strictNullChecks && symbol.flags & 16777216 && !maybeTypeOfKind(propType, 32768 | 16384) ? getOptionalType(propType) :
+ symbol.checkFlags & 524288 ? getTypeWithFacts(propType, 524288) :
+ propType;
+ if (!popTypeResolution()) {
+ error(currentNode, ts.Diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1, symbolToString(symbol), typeToString(mappedType));
+ type = errorType;
}
- });
- }
- function getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic) {
- switch (child.kind) {
- case 276:
- return { errorNode: child, innerExpression: child.expression, nameType: nameType };
- case 11:
- if (child.containsOnlyTriviaWhiteSpaces) {
- break;
- }
- return { errorNode: child, innerExpression: undefined, nameType: nameType, errorMessage: getInvalidTextDiagnostic() };
- case 266:
- case 267:
- case 270:
- return { errorNode: child, innerExpression: child, nameType: nameType };
- default:
- return ts.Debug.assertNever(child, "Found invalid jsx child");
+ symbol.type = type;
}
+ return symbol.type;
+ }
+ function getTypeParameterFromMappedType(type) {
+ return type.typeParameter ||
+ (type.typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(type.declaration.typeParameter)));
}
- function getSemanticJsxChildren(children) {
- return ts.filter(children, function (i) { return !ts.isJsxText(i) || !i.containsOnlyTriviaWhiteSpaces; });
+ function getConstraintTypeFromMappedType(type) {
+ return type.constraintType ||
+ (type.constraintType = getConstraintOfTypeParameter(getTypeParameterFromMappedType(type)) || errorType);
}
- function elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer) {
- var result = elaborateElementwise(generateJsxAttributes(node), source, target, relation, containingMessageChain, errorOutputContainer);
- var invalidTextDiagnostic;
- if (ts.isJsxOpeningElement(node.parent) && ts.isJsxElement(node.parent.parent)) {
- var containingElement = node.parent.parent;
- var childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
- var childrenPropName = childPropName === undefined ? "children" : ts.unescapeLeadingUnderscores(childPropName);
- var childrenNameType = getLiteralType(childrenPropName);
- var childrenTargetType = getIndexedAccessType(target, childrenNameType);
- var validChildren = getSemanticJsxChildren(containingElement.children);
- if (!ts.length(validChildren)) {
- return result;
+ function getNameTypeFromMappedType(type) {
+ return type.declaration.nameType ?
+ type.nameType || (type.nameType = instantiateType(getTypeFromTypeNode(type.declaration.nameType), type.mapper)) :
+ undefined;
+ }
+ function getTemplateTypeFromMappedType(type) {
+ return type.templateType ||
+ (type.templateType = type.declaration.type ?
+ instantiateType(addOptionality(getTypeFromTypeNode(type.declaration.type), !!(getMappedTypeModifiers(type) & 4)), type.mapper) :
+ errorType);
+ }
+ function getConstraintDeclarationForMappedType(type) {
+ return ts.getEffectiveConstraintOfTypeParameter(type.declaration.typeParameter);
+ }
+ function isMappedTypeWithKeyofConstraintDeclaration(type) {
+ var constraintDeclaration = getConstraintDeclarationForMappedType(type);
+ return constraintDeclaration.kind === 188 &&
+ constraintDeclaration.operator === 138;
+ }
+ function getModifiersTypeFromMappedType(type) {
+ if (!type.modifiersType) {
+ if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
+ type.modifiersType = instantiateType(getTypeFromTypeNode(getConstraintDeclarationForMappedType(type).type), type.mapper);
}
- var moreThanOneRealChildren = ts.length(validChildren) > 1;
- var arrayLikeTargetParts = filterType(childrenTargetType, isArrayOrTupleLikeType);
- var nonArrayLikeTargetParts = filterType(childrenTargetType, function (t) { return !isArrayOrTupleLikeType(t); });
- if (moreThanOneRealChildren) {
- if (arrayLikeTargetParts !== neverType) {
- var realSource = createTupleType(checkJsxChildren(containingElement, 0));
- var children = generateJsxChildren(containingElement, getInvalidTextualChildDiagnostic);
- result = elaborateElementwise(children, realSource, arrayLikeTargetParts, relation, containingMessageChain, errorOutputContainer) || result;
+ else {
+ var declaredType = getTypeFromMappedTypeNode(type.declaration);
+ var constraint = getConstraintTypeFromMappedType(declaredType);
+ var extendedConstraint = constraint && constraint.flags & 262144 ? getConstraintOfTypeParameter(constraint) : constraint;
+ type.modifiersType = extendedConstraint && extendedConstraint.flags & 4194304 ? instantiateType(extendedConstraint.type, type.mapper) : unknownType;
+ }
+ }
+ return type.modifiersType;
+ }
+ function getMappedTypeModifiers(type) {
+ var declaration = type.declaration;
+ return (declaration.readonlyToken ? declaration.readonlyToken.kind === 40 ? 2 : 1 : 0) |
+ (declaration.questionToken ? declaration.questionToken.kind === 40 ? 8 : 4 : 0);
+ }
+ function getMappedTypeOptionality(type) {
+ var modifiers = getMappedTypeModifiers(type);
+ return modifiers & 8 ? -1 : modifiers & 4 ? 1 : 0;
+ }
+ function getCombinedMappedTypeOptionality(type) {
+ var optionality = getMappedTypeOptionality(type);
+ var modifiersType = getModifiersTypeFromMappedType(type);
+ return optionality || (isGenericMappedType(modifiersType) ? getMappedTypeOptionality(modifiersType) : 0);
+ }
+ function isPartialMappedType(type) {
+ return !!(ts.getObjectFlags(type) & 32 && getMappedTypeModifiers(type) & 4);
+ }
+ function isGenericMappedType(type) {
+ return !!(ts.getObjectFlags(type) & 32) && isGenericIndexType(getConstraintTypeFromMappedType(type));
+ }
+ function resolveStructuredTypeMembers(type) {
+ if (!type.members) {
+ if (type.flags & 524288) {
+ if (type.objectFlags & 4) {
+ resolveTypeReferenceMembers(type);
}
- else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) {
- result = true;
- var diag = error(containingElement.openingElement.tagName, ts.Diagnostics.This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided, childrenPropName, typeToString(childrenTargetType));
- if (errorOutputContainer && errorOutputContainer.skipLogging) {
- (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
- }
+ else if (type.objectFlags & 3) {
+ resolveClassOrInterfaceMembers(type);
}
- }
- else {
- if (nonArrayLikeTargetParts !== neverType) {
- var child = validChildren[0];
- var elem_1 = getElaborationElementForJsxChild(child, childrenNameType, getInvalidTextualChildDiagnostic);
- if (elem_1) {
- result = elaborateElementwise((function () { return __generator(this, function (_a) {
- switch (_a.label) {
- case 0: return [4, elem_1];
- case 1:
- _a.sent();
- return [2];
- }
- }); })(), source, target, relation, containingMessageChain, errorOutputContainer) || result;
- }
+ else if (type.objectFlags & 2048) {
+ resolveReverseMappedTypeMembers(type);
}
- else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) {
- result = true;
- var diag = error(containingElement.openingElement.tagName, ts.Diagnostics.This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided, childrenPropName, typeToString(childrenTargetType));
- if (errorOutputContainer && errorOutputContainer.skipLogging) {
- (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
- }
+ else if (type.objectFlags & 16) {
+ resolveAnonymousTypeMembers(type);
+ }
+ else if (type.objectFlags & 32) {
+ resolveMappedTypeMembers(type);
}
}
- }
- return result;
- function getInvalidTextualChildDiagnostic() {
- if (!invalidTextDiagnostic) {
- var tagNameText = ts.getTextOfNode(node.parent.tagName);
- var childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
- var childrenPropName = childPropName === undefined ? "children" : ts.unescapeLeadingUnderscores(childPropName);
- var childrenTargetType = getIndexedAccessType(target, getLiteralType(childrenPropName));
- var diagnostic = ts.Diagnostics._0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2;
- invalidTextDiagnostic = __assign(__assign({}, diagnostic), { key: "!!ALREADY FORMATTED!!", message: ts.formatMessage(undefined, diagnostic, tagNameText, childrenPropName, typeToString(childrenTargetType)) });
+ else if (type.flags & 1048576) {
+ resolveUnionTypeMembers(type);
}
- return invalidTextDiagnostic;
- }
- }
- function generateLimitedTupleElements(node, target) {
- var len, i, elem, nameType;
- return __generator(this, function (_a) {
- switch (_a.label) {
- case 0:
- len = ts.length(node.elements);
- if (!len)
- return [2];
- i = 0;
- _a.label = 1;
- case 1:
- if (!(i < len)) return [3, 4];
- if (isTupleLikeType(target) && !getPropertyOfType(target, ("" + i)))
- return [3, 3];
- elem = node.elements[i];
- if (ts.isOmittedExpression(elem))
- return [3, 3];
- nameType = getLiteralType(i);
- return [4, { errorNode: elem, innerExpression: elem, nameType: nameType }];
- case 2:
- _a.sent();
- _a.label = 3;
- case 3:
- i++;
- return [3, 1];
- case 4: return [2];
+ else if (type.flags & 2097152) {
+ resolveIntersectionTypeMembers(type);
}
- });
+ }
+ return type;
}
- function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
- if (target.flags & 131068)
- return false;
- if (isTupleLikeType(source)) {
- return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
+ function getPropertiesOfObjectType(type) {
+ if (type.flags & 524288) {
+ return resolveStructuredTypeMembers(type).properties;
}
- var oldContext = node.contextualType;
- node.contextualType = target;
- try {
- var tupleizedType = checkArrayLiteral(node, 1, true);
- node.contextualType = oldContext;
- if (isTupleLikeType(tupleizedType)) {
- return elaborateElementwise(generateLimitedTupleElements(node, target), tupleizedType, target, relation, containingMessageChain, errorOutputContainer);
+ return ts.emptyArray;
+ }
+ function getPropertyOfObjectType(type, name) {
+ if (type.flags & 524288) {
+ var resolved = resolveStructuredTypeMembers(type);
+ var symbol = resolved.members.get(name);
+ if (symbol && symbolIsValue(symbol)) {
+ return symbol;
}
- return false;
- }
- finally {
- node.contextualType = oldContext;
}
}
- function generateObjectLiteralElements(node) {
- var _i, _a, prop, type, _b;
- return __generator(this, function (_c) {
- switch (_c.label) {
- case 0:
- if (!ts.length(node.properties))
- return [2];
- _i = 0, _a = node.properties;
- _c.label = 1;
- case 1:
- if (!(_i < _a.length)) return [3, 8];
- prop = _a[_i];
- if (ts.isSpreadAssignment(prop))
- return [3, 7];
- type = getLiteralTypeFromProperty(getSymbolOfNode(prop), 8576);
- if (!type || (type.flags & 131072)) {
- return [3, 7];
- }
- _b = prop.kind;
- switch (_b) {
- case 164: return [3, 2];
- case 163: return [3, 2];
- case 161: return [3, 2];
- case 282: return [3, 2];
- case 281: return [3, 4];
+ function getPropertiesOfUnionOrIntersectionType(type) {
+ if (!type.resolvedProperties) {
+ var members = ts.createSymbolTable();
+ for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+ var current = _a[_i];
+ for (var _b = 0, _c = getPropertiesOfType(current); _b < _c.length; _b++) {
+ var prop = _c[_b];
+ if (!members.has(prop.escapedName)) {
+ var combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName);
+ if (combinedProp) {
+ members.set(prop.escapedName, combinedProp);
+ }
}
- return [3, 6];
- case 2: return [4, { errorNode: prop.name, innerExpression: undefined, nameType: type }];
- case 3:
- _c.sent();
- return [3, 7];
- case 4: return [4, { errorNode: prop.name, innerExpression: prop.initializer, nameType: type, errorMessage: ts.isComputedNonLiteralName(prop.name) ? ts.Diagnostics.Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1 : undefined }];
- case 5:
- _c.sent();
- return [3, 7];
- case 6:
- ts.Debug.assertNever(prop);
- _c.label = 7;
- case 7:
- _i++;
- return [3, 1];
- case 8: return [2];
+ }
+ if (type.flags & 1048576 && !getIndexInfoOfType(current, 0) && !getIndexInfoOfType(current, 1)) {
+ break;
+ }
}
+ type.resolvedProperties = getNamedMembers(members);
+ }
+ return type.resolvedProperties;
+ }
+ function getPropertiesOfType(type) {
+ type = getReducedApparentType(type);
+ return type.flags & 3145728 ?
+ getPropertiesOfUnionOrIntersectionType(type) :
+ getPropertiesOfObjectType(type);
+ }
+ function isTypeInvalidDueToUnionDiscriminant(contextualType, obj) {
+ var list = obj.properties;
+ return list.some(function (property) {
+ var nameType = property.name && getLiteralTypeFromPropertyName(property.name);
+ var name = nameType && isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined;
+ var expected = name === undefined ? undefined : getTypeOfPropertyOfType(contextualType, name);
+ return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property), expected);
});
}
- function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
- if (target.flags & 131068)
- return false;
- return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
+ function getAllPossiblePropertiesOfTypes(types) {
+ var unionType = getUnionType(types);
+ if (!(unionType.flags & 1048576)) {
+ return getAugmentedPropertiesOfType(unionType);
+ }
+ var props = ts.createSymbolTable();
+ for (var _i = 0, types_5 = types; _i < types_5.length; _i++) {
+ var memberType = types_5[_i];
+ for (var _a = 0, _b = getAugmentedPropertiesOfType(memberType); _a < _b.length; _a++) {
+ var escapedName = _b[_a].escapedName;
+ if (!props.has(escapedName)) {
+ var prop = createUnionOrIntersectionProperty(unionType, escapedName);
+ if (prop)
+ props.set(escapedName, prop);
+ }
+ }
+ }
+ return ts.arrayFrom(props.values());
}
- function checkTypeComparableTo(source, target, errorNode, headMessage, containingMessageChain) {
- return checkTypeRelatedTo(source, target, comparableRelation, errorNode, headMessage, containingMessageChain);
+ function getConstraintOfType(type) {
+ return type.flags & 262144 ? getConstraintOfTypeParameter(type) :
+ type.flags & 8388608 ? getConstraintOfIndexedAccess(type) :
+ type.flags & 16777216 ? getConstraintOfConditionalType(type) :
+ getBaseConstraintOfType(type);
}
- function isSignatureAssignableTo(source, target, ignoreReturnTypes) {
- return compareSignaturesRelated(source, target, ignoreReturnTypes ? 4 : 0, false, undefined, undefined, compareTypesAssignable, undefined) !== 0;
+ function getConstraintOfTypeParameter(typeParameter) {
+ return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : undefined;
+ }
+ function getConstraintOfIndexedAccess(type) {
+ return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : undefined;
}
- 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 getSimplifiedTypeOrConstraint(type) {
+ var simplified = getSimplifiedType(type, false);
+ return simplified !== type ? simplified : getConstraintOfType(type);
}
- function compareSignaturesRelated(source, target, checkMode, reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) {
- if (source === target) {
- return -1;
- }
- if (isAnySignature(target)) {
- return -1;
- }
- var targetCount = getParameterCount(target);
- var sourceHasMoreParameters = !hasEffectiveRestParameter(target) &&
- (checkMode & 8 ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
- if (sourceHasMoreParameters) {
- return 0;
+ function getConstraintFromIndexedAccess(type) {
+ var indexConstraint = getSimplifiedTypeOrConstraint(type.indexType);
+ if (indexConstraint && indexConstraint !== type.indexType) {
+ var indexedAccess = getIndexedAccessTypeOrUndefined(type.objectType, indexConstraint, type.noUncheckedIndexedAccessCandidate);
+ if (indexedAccess) {
+ return indexedAccess;
+ }
}
- if (source.typeParameters && source.typeParameters !== target.typeParameters) {
- target = getCanonicalSignature(target);
- source = instantiateSignatureInContextOf(source, target, undefined, compareTypes);
+ var objectConstraint = getSimplifiedTypeOrConstraint(type.objectType);
+ if (objectConstraint && objectConstraint !== type.objectType) {
+ return getIndexedAccessTypeOrUndefined(objectConstraint, type.indexType, type.noUncheckedIndexedAccessCandidate);
}
- var sourceCount = getParameterCount(source);
- var sourceRestType = getNonArrayRestType(source);
- var targetRestType = getNonArrayRestType(target);
- if (sourceRestType || targetRestType) {
- void instantiateType(sourceRestType || targetRestType, reportUnreliableMarkers);
+ return undefined;
+ }
+ function getDefaultConstraintOfConditionalType(type) {
+ if (!type.resolvedDefaultConstraint) {
+ var trueConstraint = getInferredTrueTypeFromConditionalType(type);
+ var falseConstraint = getFalseTypeFromConditionalType(type);
+ type.resolvedDefaultConstraint = isTypeAny(trueConstraint) ? falseConstraint : isTypeAny(falseConstraint) ? trueConstraint : getUnionType([trueConstraint, falseConstraint]);
}
- if (sourceRestType && targetRestType && sourceCount !== targetCount) {
- return 0;
+ return type.resolvedDefaultConstraint;
+ }
+ function getConstraintOfDistributiveConditionalType(type) {
+ if (type.root.isDistributive && type.restrictiveInstantiation !== type) {
+ var simplified = getSimplifiedType(type.checkType, false);
+ var constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;
+ if (constraint && constraint !== type.checkType) {
+ var instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+ if (!(instantiated.flags & 131072)) {
+ return instantiated;
+ }
+ }
}
- var kind = target.declaration ? target.declaration.kind : 0;
- var strictVariance = !(checkMode & 3) && strictFunctionTypes && kind !== 161 &&
- kind !== 160 && kind !== 162;
- var result = -1;
- var sourceThisType = getThisTypeOfSignature(source);
- if (sourceThisType && sourceThisType !== voidType) {
- var targetThisType = getThisTypeOfSignature(target);
- if (targetThisType) {
- var related = !strictVariance && compareTypes(sourceThisType, targetThisType, false)
- || compareTypes(targetThisType, sourceThisType, reportErrors);
- if (!related) {
- if (reportErrors) {
- errorReporter(ts.Diagnostics.The_this_types_of_each_signature_are_incompatible);
+ return undefined;
+ }
+ function getConstraintFromConditionalType(type) {
+ return getConstraintOfDistributiveConditionalType(type) || getDefaultConstraintOfConditionalType(type);
+ }
+ function getConstraintOfConditionalType(type) {
+ return hasNonCircularBaseConstraint(type) ? getConstraintFromConditionalType(type) : undefined;
+ }
+ function getEffectiveConstraintOfIntersection(types, targetIsUnion) {
+ var constraints;
+ var hasDisjointDomainType = false;
+ for (var _i = 0, types_6 = types; _i < types_6.length; _i++) {
+ var t = types_6[_i];
+ if (t.flags & 465829888) {
+ var constraint = getConstraintOfType(t);
+ while (constraint && constraint.flags & (262144 | 4194304 | 16777216)) {
+ constraint = getConstraintOfType(constraint);
+ }
+ if (constraint) {
+ constraints = ts.append(constraints, constraint);
+ if (targetIsUnion) {
+ constraints = ts.append(constraints, t);
}
- return 0;
}
- result &= related;
}
- }
- var paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount);
- var restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
- for (var i = 0; i < paramCount; i++) {
- var sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : getTypeAtPosition(source, i);
- var targetType = i === restIndex ? getRestTypeAtPosition(target, i) : getTypeAtPosition(target, i);
- var sourceSig = checkMode & 3 ? undefined : getSingleCallSignature(getNonNullableType(sourceType));
- var targetSig = checkMode & 3 ? undefined : getSingleCallSignature(getNonNullableType(targetType));
- var callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) &&
- (getFalsyFlags(sourceType) & 98304) === (getFalsyFlags(targetType) & 98304);
- var related = callbacks ?
- compareSignaturesRelated(targetSig, sourceSig, (checkMode & 8) | (strictVariance ? 2 : 1), reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) :
- !(checkMode & 3) && !strictVariance && compareTypes(sourceType, targetType, false) || compareTypes(targetType, sourceType, reportErrors);
- if (related && checkMode & 8 && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes(sourceType, targetType, false)) {
- related = 0;
+ else if (t.flags & 469892092) {
+ hasDisjointDomainType = true;
}
- if (!related) {
- if (reportErrors) {
- errorReporter(ts.Diagnostics.Types_of_parameters_0_and_1_are_incompatible, ts.unescapeLeadingUnderscores(getParameterNameAtPosition(source, i)), ts.unescapeLeadingUnderscores(getParameterNameAtPosition(target, i)));
+ }
+ if (constraints && (targetIsUnion || hasDisjointDomainType)) {
+ if (hasDisjointDomainType) {
+ for (var _a = 0, types_7 = types; _a < types_7.length; _a++) {
+ var t = types_7[_a];
+ if (t.flags & 469892092) {
+ constraints = ts.append(constraints, t);
+ }
}
- return 0;
}
- result &= related;
+ return getIntersectionType(constraints);
}
- if (!(checkMode & 4)) {
- var targetReturnType = isResolvingReturnTypeOfSignature(target) ? anyType
- : target.declaration && isJSConstructor(target.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(target.declaration.symbol))
- : getReturnTypeOfSignature(target);
- if (targetReturnType === voidType) {
- return result;
- }
- var sourceReturnType = isResolvingReturnTypeOfSignature(source) ? anyType
- : source.declaration && isJSConstructor(source.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(source.declaration.symbol))
- : getReturnTypeOfSignature(source);
- var targetTypePredicate = getTypePredicateOfSignature(target);
- if (targetTypePredicate) {
- var sourceTypePredicate = getTypePredicateOfSignature(source);
- if (sourceTypePredicate) {
- result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors, errorReporter, compareTypes);
+ return undefined;
+ }
+ function getBaseConstraintOfType(type) {
+ if (type.flags & (58982400 | 3145728 | 134217728 | 268435456)) {
+ var constraint = getResolvedBaseConstraint(type);
+ return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : undefined;
+ }
+ return type.flags & 4194304 ? keyofConstraintType : undefined;
+ }
+ function getBaseConstraintOrType(type) {
+ return getBaseConstraintOfType(type) || type;
+ }
+ function hasNonCircularBaseConstraint(type) {
+ return getResolvedBaseConstraint(type) !== circularConstraintType;
+ }
+ function getResolvedBaseConstraint(type) {
+ if (type.resolvedBaseConstraint) {
+ return type.resolvedBaseConstraint;
+ }
+ var nonTerminating = false;
+ var stack = [];
+ return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type);
+ function getImmediateBaseConstraint(t) {
+ if (!t.immediateBaseConstraint) {
+ if (!pushTypeResolution(t, 4)) {
+ return circularConstraintType;
}
- else if (ts.isIdentifierTypePredicate(targetTypePredicate)) {
- if (reportErrors) {
- errorReporter(ts.Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
+ if (constraintDepth >= 50) {
+ ts.tracing.instant("check", "getImmediateBaseConstraint_DepthLimit", { typeId: t.id, originalTypeId: type.id, depth: constraintDepth });
+ error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
+ nonTerminating = true;
+ return t.immediateBaseConstraint = noConstraintType;
+ }
+ var result = void 0;
+ if (!isDeeplyNestedType(t, stack, stack.length)) {
+ stack.push(t);
+ constraintDepth++;
+ result = computeBaseConstraint(getSimplifiedType(t, false));
+ constraintDepth--;
+ stack.pop();
+ }
+ if (!popTypeResolution()) {
+ if (t.flags & 262144) {
+ var errorNode = getConstraintDeclaration(t);
+ if (errorNode) {
+ var diagnostic = error(errorNode, ts.Diagnostics.Type_parameter_0_has_a_circular_constraint, typeToString(t));
+ if (currentNode && !ts.isNodeDescendantOf(errorNode, currentNode) && !ts.isNodeDescendantOf(currentNode, errorNode)) {
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(currentNode, ts.Diagnostics.Circularity_originates_in_type_at_this_location));
+ }
+ }
}
- return 0;
+ result = circularConstraintType;
+ }
+ if (nonTerminating) {
+ result = circularConstraintType;
}
+ t.immediateBaseConstraint = result || noConstraintType;
}
- else {
- result &= checkMode & 1 && compareTypes(targetReturnType, sourceReturnType, false) ||
- compareTypes(sourceReturnType, targetReturnType, reportErrors);
- if (!result && reportErrors && incompatibleErrorReporter) {
- incompatibleErrorReporter(sourceReturnType, targetReturnType);
+ return t.immediateBaseConstraint;
+ }
+ function getBaseConstraint(t) {
+ var c = getImmediateBaseConstraint(t);
+ return c !== noConstraintType && c !== circularConstraintType ? c : undefined;
+ }
+ function computeBaseConstraint(t) {
+ if (t.flags & 262144) {
+ var constraint = getConstraintFromTypeParameter(t);
+ return t.isThisType || !constraint ?
+ constraint :
+ getBaseConstraint(constraint);
+ }
+ if (t.flags & 3145728) {
+ var types = t.types;
+ var baseTypes = [];
+ for (var _i = 0, types_8 = types; _i < types_8.length; _i++) {
+ var type_3 = types_8[_i];
+ var baseType = getBaseConstraint(type_3);
+ if (baseType) {
+ baseTypes.push(baseType);
+ }
}
+ return t.flags & 1048576 && baseTypes.length === types.length ? getUnionType(baseTypes) :
+ t.flags & 2097152 && baseTypes.length ? getIntersectionType(baseTypes) :
+ undefined;
+ }
+ if (t.flags & 4194304) {
+ return keyofConstraintType;
+ }
+ if (t.flags & 134217728) {
+ var types = t.types;
+ var constraints = ts.mapDefined(types, getBaseConstraint);
+ return constraints.length === types.length ? getTemplateLiteralType(t.texts, constraints) : stringType;
+ }
+ if (t.flags & 268435456) {
+ var constraint = getBaseConstraint(t.type);
+ return constraint ? getStringMappingType(t.symbol, constraint) : stringType;
+ }
+ if (t.flags & 8388608) {
+ var baseObjectType = getBaseConstraint(t.objectType);
+ var baseIndexType = getBaseConstraint(t.indexType);
+ var baseIndexedAccess = baseObjectType && baseIndexType && getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, t.noUncheckedIndexedAccessCandidate);
+ return baseIndexedAccess && getBaseConstraint(baseIndexedAccess);
+ }
+ if (t.flags & 16777216) {
+ var constraint = getConstraintFromConditionalType(t);
+ constraintDepth++;
+ var result = constraint && getBaseConstraint(constraint);
+ constraintDepth--;
+ return result;
}
+ if (t.flags & 33554432) {
+ return getBaseConstraint(t.substitute);
+ }
+ return t;
}
- return result;
}
- function compareTypePredicateRelatedTo(source, target, reportErrors, errorReporter, compareTypes) {
- if (source.kind !== target.kind) {
- if (reportErrors) {
- errorReporter(ts.Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard);
- errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
+ function getApparentTypeOfIntersectionType(type) {
+ return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(type, type, true));
+ }
+ function getResolvedTypeParameterDefault(typeParameter) {
+ if (!typeParameter.default) {
+ if (typeParameter.target) {
+ var targetDefault = getResolvedTypeParameterDefault(typeParameter.target);
+ typeParameter.default = targetDefault ? instantiateType(targetDefault, typeParameter.mapper) : noConstraintType;
}
- return 0;
- }
- if (source.kind === 1 || source.kind === 3) {
- if (source.parameterIndex !== target.parameterIndex) {
- if (reportErrors) {
- errorReporter(ts.Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, source.parameterName, target.parameterName);
- errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
+ else {
+ typeParameter.default = resolvingDefaultType;
+ var defaultDeclaration = typeParameter.symbol && ts.forEach(typeParameter.symbol.declarations, function (decl) { return ts.isTypeParameterDeclaration(decl) && decl.default; });
+ var defaultType = defaultDeclaration ? getTypeFromTypeNode(defaultDeclaration) : noConstraintType;
+ if (typeParameter.default === resolvingDefaultType) {
+ typeParameter.default = defaultType;
}
- return 0;
}
}
- var related = source.type === target.type ? -1 :
- source.type && target.type ? compareTypes(source.type, target.type, reportErrors) :
- 0;
- if (related === 0 && reportErrors) {
- errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
- }
- return related;
- }
- function isImplementationCompatibleWithOverload(implementation, overload) {
- var erasedSource = getErasedSignature(implementation);
- var erasedTarget = getErasedSignature(overload);
- var sourceReturnType = getReturnTypeOfSignature(erasedSource);
- var targetReturnType = getReturnTypeOfSignature(erasedTarget);
- if (targetReturnType === voidType
- || isTypeRelatedTo(targetReturnType, sourceReturnType, assignableRelation)
- || isTypeRelatedTo(sourceReturnType, targetReturnType, assignableRelation)) {
- return isSignatureAssignableTo(erasedSource, erasedTarget, true);
+ else if (typeParameter.default === resolvingDefaultType) {
+ typeParameter.default = circularConstraintType;
}
- return false;
+ return typeParameter.default;
}
- function isEmptyResolvedType(t) {
- return t !== anyFunctionType &&
- t.properties.length === 0 &&
- t.callSignatures.length === 0 &&
- t.constructSignatures.length === 0 &&
- !t.stringIndexInfo &&
- !t.numberIndexInfo;
+ function getDefaultFromTypeParameter(typeParameter) {
+ var defaultType = getResolvedTypeParameterDefault(typeParameter);
+ return defaultType !== noConstraintType && defaultType !== circularConstraintType ? defaultType : undefined;
}
- function isEmptyObjectType(type) {
- return type.flags & 524288 ? !isGenericMappedType(type) && isEmptyResolvedType(resolveStructuredTypeMembers(type)) :
- type.flags & 67108864 ? true :
- type.flags & 1048576 ? ts.some(type.types, isEmptyObjectType) :
- type.flags & 2097152 ? ts.every(type.types, isEmptyObjectType) :
- false;
+ function hasNonCircularTypeParameterDefault(typeParameter) {
+ return getResolvedTypeParameterDefault(typeParameter) !== circularConstraintType;
}
- function isEmptyAnonymousObjectType(type) {
- return !!(ts.getObjectFlags(type) & 16) && isEmptyObjectType(type);
+ function hasTypeParameterDefault(typeParameter) {
+ return !!(typeParameter.symbol && ts.forEach(typeParameter.symbol.declarations, function (decl) { return ts.isTypeParameterDeclaration(decl) && decl.default; }));
}
- function isStringIndexSignatureOnlyType(type) {
- return type.flags & 524288 && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfoOfType(type, 0) && !getIndexInfoOfType(type, 1) ||
- type.flags & 3145728 && ts.every(type.types, isStringIndexSignatureOnlyType) ||
- false;
+ function getApparentTypeOfMappedType(type) {
+ return type.resolvedApparentType || (type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type));
}
- function isEnumTypeRelatedTo(sourceSymbol, targetSymbol, errorReporter) {
- if (sourceSymbol === targetSymbol) {
- return true;
- }
- var id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol);
- var entry = enumRelation.get(id);
- if (entry !== undefined && !(!(entry & 4) && entry & 2 && errorReporter)) {
- return !!(entry & 1);
- }
- if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256) || !(targetSymbol.flags & 256)) {
- enumRelation.set(id, 2 | 4);
- return false;
+ function getResolvedApparentTypeOfMappedType(type) {
+ var typeVariable = getHomomorphicTypeVariable(type);
+ if (typeVariable && !type.declaration.nameType) {
+ var constraint = getConstraintOfTypeParameter(typeVariable);
+ if (constraint && (isArrayType(constraint) || isTupleType(constraint))) {
+ return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper));
+ }
}
- var targetEnumType = getTypeOfSymbol(targetSymbol);
- for (var _i = 0, _a = getPropertiesOfType(getTypeOfSymbol(sourceSymbol)); _i < _a.length; _i++) {
- var property = _a[_i];
- if (property.flags & 8) {
- var targetProperty = getPropertyOfType(targetEnumType, property.escapedName);
- if (!targetProperty || !(targetProperty.flags & 8)) {
- if (errorReporter) {
- errorReporter(ts.Diagnostics.Property_0_is_missing_in_type_1, ts.symbolName(property), typeToString(getDeclaredTypeOfSymbol(targetSymbol), undefined, 64));
- enumRelation.set(id, 2 | 4);
+ return type;
+ }
+ function getApparentType(type) {
+ var t = type.flags & 465829888 ? getBaseConstraintOfType(type) || unknownType : type;
+ return ts.getObjectFlags(t) & 32 ? getApparentTypeOfMappedType(t) :
+ t.flags & 2097152 ? getApparentTypeOfIntersectionType(t) :
+ t.flags & 402653316 ? globalStringType :
+ t.flags & 296 ? globalNumberType :
+ t.flags & 2112 ? getGlobalBigIntType(languageVersion >= 7) :
+ t.flags & 528 ? globalBooleanType :
+ t.flags & 12288 ? getGlobalESSymbolType(languageVersion >= 2) :
+ t.flags & 67108864 ? emptyObjectType :
+ t.flags & 4194304 ? keyofConstraintType :
+ t.flags & 2 && !strictNullChecks ? emptyObjectType :
+ t;
+ }
+ function getReducedApparentType(type) {
+ return getReducedType(getApparentType(getReducedType(type)));
+ }
+ function createUnionOrIntersectionProperty(containingType, name) {
+ var singleProp;
+ var propSet;
+ var indexTypes;
+ var isUnion = containingType.flags & 1048576;
+ var optionalFlag = isUnion ? 0 : 16777216;
+ var syntheticFlag = 4;
+ var checkFlags = 0;
+ for (var _i = 0, _a = containingType.types; _i < _a.length; _i++) {
+ var current = _a[_i];
+ var type = getApparentType(current);
+ if (!(type === errorType || type.flags & 131072)) {
+ var prop = getPropertyOfType(type, name);
+ var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0;
+ if (prop) {
+ if (isUnion) {
+ optionalFlag |= (prop.flags & 16777216);
}
else {
- enumRelation.set(id, 2);
+ optionalFlag &= prop.flags;
+ }
+ if (!singleProp) {
+ singleProp = prop;
+ }
+ else if (prop !== singleProp) {
+ if (!propSet) {
+ propSet = new ts.Map();
+ propSet.set(getSymbolId(singleProp), singleProp);
+ }
+ var id = getSymbolId(prop);
+ if (!propSet.has(id)) {
+ propSet.set(id, prop);
+ }
+ }
+ checkFlags |= (isReadonlySymbol(prop) ? 8 : 0) |
+ (!(modifiers & 24) ? 256 : 0) |
+ (modifiers & 16 ? 512 : 0) |
+ (modifiers & 8 ? 1024 : 0) |
+ (modifiers & 32 ? 2048 : 0);
+ if (!isPrototypeProperty(prop)) {
+ syntheticFlag = 2;
+ }
+ }
+ else if (isUnion) {
+ var indexInfo = !isLateBoundName(name) && (isNumericLiteralName(name) && getIndexInfoOfType(type, 1) || getIndexInfoOfType(type, 0));
+ if (indexInfo) {
+ checkFlags |= 32 | (indexInfo.isReadonly ? 8 : 0);
+ indexTypes = ts.append(indexTypes, isTupleType(type) ? getRestTypeOfTupleType(type) || undefinedType : indexInfo.type);
+ }
+ else if (isObjectLiteralType(type)) {
+ checkFlags |= 32;
+ indexTypes = ts.append(indexTypes, undefinedType);
+ }
+ else {
+ checkFlags |= 16;
}
- return false;
}
}
}
- enumRelation.set(id, 1);
- return true;
- }
- function isSimpleTypeRelatedTo(source, target, relation, errorReporter) {
- var s = source.flags;
- var t = target.flags;
- if (t & 3 || s & 131072 || source === wildcardType)
- return true;
- if (t & 131072)
- return false;
- if (s & 132 && t & 4)
- return true;
- if (s & 128 && s & 1024 &&
- t & 128 && !(t & 1024) &&
- source.value === target.value)
- return true;
- if (s & 296 && t & 8)
- return true;
- if (s & 256 && s & 1024 &&
- t & 256 && !(t & 1024) &&
- source.value === target.value)
- return true;
- if (s & 2112 && t & 64)
- return true;
- if (s & 528 && t & 16)
- return true;
- if (s & 12288 && t & 4096)
- return true;
- if (s & 32 && t & 32 && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
- return true;
- if (s & 1024 && t & 1024) {
- if (s & 1048576 && t & 1048576 && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
- return true;
- if (s & 2944 && t & 2944 &&
- source.value === target.value &&
- isEnumTypeRelatedTo(getParentOfSymbol(source.symbol), getParentOfSymbol(target.symbol), errorReporter))
- return true;
- }
- if (s & 32768 && (!strictNullChecks || t & (32768 | 16384)))
- return true;
- if (s & 65536 && (!strictNullChecks || t & 65536))
- return true;
- if (s & 524288 && t & 67108864)
- return true;
- if (relation === assignableRelation || relation === comparableRelation) {
- if (s & 1)
- return true;
- if (s & (8 | 256) && !(s & 1024) && (t & 32 || t & 256 && t & 1024))
- return true;
- }
- return false;
- }
- function isTypeRelatedTo(source, target, relation) {
- if (isFreshLiteralType(source)) {
- source = source.regularType;
+ if (!singleProp || isUnion && (propSet || checkFlags & 48) && checkFlags & (1024 | 512)) {
+ return undefined;
}
- if (isFreshLiteralType(target)) {
- target = target.regularType;
+ if (!propSet && !(checkFlags & 16) && !indexTypes) {
+ return singleProp;
}
- if (source === target) {
- return true;
+ var props = propSet ? ts.arrayFrom(propSet.values()) : [singleProp];
+ var declarations;
+ var firstType;
+ var nameType;
+ var propTypes = [];
+ var firstValueDeclaration;
+ var hasNonUniformValueDeclaration = false;
+ for (var _b = 0, props_1 = props; _b < props_1.length; _b++) {
+ var prop = props_1[_b];
+ if (!firstValueDeclaration) {
+ firstValueDeclaration = prop.valueDeclaration;
+ }
+ else if (prop.valueDeclaration && prop.valueDeclaration !== firstValueDeclaration) {
+ hasNonUniformValueDeclaration = true;
+ }
+ declarations = ts.addRange(declarations, prop.declarations);
+ var type = getTypeOfSymbol(prop);
+ if (!firstType) {
+ firstType = type;
+ nameType = getSymbolLinks(prop).nameType;
+ }
+ else if (type !== firstType) {
+ checkFlags |= 64;
+ }
+ if (isLiteralType(type)) {
+ checkFlags |= 128;
+ }
+ if (type.flags & 131072) {
+ checkFlags |= 131072;
+ }
+ propTypes.push(type);
}
- if (relation !== identityRelation) {
- if (relation === comparableRelation && !(target.flags & 131072) && isSimpleTypeRelatedTo(target, source, relation) || isSimpleTypeRelatedTo(source, target, relation)) {
- return true;
+ ts.addRange(propTypes, indexTypes);
+ var result = createSymbol(4 | optionalFlag, 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;
+ result.deferralParent = containingType;
+ result.deferralConstituents = propTypes;
+ }
else {
- if (!(source.flags & 3145728) && !(target.flags & 3145728) &&
- source.flags !== target.flags && !(source.flags & 66584576))
- return false;
+ result.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes);
}
- if (source.flags & 524288 && target.flags & 524288) {
- var related = relation.get(getRelationKey(source, target, 0, relation));
- if (related !== undefined) {
- return !!(related & 1);
+ return result;
+ }
+ function getUnionOrIntersectionProperty(type, name) {
+ var properties = type.propertyCache || (type.propertyCache = ts.createSymbolTable());
+ var property = properties.get(name);
+ if (!property) {
+ property = createUnionOrIntersectionProperty(type, name);
+ if (property) {
+ properties.set(name, property);
}
}
- if (source.flags & 66846720 || target.flags & 66846720) {
- return checkTypeRelatedTo(source, target, relation, undefined);
- }
- return false;
+ return property;
}
- function isIgnoredJsxProperty(source, sourceProp) {
- return ts.getObjectFlags(source) & 4096 && !isUnhyphenatedJsxName(sourceProp.escapedName);
+ function getPropertyOfUnionOrIntersectionType(type, name) {
+ var property = getUnionOrIntersectionProperty(type, name);
+ return property && !(ts.getCheckFlags(property) & 16) ? property : undefined;
}
- function getNormalizedType(type, writing) {
- while (true) {
- var t = isFreshLiteralType(type) ? type.regularType :
- ts.getObjectFlags(type) & 4 && type.node ? createTypeReference(type.target, getTypeArguments(type)) :
- type.flags & 3145728 ? getReducedType(type) :
- type.flags & 33554432 ? writing ? type.baseType : type.substitute :
- type.flags & 25165824 ? getSimplifiedType(type, writing) :
- type;
- if (t === type)
- break;
- type = t;
+ function getReducedType(type) {
+ if (type.flags & 1048576 && type.objectFlags & 268435456) {
+ return type.resolvedReducedType || (type.resolvedReducedType = getReducedUnionType(type));
+ }
+ else if (type.flags & 2097152) {
+ if (!(type.objectFlags & 268435456)) {
+ type.objectFlags |= 268435456 |
+ (ts.some(getPropertiesOfUnionOrIntersectionType(type), isNeverReducedProperty) ? 536870912 : 0);
+ }
+ return type.objectFlags & 536870912 ? neverType : type;
}
return type;
}
- function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer) {
- var errorInfo;
- var relatedInfo;
- var maybeKeys;
- var sourceStack;
- var targetStack;
- var maybeCount = 0;
- var depth = 0;
- var expandingFlags = 0;
- var overflow = false;
- var overrideNextErrorInfo = 0;
- var lastSkippedInfo;
- var incompatibleStack = [];
- var inPropertyCheck = false;
- ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
- var result = isRelatedTo(source, target, !!errorNode, headMessage);
- if (incompatibleStack.length) {
- reportIncompatibleStack();
+ function getReducedUnionType(unionType) {
+ var reducedTypes = ts.sameMap(unionType.types, getReducedType);
+ if (reducedTypes === unionType.types) {
+ return unionType;
}
- if (overflow) {
- var diag = error(errorNode || currentNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
- if (errorOutputContainer) {
- (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
+ var reduced = getUnionType(reducedTypes);
+ if (reduced.flags & 1048576) {
+ reduced.resolvedReducedType = reduced;
+ }
+ return reduced;
+ }
+ function isNeverReducedProperty(prop) {
+ return isDiscriminantWithNeverType(prop) || isConflictingPrivateProperty(prop);
+ }
+ function isDiscriminantWithNeverType(prop) {
+ return !(prop.flags & 16777216) &&
+ (ts.getCheckFlags(prop) & (192 | 131072)) === 192 &&
+ !!(getTypeOfSymbol(prop).flags & 131072);
+ }
+ function isConflictingPrivateProperty(prop) {
+ return !prop.valueDeclaration && !!(ts.getCheckFlags(prop) & 1024);
+ }
+ function elaborateNeverIntersection(errorInfo, type) {
+ if (ts.getObjectFlags(type) & 536870912) {
+ var neverProp = ts.find(getPropertiesOfUnionOrIntersectionType(type), isDiscriminantWithNeverType);
+ if (neverProp) {
+ return ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents, typeToString(type, undefined, 536870912), symbolToString(neverProp));
+ }
+ var privateProp = ts.find(getPropertiesOfUnionOrIntersectionType(type), isConflictingPrivateProperty);
+ if (privateProp) {
+ return ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some, typeToString(type, undefined, 536870912), symbolToString(privateProp));
}
}
- else if (errorInfo) {
- if (containingMessageChain) {
- var chain = containingMessageChain();
- if (chain) {
- ts.concatenateDiagnosticMessageChains(chain, errorInfo);
- errorInfo = chain;
+ return errorInfo;
+ }
+ function getPropertyOfType(type, name) {
+ type = getReducedApparentType(type);
+ if (type.flags & 524288) {
+ var resolved = resolveStructuredTypeMembers(type);
+ var symbol = resolved.members.get(name);
+ if (symbol && symbolIsValue(symbol)) {
+ return symbol;
+ }
+ var functionType = resolved === anyFunctionType ? globalFunctionType :
+ resolved.callSignatures.length ? globalCallableFunctionType :
+ resolved.constructSignatures.length ? globalNewableFunctionType :
+ undefined;
+ if (functionType) {
+ var symbol_1 = getPropertyOfObjectType(functionType, name);
+ if (symbol_1) {
+ return symbol_1;
}
}
- var relatedInformation = void 0;
- if (headMessage && errorNode && !result && source.symbol) {
- var links = getSymbolLinks(source.symbol);
- if (links.originatingImport && !ts.isImportCall(links.originatingImport)) {
- var helpfulRetry = checkTypeRelatedTo(getTypeOfSymbol(links.target), target, relation, undefined);
- if (helpfulRetry) {
- var diag_1 = ts.createDiagnosticForNode(links.originatingImport, ts.Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead);
- relatedInformation = ts.append(relatedInformation, diag_1);
- }
+ return getPropertyOfObjectType(globalObjectType, name);
+ }
+ if (type.flags & 3145728) {
+ return getPropertyOfUnionOrIntersectionType(type, name);
+ }
+ return undefined;
+ }
+ function getSignaturesOfStructuredType(type, kind) {
+ if (type.flags & 3670016) {
+ var resolved = resolveStructuredTypeMembers(type);
+ return kind === 0 ? resolved.callSignatures : resolved.constructSignatures;
+ }
+ return ts.emptyArray;
+ }
+ function getSignaturesOfType(type, kind) {
+ return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
+ }
+ function getIndexInfoOfStructuredType(type, kind) {
+ if (type.flags & 3670016) {
+ var resolved = resolveStructuredTypeMembers(type);
+ return kind === 0 ? resolved.stringIndexInfo : resolved.numberIndexInfo;
+ }
+ }
+ function getIndexTypeOfStructuredType(type, kind) {
+ var info = getIndexInfoOfStructuredType(type, kind);
+ return info && info.type;
+ }
+ function getIndexInfoOfType(type, kind) {
+ return getIndexInfoOfStructuredType(getReducedApparentType(type), kind);
+ }
+ function getIndexTypeOfType(type, kind) {
+ return getIndexTypeOfStructuredType(getReducedApparentType(type), kind);
+ }
+ function getImplicitIndexTypeOfType(type, kind) {
+ if (isObjectTypeWithInferableIndex(type)) {
+ var propTypes = [];
+ for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) {
+ var prop = _a[_i];
+ if (kind === 0 || isNumericLiteralName(prop.escapedName)) {
+ propTypes.push(getTypeOfSymbol(prop));
}
}
- var diag = ts.createDiagnosticForNodeFromMessageChain(errorNode, errorInfo, relatedInformation);
- if (relatedInfo) {
- ts.addRelatedInfo.apply(void 0, __spreadArrays([diag], relatedInfo));
+ if (kind === 0) {
+ ts.append(propTypes, getIndexTypeOfType(type, 1));
}
- if (errorOutputContainer) {
- (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
+ if (propTypes.length) {
+ return getUnionType(propTypes);
}
- if (!errorOutputContainer || !errorOutputContainer.skipLogging) {
- diagnostics.add(diag);
+ }
+ return undefined;
+ }
+ function getTypeParametersFromDeclaration(declaration) {
+ var result;
+ for (var _i = 0, _a = ts.getEffectiveTypeParameterDeclarations(declaration); _i < _a.length; _i++) {
+ var node = _a[_i];
+ result = ts.appendIfUnique(result, getDeclaredTypeOfTypeParameter(node.symbol));
+ }
+ return result;
+ }
+ function symbolsToArray(symbols) {
+ var result = [];
+ symbols.forEach(function (symbol, id) {
+ if (!isReservedMemberName(id)) {
+ result.push(symbol);
}
+ });
+ return result;
+ }
+ function isJSDocOptionalParameter(node) {
+ return ts.isInJSFile(node) && (node.type && node.type.kind === 307
+ || ts.getJSDocParameterTags(node).some(function (_a) {
+ var isBracketed = _a.isBracketed, typeExpression = _a.typeExpression;
+ return isBracketed || !!typeExpression && typeExpression.type.kind === 307;
+ }));
+ }
+ function tryFindAmbientModule(moduleName, withAugmentations) {
+ if (ts.isExternalModuleNameRelative(moduleName)) {
+ return undefined;
}
- if (errorNode && errorOutputContainer && errorOutputContainer.skipLogging && result === 0) {
- ts.Debug.assert(!!errorOutputContainer.errors, "missed opportunity to interact with error.");
+ var symbol = getSymbol(globals, '"' + moduleName + '"', 512);
+ return symbol && withAugmentations ? getMergedSymbol(symbol) : symbol;
+ }
+ function isOptionalParameter(node) {
+ if (ts.hasQuestionToken(node) || isOptionalJSDocPropertyLikeTag(node) || isJSDocOptionalParameter(node)) {
+ return true;
}
- return result !== 0;
- function resetErrorInfo(saved) {
- errorInfo = saved.errorInfo;
- lastSkippedInfo = saved.lastSkippedInfo;
- incompatibleStack = saved.incompatibleStack;
- overrideNextErrorInfo = saved.overrideNextErrorInfo;
- relatedInfo = saved.relatedInfo;
+ if (node.initializer) {
+ var signature = getSignatureFromDeclaration(node.parent);
+ var parameterIndex = node.parent.parameters.indexOf(node);
+ ts.Debug.assert(parameterIndex >= 0);
+ return parameterIndex >= getMinArgumentCount(signature, 1 | 2);
}
- function captureErrorCalculationState() {
- return {
- errorInfo: errorInfo,
- lastSkippedInfo: lastSkippedInfo,
- incompatibleStack: incompatibleStack.slice(),
- overrideNextErrorInfo: overrideNextErrorInfo,
- relatedInfo: !relatedInfo ? undefined : relatedInfo.slice()
- };
+ var iife = ts.getImmediatelyInvokedFunctionExpression(node.parent);
+ if (iife) {
+ return !node.type &&
+ !node.dotDotDotToken &&
+ node.parent.parameters.indexOf(node) >= iife.arguments.length;
}
- function reportIncompatibleError(message, arg0, arg1, arg2, arg3) {
- overrideNextErrorInfo++;
- lastSkippedInfo = undefined;
- incompatibleStack.push([message, arg0, arg1, arg2, arg3]);
+ return false;
+ }
+ function isOptionalJSDocPropertyLikeTag(node) {
+ if (!ts.isJSDocPropertyLikeTag(node)) {
+ return false;
}
- function reportIncompatibleStack() {
- var stack = incompatibleStack;
- incompatibleStack = [];
- var info = lastSkippedInfo;
- lastSkippedInfo = undefined;
- if (stack.length === 1) {
- reportError.apply(void 0, stack[0]);
- if (info) {
- reportRelationError.apply(void 0, __spreadArrays([undefined], info));
+ var isBracketed = node.isBracketed, typeExpression = node.typeExpression;
+ return isBracketed || !!typeExpression && typeExpression.type.kind === 307;
+ }
+ function createTypePredicate(kind, parameterName, parameterIndex, type) {
+ return { kind: kind, parameterName: parameterName, parameterIndex: parameterIndex, type: type };
+ }
+ function getMinTypeArgumentCount(typeParameters) {
+ var minTypeArgumentCount = 0;
+ if (typeParameters) {
+ for (var i = 0; i < typeParameters.length; i++) {
+ if (!hasTypeParameterDefault(typeParameters[i])) {
+ minTypeArgumentCount = i + 1;
}
- return;
}
- var path = "";
- var secondaryRootErrors = [];
- while (stack.length) {
- var _a = stack.pop(), msg = _a[0], args = _a.slice(1);
- switch (msg.code) {
- case ts.Diagnostics.Types_of_property_0_are_incompatible.code: {
- if (path.indexOf("new ") === 0) {
- path = "(" + path + ")";
- }
- var str = "" + args[0];
- if (path.length === 0) {
- path = "" + str;
- }
- else if (ts.isIdentifierText(str, compilerOptions.target)) {
- path = path + "." + str;
- }
- else if (str[0] === "[" && str[str.length - 1] === "]") {
- path = "" + path + str;
- }
- else {
- path = path + "[" + str + "]";
- }
- break;
- }
- case ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible.code:
- case ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code:
- case ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code:
- case ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: {
- if (path.length === 0) {
- var mappedMsg = msg;
- if (msg.code === ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
- mappedMsg = ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible;
- }
- else if (msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
- mappedMsg = ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible;
- }
- secondaryRootErrors.unshift([mappedMsg, args[0], args[1]]);
- }
- else {
- var prefix = (msg.code === ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code ||
- msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code)
- ? "new "
- : "";
- var params = (msg.code === ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ||
- msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code)
- ? ""
- : "...";
- path = "" + prefix + path + "(" + params + ")";
- }
- break;
- }
- default:
- return ts.Debug.fail("Unhandled Diagnostic: " + msg.code);
+ }
+ return minTypeArgumentCount;
+ }
+ function fillMissingTypeArguments(typeArguments, typeParameters, minTypeArgumentCount, isJavaScriptImplicitAny) {
+ var numTypeParameters = ts.length(typeParameters);
+ if (!numTypeParameters) {
+ return [];
+ }
+ var numTypeArguments = ts.length(typeArguments);
+ if (isJavaScriptImplicitAny || (numTypeArguments >= minTypeArgumentCount && numTypeArguments <= numTypeParameters)) {
+ var result = typeArguments ? typeArguments.slice() : [];
+ for (var i = numTypeArguments; i < numTypeParameters; i++) {
+ result[i] = errorType;
+ }
+ var baseDefaultType = getDefaultTypeArgumentType(isJavaScriptImplicitAny);
+ for (var i = numTypeArguments; i < numTypeParameters; i++) {
+ var defaultType = getDefaultFromTypeParameter(typeParameters[i]);
+ if (isJavaScriptImplicitAny && defaultType && (isTypeIdenticalTo(defaultType, unknownType) || isTypeIdenticalTo(defaultType, emptyObjectType))) {
+ defaultType = anyType;
}
+ result[i] = defaultType ? instantiateType(defaultType, createTypeMapper(typeParameters, result)) : baseDefaultType;
}
- if (path) {
- reportError(path[path.length - 1] === ")"
- ? ts.Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types
- : ts.Diagnostics.The_types_of_0_are_incompatible_between_these_types, path);
+ result.length = typeParameters.length;
+ return result;
+ }
+ return typeArguments && typeArguments.slice();
+ }
+ function getSignatureFromDeclaration(declaration) {
+ var links = getNodeLinks(declaration);
+ if (!links.resolvedSignature) {
+ var parameters = [];
+ var flags = 0;
+ var minArgumentCount = 0;
+ var thisParameter = void 0;
+ var hasThisParameter = false;
+ var iife = ts.getImmediatelyInvokedFunctionExpression(declaration);
+ var isJSConstructSignature = ts.isJSDocConstructSignature(declaration);
+ var isUntypedSignatureInJSFile = !iife &&
+ ts.isInJSFile(declaration) &&
+ ts.isValueSignatureDeclaration(declaration) &&
+ !ts.hasJSDocParameterTags(declaration) &&
+ !ts.getJSDocType(declaration);
+ if (isUntypedSignatureInJSFile) {
+ flags |= 16;
}
- else {
- secondaryRootErrors.shift();
+ for (var i = isJSConstructSignature ? 1 : 0; i < declaration.parameters.length; i++) {
+ var param = declaration.parameters[i];
+ var paramSymbol = param.symbol;
+ var type = ts.isJSDocParameterTag(param) ? (param.typeExpression && param.typeExpression.type) : param.type;
+ if (paramSymbol && !!(paramSymbol.flags & 4) && !ts.isBindingPattern(param.name)) {
+ var resolvedSymbol = resolveName(param, paramSymbol.escapedName, 111551, undefined, undefined, false);
+ paramSymbol = resolvedSymbol;
+ }
+ if (i === 0 && paramSymbol.escapedName === "this") {
+ hasThisParameter = true;
+ thisParameter = param.symbol;
+ }
+ else {
+ parameters.push(paramSymbol);
+ }
+ if (type && type.kind === 191) {
+ flags |= 2;
+ }
+ var isOptionalParameter_1 = isOptionalJSDocPropertyLikeTag(param) ||
+ param.initializer || param.questionToken || param.dotDotDotToken ||
+ iife && parameters.length > iife.arguments.length && !type ||
+ isJSDocOptionalParameter(param);
+ if (!isOptionalParameter_1) {
+ minArgumentCount = parameters.length;
+ }
}
- for (var _i = 0, secondaryRootErrors_1 = secondaryRootErrors; _i < secondaryRootErrors_1.length; _i++) {
- var _b = secondaryRootErrors_1[_i], msg = _b[0], args = _b.slice(1);
- var originalValue = msg.elidedInCompatabilityPyramid;
- msg.elidedInCompatabilityPyramid = false;
- reportError.apply(void 0, __spreadArrays([msg], args));
- msg.elidedInCompatabilityPyramid = originalValue;
+ if ((declaration.kind === 167 || declaration.kind === 168) &&
+ !hasNonBindableDynamicName(declaration) &&
+ (!hasThisParameter || !thisParameter)) {
+ var otherKind = declaration.kind === 167 ? 168 : 167;
+ var other = ts.getDeclarationOfKind(getSymbolOfNode(declaration), otherKind);
+ if (other) {
+ thisParameter = getAnnotatedAccessorThisParameter(other);
+ }
}
- if (info) {
- reportRelationError.apply(void 0, __spreadArrays([undefined], info));
+ var classType = declaration.kind === 166 ?
+ getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol))
+ : undefined;
+ var typeParameters = classType ? classType.localTypeParameters : getTypeParametersFromDeclaration(declaration);
+ if (ts.hasRestParameter(declaration) || ts.isInJSFile(declaration) && maybeAddJsSyntheticRestParameter(declaration, parameters)) {
+ flags |= 1;
}
+ links.resolvedSignature = createSignature(declaration, typeParameters, thisParameter, parameters, undefined, undefined, minArgumentCount, flags);
}
- function reportError(message, arg0, arg1, arg2, arg3) {
- ts.Debug.assert(!!errorNode);
- if (incompatibleStack.length)
- reportIncompatibleStack();
- if (message.elidedInCompatabilityPyramid)
- return;
- errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2, arg3);
+ return links.resolvedSignature;
+ }
+ function maybeAddJsSyntheticRestParameter(declaration, parameters) {
+ if (ts.isJSDocSignature(declaration) || !containsArgumentsReference(declaration)) {
+ return false;
}
- function associateRelatedInfo(info) {
- ts.Debug.assert(!!errorInfo);
- if (!relatedInfo) {
- relatedInfo = [info];
+ var lastParam = ts.lastOrUndefined(declaration.parameters);
+ var lastParamTags = lastParam ? ts.getJSDocParameterTags(lastParam) : ts.getJSDocTags(declaration).filter(ts.isJSDocParameterTag);
+ var lastParamVariadicType = ts.firstDefined(lastParamTags, function (p) {
+ return p.typeExpression && ts.isJSDocVariadicType(p.typeExpression.type) ? p.typeExpression.type : undefined;
+ });
+ var syntheticArgsSymbol = createSymbol(3, "args", 32768);
+ syntheticArgsSymbol.type = lastParamVariadicType ? createArrayType(getTypeFromTypeNode(lastParamVariadicType.type)) : anyArrayType;
+ if (lastParamVariadicType) {
+ parameters.pop();
+ }
+ parameters.push(syntheticArgsSymbol);
+ return true;
+ }
+ function getSignatureOfTypeTag(node) {
+ if (!(ts.isInJSFile(node) && ts.isFunctionLikeDeclaration(node)))
+ return undefined;
+ var typeTag = ts.getJSDocTypeTag(node);
+ var signature = typeTag && typeTag.typeExpression && getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
+ return signature && getErasedSignature(signature);
+ }
+ function getReturnTypeOfTypeTag(node) {
+ var signature = getSignatureOfTypeTag(node);
+ return signature && getReturnTypeOfSignature(signature);
+ }
+ function containsArgumentsReference(declaration) {
+ var links = getNodeLinks(declaration);
+ if (links.containsArgumentsReference === undefined) {
+ if (links.flags & 8192) {
+ links.containsArgumentsReference = true;
}
else {
- relatedInfo.push(info);
+ links.containsArgumentsReference = traverse(declaration.body);
}
}
- function reportRelationError(message, source, target) {
- if (incompatibleStack.length)
- reportIncompatibleStack();
- var _a = getTypeNamesForErrorDisplay(source, target), sourceType = _a[0], targetType = _a[1];
- if (target.flags & 262144) {
- var constraint = getBaseConstraintOfType(target);
- var constraintElab = constraint && isTypeAssignableTo(source, constraint);
- if (constraintElab) {
- reportError(ts.Diagnostics._0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2, sourceType, targetType, typeToString(constraint));
- }
- else {
- reportError(ts.Diagnostics._0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1, targetType, sourceType);
- }
+ return links.containsArgumentsReference;
+ function traverse(node) {
+ if (!node)
+ return false;
+ switch (node.kind) {
+ case 78:
+ return node.escapedText === "arguments" && ts.isExpressionNode(node);
+ case 163:
+ case 165:
+ case 167:
+ case 168:
+ return node.name.kind === 158
+ && traverse(node.name);
+ default:
+ return !ts.nodeStartsNewLexicalEnvironment(node) && !ts.isPartOfTypeNode(node) && !!ts.forEachChild(node, traverse);
}
- if (!message) {
- if (relation === comparableRelation) {
- message = ts.Diagnostics.Type_0_is_not_comparable_to_type_1;
- }
- else if (sourceType === targetType) {
- message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated;
- }
- else {
- message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1;
+ }
+ }
+ function getSignaturesOfSymbol(symbol) {
+ if (!symbol)
+ return ts.emptyArray;
+ var result = [];
+ for (var i = 0; i < symbol.declarations.length; i++) {
+ var decl = symbol.declarations[i];
+ if (!ts.isFunctionLike(decl))
+ continue;
+ if (i > 0 && decl.body) {
+ var previous = symbol.declarations[i - 1];
+ if (decl.parent === previous.parent && decl.kind === previous.kind && decl.pos === previous.end) {
+ continue;
}
}
- reportError(message, sourceType, targetType);
+ result.push(getSignatureFromDeclaration(decl));
}
- function tryElaborateErrorsForPrimitivesAndObjects(source, target) {
- var sourceType = symbolValueDeclarationIsContextSensitive(source.symbol) ? typeToString(source, source.symbol.valueDeclaration) : typeToString(source);
- var targetType = symbolValueDeclarationIsContextSensitive(target.symbol) ? typeToString(target, target.symbol.valueDeclaration) : typeToString(target);
- if ((globalStringType === source && stringType === target) ||
- (globalNumberType === source && numberType === target) ||
- (globalBooleanType === source && booleanType === target) ||
- (getGlobalESSymbolType(false) === source && esSymbolType === target)) {
- reportError(ts.Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType);
+ return result;
+ }
+ function resolveExternalModuleTypeByLiteral(name) {
+ var moduleSym = resolveExternalModuleName(name, name);
+ if (moduleSym) {
+ var resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym);
+ if (resolvedModuleSymbol) {
+ return getTypeOfSymbol(resolvedModuleSymbol);
+ }
+ }
+ return anyType;
+ }
+ function getThisTypeOfSignature(signature) {
+ if (signature.thisParameter) {
+ return getTypeOfSymbol(signature.thisParameter);
+ }
+ }
+ function getTypePredicateOfSignature(signature) {
+ if (!signature.resolvedTypePredicate) {
+ if (signature.target) {
+ var targetTypePredicate = getTypePredicateOfSignature(signature.target);
+ signature.resolvedTypePredicate = targetTypePredicate ? instantiateTypePredicate(targetTypePredicate, signature.mapper) : noTypePredicate;
}
- }
- function tryElaborateArrayLikeErrors(source, target, reportErrors) {
- if (isTupleType(source)) {
- if (source.target.readonly && isMutableArrayOrTuple(target)) {
- if (reportErrors) {
- reportError(ts.Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source), typeToString(target));
+ else if (signature.unionSignatures) {
+ signature.resolvedTypePredicate = getUnionTypePredicate(signature.unionSignatures) || noTypePredicate;
+ }
+ else {
+ var type = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration);
+ var jsdocPredicate = void 0;
+ if (!type && ts.isInJSFile(signature.declaration)) {
+ var jsdocSignature = getSignatureOfTypeTag(signature.declaration);
+ if (jsdocSignature && signature !== jsdocSignature) {
+ jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
}
- return false;
}
- return isTupleType(target) || isArrayType(target);
+ signature.resolvedTypePredicate = type && ts.isTypePredicateNode(type) ?
+ createTypePredicateFromTypePredicateNode(type, signature) :
+ jsdocPredicate || noTypePredicate;
}
- if (isReadonlyArrayType(source) && isMutableArrayOrTuple(target)) {
- if (reportErrors) {
- reportError(ts.Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source), typeToString(target));
- }
- return false;
+ ts.Debug.assert(!!signature.resolvedTypePredicate);
+ }
+ return signature.resolvedTypePredicate === noTypePredicate ? undefined : signature.resolvedTypePredicate;
+ }
+ function createTypePredicateFromTypePredicateNode(node, signature) {
+ var parameterName = node.parameterName;
+ var type = node.type && getTypeFromTypeNode(node.type);
+ return parameterName.kind === 187 ?
+ createTypePredicate(node.assertsModifier ? 2 : 0, undefined, undefined, type) :
+ createTypePredicate(node.assertsModifier ? 3 : 1, parameterName.escapedText, ts.findIndex(signature.parameters, function (p) { return p.escapedName === parameterName.escapedText; }), type);
+ }
+ function getReturnTypeOfSignature(signature) {
+ if (!signature.resolvedReturnType) {
+ if (!pushTypeResolution(signature, 3)) {
+ return errorType;
}
- if (isTupleType(target)) {
- return isArrayType(source);
+ var type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper) :
+ signature.unionSignatures ? getUnionType(ts.map(signature.unionSignatures, getReturnTypeOfSignature), 2) :
+ getReturnTypeFromAnnotation(signature.declaration) ||
+ (ts.nodeIsMissing(signature.declaration.body) ? anyType : getReturnTypeFromBody(signature.declaration));
+ if (signature.flags & 4) {
+ type = addOptionalTypeMarker(type);
}
- return true;
- }
- function isRelatedTo(originalSource, originalTarget, reportErrors, headMessage, intersectionState) {
- if (reportErrors === void 0) { reportErrors = false; }
- if (intersectionState === void 0) { intersectionState = 0; }
- if (originalSource.flags & 524288 && originalTarget.flags & 131068) {
- if (isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors ? reportError : undefined)) {
- return -1;
+ else if (signature.flags & 8) {
+ type = getOptionalType(type);
+ }
+ if (!popTypeResolution()) {
+ if (signature.declaration) {
+ var typeNode = ts.getEffectiveReturnTypeNode(signature.declaration);
+ if (typeNode) {
+ error(typeNode, ts.Diagnostics.Return_type_annotation_circularly_references_itself);
+ }
+ else if (noImplicitAny) {
+ var declaration = signature.declaration;
+ var name = ts.getNameOfDeclaration(declaration);
+ if (name) {
+ error(name, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, ts.declarationNameToString(name));
+ }
+ else {
+ error(declaration, ts.Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions);
+ }
+ }
}
- reportErrorResults(originalSource, originalTarget, 0, !!(ts.getObjectFlags(originalSource) & 4096));
- return 0;
+ type = anyType;
}
- var source = getNormalizedType(originalSource, false);
- var target = getNormalizedType(originalTarget, true);
- if (source === target)
- return -1;
- if (relation === identityRelation) {
- return isIdenticalTo(source, target);
+ signature.resolvedReturnType = type;
+ }
+ return signature.resolvedReturnType;
+ }
+ function getReturnTypeFromAnnotation(declaration) {
+ if (declaration.kind === 166) {
+ return getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol));
+ }
+ if (ts.isJSDocConstructSignature(declaration)) {
+ return getTypeFromTypeNode(declaration.parameters[0].type);
+ }
+ var typeNode = ts.getEffectiveReturnTypeNode(declaration);
+ if (typeNode) {
+ return getTypeFromTypeNode(typeNode);
+ }
+ if (declaration.kind === 167 && !hasNonBindableDynamicName(declaration)) {
+ var jsDocType = ts.isInJSFile(declaration) && getTypeForDeclarationFromJSDocComment(declaration);
+ if (jsDocType) {
+ return jsDocType;
}
- if (source.flags & 262144 && getConstraintOfType(source) === target) {
- return -1;
+ var setter = ts.getDeclarationOfKind(getSymbolOfNode(declaration), 168);
+ var setterType = getAnnotatedAccessorType(setter);
+ if (setterType) {
+ return setterType;
}
- if (target.flags & 1048576 && source.flags & 524288 &&
- target.types.length <= 3 && maybeTypeOfKind(target, 98304)) {
- var nullStrippedTarget = extractTypesOfKind(target, ~98304);
- if (!(nullStrippedTarget.flags & (1048576 | 131072))) {
- if (source === nullStrippedTarget)
- return -1;
- target = nullStrippedTarget;
- }
+ }
+ return getReturnTypeOfTypeTag(declaration);
+ }
+ function isResolvingReturnTypeOfSignature(signature) {
+ return !signature.resolvedReturnType && findResolutionCycleStartIndex(signature, 3) >= 0;
+ }
+ function getRestTypeOfSignature(signature) {
+ return tryGetRestTypeOfSignature(signature) || anyType;
+ }
+ function tryGetRestTypeOfSignature(signature) {
+ if (signatureHasRestParameter(signature)) {
+ var sigRestType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
+ var restType = isTupleType(sigRestType) ? getRestTypeOfTupleType(sigRestType) : sigRestType;
+ return restType && getIndexTypeOfType(restType, 1);
+ }
+ return undefined;
+ }
+ function getSignatureInstantiation(signature, typeArguments, isJavascript, inferredTypeParameters) {
+ var instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, fillMissingTypeArguments(typeArguments, signature.typeParameters, getMinTypeArgumentCount(signature.typeParameters), isJavascript));
+ if (inferredTypeParameters) {
+ var returnSignature = getSingleCallOrConstructSignature(getReturnTypeOfSignature(instantiatedSignature));
+ if (returnSignature) {
+ var newReturnSignature = cloneSignature(returnSignature);
+ newReturnSignature.typeParameters = inferredTypeParameters;
+ var newInstantiatedSignature = cloneSignature(instantiatedSignature);
+ newInstantiatedSignature.resolvedReturnType = getOrCreateTypeFromSignature(newReturnSignature);
+ return newInstantiatedSignature;
}
- if (relation === comparableRelation && !(target.flags & 131072) && isSimpleTypeRelatedTo(target, source, relation) ||
- isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined))
- return -1;
- var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 4096);
- var isPerformingExcessPropertyChecks = !(intersectionState & 2) && (isObjectLiteralType(source) && ts.getObjectFlags(source) & 32768);
- if (isPerformingExcessPropertyChecks) {
- if (hasExcessProperties(source, target, reportErrors)) {
- if (reportErrors) {
- reportRelationError(headMessage, source, target);
+ }
+ return instantiatedSignature;
+ }
+ function getSignatureInstantiationWithoutFillingInTypeArguments(signature, typeArguments) {
+ var instantiations = signature.instantiations || (signature.instantiations = new ts.Map());
+ var id = getTypeListId(typeArguments);
+ var instantiation = instantiations.get(id);
+ if (!instantiation) {
+ instantiations.set(id, instantiation = createSignatureInstantiation(signature, typeArguments));
+ }
+ return instantiation;
+ }
+ function createSignatureInstantiation(signature, typeArguments) {
+ return instantiateSignature(signature, createSignatureTypeMapper(signature, typeArguments), 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, ts.map(signature.typeParameters, function (tp) { return tp.target && !getConstraintOfTypeParameter(tp.target) ? tp.target : tp; }), ts.isInJSFile(signature.declaration));
+ }
+ function getBaseSignature(signature) {
+ var typeParameters = signature.typeParameters;
+ if (typeParameters) {
+ var typeEraser_1 = createTypeEraser(typeParameters);
+ var baseConstraints = ts.map(typeParameters, function (tp) { return instantiateType(getBaseConstraintOfType(tp), typeEraser_1) || unknownType; });
+ return instantiateSignature(signature, createTypeMapper(typeParameters, baseConstraints), true);
+ }
+ return signature;
+ }
+ function getOrCreateTypeFromSignature(signature) {
+ if (!signature.isolatedSignatureType) {
+ var kind = signature.declaration ? signature.declaration.kind : 0;
+ var isConstructor = kind === 166 || kind === 170 || kind === 175;
+ var type = createObjectType(16);
+ type.members = emptySymbols;
+ type.properties = ts.emptyArray;
+ type.callSignatures = !isConstructor ? [signature] : ts.emptyArray;
+ type.constructSignatures = isConstructor ? [signature] : ts.emptyArray;
+ signature.isolatedSignatureType = type;
+ }
+ return signature.isolatedSignatureType;
+ }
+ function getIndexSymbol(symbol) {
+ return symbol.members.get("__index");
+ }
+ function getIndexDeclarationOfSymbol(symbol, kind) {
+ var syntaxKind = kind === 1 ? 144 : 147;
+ var indexSymbol = getIndexSymbol(symbol);
+ if (indexSymbol) {
+ for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ var node = ts.cast(decl, ts.isIndexSignatureDeclaration);
+ if (node.parameters.length === 1) {
+ var parameter = node.parameters[0];
+ if (parameter.type && parameter.type.kind === syntaxKind) {
+ return node;
}
- return 0;
}
}
- var isPerformingCommonPropertyChecks = relation !== comparableRelation && !(intersectionState & 2) &&
- source.flags & (131068 | 524288 | 2097152) && source !== globalObjectType &&
- target.flags & (524288 | 2097152) && isWeakType(target) &&
- (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source));
- if (isPerformingCommonPropertyChecks && !hasCommonProperties(source, target, isComparingJsxAttributes)) {
- if (reportErrors) {
- var calls = getSignaturesOfType(source, 0);
- var constructs = getSignaturesOfType(source, 1);
- if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, false) ||
- constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, false)) {
- reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, typeToString(source), typeToString(target));
+ }
+ return undefined;
+ }
+ function createIndexInfo(type, isReadonly, declaration) {
+ return { type: type, isReadonly: isReadonly, declaration: declaration };
+ }
+ function getIndexInfoOfSymbol(symbol, kind) {
+ var declaration = getIndexDeclarationOfSymbol(symbol, kind);
+ if (declaration) {
+ return createIndexInfo(declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasEffectiveModifier(declaration, 64), declaration);
+ }
+ return undefined;
+ }
+ function getConstraintDeclaration(type) {
+ return ts.mapDefined(ts.filter(type.symbol && type.symbol.declarations, ts.isTypeParameterDeclaration), ts.getEffectiveConstraintOfTypeParameter)[0];
+ }
+ function getInferredTypeParameterConstraint(typeParameter) {
+ var inferences;
+ if (typeParameter.symbol) {
+ for (var _i = 0, _a = typeParameter.symbol.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ if (declaration.parent.kind === 185) {
+ var _b = ts.walkUpParenthesizedTypesAndGetParentAndChild(declaration.parent.parent), _c = _b[0], childTypeParameter = _c === void 0 ? declaration.parent : _c, grandParent = _b[1];
+ if (grandParent.kind === 173) {
+ var typeReference = grandParent;
+ var typeParameters = getTypeParametersForTypeReference(typeReference);
+ if (typeParameters) {
+ var index = typeReference.typeArguments.indexOf(childTypeParameter);
+ if (index < typeParameters.length) {
+ var declaredConstraint = getConstraintOfTypeParameter(typeParameters[index]);
+ if (declaredConstraint) {
+ var mapper = createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReference, typeParameters));
+ var constraint = instantiateType(declaredConstraint, mapper);
+ if (constraint !== typeParameter) {
+ inferences = ts.append(inferences, constraint);
+ }
+ }
+ }
+ }
}
- else {
- reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, typeToString(source), typeToString(target));
+ else if (grandParent.kind === 160 && grandParent.dotDotDotToken ||
+ grandParent.kind === 181 ||
+ grandParent.kind === 192 && grandParent.dotDotDotToken) {
+ inferences = ts.append(inferences, createArrayType(unknownType));
+ }
+ else if (grandParent.kind === 194) {
+ inferences = ts.append(inferences, stringType);
}
}
- return 0;
}
- var result = 0;
- var saveErrorInfo = captureErrorCalculationState();
- if (source.flags & 1048576) {
- result = relation === comparableRelation ?
- someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068), intersectionState) :
- eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068), intersectionState);
+ }
+ return inferences && getIntersectionType(inferences);
+ }
+ function getConstraintFromTypeParameter(typeParameter) {
+ if (!typeParameter.constraint) {
+ if (typeParameter.target) {
+ var targetConstraint = getConstraintOfTypeParameter(typeParameter.target);
+ typeParameter.constraint = targetConstraint ? instantiateType(targetConstraint, typeParameter.mapper) : noConstraintType;
}
else {
- if (target.flags & 1048576) {
- result = typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068) && !(target.flags & 131068));
- }
- else if (target.flags & 2097152) {
- result = typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2);
- }
- else if (source.flags & 2097152) {
- result = someTypeRelatedToType(source, target, false, 1);
+ var constraintDeclaration = getConstraintDeclaration(typeParameter);
+ if (!constraintDeclaration) {
+ typeParameter.constraint = getInferredTypeParameterConstraint(typeParameter) || noConstraintType;
}
- if (!result && (source.flags & 66846720 || target.flags & 66846720)) {
- if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState)) {
- resetErrorInfo(saveErrorInfo);
+ else {
+ var type = getTypeFromTypeNode(constraintDeclaration);
+ if (type.flags & 1 && type !== errorType) {
+ type = constraintDeclaration.parent.parent.kind === 190 ? keyofConstraintType : unknownType;
}
+ typeParameter.constraint = type;
}
}
- if (!result && source.flags & (2097152 | 262144)) {
- var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 ? source.types : [source], !!(target.flags & 1048576));
- if (constraint && (source.flags & 2097152 || target.flags & 1048576)) {
- if (everyType(constraint, function (c) { return c !== source; })) {
- if (result = isRelatedTo(constraint, target, false, undefined, intersectionState)) {
- resetErrorInfo(saveErrorInfo);
- }
- }
+ }
+ return typeParameter.constraint === noConstraintType ? undefined : typeParameter.constraint;
+ }
+ function getParentSymbolOfTypeParameter(typeParameter) {
+ var tp = ts.getDeclarationOfKind(typeParameter.symbol, 159);
+ var host = ts.isJSDocTemplateTag(tp.parent) ? ts.getHostSignatureFromJSDoc(tp.parent) : tp.parent;
+ return host && getSymbolOfNode(host);
+ }
+ function getTypeListId(types) {
+ var result = "";
+ if (types) {
+ var length_4 = types.length;
+ var i = 0;
+ while (i < length_4) {
+ var startId = types[i].id;
+ var count = 1;
+ while (i + count < length_4 && types[i + count].id === startId + count) {
+ count++;
}
- }
- if (result && !inPropertyCheck && (target.flags & 2097152 && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
- isNonGenericObjectType(target) && !isArrayType(target) && !isTupleType(target) && source.flags & 2097152 && getApparentType(source).flags & 3670016 && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 2097152); }))) {
- inPropertyCheck = true;
- result &= recursiveTypeRelatedTo(source, target, reportErrors, 4);
- inPropertyCheck = false;
- }
- reportErrorResults(source, target, result, isComparingJsxAttributes);
- return result;
- function reportErrorResults(source, target, result, isComparingJsxAttributes) {
- if (!result && reportErrors) {
- source = originalSource.aliasSymbol ? originalSource : source;
- target = originalTarget.aliasSymbol ? originalTarget : target;
- var maybeSuppress = overrideNextErrorInfo > 0;
- if (maybeSuppress) {
- overrideNextErrorInfo--;
- }
- if (source.flags & 524288 && target.flags & 524288) {
- var currentError = errorInfo;
- tryElaborateArrayLikeErrors(source, target, reportErrors);
- if (errorInfo !== currentError) {
- maybeSuppress = !!errorInfo;
- }
- }
- if (source.flags & 524288 && target.flags & 131068) {
- tryElaborateErrorsForPrimitivesAndObjects(source, target);
- }
- else if (source.symbol && source.flags & 524288 && globalObjectType === source) {
- reportError(ts.Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
- }
- else if (isComparingJsxAttributes && target.flags & 2097152) {
- var targetTypes = target.types;
- var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
- var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
- if (intrinsicAttributes !== errorType && intrinsicClassAttributes !== errorType &&
- (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) {
- return result;
- }
- }
- else {
- errorInfo = elaborateNeverIntersection(errorInfo, originalTarget);
- }
- if (!headMessage && maybeSuppress) {
- lastSkippedInfo = [source, target];
- return result;
- }
- reportRelationError(headMessage, source, target);
+ if (result.length) {
+ result += ",";
+ }
+ result += startId;
+ if (count > 1) {
+ result += ":" + count;
}
+ i += count;
}
}
- function isIdenticalTo(source, target) {
- var flags = source.flags & target.flags;
- if (!(flags & 66584576)) {
- return 0;
- }
- if (flags & 3145728) {
- var result_5 = eachTypeRelatedToSomeType(source, target);
- if (result_5) {
- result_5 &= eachTypeRelatedToSomeType(target, source);
- }
- return result_5;
+ return result;
+ }
+ function getPropagatingFlagsOfTypes(types, excludeKinds) {
+ var result = 0;
+ for (var _i = 0, types_9 = types; _i < types_9.length; _i++) {
+ var type = types_9[_i];
+ if (!(type.flags & excludeKinds)) {
+ result |= ts.getObjectFlags(type);
}
- return recursiveTypeRelatedTo(source, target, false, 0);
}
- function getTypeOfPropertyInTypes(types, name) {
- var appendPropType = function (propTypes, type) {
- type = getApparentType(type);
- var prop = type.flags & 3145728 ? getPropertyOfUnionOrIntersectionType(type, name) : getPropertyOfObjectType(type, name);
- var propType = prop && getTypeOfSymbol(prop) || isNumericLiteralName(name) && getIndexTypeOfType(type, 1) || getIndexTypeOfType(type, 0) || undefinedType;
- return ts.append(propTypes, propType);
- };
- return getUnionType(ts.reduceLeft(types, appendPropType, undefined) || ts.emptyArray);
+ return result & 3670016;
+ }
+ function createTypeReference(target, typeArguments) {
+ var id = getTypeListId(typeArguments);
+ var type = target.instantiations.get(id);
+ if (!type) {
+ type = createObjectType(4, target.symbol);
+ target.instantiations.set(id, type);
+ type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, 0) : 0;
+ type.target = target;
+ type.resolvedTypeArguments = typeArguments;
}
- function hasExcessProperties(source, target, reportErrors) {
- if (!isExcessPropertyCheckTarget(target) || !noImplicitAny && ts.getObjectFlags(target) & 16384) {
- return false;
+ return type;
+ }
+ function cloneTypeReference(source) {
+ var type = createType(source.flags);
+ type.symbol = source.symbol;
+ type.objectFlags = source.objectFlags;
+ type.target = source.target;
+ type.resolvedTypeArguments = source.resolvedTypeArguments;
+ return type;
+ }
+ function createDeferredTypeReference(target, node, mapper) {
+ var aliasSymbol = getAliasSymbolForTypeNode(node);
+ var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
+ var type = createObjectType(4, target.symbol);
+ type.target = target;
+ type.node = node;
+ type.mapper = mapper;
+ type.aliasSymbol = aliasSymbol;
+ type.aliasTypeArguments = mapper ? instantiateTypes(aliasTypeArguments, mapper) : aliasTypeArguments;
+ return type;
+ }
+ function getTypeArguments(type) {
+ var _a, _b;
+ if (!type.resolvedTypeArguments) {
+ if (!pushTypeResolution(type, 6)) {
+ return ((_a = type.target.localTypeParameters) === null || _a === void 0 ? void 0 : _a.map(function () { return errorType; })) || ts.emptyArray;
}
- var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 4096);
- if ((relation === assignableRelation || relation === comparableRelation) &&
- (isTypeSubsetOf(globalObjectType, target) || (!isComparingJsxAttributes && isEmptyObjectType(target)))) {
- return false;
+ var node = type.node;
+ var typeArguments = !node ? ts.emptyArray :
+ node.kind === 173 ? ts.concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments(node, type.target.localTypeParameters)) :
+ node.kind === 178 ? [getTypeFromTypeNode(node.elementType)] :
+ ts.map(node.elements, getTypeFromTypeNode);
+ if (popTypeResolution()) {
+ type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments;
}
- var reducedTarget = target;
- var checkTypes;
- if (target.flags & 1048576) {
- reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target);
- checkTypes = reducedTarget.flags & 1048576 ? reducedTarget.types : [reducedTarget];
+ else {
+ type.resolvedTypeArguments = ((_b = type.target.localTypeParameters) === null || _b === void 0 ? void 0 : _b.map(function () { return errorType; })) || ts.emptyArray;
+ error(type.node || currentNode, type.target.symbol ? ts.Diagnostics.Type_arguments_for_0_circularly_reference_themselves : ts.Diagnostics.Tuple_type_arguments_circularly_reference_themselves, type.target.symbol && symbolToString(type.target.symbol));
}
- var _loop_13 = function (prop) {
- if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) {
- if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
- if (reportErrors) {
- var errorTarget = filterType(reducedTarget, isExcessPropertyCheckTarget);
- if (!errorNode)
- return { value: ts.Debug.fail() };
- if (ts.isJsxAttributes(errorNode) || ts.isJsxOpeningLikeElement(errorNode) || ts.isJsxOpeningLikeElement(errorNode.parent)) {
- if (prop.valueDeclaration && ts.isJsxAttribute(prop.valueDeclaration) && ts.getSourceFileOfNode(errorNode) === ts.getSourceFileOfNode(prop.valueDeclaration.name)) {
- errorNode = prop.valueDeclaration.name;
- }
- reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(prop), typeToString(errorTarget));
- }
- else {
- var objectLiteralDeclaration_1 = source.symbol && ts.firstOrUndefined(source.symbol.declarations);
- var suggestion = void 0;
- if (prop.valueDeclaration && ts.findAncestor(prop.valueDeclaration, function (d) { return d === objectLiteralDeclaration_1; }) && ts.getSourceFileOfNode(objectLiteralDeclaration_1) === ts.getSourceFileOfNode(errorNode)) {
- var propDeclaration = prop.valueDeclaration;
- ts.Debug.assertNode(propDeclaration, ts.isObjectLiteralElementLike);
- errorNode = propDeclaration;
- var name = propDeclaration.name;
- if (ts.isIdentifier(name)) {
- suggestion = getSuggestionForNonexistentProperty(name, errorTarget);
- }
- }
- if (suggestion !== undefined) {
- reportError(ts.Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2, symbolToString(prop), typeToString(errorTarget), suggestion);
- }
- else {
- reportError(ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(errorTarget));
- }
- }
- }
- return { value: true };
- }
- if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), reportErrors)) {
- if (reportErrors) {
- reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(prop));
- }
- return { value: true };
- }
+ }
+ return type.resolvedTypeArguments;
+ }
+ function getTypeReferenceArity(type) {
+ return ts.length(type.target.typeParameters);
+ }
+ function getTypeFromClassOrInterfaceReference(node, symbol) {
+ var type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
+ var typeParameters = type.localTypeParameters;
+ if (typeParameters) {
+ var numTypeArguments = ts.length(node.typeArguments);
+ var minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
+ var isJs = ts.isInJSFile(node);
+ var isJsImplicitAny = !noImplicitAny && isJs;
+ if (!isJsImplicitAny && (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length)) {
+ var missingAugmentsTag = isJs && ts.isExpressionWithTypeArguments(node) && !ts.isJSDocAugmentsTag(node.parent);
+ var diag = minTypeArgumentCount === typeParameters.length ?
+ missingAugmentsTag ?
+ ts.Diagnostics.Expected_0_type_arguments_provide_these_with_an_extends_tag :
+ ts.Diagnostics.Generic_type_0_requires_1_type_argument_s :
+ missingAugmentsTag ?
+ ts.Diagnostics.Expected_0_1_type_arguments_provide_these_with_an_extends_tag :
+ ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments;
+ var typeStr = typeToString(type, undefined, 2);
+ error(node, diag, typeStr, minTypeArgumentCount, typeParameters.length);
+ if (!isJs) {
+ return errorType;
}
- };
- for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) {
- var prop = _a[_i];
- var state_5 = _loop_13(prop);
- if (typeof state_5 === "object")
- return state_5.value;
}
- return false;
+ if (node.kind === 173 && isDeferredTypeReferenceNode(node, ts.length(node.typeArguments) !== typeParameters.length)) {
+ return createDeferredTypeReference(type, node, undefined);
+ }
+ var typeArguments = ts.concatenate(type.outerTypeParameters, fillMissingTypeArguments(typeArgumentsFromTypeReferenceNode(node), typeParameters, minTypeArgumentCount, isJs));
+ return createTypeReference(type, typeArguments);
}
- function shouldCheckAsExcessProperty(prop, container) {
- return prop.valueDeclaration && container.valueDeclaration && prop.valueDeclaration.parent === container.valueDeclaration;
+ return checkNoTypeArguments(node, symbol) ? type : errorType;
+ }
+ function getTypeAliasInstantiation(symbol, typeArguments) {
+ var type = getDeclaredTypeOfSymbol(symbol);
+ if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
+ return getStringMappingType(symbol, typeArguments[0]);
}
- function eachTypeRelatedToSomeType(source, target) {
- var result = -1;
- var sourceTypes = source.types;
- for (var _i = 0, sourceTypes_1 = sourceTypes; _i < sourceTypes_1.length; _i++) {
- var sourceType = sourceTypes_1[_i];
- var related = typeRelatedToSomeType(sourceType, target, false);
- if (!related) {
- return 0;
- }
- result &= related;
- }
- return result;
+ var links = getSymbolLinks(symbol);
+ var typeParameters = links.typeParameters;
+ var id = getTypeListId(typeArguments);
+ var instantiation = links.instantiations.get(id);
+ if (!instantiation) {
+ links.instantiations.set(id, instantiation = instantiateType(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(symbol.valueDeclaration)))));
}
- function typeRelatedToSomeType(source, target, reportErrors) {
- var targetTypes = target.types;
- if (target.flags & 1048576 && containsType(targetTypes, source)) {
- return -1;
+ return instantiation;
+ }
+ function getTypeFromTypeAliasReference(node, symbol) {
+ var type = getDeclaredTypeOfSymbol(symbol);
+ var typeParameters = getSymbolLinks(symbol).typeParameters;
+ if (typeParameters) {
+ var numTypeArguments = ts.length(node.typeArguments);
+ var minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
+ if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) {
+ error(node, minTypeArgumentCount === typeParameters.length ?
+ ts.Diagnostics.Generic_type_0_requires_1_type_argument_s :
+ ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments, symbolToString(symbol), minTypeArgumentCount, typeParameters.length);
+ return errorType;
}
- for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) {
- var type = targetTypes_1[_i];
- var related = isRelatedTo(source, type, false);
- if (related) {
- return related;
+ return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node));
+ }
+ return checkNoTypeArguments(node, symbol) ? type : errorType;
+ }
+ function getTypeReferenceName(node) {
+ switch (node.kind) {
+ case 173:
+ return node.typeName;
+ case 223:
+ var expr = node.expression;
+ if (ts.isEntityNameExpression(expr)) {
+ return expr;
}
+ }
+ return undefined;
+ }
+ function resolveTypeReferenceName(typeReferenceName, meaning, ignoreErrors) {
+ if (!typeReferenceName) {
+ return unknownSymbol;
+ }
+ return resolveEntityName(typeReferenceName, meaning, ignoreErrors) || unknownSymbol;
+ }
+ function getTypeReferenceType(node, symbol) {
+ if (symbol === unknownSymbol) {
+ return errorType;
+ }
+ symbol = getExpandoSymbol(symbol) || symbol;
+ if (symbol.flags & (32 | 64)) {
+ return getTypeFromClassOrInterfaceReference(node, symbol);
+ }
+ if (symbol.flags & 524288) {
+ return getTypeFromTypeAliasReference(node, symbol);
+ }
+ var res = tryGetDeclaredTypeOfSymbol(symbol);
+ if (res) {
+ return checkNoTypeArguments(node, symbol) ? getRegularTypeOfLiteralType(res) : errorType;
+ }
+ if (symbol.flags & 111551 && isJSDocTypeReference(node)) {
+ var jsdocType = getTypeFromJSDocValueReference(node, symbol);
+ if (jsdocType) {
+ return jsdocType;
}
- if (reportErrors) {
- var bestMatchingType = getBestMatchingType(source, target, isRelatedTo);
- isRelatedTo(source, bestMatchingType || targetTypes[targetTypes.length - 1], true);
+ else {
+ resolveTypeReferenceName(getTypeReferenceName(node), 788968);
+ return getTypeOfSymbol(symbol);
}
- return 0;
}
- function typeRelatedToEachType(source, target, reportErrors, intersectionState) {
- var result = -1;
- var targetTypes = target.types;
- for (var _i = 0, targetTypes_2 = targetTypes; _i < targetTypes_2.length; _i++) {
- var targetType = targetTypes_2[_i];
- var related = isRelatedTo(source, targetType, reportErrors, undefined, intersectionState);
- if (!related) {
- return 0;
+ return errorType;
+ }
+ function getTypeFromJSDocValueReference(node, symbol) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedJSDocType) {
+ var valueType = getTypeOfSymbol(symbol);
+ var typeType = valueType;
+ if (symbol.valueDeclaration) {
+ var isImportTypeWithQualifier = node.kind === 195 && node.qualifier;
+ if (valueType.symbol && valueType.symbol !== symbol && isImportTypeWithQualifier) {
+ typeType = getTypeReferenceType(node, valueType.symbol);
}
- result &= related;
}
- return result;
+ links.resolvedJSDocType = typeType;
}
- function someTypeRelatedToType(source, target, reportErrors, intersectionState) {
- var sourceTypes = source.types;
- if (source.flags & 1048576 && containsType(sourceTypes, target)) {
- return -1;
- }
- var len = sourceTypes.length;
- for (var i = 0; i < len; i++) {
- var related = isRelatedTo(sourceTypes[i], target, reportErrors && i === len - 1, undefined, intersectionState);
- if (related) {
- return related;
+ return links.resolvedJSDocType;
+ }
+ function getSubstitutionType(baseType, substitute) {
+ if (substitute.flags & 3 || substitute === baseType) {
+ return baseType;
+ }
+ var id = getTypeId(baseType) + ">" + getTypeId(substitute);
+ var cached = substitutionTypes.get(id);
+ if (cached) {
+ return cached;
+ }
+ var result = createType(33554432);
+ result.baseType = baseType;
+ result.substitute = substitute;
+ substitutionTypes.set(id, result);
+ return result;
+ }
+ function isUnaryTupleTypeNode(node) {
+ return node.kind === 179 && 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)) === type ? getTypeFromTypeNode(extendsNode) :
+ undefined;
+ }
+ function getConditionalFlowTypeOfType(type, node) {
+ var constraints;
+ while (node && !ts.isStatement(node) && node.kind !== 311) {
+ var parent = node.parent;
+ if (parent.kind === 184 && node === parent.trueType) {
+ var constraint = getImpliedConstraint(type, parent.checkType, parent.extendsType);
+ if (constraint) {
+ constraints = ts.append(constraints, constraint);
}
}
- return 0;
+ node = parent;
}
- function eachTypeRelatedToType(source, target, reportErrors, intersectionState) {
- var result = -1;
- var sourceTypes = source.types;
- for (var i = 0; i < sourceTypes.length; i++) {
- var sourceType = sourceTypes[i];
- if (target.flags & 1048576 && target.types.length === sourceTypes.length) {
- var related_1 = isRelatedTo(sourceType, target.types[i], false, undefined, intersectionState);
- if (related_1) {
- result &= related_1;
- continue;
+ return constraints ? getSubstitutionType(type, getIntersectionType(ts.append(constraints, type))) : type;
+ }
+ function isJSDocTypeReference(node) {
+ return !!(node.flags & 4194304) && (node.kind === 173 || node.kind === 195);
+ }
+ function checkNoTypeArguments(node, symbol) {
+ if (node.typeArguments) {
+ error(node, ts.Diagnostics.Type_0_is_not_generic, symbol ? symbolToString(symbol) : node.typeName ? ts.declarationNameToString(node.typeName) : anon);
+ return false;
+ }
+ return true;
+ }
+ function getIntendedTypeFromJSDocTypeReference(node) {
+ if (ts.isIdentifier(node.typeName)) {
+ var typeArgs = node.typeArguments;
+ switch (node.typeName.escapedText) {
+ case "String":
+ checkNoTypeArguments(node);
+ return stringType;
+ case "Number":
+ checkNoTypeArguments(node);
+ return numberType;
+ case "Boolean":
+ checkNoTypeArguments(node);
+ return booleanType;
+ case "Void":
+ checkNoTypeArguments(node);
+ return voidType;
+ case "Undefined":
+ checkNoTypeArguments(node);
+ return undefinedType;
+ case "Null":
+ checkNoTypeArguments(node);
+ return nullType;
+ case "Function":
+ case "function":
+ checkNoTypeArguments(node);
+ return globalFunctionType;
+ case "array":
+ return (!typeArgs || !typeArgs.length) && !noImplicitAny ? anyArrayType : undefined;
+ case "promise":
+ return (!typeArgs || !typeArgs.length) && !noImplicitAny ? createPromiseType(anyType) : undefined;
+ case "Object":
+ if (typeArgs && typeArgs.length === 2) {
+ if (ts.isJSDocIndexSignature(node)) {
+ var indexed = getTypeFromTypeNode(typeArgs[0]);
+ var target = getTypeFromTypeNode(typeArgs[1]);
+ var index = createIndexInfo(target, false);
+ return createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, indexed === stringType ? index : undefined, indexed === numberType ? index : undefined);
+ }
+ return anyType;
}
- }
- var related = isRelatedTo(sourceType, target, reportErrors, undefined, intersectionState);
- if (!related) {
- return 0;
- }
- result &= related;
+ checkNoTypeArguments(node);
+ return !noImplicitAny ? anyType : undefined;
}
- return result;
}
- function typeArgumentsRelatedTo(sources, targets, variances, reportErrors, intersectionState) {
- if (sources === void 0) { sources = ts.emptyArray; }
- if (targets === void 0) { targets = ts.emptyArray; }
- if (variances === void 0) { variances = ts.emptyArray; }
- if (sources.length !== targets.length && relation === identityRelation) {
- return 0;
+ }
+ function getTypeFromJSDocNullableTypeNode(node) {
+ var type = getTypeFromTypeNode(node.type);
+ return strictNullChecks ? getNullableType(type, 65536) : type;
+ }
+ function getTypeFromTypeReference(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ if (ts.isConstTypeReference(node) && ts.isAssertionExpression(node.parent)) {
+ links.resolvedSymbol = unknownSymbol;
+ return links.resolvedType = checkExpressionCached(node.parent.expression);
}
- var length = sources.length <= targets.length ? sources.length : targets.length;
- var result = -1;
- for (var i = 0; i < length; i++) {
- var varianceFlags = i < variances.length ? variances[i] : 1;
- var variance = varianceFlags & 7;
- if (variance !== 4) {
- var s = sources[i];
- var t = targets[i];
- var related = -1;
- if (varianceFlags & 8) {
- related = relation === identityRelation ? isRelatedTo(s, t, false) : compareTypesIdentical(s, t);
- }
- else if (variance === 1) {
- related = isRelatedTo(s, t, reportErrors, undefined, intersectionState);
- }
- else if (variance === 2) {
- related = isRelatedTo(t, s, reportErrors, undefined, intersectionState);
- }
- else if (variance === 3) {
- related = isRelatedTo(t, s, false);
- if (!related) {
- related = isRelatedTo(s, t, reportErrors, undefined, intersectionState);
- }
+ var symbol = void 0;
+ var type = void 0;
+ var meaning = 788968;
+ if (isJSDocTypeReference(node)) {
+ type = getIntendedTypeFromJSDocTypeReference(node);
+ if (!type) {
+ symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning, true);
+ if (symbol === unknownSymbol) {
+ symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning | 111551);
}
else {
- related = isRelatedTo(s, t, reportErrors, undefined, intersectionState);
- if (related) {
- related &= isRelatedTo(t, s, reportErrors, undefined, intersectionState);
- }
- }
- if (!related) {
- return 0;
+ resolveTypeReferenceName(getTypeReferenceName(node), meaning);
}
- result &= related;
+ type = getTypeReferenceType(node, symbol);
}
}
- return result;
- }
- function recursiveTypeRelatedTo(source, target, reportErrors, intersectionState) {
- if (overflow) {
- return 0;
+ if (!type) {
+ symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning);
+ type = getTypeReferenceType(node, symbol);
}
- var id = getRelationKey(source, target, intersectionState | (inPropertyCheck ? 8 : 0), relation);
- var entry = relation.get(id);
- if (entry !== undefined) {
- if (reportErrors && entry & 2 && !(entry & 4)) {
- }
- else {
- if (outofbandVarianceMarkerHandler) {
- var saved = entry & 24;
- if (saved & 8) {
- instantiateType(source, makeFunctionTypeMapper(reportUnmeasurableMarkers));
- }
- if (saved & 16) {
- instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers));
- }
- }
- return entry & 1 ? -1 : 0;
+ links.resolvedSymbol = symbol;
+ links.resolvedType = type;
+ }
+ return links.resolvedType;
+ }
+ function typeArgumentsFromTypeReferenceNode(node) {
+ return ts.map(node.typeArguments, getTypeFromTypeNode);
+ }
+ function getTypeFromTypeQueryNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ links.resolvedType = getRegularTypeOfLiteralType(getWidenedType(checkExpression(node.exprName)));
+ }
+ return links.resolvedType;
+ }
+ function getTypeOfGlobalSymbol(symbol, arity) {
+ function getTypeDeclaration(symbol) {
+ var declarations = symbol.declarations;
+ for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) {
+ var declaration = declarations_3[_i];
+ switch (declaration.kind) {
+ case 252:
+ case 253:
+ case 255:
+ return declaration;
}
}
- if (!maybeKeys) {
- maybeKeys = [];
- sourceStack = [];
- targetStack = [];
+ }
+ if (!symbol) {
+ return arity ? emptyGenericType : emptyObjectType;
+ }
+ var type = getDeclaredTypeOfSymbol(symbol);
+ if (!(type.flags & 524288)) {
+ error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_be_a_class_or_interface_type, ts.symbolName(symbol));
+ return arity ? emptyGenericType : emptyObjectType;
+ }
+ if (ts.length(type.typeParameters) !== arity) {
+ error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_have_1_type_parameter_s, ts.symbolName(symbol), arity);
+ return arity ? emptyGenericType : emptyObjectType;
+ }
+ return type;
+ }
+ function getGlobalValueSymbol(name, reportErrors) {
+ return getGlobalSymbol(name, 111551, reportErrors ? ts.Diagnostics.Cannot_find_global_value_0 : undefined);
+ }
+ function getGlobalTypeSymbol(name, reportErrors) {
+ return getGlobalSymbol(name, 788968, reportErrors ? ts.Diagnostics.Cannot_find_global_type_0 : undefined);
+ }
+ function getGlobalSymbol(name, meaning, diagnostic) {
+ return resolveName(undefined, name, meaning, diagnostic, name, false);
+ }
+ function getGlobalType(name, arity, reportErrors) {
+ var symbol = getGlobalTypeSymbol(name, reportErrors);
+ return symbol || reportErrors ? getTypeOfGlobalSymbol(symbol, arity) : undefined;
+ }
+ 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 getGlobalESSymbolConstructorSymbol(reportErrors) {
+ return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors));
+ }
+ function getGlobalESSymbolType(reportErrors) {
+ return deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol", 0, reportErrors)) || emptyObjectType;
+ }
+ function getGlobalPromiseType(reportErrors) {
+ return deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise", 1, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalPromiseLikeType(reportErrors) {
+ return deferredGlobalPromiseLikeType || (deferredGlobalPromiseLikeType = getGlobalType("PromiseLike", 1, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalPromiseConstructorSymbol(reportErrors) {
+ return deferredGlobalPromiseConstructorSymbol || (deferredGlobalPromiseConstructorSymbol = getGlobalValueSymbol("Promise", reportErrors));
+ }
+ function getGlobalPromiseConstructorLikeType(reportErrors) {
+ return deferredGlobalPromiseConstructorLikeType || (deferredGlobalPromiseConstructorLikeType = getGlobalType("PromiseConstructorLike", 0, reportErrors)) || emptyObjectType;
+ }
+ function getGlobalAsyncIterableType(reportErrors) {
+ return deferredGlobalAsyncIterableType || (deferredGlobalAsyncIterableType = getGlobalType("AsyncIterable", 1, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalAsyncIteratorType(reportErrors) {
+ return deferredGlobalAsyncIteratorType || (deferredGlobalAsyncIteratorType = getGlobalType("AsyncIterator", 3, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalAsyncIterableIteratorType(reportErrors) {
+ return deferredGlobalAsyncIterableIteratorType || (deferredGlobalAsyncIterableIteratorType = getGlobalType("AsyncIterableIterator", 1, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalAsyncGeneratorType(reportErrors) {
+ return deferredGlobalAsyncGeneratorType || (deferredGlobalAsyncGeneratorType = getGlobalType("AsyncGenerator", 3, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalIterableType(reportErrors) {
+ return deferredGlobalIterableType || (deferredGlobalIterableType = getGlobalType("Iterable", 1, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalIteratorType(reportErrors) {
+ return deferredGlobalIteratorType || (deferredGlobalIteratorType = getGlobalType("Iterator", 3, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalIterableIteratorType(reportErrors) {
+ return deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType("IterableIterator", 1, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalGeneratorType(reportErrors) {
+ return deferredGlobalGeneratorType || (deferredGlobalGeneratorType = getGlobalType("Generator", 3, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalIteratorYieldResultType(reportErrors) {
+ return deferredGlobalIteratorYieldResultType || (deferredGlobalIteratorYieldResultType = getGlobalType("IteratorYieldResult", 1, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalIteratorReturnResultType(reportErrors) {
+ return deferredGlobalIteratorReturnResultType || (deferredGlobalIteratorReturnResultType = getGlobalType("IteratorReturnResult", 1, reportErrors)) || emptyGenericType;
+ }
+ function getGlobalTypeOrUndefined(name, arity) {
+ if (arity === void 0) { arity = 0; }
+ var symbol = getGlobalSymbol(name, 788968, undefined);
+ return symbol && getTypeOfGlobalSymbol(symbol, arity);
+ }
+ function getGlobalExtractSymbol() {
+ return deferredGlobalExtractSymbol || (deferredGlobalExtractSymbol = getGlobalSymbol("Extract", 524288, ts.Diagnostics.Cannot_find_global_type_0));
+ }
+ function getGlobalOmitSymbol() {
+ return deferredGlobalOmitSymbol || (deferredGlobalOmitSymbol = getGlobalSymbol("Omit", 524288, ts.Diagnostics.Cannot_find_global_type_0));
+ }
+ function getGlobalBigIntType(reportErrors) {
+ return deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", 0, reportErrors)) || emptyObjectType;
+ }
+ 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 180:
+ return 2;
+ case 181:
+ return getRestTypeElementFlags(node);
+ case 192:
+ return node.questionToken ? 2 :
+ node.dotDotDotToken ? getRestTypeElementFlags(node) :
+ 1;
+ default:
+ return 1;
+ }
+ }
+ function getRestTypeElementFlags(node) {
+ return getArrayElementTypeNode(node.type) ? 4 : 8;
+ }
+ function getArrayOrTupleTargetType(node) {
+ var readonly = isReadonlyTypeOperator(node.parent);
+ var elementType = getArrayElementTypeNode(node);
+ if (elementType) {
+ return readonly ? globalReadonlyArrayType : globalArrayType;
+ }
+ var elementFlags = ts.map(node.elements, getTupleElementFlags);
+ var missingName = ts.some(node.elements, function (e) { return e.kind !== 192; });
+ return getTupleTargetType(elementFlags, readonly, missingName ? undefined : node.elements);
+ }
+ function isDeferredTypeReferenceNode(node, hasDefaultTypeArguments) {
+ return !!getAliasSymbolForTypeNode(node) || isResolvedByTypeAlias(node) && (node.kind === 178 ? mayResolveTypeAlias(node.elementType) :
+ node.kind === 179 ? ts.some(node.elements, mayResolveTypeAlias) :
+ hasDefaultTypeArguments || ts.some(node.typeArguments, mayResolveTypeAlias));
+ }
+ function isResolvedByTypeAlias(node) {
+ var parent = node.parent;
+ switch (parent.kind) {
+ case 186:
+ case 192:
+ case 173:
+ case 182:
+ case 183:
+ case 189:
+ case 184:
+ case 188:
+ case 178:
+ case 179:
+ return isResolvedByTypeAlias(parent);
+ case 254:
+ return true;
+ }
+ return false;
+ }
+ function mayResolveTypeAlias(node) {
+ switch (node.kind) {
+ case 173:
+ return isJSDocTypeReference(node) || !!(resolveTypeReferenceName(node.typeName, 788968).flags & 524288);
+ case 176:
+ return true;
+ case 188:
+ return node.operator !== 151 && mayResolveTypeAlias(node.type);
+ case 186:
+ case 180:
+ case 192:
+ case 307:
+ case 305:
+ case 306:
+ case 301:
+ return mayResolveTypeAlias(node.type);
+ case 181:
+ return node.type.kind !== 178 || mayResolveTypeAlias(node.type.elementType);
+ case 182:
+ case 183:
+ return ts.some(node.types, mayResolveTypeAlias);
+ case 189:
+ return mayResolveTypeAlias(node.objectType) || mayResolveTypeAlias(node.indexType);
+ case 184:
+ return mayResolveTypeAlias(node.checkType) || mayResolveTypeAlias(node.extendsType) ||
+ mayResolveTypeAlias(node.trueType) || mayResolveTypeAlias(node.falseType);
+ }
+ return false;
+ }
+ function getTypeFromArrayOrTupleTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ var target = getArrayOrTupleTargetType(node);
+ if (target === emptyGenericType) {
+ links.resolvedType = emptyObjectType;
+ }
+ else if (!(node.kind === 179 && ts.some(node.elements, function (e) { return !!(getTupleElementFlags(e) & 8); })) && isDeferredTypeReferenceNode(node)) {
+ links.resolvedType = node.kind === 179 && node.elements.length === 0 ? target :
+ createDeferredTypeReference(target, node, undefined);
}
else {
- for (var i = 0; i < maybeCount; i++) {
- if (id === maybeKeys[i]) {
- return 1;
- }
- }
- if (depth === 100) {
- overflow = true;
- return 0;
- }
- }
- var maybeStart = maybeCount;
- maybeKeys[maybeCount] = id;
- maybeCount++;
- sourceStack[depth] = source;
- targetStack[depth] = target;
- depth++;
- var saveExpandingFlags = expandingFlags;
- if (!(expandingFlags & 1) && isDeeplyNestedType(source, sourceStack, depth))
- expandingFlags |= 1;
- if (!(expandingFlags & 2) && isDeeplyNestedType(target, targetStack, depth))
- expandingFlags |= 2;
- var originalHandler;
- var propagatingVarianceFlags = 0;
- if (outofbandVarianceMarkerHandler) {
- originalHandler = outofbandVarianceMarkerHandler;
- outofbandVarianceMarkerHandler = function (onlyUnreliable) {
- propagatingVarianceFlags |= onlyUnreliable ? 16 : 8;
- return originalHandler(onlyUnreliable);
- };
+ var elementTypes = node.kind === 178 ? [getTypeFromTypeNode(node.elementType)] : ts.map(node.elements, getTypeFromTypeNode);
+ links.resolvedType = createNormalizedTypeReference(target, elementTypes);
}
- var result = expandingFlags !== 3 ? structuredTypeRelatedTo(source, target, reportErrors, intersectionState) : 1;
- if (outofbandVarianceMarkerHandler) {
- outofbandVarianceMarkerHandler = originalHandler;
+ }
+ return links.resolvedType;
+ }
+ function isReadonlyTypeOperator(node) {
+ return ts.isTypeOperatorNode(node) && node.operator === 142;
+ }
+ function createTupleType(elementTypes, elementFlags, readonly, namedMemberDeclarations) {
+ if (readonly === void 0) { readonly = false; }
+ var tupleTarget = getTupleTargetType(elementFlags || ts.map(elementTypes, function (_) { return 1; }), readonly, namedMemberDeclarations);
+ return tupleTarget === emptyGenericType ? emptyObjectType :
+ elementTypes.length ? createNormalizedTypeReference(tupleTarget, elementTypes) :
+ tupleTarget;
+ }
+ function getTupleTargetType(elementFlags, readonly, namedMemberDeclarations) {
+ if (elementFlags.length === 1 && elementFlags[0] & 4) {
+ return readonly ? globalReadonlyArrayType : globalArrayType;
+ }
+ var key = ts.map(elementFlags, function (f) { return f & 1 ? "#" : f & 2 ? "?" : f & 4 ? "." : "*"; }).join() +
+ (readonly ? "R" : "") +
+ (namedMemberDeclarations && namedMemberDeclarations.length ? "," + ts.map(namedMemberDeclarations, getNodeId).join(",") : "");
+ var type = tupleTypes.get(key);
+ if (!type) {
+ tupleTypes.set(key, type = createTupleTargetType(elementFlags, readonly, namedMemberDeclarations));
+ }
+ return type;
+ }
+ function createTupleTargetType(elementFlags, readonly, namedMemberDeclarations) {
+ var arity = elementFlags.length;
+ var minLength = ts.findLastIndex(elementFlags, function (f) { return !!(f & (1 | 8)); }) + 1;
+ var typeParameters;
+ var properties = [];
+ var combinedFlags = 0;
+ if (arity) {
+ typeParameters = new Array(arity);
+ for (var i = 0; i < arity; i++) {
+ var typeParameter = typeParameters[i] = createTypeParameter();
+ var flags = elementFlags[i];
+ combinedFlags |= flags;
+ if (!(combinedFlags & 12)) {
+ var property = createSymbol(4 | (flags & 2 ? 16777216 : 0), "" + i, readonly ? 8 : 0);
+ property.tupleLabelDeclaration = namedMemberDeclarations === null || namedMemberDeclarations === void 0 ? void 0 : namedMemberDeclarations[i];
+ property.type = typeParameter;
+ properties.push(property);
+ }
}
- expandingFlags = saveExpandingFlags;
- depth--;
- if (result) {
- if (result === -1 || depth === 0) {
- for (var i = maybeStart; i < maybeCount; i++) {
- relation.set(maybeKeys[i], 1 | propagatingVarianceFlags);
- }
- maybeCount = maybeStart;
+ }
+ var fixedLength = properties.length;
+ var lengthSymbol = createSymbol(4, "length");
+ if (combinedFlags & 12) {
+ lengthSymbol.type = numberType;
+ }
+ else {
+ var literalTypes_1 = [];
+ for (var i = minLength; i <= arity; i++)
+ literalTypes_1.push(getLiteralType(i));
+ lengthSymbol.type = getUnionType(literalTypes_1);
+ }
+ properties.push(lengthSymbol);
+ var type = createObjectType(8 | 4);
+ type.typeParameters = typeParameters;
+ type.outerTypeParameters = undefined;
+ type.localTypeParameters = typeParameters;
+ type.instantiations = new ts.Map();
+ type.instantiations.set(getTypeListId(type.typeParameters), type);
+ type.target = type;
+ type.resolvedTypeArguments = type.typeParameters;
+ type.thisType = createTypeParameter();
+ type.thisType.isThisType = true;
+ type.thisType.constraint = type;
+ type.declaredProperties = properties;
+ type.declaredCallSignatures = ts.emptyArray;
+ type.declaredConstructSignatures = ts.emptyArray;
+ type.declaredStringIndexInfo = undefined;
+ type.declaredNumberIndexInfo = undefined;
+ type.elementFlags = elementFlags;
+ type.minLength = minLength;
+ type.fixedLength = fixedLength;
+ type.hasRestElement = !!(combinedFlags & 12);
+ type.combinedFlags = combinedFlags;
+ type.readonly = readonly;
+ type.labeledElementDeclarations = namedMemberDeclarations;
+ return type;
+ }
+ function createNormalizedTypeReference(target, typeArguments) {
+ return target.objectFlags & 8 && target.combinedFlags & 8 ?
+ createNormalizedTupleType(target, typeArguments) :
+ createTypeReference(target, typeArguments);
+ }
+ function createNormalizedTupleType(target, elementTypes) {
+ var _a, _b, _c;
+ var unionIndex = ts.findIndex(elementTypes, function (t, i) { return !!(target.elementFlags[i] & 8 && t.flags & (131072 | 1048576)); });
+ if (unionIndex >= 0) {
+ return checkCrossProductUnion(ts.map(elementTypes, function (t, i) { return target.elementFlags[i] & 8 ? t : unknownType; })) ?
+ mapType(elementTypes[unionIndex], function (t) { return createNormalizedTupleType(target, ts.replaceElement(elementTypes, unionIndex, t)); }) :
+ errorType;
+ }
+ var spreadIndex = ts.findIndex(elementTypes, function (t, i) { return !!(target.elementFlags[i] & 8) && !(t.flags & 58982400) && !isGenericMappedType(t); });
+ if (spreadIndex < 0) {
+ return createTypeReference(target, elementTypes);
+ }
+ var expandedTypes = [];
+ var expandedFlags = [];
+ var expandedDeclarations = [];
+ var optionalIndex = -1;
+ var restTypes;
+ var _loop_13 = function (i) {
+ var type = elementTypes[i];
+ var flags = target.elementFlags[i];
+ if (flags & 8) {
+ if (type.flags & 58982400 || isGenericMappedType(type)) {
+ addElementOrRest(type, 8, (_a = target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[i]);
+ }
+ else if (isTupleType(type)) {
+ ts.forEach(getTypeArguments(type), function (t, n) { var _a; return addElementOrRest(t, type.target.elementFlags[n], (_a = type.target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[n]); });
+ }
+ else {
+ addElementOrRest(isArrayLikeType(type) && getIndexTypeOfType(type, 1) || errorType, 4, (_b = target.labeledElementDeclarations) === null || _b === void 0 ? void 0 : _b[i]);
}
}
else {
- relation.set(id, (reportErrors ? 4 : 0) | 2 | propagatingVarianceFlags);
- maybeCount = maybeStart;
+ addElementOrRest(type, flags, (_c = target.labeledElementDeclarations) === null || _c === void 0 ? void 0 : _c[i]);
}
- return result;
+ };
+ for (var i = 0; i < elementTypes.length; i++) {
+ _loop_13(i);
}
- function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
- if (intersectionState & 4) {
- return propertiesRelatedTo(source, target, reportErrors, undefined, 0);
+ if (restTypes) {
+ expandedTypes[expandedTypes.length - 1] = getUnionType(restTypes);
+ }
+ var tupleTarget = getTupleTargetType(expandedFlags, target.readonly, expandedDeclarations);
+ return tupleTarget === emptyGenericType ? emptyObjectType :
+ expandedFlags.length ? createTypeReference(tupleTarget, expandedTypes) :
+ tupleTarget;
+ function addElementOrRest(type, flags, declaration) {
+ if (restTypes) {
+ restTypes.push(flags & 8 ? getIndexedAccessType(type, numberType) : type);
}
- var flags = source.flags & target.flags;
- if (relation === identityRelation && !(flags & 524288)) {
- if (flags & 4194304) {
- return isRelatedTo(source.type, target.type, false);
- }
- var result_6 = 0;
- if (flags & 8388608) {
- if (result_6 = isRelatedTo(source.objectType, target.objectType, false)) {
- if (result_6 &= isRelatedTo(source.indexType, target.indexType, false)) {
- return result_6;
- }
+ else {
+ if (flags & 1 && optionalIndex >= 0) {
+ for (var i = optionalIndex; i < expandedFlags.length; i++) {
+ if (expandedFlags[i] & 2)
+ expandedFlags[i] = 1;
}
+ optionalIndex = -1;
}
- if (flags & 16777216) {
- if (source.root.isDistributive === target.root.isDistributive) {
- if (result_6 = isRelatedTo(source.checkType, target.checkType, false)) {
- if (result_6 &= isRelatedTo(source.extendsType, target.extendsType, false)) {
- if (result_6 &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), false)) {
- if (result_6 &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), false)) {
- return result_6;
- }
- }
- }
- }
- }
+ else if (flags & 2 && optionalIndex < 0) {
+ optionalIndex = expandedFlags.length;
}
- if (flags & 33554432) {
- return isRelatedTo(source.substitute, target.substitute, false);
+ else if (flags & 4) {
+ restTypes = [type];
}
- return 0;
- }
- var result;
- var originalErrorInfo;
- var varianceCheckFailed = false;
- var saveErrorInfo = captureErrorCalculationState();
- if (source.flags & (524288 | 16777216) && source.aliasSymbol &&
- source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol &&
- !(source.aliasTypeArgumentsContainsMarker || target.aliasTypeArgumentsContainsMarker)) {
- var variances = getAliasVariances(source.aliasSymbol);
- if (variances === ts.emptyArray) {
- return 1;
+ expandedTypes.push(type);
+ expandedFlags.push(flags);
+ if (expandedDeclarations && declaration) {
+ expandedDeclarations.push(declaration);
}
- var varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances, intersectionState);
- if (varianceResult !== undefined) {
- return varianceResult;
+ else {
+ expandedDeclarations = undefined;
}
}
- if (target.flags & 262144) {
- if (ts.getObjectFlags(source) & 32 && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source))) {
- if (!(getMappedTypeModifiers(source) & 4)) {
- var templateType = getTemplateTypeFromMappedType(source);
- var indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(source));
- if (result = isRelatedTo(templateType, indexedAccessType, reportErrors)) {
- return result;
- }
- }
- }
+ }
+ }
+ function sliceTupleType(type, index, endSkipCount) {
+ if (endSkipCount === void 0) { endSkipCount = 0; }
+ var target = type.target;
+ var endIndex = getTypeReferenceArity(type) - endSkipCount;
+ return index > target.fixedLength ? getRestArrayTypeOfTupleType(type) || createTupleType(ts.emptyArray) :
+ createTupleType(getTypeArguments(type).slice(index, endIndex), target.elementFlags.slice(index, endIndex), false, target.labeledElementDeclarations && target.labeledElementDeclarations.slice(index, endIndex));
+ }
+ function getKnownKeysOfTupleType(type) {
+ return getUnionType(ts.append(ts.arrayOf(type.target.fixedLength, function (i) { return getLiteralType("" + i); }), getIndexType(type.target.readonly ? globalReadonlyArrayType : globalArrayType)));
+ }
+ function getTypeFromOptionalTypeNode(node) {
+ var type = getTypeFromTypeNode(node.type);
+ return strictNullChecks ? getOptionalType(type) : type;
+ }
+ function getTypeId(type) {
+ return type.id;
+ }
+ function containsType(types, type) {
+ return ts.binarySearch(types, type, getTypeId, ts.compareValues) >= 0;
+ }
+ function insertType(types, type) {
+ var index = ts.binarySearch(types, type, getTypeId, ts.compareValues);
+ if (index < 0) {
+ types.splice(~index, 0, type);
+ return true;
+ }
+ return false;
+ }
+ function addTypeToUnion(typeSet, includes, type) {
+ var flags = type.flags;
+ if (flags & 1048576) {
+ return addTypesToUnion(typeSet, includes, type.types);
+ }
+ if (!(flags & 131072)) {
+ includes |= flags & 205258751;
+ if (flags & 469499904)
+ includes |= 262144;
+ if (type === wildcardType)
+ includes |= 8388608;
+ if (!strictNullChecks && flags & 98304) {
+ if (!(ts.getObjectFlags(type) & 524288))
+ includes |= 4194304;
}
- else if (target.flags & 4194304) {
- if (source.flags & 4194304) {
- if (result = isRelatedTo(target.type, source.type, false)) {
- return result;
- }
- }
- var constraint = getSimplifiedTypeOrConstraint(target.type);
- if (constraint) {
- if (isRelatedTo(source, getIndexType(constraint, target.stringsOnly), reportErrors) === -1) {
- return -1;
- }
+ else {
+ var len = typeSet.length;
+ var index = len && type.id > typeSet[len - 1].id ? ~len : ts.binarySearch(typeSet, type, getTypeId, ts.compareValues);
+ if (index < 0) {
+ typeSet.splice(~index, 0, type);
}
}
- else if (target.flags & 8388608) {
- if (relation !== identityRelation) {
- var objectType = target.objectType;
- var indexType = target.indexType;
- var baseObjectType = getBaseConstraintOfType(objectType) || objectType;
- var baseIndexType = getBaseConstraintOfType(indexType) || indexType;
- if (!isGenericObjectType(baseObjectType) && !isGenericIndexType(baseIndexType)) {
- var accessFlags = 2 | (baseObjectType !== objectType ? 1 : 0);
- var constraint = getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, undefined, accessFlags);
- if (constraint && (result = isRelatedTo(source, constraint, reportErrors))) {
- return result;
- }
- }
+ }
+ return includes;
+ }
+ function addTypesToUnion(typeSet, includes, types) {
+ for (var _i = 0, types_10 = types; _i < types_10.length; _i++) {
+ var type = types_10[_i];
+ includes = addTypeToUnion(typeSet, includes, type);
+ }
+ return includes;
+ }
+ function isSetOfLiteralsFromSameEnum(types) {
+ var first = types[0];
+ if (first.flags & 1024) {
+ var firstEnum = getParentOfSymbol(first.symbol);
+ for (var i = 1; i < types.length; i++) {
+ var other = types[i];
+ if (!(other.flags & 1024) || (firstEnum !== getParentOfSymbol(other.symbol))) {
+ return false;
}
}
- else if (isGenericMappedType(target)) {
- var template = getTemplateTypeFromMappedType(target);
- var modifiers = getMappedTypeModifiers(target);
- if (!(modifiers & 8)) {
- if (template.flags & 8388608 && template.objectType === source &&
- template.indexType === getTypeParameterFromMappedType(target)) {
- return -1;
- }
- if (!isGenericMappedType(source)) {
- var targetConstraint = getConstraintTypeFromMappedType(target);
- var sourceKeys = getIndexType(source, undefined, true);
- var includeOptional = modifiers & 4;
- var filteredByApplicability = includeOptional ? intersectTypes(targetConstraint, sourceKeys) : undefined;
- if (includeOptional
- ? !(filteredByApplicability.flags & 131072)
- : isRelatedTo(targetConstraint, sourceKeys)) {
- var typeParameter = getTypeParameterFromMappedType(target);
- var indexingType = filteredByApplicability ? getIntersectionType([filteredByApplicability, typeParameter]) : typeParameter;
- var indexedAccessType = getIndexedAccessType(source, indexingType);
- var templateType = getTemplateTypeFromMappedType(target);
- if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) {
- return result;
- }
+ return true;
+ }
+ return false;
+ }
+ function removeSubtypes(types, primitivesOnly) {
+ var len = types.length;
+ if (len === 0 || isSetOfLiteralsFromSameEnum(types)) {
+ return true;
+ }
+ var i = len;
+ var count = 0;
+ while (i > 0) {
+ i--;
+ var source = types[i];
+ for (var _i = 0, types_11 = types; _i < types_11.length; _i++) {
+ var target = types_11[_i];
+ if (source !== target) {
+ if (count === 100000) {
+ var estimatedCount = (count / (len - i)) * len;
+ if (estimatedCount > (primitivesOnly ? 25000000 : 1000000)) {
+ ts.tracing.instant("check", "removeSubtypes_DepthLimit", { typeIds: types.map(function (t) { return t.id; }) });
+ error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
+ return false;
}
- originalErrorInfo = errorInfo;
- resetErrorInfo(saveErrorInfo);
+ }
+ count++;
+ if (isTypeRelatedTo(source, target, strictSubtypeRelation) && (!(ts.getObjectFlags(getTargetType(source)) & 1) ||
+ !(ts.getObjectFlags(getTargetType(target)) & 1) ||
+ isTypeDerivedFrom(source, target))) {
+ ts.orderedRemoveItemAt(types, i);
+ break;
}
}
}
- if (source.flags & 8650752) {
- if (source.flags & 8388608 && target.flags & 8388608) {
- if (result = isRelatedTo(source.objectType, target.objectType, reportErrors)) {
- result &= isRelatedTo(source.indexType, target.indexType, reportErrors);
- }
- if (result) {
- resetErrorInfo(saveErrorInfo);
- return result;
- }
+ }
+ return true;
+ }
+ function removeRedundantLiteralTypes(types, includes) {
+ var i = types.length;
+ while (i > 0) {
+ i--;
+ var t = types[i];
+ var remove = t.flags & 128 && includes & 4 ||
+ t.flags & 256 && includes & 8 ||
+ t.flags & 2048 && includes & 64 ||
+ t.flags & 8192 && includes & 4096 ||
+ isFreshLiteralType(t) && containsType(types, t.regularType);
+ if (remove) {
+ ts.orderedRemoveItemAt(types, i);
+ }
+ }
+ }
+ function removeStringLiteralsMatchedByTemplateLiterals(types) {
+ var templates = ts.filter(types, isPatternLiteralType);
+ if (templates.length) {
+ var i = types.length;
+ var _loop_14 = function () {
+ i--;
+ var t = types[i];
+ if (t.flags & 128 && ts.some(templates, function (template) { return isTypeSubtypeOf(t, template); })) {
+ ts.orderedRemoveItemAt(types, i);
}
- else {
- var constraint = getConstraintOfType(source);
- if (!constraint || (source.flags & 262144 && constraint.flags & 1)) {
- if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864))) {
- resetErrorInfo(saveErrorInfo);
- return result;
- }
+ };
+ while (i > 0) {
+ _loop_14();
+ }
+ }
+ }
+ function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments) {
+ if (unionReduction === void 0) { unionReduction = 1; }
+ if (types.length === 0) {
+ return neverType;
+ }
+ if (types.length === 1) {
+ return types[0];
+ }
+ var typeSet = [];
+ var includes = addTypesToUnion(typeSet, 0, types);
+ if (unionReduction !== 0) {
+ if (includes & 3) {
+ return includes & 1 ? includes & 8388608 ? wildcardType : anyType : unknownType;
+ }
+ switch (unionReduction) {
+ case 1:
+ if (includes & (2944 | 8192)) {
+ removeRedundantLiteralTypes(typeSet, includes);
}
- else if (result = isRelatedTo(constraint, target, false, undefined, intersectionState)) {
- resetErrorInfo(saveErrorInfo);
- return result;
+ if (includes & 128 && includes & 134217728) {
+ removeStringLiteralsMatchedByTemplateLiterals(typeSet);
}
- else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, reportErrors, undefined, intersectionState)) {
- resetErrorInfo(saveErrorInfo);
- return result;
+ break;
+ case 2:
+ if (!removeSubtypes(typeSet, !(includes & 262144))) {
+ return errorType;
}
- }
+ break;
}
- else if (source.flags & 4194304) {
- if (result = isRelatedTo(keyofConstraintType, target, reportErrors)) {
- resetErrorInfo(saveErrorInfo);
- return result;
- }
+ if (typeSet.length === 0) {
+ return includes & 65536 ? includes & 4194304 ? nullType : nullWideningType :
+ includes & 32768 ? includes & 4194304 ? undefinedType : undefinedWideningType :
+ neverType;
}
- else if (source.flags & 16777216) {
- if (target.flags & 16777216) {
- var sourceParams = source.root.inferTypeParameters;
- var sourceExtends = source.extendsType;
- var mapper = void 0;
- if (sourceParams) {
- var ctx = createInferenceContext(sourceParams, undefined, 0, isRelatedTo);
- inferTypes(ctx.inferences, target.extendsType, sourceExtends, 128 | 256);
- sourceExtends = instantiateType(sourceExtends, ctx.mapper);
- mapper = ctx.mapper;
- }
- if (isTypeIdenticalTo(sourceExtends, target.extendsType) &&
- (isRelatedTo(source.checkType, target.checkType) || isRelatedTo(target.checkType, source.checkType))) {
- if (result = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source), mapper), getTrueTypeFromConditionalType(target), reportErrors)) {
- result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), reportErrors);
- }
- if (result) {
- resetErrorInfo(saveErrorInfo);
- return result;
- }
- }
+ }
+ var objectFlags = (includes & 469647395 ? 0 : 262144) |
+ (includes & 2097152 ? 268435456 : 0);
+ return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments);
+ }
+ function getUnionTypePredicate(signatures) {
+ var first;
+ var types = [];
+ for (var _i = 0, signatures_6 = signatures; _i < signatures_6.length; _i++) {
+ var sig = signatures_6[_i];
+ var pred = getTypePredicateOfSignature(sig);
+ if (!pred || pred.kind === 2 || pred.kind === 3) {
+ continue;
+ }
+ if (first) {
+ if (!typePredicateKindsMatch(first, pred)) {
+ return undefined;
}
- else {
- var distributiveConstraint = getConstraintOfDistributiveConditionalType(source);
- if (distributiveConstraint) {
- if (result = isRelatedTo(distributiveConstraint, target, reportErrors)) {
- resetErrorInfo(saveErrorInfo);
- return result;
- }
- }
+ }
+ else {
+ first = pred;
+ }
+ types.push(pred.type);
+ }
+ if (!first) {
+ return undefined;
+ }
+ var unionType = getUnionType(types);
+ return createTypePredicate(first.kind, first.parameterName, first.parameterIndex, unionType);
+ }
+ function typePredicateKindsMatch(a, b) {
+ return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
+ }
+ function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments) {
+ if (types.length === 0) {
+ return neverType;
+ }
+ if (types.length === 1) {
+ return types[0];
+ }
+ var id = getTypeListId(types);
+ var type = unionTypes.get(id);
+ if (!type) {
+ type = createType(1048576);
+ unionTypes.set(id, type);
+ type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(types, 98304);
+ type.types = types;
+ type.aliasSymbol = aliasSymbol;
+ type.aliasTypeArguments = aliasTypeArguments;
+ }
+ return type;
+ }
+ function getTypeFromUnionTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ var aliasSymbol = getAliasSymbolForTypeNode(node);
+ links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), 1, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
+ }
+ return links.resolvedType;
+ }
+ function addTypeToIntersection(typeSet, includes, type) {
+ var flags = type.flags;
+ if (flags & 2097152) {
+ return addTypesToIntersection(typeSet, includes, type.types);
+ }
+ if (isEmptyAnonymousObjectType(type)) {
+ if (!(includes & 16777216)) {
+ includes |= 16777216;
+ typeSet.set(type.id.toString(), type);
+ }
+ }
+ else {
+ if (flags & 3) {
+ if (type === wildcardType)
+ includes |= 8388608;
+ }
+ else if ((strictNullChecks || !(flags & 98304)) && !typeSet.has(type.id.toString())) {
+ if (type.flags & 109440 && includes & 109440) {
+ includes |= 67108864;
}
- var defaultConstraint = getDefaultConstraintOfConditionalType(source);
- if (defaultConstraint) {
- if (result = isRelatedTo(defaultConstraint, target, reportErrors)) {
- resetErrorInfo(saveErrorInfo);
- return result;
- }
+ typeSet.set(type.id.toString(), type);
+ }
+ includes |= flags & 205258751;
+ }
+ return includes;
+ }
+ function addTypesToIntersection(typeSet, includes, types) {
+ for (var _i = 0, types_12 = types; _i < types_12.length; _i++) {
+ var type = types_12[_i];
+ includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type));
+ }
+ return includes;
+ }
+ function removeRedundantPrimitiveTypes(types, includes) {
+ var i = types.length;
+ while (i > 0) {
+ i--;
+ var t = types[i];
+ var remove = t.flags & 4 && includes & 128 ||
+ t.flags & 8 && includes & 256 ||
+ t.flags & 64 && includes & 2048 ||
+ t.flags & 4096 && includes & 8192;
+ if (remove) {
+ ts.orderedRemoveItemAt(types, i);
+ }
+ }
+ }
+ function eachUnionContains(unionTypes, type) {
+ for (var _i = 0, unionTypes_1 = unionTypes; _i < unionTypes_1.length; _i++) {
+ var u = unionTypes_1[_i];
+ if (!containsType(u.types, type)) {
+ var primitive = type.flags & 128 ? stringType :
+ type.flags & 256 ? numberType :
+ type.flags & 2048 ? bigintType :
+ type.flags & 8192 ? esSymbolType :
+ undefined;
+ if (!primitive || !containsType(u.types, primitive)) {
+ return false;
}
}
- else {
- if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target) && isEmptyObjectType(source)) {
- return -1;
- }
- if (isGenericMappedType(target)) {
- if (isGenericMappedType(source)) {
- if (result = mappedTypeRelatedTo(source, target, reportErrors)) {
- resetErrorInfo(saveErrorInfo);
- return result;
- }
- }
- return 0;
- }
- var sourceIsPrimitive = !!(source.flags & 131068);
- if (relation !== identityRelation) {
- source = getApparentType(source);
+ }
+ return true;
+ }
+ function extractRedundantTemplateLiterals(types) {
+ var i = types.length;
+ var literals = ts.filter(types, function (t) { return !!(t.flags & 128); });
+ while (i > 0) {
+ i--;
+ var t = types[i];
+ if (!(t.flags & 134217728))
+ continue;
+ for (var _i = 0, literals_1 = literals; _i < literals_1.length; _i++) {
+ var t2 = literals_1[_i];
+ if (isTypeSubtypeOf(t2, t)) {
+ ts.orderedRemoveItemAt(types, i);
+ break;
}
- else if (isGenericMappedType(source)) {
- return 0;
+ else if (isPatternLiteralType(t)) {
+ return true;
}
- if (ts.getObjectFlags(source) & 4 && ts.getObjectFlags(target) & 4 && source.target === target.target &&
- !(ts.getObjectFlags(source) & 8192 || ts.getObjectFlags(target) & 8192)) {
- var variances = getVariances(source.target);
- if (variances === ts.emptyArray) {
- return 1;
- }
- var varianceResult = relateVariances(getTypeArguments(source), getTypeArguments(target), variances, intersectionState);
- if (varianceResult !== undefined) {
- return varianceResult;
+ }
+ }
+ return false;
+ }
+ function extractIrreducible(types, flag) {
+ if (ts.every(types, function (t) { return !!(t.flags & 1048576) && ts.some(t.types, function (tt) { return !!(tt.flags & flag); }); })) {
+ for (var i = 0; i < types.length; i++) {
+ types[i] = filterType(types[i], function (t) { return !(t.flags & flag); });
+ }
+ return true;
+ }
+ return false;
+ }
+ function intersectUnionsOfPrimitiveTypes(types) {
+ var unionTypes;
+ var index = ts.findIndex(types, function (t) { return !!(ts.getObjectFlags(t) & 262144); });
+ if (index < 0) {
+ return false;
+ }
+ var i = index + 1;
+ while (i < types.length) {
+ var t = types[i];
+ if (ts.getObjectFlags(t) & 262144) {
+ (unionTypes || (unionTypes = [types[index]])).push(t);
+ ts.orderedRemoveItemAt(types, i);
+ }
+ else {
+ i++;
+ }
+ }
+ if (!unionTypes) {
+ return false;
+ }
+ var checked = [];
+ var result = [];
+ for (var _i = 0, unionTypes_2 = unionTypes; _i < unionTypes_2.length; _i++) {
+ var u = unionTypes_2[_i];
+ for (var _a = 0, _b = u.types; _a < _b.length; _a++) {
+ var t = _b[_a];
+ if (insertType(checked, t)) {
+ if (eachUnionContains(unionTypes, t)) {
+ insertType(result, t);
}
}
- else if (isReadonlyArrayType(target) ? isArrayType(source) || isTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) {
- if (relation !== identityRelation) {
- return isRelatedTo(getIndexTypeOfType(source, 1) || anyType, getIndexTypeOfType(target, 1) || anyType, reportErrors);
- }
- else {
- return 0;
- }
+ }
+ }
+ types[index] = getUnionTypeFromSortedList(result, 262144);
+ return true;
+ }
+ function createIntersectionType(types, aliasSymbol, aliasTypeArguments) {
+ var result = createType(2097152);
+ result.objectFlags = getPropagatingFlagsOfTypes(types, 98304);
+ result.types = types;
+ result.aliasSymbol = aliasSymbol;
+ result.aliasTypeArguments = aliasTypeArguments;
+ return result;
+ }
+ function getIntersectionType(types, aliasSymbol, aliasTypeArguments) {
+ var typeMembershipMap = new ts.Map();
+ var includes = addTypesToIntersection(typeMembershipMap, 0, types);
+ var typeSet = ts.arrayFrom(typeMembershipMap.values());
+ if (includes & 131072 ||
+ strictNullChecks && includes & 98304 && includes & (524288 | 67108864 | 16777216) ||
+ includes & 67108864 && includes & (469892092 & ~67108864) ||
+ includes & 402653316 && includes & (469892092 & ~402653316) ||
+ includes & 296 && includes & (469892092 & ~296) ||
+ includes & 2112 && includes & (469892092 & ~2112) ||
+ includes & 12288 && includes & (469892092 & ~12288) ||
+ includes & 49152 && includes & (469892092 & ~49152)) {
+ return neverType;
+ }
+ if (includes & 134217728 && includes & 128 && extractRedundantTemplateLiterals(typeSet)) {
+ return neverType;
+ }
+ if (includes & 1) {
+ return includes & 8388608 ? wildcardType : anyType;
+ }
+ if (!strictNullChecks && includes & 98304) {
+ return includes & 32768 ? undefinedType : nullType;
+ }
+ if (includes & 4 && includes & 128 ||
+ includes & 8 && includes & 256 ||
+ includes & 64 && includes & 2048 ||
+ includes & 4096 && includes & 8192) {
+ removeRedundantPrimitiveTypes(typeSet, includes);
+ }
+ if (includes & 16777216 && includes & 524288) {
+ ts.orderedRemoveItemAt(typeSet, ts.findIndex(typeSet, isEmptyAnonymousObjectType));
+ }
+ if (typeSet.length === 0) {
+ return unknownType;
+ }
+ if (typeSet.length === 1) {
+ return typeSet[0];
+ }
+ var id = getTypeListId(typeSet);
+ var result = intersectionTypes.get(id);
+ if (!result) {
+ if (includes & 1048576) {
+ if (intersectUnionsOfPrimitiveTypes(typeSet)) {
+ result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
}
- else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target) && ts.getObjectFlags(target) & 32768 && !isEmptyObjectType(source)) {
- return 0;
+ else if (extractIrreducible(typeSet, 32768)) {
+ result = getUnionType([getIntersectionType(typeSet), undefinedType], 1, aliasSymbol, aliasTypeArguments);
}
- if (source.flags & (524288 | 2097152) && target.flags & 524288) {
- var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo.errorInfo && !sourceIsPrimitive;
- result = propertiesRelatedTo(source, target, reportStructuralErrors, undefined, intersectionState);
- if (result) {
- result &= signaturesRelatedTo(source, target, 0, reportStructuralErrors);
- if (result) {
- result &= signaturesRelatedTo(source, target, 1, reportStructuralErrors);
- if (result) {
- result &= indexTypesRelatedTo(source, target, 0, sourceIsPrimitive, reportStructuralErrors, intersectionState);
- if (result) {
- result &= indexTypesRelatedTo(source, target, 1, sourceIsPrimitive, reportStructuralErrors, intersectionState);
- }
- }
- }
- }
- if (varianceCheckFailed && result) {
- errorInfo = originalErrorInfo || errorInfo || saveErrorInfo.errorInfo;
- }
- else if (result) {
- return result;
- }
+ else if (extractIrreducible(typeSet, 65536)) {
+ result = getUnionType([getIntersectionType(typeSet), nullType], 1, aliasSymbol, aliasTypeArguments);
}
- if (source.flags & (524288 | 2097152) && target.flags & 1048576) {
- var objectOnlyTarget = extractTypesOfKind(target, 524288 | 2097152 | 33554432);
- if (objectOnlyTarget.flags & 1048576) {
- var result_7 = typeRelatedToDiscriminatedType(source, objectOnlyTarget);
- if (result_7) {
- return result_7;
- }
+ else {
+ if (!checkCrossProductUnion(typeSet)) {
+ return errorType;
}
+ var unionIndex_1 = ts.findIndex(typeSet, function (t) { return (t.flags & 1048576) !== 0; });
+ var unionType = typeSet[unionIndex_1];
+ result = getUnionType(ts.map(unionType.types, function (t) { return getIntersectionType(ts.replaceElement(typeSet, unionIndex_1, t)); }), 1, aliasSymbol, aliasTypeArguments);
}
}
- return 0;
- function relateVariances(sourceTypeArguments, targetTypeArguments, variances, intersectionState) {
- if (result = typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, variances, reportErrors, intersectionState)) {
- return result;
- }
- if (ts.some(variances, function (v) { return !!(v & 24); })) {
- originalErrorInfo = undefined;
- resetErrorInfo(saveErrorInfo);
- return undefined;
- }
- var allowStructuralFallback = targetTypeArguments && hasCovariantVoidArgument(targetTypeArguments, variances);
- varianceCheckFailed = !allowStructuralFallback;
- if (variances !== ts.emptyArray && !allowStructuralFallback) {
- if (varianceCheckFailed && !(reportErrors && ts.some(variances, function (v) { return (v & 7) === 0; }))) {
- return 0;
- }
- originalErrorInfo = errorInfo;
- resetErrorInfo(saveErrorInfo);
- }
+ else {
+ result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
}
+ intersectionTypes.set(id, result);
}
- function reportUnmeasurableMarkers(p) {
- if (outofbandVarianceMarkerHandler && (p === markerSuperType || p === markerSubType || p === markerOtherType)) {
- outofbandVarianceMarkerHandler(false);
- }
- return p;
+ return result;
+ }
+ function checkCrossProductUnion(types) {
+ var size = ts.reduceLeft(types, function (n, t) { return n * (t.flags & 1048576 ? t.types.length : t.flags & 131072 ? 0 : 1); }, 1);
+ if (size >= 100000) {
+ ts.tracing.instant("check", "checkCrossProductUnion_DepthLimit", { typeIds: types.map(function (t) { return t.id; }), size: size });
+ error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
+ return false;
}
- function reportUnreliableMarkers(p) {
- if (outofbandVarianceMarkerHandler && (p === markerSuperType || p === markerSubType || p === markerOtherType)) {
- outofbandVarianceMarkerHandler(true);
- }
- return p;
+ return true;
+ }
+ function getTypeFromIntersectionTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ var aliasSymbol = getAliasSymbolForTypeNode(node);
+ links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
}
- function mappedTypeRelatedTo(source, target, reportErrors) {
- var modifiersRelated = relation === comparableRelation || (relation === identityRelation ? getMappedTypeModifiers(source) === getMappedTypeModifiers(target) :
- getCombinedMappedTypeOptionality(source) <= getCombinedMappedTypeOptionality(target));
- if (modifiersRelated) {
- var result_8;
- var targetConstraint = getConstraintTypeFromMappedType(target);
- var sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source), makeFunctionTypeMapper(getCombinedMappedTypeOptionality(source) < 0 ? reportUnmeasurableMarkers : reportUnreliableMarkers));
- if (result_8 = isRelatedTo(targetConstraint, sourceConstraint, reportErrors)) {
- var mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]);
- return result_8 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), reportErrors);
- }
- }
- return 0;
+ return links.resolvedType;
+ }
+ function createIndexType(type, stringsOnly) {
+ var result = createType(4194304);
+ result.type = type;
+ result.stringsOnly = stringsOnly;
+ 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, noIndexSignatures) {
+ var constraint = filterType(getConstraintTypeFromMappedType(type), function (t) { return !(noIndexSignatures && t.flags & (1 | 4)); });
+ var nameType = type.declaration.nameType && getTypeFromTypeNode(type.declaration.nameType);
+ return nameType ?
+ mapType(constraint, function (t) { return instantiateType(nameType, appendTypeMapping(type.mapper, getTypeParameterFromMappedType(type), t)); }) :
+ constraint;
+ }
+ function isNonDistributiveNameType(type) {
+ return !!(type && (type.flags & 16777216 && !type.root.isDistributive ||
+ type.flags & (3145728 | 134217728) && ts.some(type.types, isNonDistributiveNameType) ||
+ type.flags & (4194304 | 268435456) && isNonDistributiveNameType(type.type) ||
+ type.flags & 8388608 && isNonDistributiveNameType(type.indexType) ||
+ type.flags & 33554432 && isNonDistributiveNameType(type.substitute)));
+ }
+ function getLiteralTypeFromPropertyName(name) {
+ if (ts.isPrivateIdentifier(name)) {
+ return neverType;
}
- function typeRelatedToDiscriminatedType(source, target) {
- var sourceProperties = getPropertiesOfType(source);
- var sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
- if (!sourcePropertiesFiltered)
- return 0;
- var numCombinations = 1;
- for (var _i = 0, sourcePropertiesFiltered_1 = sourcePropertiesFiltered; _i < sourcePropertiesFiltered_1.length; _i++) {
- var sourceProperty = sourcePropertiesFiltered_1[_i];
- numCombinations *= countTypes(getTypeOfSymbol(sourceProperty));
- if (numCombinations > 25) {
- return 0;
+ return ts.isIdentifier(name) ? getLiteralType(ts.unescapeLeadingUnderscores(name.escapedText)) :
+ getRegularTypeOfLiteralType(ts.isComputedPropertyName(name) ? checkComputedPropertyName(name) : checkExpression(name));
+ }
+ function getBigIntLiteralType(node) {
+ return getLiteralType({
+ negative: false,
+ base10Value: ts.parsePseudoBigInt(node.text)
+ });
+ }
+ function getLiteralTypeFromProperty(prop, include) {
+ if (!(ts.getDeclarationModifierFlagsFromSymbol(prop) & 24)) {
+ var type = getSymbolLinks(getLateBoundSymbol(prop)).nameType;
+ if (!type && !ts.isKnownSymbol(prop)) {
+ if (prop.escapedName === "default") {
+ type = getLiteralType("default");
+ }
+ else {
+ var name = prop.valueDeclaration && ts.getNameOfDeclaration(prop.valueDeclaration);
+ type = name && getLiteralTypeFromPropertyName(name) || getLiteralType(ts.symbolName(prop));
}
}
- var sourceDiscriminantTypes = new Array(sourcePropertiesFiltered.length);
- var excludedProperties = ts.createUnderscoreEscapedMap();
- for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
- var sourceProperty = sourcePropertiesFiltered[i];
- var sourcePropertyType = getTypeOfSymbol(sourceProperty);
- sourceDiscriminantTypes[i] = sourcePropertyType.flags & 1048576
- ? sourcePropertyType.types
- : [sourcePropertyType];
- excludedProperties.set(sourceProperty.escapedName, true);
+ if (type && type.flags & include) {
+ return type;
}
- var discriminantCombinations = ts.cartesianProduct(sourceDiscriminantTypes);
- var matchingTypes = [];
- var _loop_14 = function (combination) {
- var hasMatch = false;
- outer: for (var _i = 0, _a = target.types; _i < _a.length; _i++) {
- var type = _a[_i];
- var _loop_15 = function (i) {
- var sourceProperty = sourcePropertiesFiltered[i];
- var targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
- if (!targetProperty)
- return "continue-outer";
- if (sourceProperty === targetProperty)
- return "continue";
- var related = propertyRelatedTo(source, target, sourceProperty, targetProperty, function (_) { return combination[i]; }, false, 0, strictNullChecks || relation === comparableRelation);
- if (!related) {
- return "continue-outer";
- }
- };
- for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
- var state_7 = _loop_15(i);
- switch (state_7) {
- case "continue-outer": continue outer;
- }
- }
- ts.pushIfUnique(matchingTypes, type, ts.equateValues);
- hasMatch = true;
- }
- if (!hasMatch) {
- return { value: 0 };
- }
- };
- for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) {
- var combination = discriminantCombinations_1[_a];
- var state_6 = _loop_14(combination);
- if (typeof state_6 === "object")
- return state_6.value;
+ }
+ return neverType;
+ }
+ function getLiteralTypeFromProperties(type, include) {
+ return getUnionType(ts.map(getPropertiesOfType(type), function (p) { return getLiteralTypeFromProperty(p, include); }));
+ }
+ function getNonEnumNumberIndexInfo(type) {
+ var numberIndexInfo = getIndexInfoOfType(type, 1);
+ return numberIndexInfo !== enumNumberIndexInfo ? numberIndexInfo : undefined;
+ }
+ function getIndexType(type, stringsOnly, noIndexSignatures) {
+ if (stringsOnly === void 0) { stringsOnly = keyofStringsOnly; }
+ type = getReducedType(type);
+ return type.flags & 1048576 ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
+ type.flags & 2097152 ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
+ type.flags & 58982400 || isGenericTupleType(type) || isGenericMappedType(type) && isNonDistributiveNameType(getNameTypeFromMappedType(type)) ? getIndexTypeForGenericType(type, stringsOnly) :
+ ts.getObjectFlags(type) & 32 ? getIndexTypeForMappedType(type, noIndexSignatures) :
+ type === wildcardType ? wildcardType :
+ type.flags & 2 ? neverType :
+ type.flags & (1 | 131072) ? keyofConstraintType :
+ stringsOnly ? !noIndexSignatures && getIndexInfoOfType(type, 0) ? stringType : getLiteralTypeFromProperties(type, 128) :
+ !noIndexSignatures && getIndexInfoOfType(type, 0) ? getUnionType([stringType, numberType, getLiteralTypeFromProperties(type, 8192)]) :
+ getNonEnumNumberIndexInfo(type) ? getUnionType([numberType, getLiteralTypeFromProperties(type, 128 | 8192)]) :
+ getLiteralTypeFromProperties(type, 8576);
+ }
+ function getExtractStringType(type) {
+ if (keyofStringsOnly) {
+ return type;
+ }
+ var extractTypeAlias = getGlobalExtractSymbol();
+ return extractTypeAlias ? getTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType;
+ }
+ function getIndexTypeOrString(type) {
+ var indexType = getExtractStringType(getIndexType(type));
+ return indexType.flags & 131072 ? stringType : indexType;
+ }
+ function getTypeFromTypeOperatorNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ switch (node.operator) {
+ case 138:
+ links.resolvedType = getIndexType(getTypeFromTypeNode(node.type));
+ break;
+ case 151:
+ links.resolvedType = node.type.kind === 148
+ ? getESSymbolLikeTypeForNode(ts.walkUpParenthesizedTypes(node.parent))
+ : errorType;
+ break;
+ case 142:
+ links.resolvedType = getTypeFromTypeNode(node.type);
+ break;
+ default:
+ throw ts.Debug.assertNever(node.operator);
}
- var result = -1;
- for (var _b = 0, matchingTypes_1 = matchingTypes; _b < matchingTypes_1.length; _b++) {
- var type = matchingTypes_1[_b];
- result &= propertiesRelatedTo(source, type, false, excludedProperties, 0);
- if (result) {
- result &= signaturesRelatedTo(source, type, 0, false);
- if (result) {
- result &= signaturesRelatedTo(source, type, 1, false);
- if (result) {
- result &= indexTypesRelatedTo(source, type, 0, false, false, 0);
- if (result) {
- result &= indexTypesRelatedTo(source, type, 1, false, false, 0);
- }
- }
- }
+ }
+ return links.resolvedType;
+ }
+ function getTypeFromTemplateTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ links.resolvedType = getTemplateLiteralType(__spreadArrays([node.head.text], ts.map(node.templateSpans, function (span) { return span.literal.text; })), ts.map(node.templateSpans, function (span) { return getTypeFromTypeNode(span.type); }));
+ }
+ return links.resolvedType;
+ }
+ function getTemplateLiteralType(texts, types) {
+ var unionIndex = ts.findIndex(types, function (t) { return !!(t.flags & (131072 | 1048576)); });
+ if (unionIndex >= 0) {
+ return checkCrossProductUnion(types) ?
+ mapType(types[unionIndex], function (t) { return getTemplateLiteralType(texts, ts.replaceElement(types, unionIndex, t)); }) :
+ errorType;
+ }
+ if (ts.contains(types, wildcardType)) {
+ return wildcardType;
+ }
+ var newTypes = [];
+ var newTexts = [];
+ var text = texts[0];
+ if (!addSpans(texts, types)) {
+ return stringType;
+ }
+ if (newTypes.length === 0) {
+ return getLiteralType(text);
+ }
+ newTexts.push(text);
+ var id = getTypeListId(newTypes) + "|" + ts.map(newTexts, function (t) { return t.length; }).join(",") + "|" + newTexts.join("");
+ var type = templateLiteralTypes.get(id);
+ if (!type) {
+ templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newTypes));
+ }
+ return type;
+ function addSpans(texts, types) {
+ for (var i = 0; i < types.length; i++) {
+ var t = types[i];
+ if (t.flags & (2944 | 65536 | 32768)) {
+ text += getTemplateStringForType(t) || "";
+ text += texts[i + 1];
+ }
+ else if (t.flags & 134217728) {
+ text += t.texts[0];
+ if (!addSpans(t.texts, t.types))
+ return false;
+ text += texts[i + 1];
}
- if (!result) {
- return result;
+ else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t)) {
+ newTypes.push(t);
+ newTexts.push(text);
+ text = texts[i + 1];
+ }
+ else {
+ return false;
}
}
- return result;
+ return true;
}
- function excludeProperties(properties, excludedProperties) {
- if (!excludedProperties || properties.length === 0)
- return properties;
- var result;
- for (var i = 0; i < properties.length; i++) {
- if (!excludedProperties.has(properties[i].escapedName)) {
- if (result) {
- result.push(properties[i]);
- }
+ }
+ function getTemplateStringForType(type) {
+ return type.flags & 128 ? type.value :
+ type.flags & 256 ? "" + type.value :
+ type.flags & 2048 ? ts.pseudoBigIntToString(type.value) :
+ type.flags & 512 ? type.intrinsicName :
+ type.flags & 65536 ? "null" :
+ type.flags & 32768 ? "undefined" :
+ undefined;
+ }
+ function createTemplateLiteralType(texts, types) {
+ var type = createType(134217728);
+ type.texts = texts;
+ type.types = types;
+ return type;
+ }
+ function getStringMappingType(symbol, type) {
+ return type.flags & (1048576 | 131072) ? mapType(type, function (t) { return getStringMappingType(symbol, t); }) :
+ isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) :
+ type.flags & 128 ? getLiteralType(applyStringMapping(symbol, type.value)) :
+ type;
+ }
+ function applyStringMapping(symbol, str) {
+ switch (intrinsicTypeKinds.get(symbol.escapedName)) {
+ case 0: return str.toUpperCase();
+ case 1: return str.toLowerCase();
+ case 2: return str.charAt(0).toUpperCase() + str.slice(1);
+ case 3: return str.charAt(0).toLowerCase() + str.slice(1);
+ }
+ return str;
+ }
+ function getStringMappingTypeForGenericType(symbol, type) {
+ var id = getSymbolId(symbol) + "," + getTypeId(type);
+ var result = stringMappingTypes.get(id);
+ if (!result) {
+ stringMappingTypes.set(id, result = createStringMappingType(symbol, type));
+ }
+ return result;
+ }
+ function createStringMappingType(symbol, type) {
+ var result = createType(268435456);
+ result.symbol = symbol;
+ result.type = type;
+ return result;
+ }
+ function createIndexedAccessType(objectType, indexType, aliasSymbol, aliasTypeArguments, shouldIncludeUndefined) {
+ var type = createType(8388608);
+ type.objectType = objectType;
+ type.indexType = indexType;
+ type.aliasSymbol = aliasSymbol;
+ type.aliasTypeArguments = aliasTypeArguments;
+ type.noUncheckedIndexedAccessCandidate = shouldIncludeUndefined;
+ return type;
+ }
+ function isJSLiteralType(type) {
+ if (noImplicitAny) {
+ return false;
+ }
+ if (ts.getObjectFlags(type) & 16384) {
+ return true;
+ }
+ if (type.flags & 1048576) {
+ return ts.every(type.types, isJSLiteralType);
+ }
+ if (type.flags & 2097152) {
+ return ts.some(type.types, isJSLiteralType);
+ }
+ if (type.flags & 465829888) {
+ return isJSLiteralType(getResolvedBaseConstraint(type));
+ }
+ return false;
+ }
+ function getPropertyNameFromIndex(indexType, accessNode) {
+ var accessExpression = accessNode && accessNode.kind === 202 ? accessNode : undefined;
+ return isTypeUsableAsPropertyName(indexType) ?
+ getPropertyNameFromType(indexType) :
+ accessExpression && checkThatExpressionIsProperSymbolReference(accessExpression.argumentExpression, indexType, false) ?
+ ts.getPropertyNameForKnownSymbolName(ts.idText(accessExpression.argumentExpression.name)) :
+ accessNode && ts.isPropertyName(accessNode) ?
+ ts.getPropertyNameForPropertyNameNode(accessNode) :
+ undefined;
+ }
+ function isUncalledFunctionReference(node, symbol) {
+ return !(symbol.flags & (16 | 8192))
+ || !ts.isCallLikeExpression(ts.findAncestor(node, function (n) { return !ts.isAccessExpression(n); }) || node.parent)
+ && ts.every(symbol.declarations, function (d) { return !ts.isFunctionLike(d) || !!(ts.getCombinedNodeFlags(d) & 134217728); });
+ }
+ function getPropertyTypeForIndexType(originalObjectType, objectType, indexType, fullIndexType, suppressNoImplicitAnyError, accessNode, accessFlags, noUncheckedIndexedAccessCandidate, reportDeprecated) {
+ var _a;
+ var accessExpression = accessNode && accessNode.kind === 202 ? accessNode : undefined;
+ var propName = accessNode && ts.isPrivateIdentifier(accessNode) ? undefined : getPropertyNameFromIndex(indexType, accessNode);
+ if (propName !== undefined) {
+ var prop = getPropertyOfType(objectType, propName);
+ if (prop) {
+ if (reportDeprecated && accessNode && getDeclarationNodeFlagsFromSymbol(prop) & 134217728 && isUncalledFunctionReference(accessNode, prop)) {
+ var deprecatedNode = (_a = accessExpression === null || accessExpression === void 0 ? void 0 : accessExpression.argumentExpression) !== null && _a !== void 0 ? _a : (ts.isIndexedAccessTypeNode(accessNode) ? accessNode.indexType : accessNode);
+ errorOrSuggestion(false, deprecatedNode, ts.Diagnostics._0_is_deprecated, propName);
}
- else if (!result) {
- result = properties.slice(0, i);
+ if (accessExpression) {
+ markPropertyAsReferenced(prop, accessExpression, accessExpression.expression.kind === 107);
+ if (isAssignmentToReadonlyEntity(accessExpression, prop, ts.getAssignmentTargetKind(accessExpression))) {
+ error(accessExpression.argumentExpression, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(prop));
+ return undefined;
+ }
+ if (accessFlags & 4) {
+ getNodeLinks(accessNode).resolvedSymbol = prop;
+ }
+ if (isThisPropertyAccessInConstructor(accessExpression, prop)) {
+ return autoType;
+ }
}
+ var propType = getTypeOfSymbol(prop);
+ return accessExpression && ts.getAssignmentTargetKind(accessExpression) !== 1 ?
+ getFlowTypeOfReference(accessExpression, propType) :
+ propType;
}
- return result || properties;
- }
- function isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState) {
- var targetIsOptional = strictNullChecks && !!(ts.getCheckFlags(targetProp) & 48);
- var source = getTypeOfSourceProperty(sourceProp);
- if (ts.getCheckFlags(targetProp) & 65536 && !getSymbolLinks(targetProp).type) {
- var links = getSymbolLinks(targetProp);
- ts.Debug.assertIsDefined(links.deferralParent);
- ts.Debug.assertIsDefined(links.deferralConstituents);
- var unionParent = !!(links.deferralParent.flags & 1048576);
- var result_9 = unionParent ? 0 : -1;
- var targetTypes = links.deferralConstituents;
- for (var _i = 0, targetTypes_3 = targetTypes; _i < targetTypes_3.length; _i++) {
- var targetType = targetTypes_3[_i];
- var related = isRelatedTo(source, targetType, false, undefined, unionParent ? 0 : 2);
- if (!unionParent) {
- if (!related) {
- return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors);
- }
- result_9 &= related;
- }
- else {
- if (related) {
- return related;
- }
+ if (everyType(objectType, isTupleType) && isNumericLiteralName(propName) && +propName >= 0) {
+ if (accessNode && everyType(objectType, function (t) { return !t.target.hasRestElement; }) && !(accessFlags & 8)) {
+ var indexNode = getIndexNodeForAccessExpression(accessNode);
+ if (isTupleType(objectType)) {
+ error(indexNode, ts.Diagnostics.Tuple_type_0_of_length_1_has_no_element_at_index_2, typeToString(objectType), getTypeReferenceArity(objectType), ts.unescapeLeadingUnderscores(propName));
+ }
+ else {
+ error(indexNode, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType));
}
}
- if (unionParent && !result_9 && targetIsOptional) {
- result_9 = isRelatedTo(source, undefinedType);
+ errorIfWritingToReadonlyIndex(getIndexInfoOfType(objectType, 1));
+ return mapType(objectType, function (t) {
+ var restType = getRestTypeOfTupleType(t) || undefinedType;
+ return noUncheckedIndexedAccessCandidate ? getUnionType([restType, undefinedType]) : restType;
+ });
+ }
+ }
+ if (!(indexType.flags & 98304) && isTypeAssignableToKind(indexType, 402653316 | 296 | 12288)) {
+ if (objectType.flags & (1 | 131072)) {
+ return objectType;
+ }
+ var stringIndexInfo = getIndexInfoOfType(objectType, 0);
+ var indexInfo = isTypeAssignableToKind(indexType, 296) && getIndexInfoOfType(objectType, 1) || stringIndexInfo;
+ if (indexInfo) {
+ if (accessFlags & 1 && indexInfo === stringIndexInfo) {
+ if (accessExpression) {
+ error(accessExpression, ts.Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(originalObjectType));
+ }
+ return undefined;
}
- if (unionParent && !result_9 && reportErrors) {
- return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors);
+ if (accessNode && !isTypeAssignableToKind(indexType, 4 | 8)) {
+ var indexNode = getIndexNodeForAccessExpression(accessNode);
+ error(indexNode, ts.Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
+ return noUncheckedIndexedAccessCandidate ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
}
- return result_9;
+ errorIfWritingToReadonlyIndex(indexInfo);
+ return noUncheckedIndexedAccessCandidate ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
}
- else {
- return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors, undefined, intersectionState);
+ if (indexType.flags & 131072) {
+ return neverType;
}
- }
- function propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState, skipOptional) {
- var sourcePropFlags = ts.getDeclarationModifierFlagsFromSymbol(sourceProp);
- var targetPropFlags = ts.getDeclarationModifierFlagsFromSymbol(targetProp);
- if (sourcePropFlags & 8 || targetPropFlags & 8) {
- if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
- if (reportErrors) {
- if (sourcePropFlags & 8 && targetPropFlags & 8) {
- reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
+ if (isJSLiteralType(objectType)) {
+ return anyType;
+ }
+ if (accessExpression && !isConstEnumObjectType(objectType)) {
+ if (objectType.symbol === globalThisSymbol && propName !== undefined && globalThisSymbol.exports.has(propName) && (globalThisSymbol.exports.get(propName).flags & 418)) {
+ error(accessExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType));
+ }
+ else if (noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !suppressNoImplicitAnyError) {
+ if (propName !== undefined && typeHasStaticProperty(propName, objectType)) {
+ error(accessExpression, ts.Diagnostics.Property_0_is_a_static_member_of_type_1, propName, typeToString(objectType));
+ }
+ else if (getIndexTypeOfType(objectType, 1)) {
+ error(accessExpression.argumentExpression, ts.Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number);
+ }
+ else {
+ var suggestion = void 0;
+ if (propName !== undefined && (suggestion = getSuggestionForNonexistentProperty(propName, objectType))) {
+ if (suggestion !== undefined) {
+ error(accessExpression.argumentExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(objectType), suggestion);
+ }
}
else {
- reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 8 ? source : target), typeToString(sourcePropFlags & 8 ? target : source));
+ var suggestion_1 = getSuggestionForNonexistentIndexSignature(objectType, accessExpression, indexType);
+ if (suggestion_1 !== undefined) {
+ error(accessExpression, ts.Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1, typeToString(objectType), suggestion_1);
+ }
+ else {
+ var errorInfo = void 0;
+ if (indexType.flags & 1024) {
+ errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "[" + typeToString(indexType) + "]", typeToString(objectType));
+ }
+ else if (indexType.flags & 8192) {
+ var symbolName_2 = getFullyQualifiedName(indexType.symbol, accessExpression);
+ errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "[" + symbolName_2 + "]", typeToString(objectType));
+ }
+ else if (indexType.flags & 128) {
+ errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType));
+ }
+ else if (indexType.flags & 256) {
+ errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType));
+ }
+ else if (indexType.flags & (8 | 4)) {
+ errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1, typeToString(indexType), typeToString(objectType));
+ }
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1, typeToString(fullIndexType), typeToString(objectType));
+ diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(accessExpression, errorInfo));
+ }
}
}
- return 0;
}
+ return undefined;
}
- else if (targetPropFlags & 16) {
- if (!isValidOverrideOf(sourceProp, targetProp)) {
- if (reportErrors) {
- reportError(ts.Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, symbolToString(targetProp), typeToString(getDeclaringClass(sourceProp) || source), typeToString(getDeclaringClass(targetProp) || target));
- }
- return 0;
- }
+ }
+ if (isJSLiteralType(objectType)) {
+ return anyType;
+ }
+ if (accessNode) {
+ var indexNode = getIndexNodeForAccessExpression(accessNode);
+ if (indexType.flags & (128 | 256)) {
+ error(indexNode, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "" + indexType.value, typeToString(objectType));
}
- else if (sourcePropFlags & 16) {
- if (reportErrors) {
- reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
- }
- return 0;
+ else if (indexType.flags & (4 | 8)) {
+ error(indexNode, ts.Diagnostics.Type_0_has_no_matching_index_signature_for_type_1, typeToString(objectType), typeToString(indexType));
}
- var related = isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState);
- if (!related) {
- if (reportErrors) {
- reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
- }
- return 0;
+ else {
+ error(indexNode, ts.Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
}
- if (!skipOptional && sourceProp.flags & 16777216 && !(targetProp.flags & 16777216)) {
- if (reportErrors) {
- reportError(ts.Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
- }
- return 0;
+ }
+ if (isTypeAny(indexType)) {
+ return indexType;
+ }
+ return undefined;
+ function errorIfWritingToReadonlyIndex(indexInfo) {
+ if (indexInfo && indexInfo.isReadonly && accessExpression && (ts.isAssignmentTarget(accessExpression) || ts.isDeleteTarget(accessExpression))) {
+ error(accessExpression, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
}
- return related;
}
- function reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties) {
- var shouldSkipElaboration = false;
- if (unmatchedProperty.valueDeclaration
- && ts.isNamedDeclaration(unmatchedProperty.valueDeclaration)
- && ts.isPrivateIdentifier(unmatchedProperty.valueDeclaration.name)
- && source.symbol
- && source.symbol.flags & 32) {
- var privateIdentifierDescription = unmatchedProperty.valueDeclaration.name.escapedText;
- var symbolTableKey = ts.getSymbolNameForPrivateIdentifier(source.symbol, privateIdentifierDescription);
- if (symbolTableKey && getPropertyOfType(source, symbolTableKey)) {
- var sourceName = ts.getDeclarationName(source.symbol.valueDeclaration);
- var targetName = ts.getDeclarationName(target.symbol.valueDeclaration);
- reportError(ts.Diagnostics.Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2, diagnosticName(privateIdentifierDescription), diagnosticName(sourceName.escapedText === "" ? anon : sourceName), diagnosticName(targetName.escapedText === "" ? anon : targetName));
- return;
- }
+ }
+ function getIndexNodeForAccessExpression(accessNode) {
+ return accessNode.kind === 202 ? accessNode.argumentExpression :
+ accessNode.kind === 189 ? accessNode.indexType :
+ accessNode.kind === 158 ? accessNode.expression :
+ accessNode;
+ }
+ function isPatternLiteralPlaceholderType(type) {
+ return templateConstraintType.types.indexOf(type) !== -1 || !!(type.flags & 1);
+ }
+ function isPatternLiteralType(type) {
+ return !!(type.flags & 134217728) && ts.every(type.types, isPatternLiteralPlaceholderType);
+ }
+ function isGenericObjectType(type) {
+ if (type.flags & 3145728) {
+ if (!(type.objectFlags & 4194304)) {
+ type.objectFlags |= 4194304 |
+ (ts.some(type.types, isGenericObjectType) ? 8388608 : 0);
}
- var props = ts.arrayFrom(getUnmatchedProperties(source, target, requireOptionalProperties, false));
- if (!headMessage || (headMessage.code !== ts.Diagnostics.Class_0_incorrectly_implements_interface_1.code &&
- headMessage.code !== ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code)) {
- shouldSkipElaboration = true;
+ return !!(type.objectFlags & 8388608);
+ }
+ return !!(type.flags & 58982400) || isGenericMappedType(type) || isGenericTupleType(type);
+ }
+ function isGenericIndexType(type) {
+ if (type.flags & 3145728) {
+ if (!(type.objectFlags & 16777216)) {
+ type.objectFlags |= 16777216 |
+ (ts.some(type.types, isGenericIndexType) ? 33554432 : 0);
}
- if (props.length === 1) {
- var propName = symbolToString(unmatchedProperty);
- reportError.apply(void 0, __spreadArrays([ts.Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2, propName], getTypeNamesForErrorDisplay(source, target)));
- if (ts.length(unmatchedProperty.declarations)) {
- associateRelatedInfo(ts.createDiagnosticForNode(unmatchedProperty.declarations[0], ts.Diagnostics._0_is_declared_here, propName));
- }
- if (shouldSkipElaboration && errorInfo) {
- overrideNextErrorInfo++;
+ return !!(type.objectFlags & 33554432);
+ }
+ return !!(type.flags & (58982400 | 4194304 | 134217728 | 268435456)) && !isPatternLiteralType(type);
+ }
+ function isThisTypeParameter(type) {
+ return !!(type.flags & 262144 && type.isThisType);
+ }
+ function getSimplifiedType(type, writing) {
+ return type.flags & 8388608 ? getSimplifiedIndexedAccessType(type, writing) :
+ type.flags & 16777216 ? getSimplifiedConditionalType(type, writing) :
+ type;
+ }
+ function distributeIndexOverObjectType(objectType, indexType, writing) {
+ if (objectType.flags & 3145728) {
+ var types = ts.map(objectType.types, function (t) { return getSimplifiedType(getIndexedAccessType(t, indexType), writing); });
+ return objectType.flags & 2097152 || writing ? getIntersectionType(types) : getUnionType(types);
+ }
+ }
+ function distributeObjectOverIndexType(objectType, indexType, writing) {
+ if (indexType.flags & 1048576) {
+ var types = ts.map(indexType.types, function (t) { return getSimplifiedType(getIndexedAccessType(objectType, t), writing); });
+ return writing ? getIntersectionType(types) : getUnionType(types);
+ }
+ }
+ function unwrapSubstitution(type) {
+ if (type.flags & 33554432) {
+ return type.substitute;
+ }
+ return type;
+ }
+ function getSimplifiedIndexedAccessType(type, writing) {
+ var cache = writing ? "simplifiedForWriting" : "simplifiedForReading";
+ if (type[cache]) {
+ return type[cache] === circularConstraintType ? type : type[cache];
+ }
+ type[cache] = circularConstraintType;
+ var objectType = unwrapSubstitution(getSimplifiedType(type.objectType, writing));
+ var indexType = getSimplifiedType(type.indexType, writing);
+ var distributedOverIndex = distributeObjectOverIndexType(objectType, indexType, writing);
+ if (distributedOverIndex) {
+ return type[cache] = distributedOverIndex;
+ }
+ if (!(indexType.flags & 465829888)) {
+ var distributedOverObject = distributeIndexOverObjectType(objectType, indexType, writing);
+ if (distributedOverObject) {
+ return type[cache] = distributedOverObject;
+ }
+ }
+ if (isGenericTupleType(objectType) && indexType.flags & 296) {
+ var elementType = getElementTypeOfSliceOfTupleType(objectType, indexType.flags & 8 ? 0 : objectType.target.fixedLength, 0, writing);
+ if (elementType) {
+ return type[cache] = elementType;
+ }
+ }
+ if (isGenericMappedType(objectType)) {
+ return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+ }
+ return type[cache] = type;
+ }
+ function getSimplifiedConditionalType(type, writing) {
+ var checkType = type.checkType;
+ var extendsType = type.extendsType;
+ var trueType = getTrueTypeFromConditionalType(type);
+ var falseType = getFalseTypeFromConditionalType(type);
+ if (falseType.flags & 131072 && getActualTypeVariable(trueType) === getActualTypeVariable(checkType)) {
+ if (checkType.flags & 1 || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {
+ return getSimplifiedType(trueType, writing);
+ }
+ else if (isIntersectionEmpty(checkType, extendsType)) {
+ return neverType;
+ }
+ }
+ else if (trueType.flags & 131072 && getActualTypeVariable(falseType) === getActualTypeVariable(checkType)) {
+ if (!(checkType.flags & 1) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {
+ return neverType;
+ }
+ else if (checkType.flags & 1 || isIntersectionEmpty(checkType, extendsType)) {
+ return getSimplifiedType(falseType, writing);
+ }
+ }
+ return type;
+ }
+ function isIntersectionEmpty(type1, type2) {
+ return !!(getUnionType([intersectTypes(type1, type2), neverType]).flags & 131072);
+ }
+ function substituteIndexedMappedType(objectType, index) {
+ var mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
+ var templateMapper = combineTypeMappers(objectType.mapper, mapper);
+ return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper);
+ }
+ function getIndexedAccessType(objectType, indexType, noUncheckedIndexedAccessCandidate, accessNode, aliasSymbol, aliasTypeArguments, accessFlags) {
+ if (accessFlags === void 0) { accessFlags = 0; }
+ return getIndexedAccessTypeOrUndefined(objectType, indexType, noUncheckedIndexedAccessCandidate, accessNode, accessFlags, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
+ }
+ function indexTypeLessThan(indexType, limit) {
+ return everyType(indexType, function (t) {
+ if (t.flags & 384) {
+ var propName = getPropertyNameFromType(t);
+ if (isNumericLiteralName(propName)) {
+ var index = +propName;
+ return index >= 0 && index < limit;
}
}
- else if (tryElaborateArrayLikeErrors(source, target, false)) {
- if (props.length > 5) {
- reportError(ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more, typeToString(source), typeToString(target), ts.map(props.slice(0, 4), function (p) { return symbolToString(p); }).join(", "), props.length - 4);
+ return false;
+ });
+ }
+ function getIndexedAccessTypeOrUndefined(objectType, indexType, noUncheckedIndexedAccessCandidate, accessNode, accessFlags, aliasSymbol, aliasTypeArguments) {
+ if (accessFlags === void 0) { accessFlags = 0; }
+ if (objectType === wildcardType || indexType === wildcardType) {
+ return wildcardType;
+ }
+ var shouldIncludeUndefined = noUncheckedIndexedAccessCandidate ||
+ (!!compilerOptions.noUncheckedIndexedAccess &&
+ (accessFlags & (2 | 16)) === 16);
+ if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304) && isTypeAssignableToKind(indexType, 4 | 8)) {
+ indexType = stringType;
+ }
+ if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 189 ?
+ isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) :
+ isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)))) {
+ if (objectType.flags & 3) {
+ return objectType;
+ }
+ var id = objectType.id + "," + indexType.id + (shouldIncludeUndefined ? "?" : "");
+ var type = indexedAccessTypes.get(id);
+ if (!type) {
+ indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType, aliasSymbol, aliasTypeArguments, shouldIncludeUndefined));
+ }
+ return type;
+ }
+ var apparentObjectType = getReducedApparentType(objectType);
+ if (indexType.flags & 1048576 && !(indexType.flags & 16)) {
+ var propTypes = [];
+ var wasMissingProp = false;
+ for (var _i = 0, _a = indexType.types; _i < _a.length; _i++) {
+ var t = _a[_i];
+ var propType = getPropertyTypeForIndexType(objectType, apparentObjectType, t, indexType, wasMissingProp, accessNode, accessFlags, shouldIncludeUndefined);
+ if (propType) {
+ propTypes.push(propType);
}
- else {
- reportError(ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2, typeToString(source), typeToString(target), ts.map(props, function (p) { return symbolToString(p); }).join(", "));
+ else if (!accessNode) {
+ return undefined;
}
- if (shouldSkipElaboration && errorInfo) {
- overrideNextErrorInfo++;
+ else {
+ wasMissingProp = true;
}
}
+ if (wasMissingProp) {
+ return undefined;
+ }
+ return accessFlags & 2
+ ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments)
+ : getUnionType(propTypes, 1, aliasSymbol, aliasTypeArguments);
}
- function propertiesRelatedTo(source, target, reportErrors, excludedProperties, intersectionState) {
- if (relation === identityRelation) {
- return propertiesIdenticalTo(source, target, excludedProperties);
+ return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, false, accessNode, accessFlags | 4, shouldIncludeUndefined, true);
+ }
+ function getTypeFromIndexedAccessTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ var objectType = getTypeFromTypeNode(node.objectType);
+ var indexType = getTypeFromTypeNode(node.indexType);
+ var potentialAlias = getAliasSymbolForTypeNode(node);
+ var resolved = getIndexedAccessType(objectType, indexType, undefined, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias));
+ links.resolvedType = resolved.flags & 8388608 &&
+ resolved.objectType === objectType &&
+ resolved.indexType === indexType ?
+ getConditionalFlowTypeOfType(resolved, node) : resolved;
+ }
+ return links.resolvedType;
+ }
+ function getTypeFromMappedTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ var type = createObjectType(32, 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) {
+ return type.baseType;
+ }
+ if (type.flags & 8388608 && (type.objectType.flags & 33554432 ||
+ type.indexType.flags & 33554432)) {
+ return getIndexedAccessType(getActualTypeVariable(type.objectType), getActualTypeVariable(type.indexType));
+ }
+ return type;
+ }
+ function getConditionalType(root, mapper) {
+ var result;
+ var extraTypes;
+ var _loop_15 = function () {
+ var checkType = instantiateType(root.checkType, mapper);
+ var checkTypeInstantiable = isGenericObjectType(checkType) || isGenericIndexType(checkType);
+ var extendsType = instantiateType(root.extendsType, mapper);
+ if (checkType === wildcardType || extendsType === wildcardType) {
+ return { value: wildcardType };
}
- var requireOptionalProperties = (relation === subtypeRelation || relation === strictSubtypeRelation) && !isObjectLiteralType(source) && !isEmptyArrayLiteralType(source) && !isTupleType(source);
- var unmatchedProperty = getUnmatchedProperty(source, target, requireOptionalProperties, false);
- if (unmatchedProperty) {
- if (reportErrors) {
- reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties);
+ var combinedMapper = void 0;
+ if (root.inferTypeParameters) {
+ var context = createInferenceContext(root.inferTypeParameters, undefined, 0);
+ if (!checkTypeInstantiable || !ts.some(root.inferTypeParameters, function (t) { return t === extendsType; })) {
+ inferTypes(context.inferences, checkType, extendsType, 256 | 512);
}
- return 0;
+ combinedMapper = mergeTypeMappers(mapper, context.mapper);
}
- if (isObjectLiteralType(target)) {
- for (var _i = 0, _a = excludeProperties(getPropertiesOfType(source), excludedProperties); _i < _a.length; _i++) {
- var sourceProp = _a[_i];
- if (!getPropertyOfObjectType(target, sourceProp.escapedName)) {
- var sourceType = getTypeOfSymbol(sourceProp);
- if (!(sourceType === undefinedType || sourceType === undefinedWideningType || sourceType === optionalType)) {
- if (reportErrors) {
- reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target));
- }
- return 0;
+ var inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
+ if (!checkTypeInstantiable && !isGenericObjectType(inferredExtendsType) && !isGenericIndexType(inferredExtendsType)) {
+ if (!(inferredExtendsType.flags & 3) && (checkType.flags & 1 || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
+ if (checkType.flags & 1) {
+ (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
+ }
+ var falseType_1 = getTypeFromTypeNode(root.node.falseType);
+ if (falseType_1.flags & 16777216) {
+ var newRoot = falseType_1.root;
+ if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
+ root = newRoot;
+ return "continue";
}
}
+ result = instantiateType(falseType_1, mapper);
+ return "break";
+ }
+ if (inferredExtendsType.flags & 3 || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
+ result = instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper);
+ return "break";
}
}
- var result = -1;
- if (isTupleType(target)) {
- var targetRestType = getRestTypeOfTupleType(target);
- if (targetRestType) {
- if (!isTupleType(source)) {
- return 0;
- }
- var sourceRestType = getRestTypeOfTupleType(source);
- if (sourceRestType && !isRelatedTo(sourceRestType, targetRestType, reportErrors)) {
- if (reportErrors) {
- reportError(ts.Diagnostics.Rest_signatures_are_incompatible);
- }
- return 0;
- }
- var targetCount = getTypeReferenceArity(target) - 1;
- var sourceCount = getTypeReferenceArity(source) - (sourceRestType ? 1 : 0);
- var sourceTypeArguments = getTypeArguments(source);
- for (var i = targetCount; i < sourceCount; i++) {
- var related = isRelatedTo(sourceTypeArguments[i], targetRestType, reportErrors);
- if (!related) {
- if (reportErrors) {
- reportError(ts.Diagnostics.Property_0_is_incompatible_with_rest_element_type, "" + i);
- }
- return 0;
- }
- result &= related;
- }
+ var erasedCheckType = getActualTypeVariable(checkType);
+ result = createType(16777216);
+ result.root = root;
+ result.checkType = erasedCheckType;
+ result.extendsType = extendsType;
+ result.mapper = mapper;
+ result.combinedMapper = combinedMapper;
+ result.aliasSymbol = root.aliasSymbol;
+ result.aliasTypeArguments = instantiateTypes(root.aliasTypeArguments, mapper);
+ return "break";
+ };
+ while (true) {
+ var state_4 = _loop_15();
+ if (typeof state_4 === "object")
+ return state_4.value;
+ if (state_4 === "break")
+ break;
+ }
+ return extraTypes ? getUnionType(ts.append(extraTypes, result)) : result;
+ }
+ function getTrueTypeFromConditionalType(type) {
+ return type.resolvedTrueType || (type.resolvedTrueType = instantiateType(getTypeFromTypeNode(type.root.node.trueType), type.mapper));
+ }
+ function getFalseTypeFromConditionalType(type) {
+ return type.resolvedFalseType || (type.resolvedFalseType = instantiateType(getTypeFromTypeNode(type.root.node.falseType), type.mapper));
+ }
+ function getInferredTrueTypeFromConditionalType(type) {
+ return type.resolvedInferredTrueType || (type.resolvedInferredTrueType = type.combinedMapper ? instantiateType(getTypeFromTypeNode(type.root.node.trueType), type.combinedMapper) : getTrueTypeFromConditionalType(type));
+ }
+ function getInferTypeParameters(node) {
+ var result;
+ if (node.locals) {
+ node.locals.forEach(function (symbol) {
+ if (symbol.flags & 262144) {
+ result = ts.append(result, getDeclaredTypeOfSymbol(symbol));
}
+ });
+ }
+ return result;
+ }
+ function getTypeFromConditionalTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ var checkType = getTypeFromTypeNode(node.checkType);
+ var aliasSymbol = getAliasSymbolForTypeNode(node);
+ var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
+ var allOuterTypeParameters = getOuterTypeParameters(node, true);
+ var outerTypeParameters = aliasTypeArguments ? allOuterTypeParameters : ts.filter(allOuterTypeParameters, function (tp) { return isTypeParameterPossiblyReferenced(tp, node); });
+ var root = {
+ node: node,
+ checkType: checkType,
+ extendsType: getTypeFromTypeNode(node.extendsType),
+ isDistributive: !!(checkType.flags & 262144),
+ inferTypeParameters: getInferTypeParameters(node),
+ outerTypeParameters: outerTypeParameters,
+ instantiations: undefined,
+ aliasSymbol: aliasSymbol,
+ aliasTypeArguments: aliasTypeArguments
+ };
+ links.resolvedType = getConditionalType(root, undefined);
+ if (outerTypeParameters) {
+ root.instantiations = new ts.Map();
+ root.instantiations.set(getTypeListId(outerTypeParameters), links.resolvedType);
}
- var properties = getPropertiesOfType(target);
- var numericNamesOnly = isTupleType(source) && isTupleType(target);
- for (var _b = 0, _c = excludeProperties(properties, excludedProperties); _b < _c.length; _b++) {
- var targetProp = _c[_b];
- var name = targetProp.escapedName;
- if (!(targetProp.flags & 4194304) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length")) {
- var sourceProp = getPropertyOfType(source, name);
- if (sourceProp && sourceProp !== targetProp) {
- var related = propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSymbol, reportErrors, intersectionState, relation === comparableRelation);
- if (!related) {
- return 0;
- }
- result &= related;
+ }
+ return links.resolvedType;
+ }
+ function getTypeFromInferTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ links.resolvedType = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter));
+ }
+ return links.resolvedType;
+ }
+ function getIdentifierChain(node) {
+ if (ts.isIdentifier(node)) {
+ return [node];
+ }
+ else {
+ return ts.append(getIdentifierChain(node.left), node.right);
+ }
+ }
+ function getTypeFromImportTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ if (node.isTypeOf && node.typeArguments) {
+ error(node, ts.Diagnostics.Type_arguments_cannot_be_used_here);
+ links.resolvedSymbol = unknownSymbol;
+ return links.resolvedType = errorType;
+ }
+ if (!ts.isLiteralImportTypeNode(node)) {
+ error(node.argument, ts.Diagnostics.String_literal_expected);
+ links.resolvedSymbol = unknownSymbol;
+ return links.resolvedType = errorType;
+ }
+ var targetMeaning = node.isTypeOf ? 111551 : node.flags & 4194304 ? 111551 | 788968 : 788968;
+ var innerModuleSymbol = resolveExternalModuleName(node, node.argument.literal);
+ if (!innerModuleSymbol) {
+ links.resolvedSymbol = unknownSymbol;
+ return links.resolvedType = errorType;
+ }
+ var moduleSymbol = resolveExternalModuleSymbol(innerModuleSymbol, false);
+ if (!ts.nodeIsMissing(node.qualifier)) {
+ var nameStack = getIdentifierChain(node.qualifier);
+ var currentNamespace = moduleSymbol;
+ var current = void 0;
+ while (current = nameStack.shift()) {
+ var meaning = nameStack.length ? 1920 : targetMeaning;
+ var mergedResolvedSymbol = getMergedSymbol(resolveSymbol(currentNamespace));
+ var next = node.isTypeOf
+ ? getPropertyOfType(getTypeOfSymbol(mergedResolvedSymbol), current.escapedText)
+ : getSymbol(getExportsOfSymbol(mergedResolvedSymbol), current.escapedText, meaning);
+ if (!next) {
+ error(current, ts.Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(currentNamespace), ts.declarationNameToString(current));
+ return links.resolvedType = errorType;
}
+ getNodeLinks(current).resolvedSymbol = next;
+ getNodeLinks(current.parent).resolvedSymbol = next;
+ currentNamespace = next;
}
+ links.resolvedType = resolveImportSymbolType(node, links, currentNamespace, targetMeaning);
}
- return result;
- }
- function propertiesIdenticalTo(source, target, excludedProperties) {
- if (!(source.flags & 524288 && target.flags & 524288)) {
- return 0;
- }
- var sourceProperties = excludeProperties(getPropertiesOfObjectType(source), excludedProperties);
- var targetProperties = excludeProperties(getPropertiesOfObjectType(target), excludedProperties);
- if (sourceProperties.length !== targetProperties.length) {
- return 0;
- }
- var result = -1;
- for (var _i = 0, sourceProperties_1 = sourceProperties; _i < sourceProperties_1.length; _i++) {
- var sourceProp = sourceProperties_1[_i];
- var targetProp = getPropertyOfObjectType(target, sourceProp.escapedName);
- if (!targetProp) {
- return 0;
+ else {
+ if (moduleSymbol.flags & targetMeaning) {
+ links.resolvedType = resolveImportSymbolType(node, links, moduleSymbol, targetMeaning);
}
- var related = compareProperties(sourceProp, targetProp, isRelatedTo);
- if (!related) {
- return 0;
+ else {
+ var errorMessage = targetMeaning === 111551
+ ? ts.Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here
+ : ts.Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0;
+ error(node, errorMessage, node.argument.literal.text);
+ links.resolvedSymbol = unknownSymbol;
+ links.resolvedType = errorType;
}
- result &= related;
}
- return result;
}
- function signaturesRelatedTo(source, target, kind, reportErrors) {
- if (relation === identityRelation) {
- return signaturesIdenticalTo(source, target, kind);
- }
- if (target === anyFunctionType || source === anyFunctionType) {
- return -1;
+ return links.resolvedType;
+ }
+ function resolveImportSymbolType(node, links, symbol, meaning) {
+ var resolvedSymbol = resolveSymbol(symbol);
+ links.resolvedSymbol = resolvedSymbol;
+ if (meaning === 111551) {
+ return getTypeOfSymbol(symbol);
+ }
+ else {
+ return getTypeReferenceType(node, resolvedSymbol);
+ }
+ }
+ function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ var aliasSymbol = getAliasSymbolForTypeNode(node);
+ if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) {
+ links.resolvedType = emptyTypeLiteralType;
}
- var sourceIsJSConstructor = source.symbol && isJSConstructor(source.symbol.valueDeclaration);
- var targetIsJSConstructor = target.symbol && isJSConstructor(target.symbol.valueDeclaration);
- var sourceSignatures = getSignaturesOfType(source, (sourceIsJSConstructor && kind === 1) ?
- 0 : kind);
- var targetSignatures = getSignaturesOfType(target, (targetIsJSConstructor && kind === 1) ?
- 0 : kind);
- if (kind === 1 && sourceSignatures.length && targetSignatures.length) {
- if (ts.isAbstractConstructorType(source) && !ts.isAbstractConstructorType(target)) {
- if (reportErrors) {
- reportError(ts.Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type);
- }
- return 0;
- }
- if (!constructorVisibilitiesAreCompatible(sourceSignatures[0], targetSignatures[0], reportErrors)) {
- return 0;
+ else {
+ var type = createObjectType(16, node.symbol);
+ type.aliasSymbol = aliasSymbol;
+ type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
+ if (ts.isJSDocTypeLiteral(node) && node.isArrayType) {
+ type = createArrayType(type);
}
+ links.resolvedType = type;
}
- var result = -1;
- var saveErrorInfo = captureErrorCalculationState();
- var incompatibleReporter = kind === 1 ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
- if (ts.getObjectFlags(source) & 64 && ts.getObjectFlags(target) & 64 && source.symbol === target.symbol) {
- for (var i = 0; i < targetSignatures.length; i++) {
- var related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], true, reportErrors, incompatibleReporter(sourceSignatures[i], targetSignatures[i]));
- if (!related) {
- return 0;
- }
- result &= related;
- }
+ }
+ return links.resolvedType;
+ }
+ function getAliasSymbolForTypeNode(node) {
+ var host = node.parent;
+ while (ts.isParenthesizedTypeNode(host) || ts.isJSDocTypeExpression(host) || ts.isTypeOperatorNode(host) && host.operator === 142) {
+ host = host.parent;
+ }
+ return ts.isTypeAlias(host) ? getSymbolOfNode(host) : undefined;
+ }
+ function getTypeArgumentsForAliasSymbol(symbol) {
+ return symbol ? getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) : undefined;
+ }
+ function isNonGenericObjectType(type) {
+ return !!(type.flags & 524288) && !isGenericMappedType(type);
+ }
+ function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type) {
+ return isEmptyObjectType(type) || !!(type.flags & (65536 | 32768 | 528 | 296 | 2112 | 402653316 | 1056 | 67108864 | 4194304));
+ }
+ function tryMergeUnionOfObjectTypeAndEmptyObject(type, readonly) {
+ if (type.types.length === 2) {
+ var firstType = type.types[0];
+ var secondType = type.types[1];
+ if (ts.every(type.types, isEmptyObjectTypeOrSpreadsIntoEmptyObject)) {
+ return isEmptyObjectType(firstType) ? firstType : isEmptyObjectType(secondType) ? secondType : emptyObjectType;
}
- else if (sourceSignatures.length === 1 && targetSignatures.length === 1) {
- var eraseGenerics = relation === comparableRelation || !!compilerOptions.noStrictGenericChecks;
- result = signatureRelatedTo(sourceSignatures[0], targetSignatures[0], eraseGenerics, reportErrors, incompatibleReporter(sourceSignatures[0], targetSignatures[0]));
+ if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(firstType)) {
+ return getAnonymousPartialType(secondType);
}
- else {
- outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) {
- var t = targetSignatures_1[_i];
- var shouldElaborateErrors = reportErrors;
- for (var _a = 0, sourceSignatures_1 = sourceSignatures; _a < sourceSignatures_1.length; _a++) {
- var s = sourceSignatures_1[_a];
- var related = signatureRelatedTo(s, t, true, shouldElaborateErrors, incompatibleReporter(s, t));
- if (related) {
- result &= related;
- resetErrorInfo(saveErrorInfo);
- continue outer;
- }
- shouldElaborateErrors = false;
- }
- if (shouldElaborateErrors) {
- reportError(ts.Diagnostics.Type_0_provides_no_match_for_the_signature_1, typeToString(source), signatureToString(t, undefined, undefined, kind));
- }
- return 0;
+ if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(secondType)) {
+ return getAnonymousPartialType(firstType);
+ }
+ }
+ function getAnonymousPartialType(type) {
+ var members = ts.createSymbolTable();
+ for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) {
+ var prop = _a[_i];
+ if (ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 | 16)) {
+ }
+ else if (isSpreadableProperty(prop)) {
+ var isSetonlyAccessor = prop.flags & 65536 && !(prop.flags & 32768);
+ var flags = 4 | 16777216;
+ var result = createSymbol(flags, prop.escapedName, readonly ? 8 : 0);
+ result.type = isSetonlyAccessor ? undefinedType : getTypeOfSymbol(prop);
+ result.declarations = prop.declarations;
+ result.nameType = getSymbolLinks(prop).nameType;
+ result.syntheticOrigin = prop;
+ members.set(prop.escapedName, result);
}
}
- return result;
+ var spread = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, getIndexInfoOfType(type, 0), getIndexInfoOfType(type, 1));
+ spread.objectFlags |= 128 | 1048576;
+ return spread;
}
- function reportIncompatibleCallSignatureReturn(siga, sigb) {
- if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
- return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); };
+ }
+ function getSpreadType(left, right, symbol, objectFlags, readonly) {
+ if (left.flags & 1 || right.flags & 1) {
+ return anyType;
+ }
+ if (left.flags & 2 || right.flags & 2) {
+ return unknownType;
+ }
+ if (left.flags & 131072) {
+ return right;
+ }
+ if (right.flags & 131072) {
+ return left;
+ }
+ if (left.flags & 1048576) {
+ var merged = tryMergeUnionOfObjectTypeAndEmptyObject(left, readonly);
+ if (merged) {
+ return getSpreadType(merged, right, symbol, objectFlags, readonly);
}
- return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target)); };
+ return checkCrossProductUnion([left, right])
+ ? mapType(left, function (t) { return getSpreadType(t, right, symbol, objectFlags, readonly); })
+ : errorType;
}
- function reportIncompatibleConstructSignatureReturn(siga, sigb) {
- if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
- return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); };
+ if (right.flags & 1048576) {
+ var merged = tryMergeUnionOfObjectTypeAndEmptyObject(right, readonly);
+ if (merged) {
+ return getSpreadType(left, merged, symbol, objectFlags, readonly);
}
- return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target)); };
+ return checkCrossProductUnion([left, right])
+ ? mapType(right, function (t) { return getSpreadType(left, t, symbol, objectFlags, readonly); })
+ : errorType;
}
- function signatureRelatedTo(source, target, erase, reportErrors, incompatibleReporter) {
- return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 : 0, reportErrors, reportError, incompatibleReporter, isRelatedTo, makeFunctionTypeMapper(reportUnreliableMarkers));
+ if (right.flags & (528 | 296 | 2112 | 402653316 | 1056 | 67108864 | 4194304)) {
+ return left;
}
- function signaturesIdenticalTo(source, target, kind) {
- var sourceSignatures = getSignaturesOfType(source, kind);
- var targetSignatures = getSignaturesOfType(target, kind);
- if (sourceSignatures.length !== targetSignatures.length) {
- return 0;
+ if (isGenericObjectType(left) || isGenericObjectType(right)) {
+ if (isEmptyObjectType(left)) {
+ return right;
}
- var result = -1;
- for (var i = 0; i < sourceSignatures.length; i++) {
- var related = compareSignaturesIdentical(sourceSignatures[i], targetSignatures[i], false, false, false, isRelatedTo);
- if (!related) {
- return 0;
+ if (left.flags & 2097152) {
+ var types = left.types;
+ var lastLeft = types[types.length - 1];
+ if (isNonGenericObjectType(lastLeft) && isNonGenericObjectType(right)) {
+ return getIntersectionType(ts.concatenate(types.slice(0, types.length - 1), [getSpreadType(lastLeft, right, symbol, objectFlags, readonly)]));
}
- result &= related;
}
- return result;
+ return getIntersectionType([left, right]);
}
- function eachPropertyRelatedTo(source, target, kind, reportErrors) {
- var result = -1;
- var props = source.flags & 2097152 ? getPropertiesOfUnionOrIntersectionType(source) : getPropertiesOfObjectType(source);
- for (var _i = 0, props_2 = props; _i < props_2.length; _i++) {
- var prop = props_2[_i];
- if (isIgnoredJsxProperty(source, prop)) {
- continue;
- }
- var nameType = getSymbolLinks(prop).nameType;
- if (nameType && nameType.flags & 8192) {
- continue;
- }
- if (kind === 0 || isNumericLiteralName(prop.escapedName)) {
- var related = isRelatedTo(getTypeOfSymbol(prop), target, reportErrors);
- if (!related) {
- if (reportErrors) {
- reportError(ts.Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop));
- }
- return 0;
- }
- result &= related;
- }
- }
- return result;
+ var members = ts.createSymbolTable();
+ var skippedPrivateMembers = new ts.Set();
+ var stringIndexInfo;
+ var numberIndexInfo;
+ if (left === emptyObjectType) {
+ stringIndexInfo = getIndexInfoOfType(right, 0);
+ numberIndexInfo = getIndexInfoOfType(right, 1);
}
- function indexTypeRelatedTo(sourceType, targetType, reportErrors) {
- var related = isRelatedTo(sourceType, targetType, reportErrors);
- if (!related && reportErrors) {
- reportError(ts.Diagnostics.Index_signatures_are_incompatible);
+ else {
+ stringIndexInfo = unionSpreadIndexInfos(getIndexInfoOfType(left, 0), getIndexInfoOfType(right, 0));
+ numberIndexInfo = unionSpreadIndexInfos(getIndexInfoOfType(left, 1), getIndexInfoOfType(right, 1));
+ }
+ for (var _i = 0, _a = getPropertiesOfType(right); _i < _a.length; _i++) {
+ var rightProp = _a[_i];
+ if (ts.getDeclarationModifierFlagsFromSymbol(rightProp) & (8 | 16)) {
+ skippedPrivateMembers.add(rightProp.escapedName);
+ }
+ else if (isSpreadableProperty(rightProp)) {
+ members.set(rightProp.escapedName, getSpreadSymbol(rightProp, readonly));
}
- return related;
}
- function indexTypesRelatedTo(source, target, kind, sourceIsPrimitive, reportErrors, intersectionState) {
- if (relation === identityRelation) {
- return indexTypesIdenticalTo(source, target, kind);
+ for (var _b = 0, _c = getPropertiesOfType(left); _b < _c.length; _b++) {
+ var leftProp = _c[_b];
+ if (skippedPrivateMembers.has(leftProp.escapedName) || !isSpreadableProperty(leftProp)) {
+ continue;
}
- var targetType = getIndexTypeOfType(target, kind);
- if (!targetType || targetType.flags & 1 && !sourceIsPrimitive) {
- return -1;
+ if (members.has(leftProp.escapedName)) {
+ var rightProp = members.get(leftProp.escapedName);
+ var rightType = getTypeOfSymbol(rightProp);
+ if (rightProp.flags & 16777216) {
+ var declarations = ts.concatenate(leftProp.declarations, rightProp.declarations);
+ var flags = 4 | (leftProp.flags & 16777216);
+ var result = createSymbol(flags, leftProp.escapedName);
+ result.type = getUnionType([getTypeOfSymbol(leftProp), getTypeWithFacts(rightType, 524288)]);
+ result.leftSpread = leftProp;
+ result.rightSpread = rightProp;
+ result.declarations = declarations;
+ result.nameType = getSymbolLinks(leftProp).nameType;
+ members.set(leftProp.escapedName, result);
+ }
}
- if (isGenericMappedType(source)) {
- return kind === 0 ? isRelatedTo(getTemplateTypeFromMappedType(source), targetType, reportErrors) : 0;
+ else {
+ members.set(leftProp.escapedName, getSpreadSymbol(leftProp, readonly));
}
- var indexType = getIndexTypeOfType(source, kind) || kind === 1 && getIndexTypeOfType(source, 0);
- if (indexType) {
- return indexTypeRelatedTo(indexType, targetType, reportErrors);
+ }
+ var spread = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, getIndexInfoWithReadonly(stringIndexInfo, readonly), getIndexInfoWithReadonly(numberIndexInfo, readonly));
+ spread.objectFlags |= 128 | 1048576 | 1024 | objectFlags;
+ return spread;
+ }
+ function isSpreadableProperty(prop) {
+ return !ts.some(prop.declarations, ts.isPrivateIdentifierPropertyDeclaration) &&
+ (!(prop.flags & (8192 | 32768 | 65536)) ||
+ !prop.declarations.some(function (decl) { return ts.isClassLike(decl.parent); }));
+ }
+ function getSpreadSymbol(prop, readonly) {
+ var isSetonlyAccessor = prop.flags & 65536 && !(prop.flags & 32768);
+ if (!isSetonlyAccessor && readonly === isReadonlySymbol(prop)) {
+ return prop;
+ }
+ var flags = 4 | (prop.flags & 16777216);
+ var result = createSymbol(flags, prop.escapedName, readonly ? 8 : 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 && info.isReadonly !== readonly ? createIndexInfo(info.type, readonly, info.declaration) : info;
+ }
+ function createLiteralType(flags, value, symbol) {
+ var type = createType(flags);
+ type.symbol = symbol;
+ type.value = value;
+ return type;
+ }
+ function getFreshTypeOfLiteralType(type) {
+ if (type.flags & 2944) {
+ if (!type.freshType) {
+ var freshType = createLiteralType(type.flags, type.value, type.symbol);
+ freshType.regularType = type;
+ freshType.freshType = freshType;
+ type.freshType = freshType;
}
- if (!(intersectionState & 1) && isObjectTypeWithInferableIndex(source)) {
- var related = eachPropertyRelatedTo(source, targetType, kind, reportErrors);
- if (related && kind === 0) {
- var numberIndexType = getIndexTypeOfType(source, 1);
- if (numberIndexType) {
- related &= indexTypeRelatedTo(numberIndexType, targetType, reportErrors);
+ return type.freshType;
+ }
+ return type;
+ }
+ function getRegularTypeOfLiteralType(type) {
+ return type.flags & 2944 ? type.regularType :
+ type.flags & 1048576 ? (type.regularType || (type.regularType = getUnionType(ts.sameMap(type.types, getRegularTypeOfLiteralType)))) :
+ type;
+ }
+ function isFreshLiteralType(type) {
+ return !!(type.flags & 2944) && type.freshType === type;
+ }
+ function getLiteralType(value, enumId, symbol) {
+ var qualifier = typeof value === "number" ? "#" : typeof value === "string" ? "@" : "n";
+ var key = (enumId ? enumId : "") + qualifier + (typeof value === "object" ? ts.pseudoBigIntToString(value) : value);
+ var type = literalTypes.get(key);
+ if (!type) {
+ var flags = (typeof value === "number" ? 256 :
+ typeof value === "string" ? 128 : 2048) |
+ (enumId ? 1024 : 0);
+ literalTypes.set(key, type = createLiteralType(flags, value, symbol));
+ type.regularType = type;
+ }
+ return type;
+ }
+ function getTypeFromLiteralTypeNode(node) {
+ if (node.literal.kind === 103) {
+ return nullType;
+ }
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ links.resolvedType = getRegularTypeOfLiteralType(checkExpression(node.literal));
+ }
+ return links.resolvedType;
+ }
+ function createUniqueESSymbolType(symbol) {
+ var type = createType(8192);
+ type.symbol = symbol;
+ type.escapedName = "__@" + type.symbol.escapedName + "@" + getSymbolId(type.symbol);
+ return type;
+ }
+ function getESSymbolLikeTypeForNode(node) {
+ if (ts.isValidESSymbolDeclaration(node)) {
+ var symbol = getSymbolOfNode(node);
+ var links = getSymbolLinks(symbol);
+ return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol));
+ }
+ return esSymbolType;
+ }
+ function getThisType(node) {
+ var container = ts.getThisContainer(node, false);
+ var parent = container && container.parent;
+ if (parent && (ts.isClassLike(parent) || parent.kind === 253)) {
+ if (!ts.hasSyntacticModifier(container, 32) &&
+ (!ts.isConstructorDeclaration(container) || ts.isNodeDescendantOf(node, container.body))) {
+ return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
+ }
+ }
+ if (parent && ts.isObjectLiteralExpression(parent) && ts.isBinaryExpression(parent.parent) && ts.getAssignmentDeclarationKind(parent.parent) === 6) {
+ return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent.parent.left).parent).thisType;
+ }
+ var host = node.flags & 4194304 ? ts.getHostSignatureFromJSDoc(node) : undefined;
+ if (host && ts.isFunctionExpression(host) && ts.isBinaryExpression(host.parent) && ts.getAssignmentDeclarationKind(host.parent) === 3) {
+ return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(host.parent.left).parent).thisType;
+ }
+ if (isJSConstructor(container) && ts.isNodeDescendantOf(node, container.body)) {
+ return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(container)).thisType;
+ }
+ error(node, ts.Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface);
+ return errorType;
+ }
+ function getTypeFromThisTypeNode(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ links.resolvedType = getThisType(node);
+ }
+ return links.resolvedType;
+ }
+ function getTypeFromRestTypeNode(node) {
+ return getTypeFromTypeNode(getArrayElementTypeNode(node.type) || node.type);
+ }
+ function getArrayElementTypeNode(node) {
+ switch (node.kind) {
+ case 186:
+ return getArrayElementTypeNode(node.type);
+ case 179:
+ if (node.elements.length === 1) {
+ node = node.elements[0];
+ if (node.kind === 181 || node.kind === 192 && node.dotDotDotToken) {
+ return getArrayElementTypeNode(node.type);
+ }
+ }
+ break;
+ case 178:
+ return node.elementType;
+ }
+ return undefined;
+ }
+ function getTypeFromNamedTupleTypeNode(node) {
+ var links = getNodeLinks(node);
+ return links.resolvedType || (links.resolvedType =
+ node.dotDotDotToken ? getTypeFromRestTypeNode(node) :
+ node.questionToken && strictNullChecks ? getOptionalType(getTypeFromTypeNode(node.type)) :
+ getTypeFromTypeNode(node.type));
+ }
+ function getTypeFromTypeNode(node) {
+ return getConditionalFlowTypeOfType(getTypeFromTypeNodeWorker(node), node);
+ }
+ function getTypeFromTypeNodeWorker(node) {
+ switch (node.kind) {
+ case 128:
+ case 303:
+ case 304:
+ return anyType;
+ case 152:
+ return unknownType;
+ case 147:
+ return stringType;
+ case 144:
+ return numberType;
+ case 155:
+ return bigintType;
+ case 131:
+ return booleanType;
+ case 148:
+ return esSymbolType;
+ case 113:
+ return voidType;
+ case 150:
+ return undefinedType;
+ case 103:
+ return nullType;
+ case 141:
+ return neverType;
+ case 145:
+ return node.flags & 131072 && !noImplicitAny ? anyType : nonPrimitiveType;
+ case 136:
+ return intrinsicMarkerType;
+ case 187:
+ case 107:
+ return getTypeFromThisTypeNode(node);
+ case 191:
+ return getTypeFromLiteralTypeNode(node);
+ case 173:
+ return getTypeFromTypeReference(node);
+ case 172:
+ return node.assertsModifier ? voidType : booleanType;
+ case 223:
+ return getTypeFromTypeReference(node);
+ case 176:
+ return getTypeFromTypeQueryNode(node);
+ case 178:
+ case 179:
+ return getTypeFromArrayOrTupleTypeNode(node);
+ case 180:
+ return getTypeFromOptionalTypeNode(node);
+ case 182:
+ return getTypeFromUnionTypeNode(node);
+ case 183:
+ return getTypeFromIntersectionTypeNode(node);
+ case 305:
+ return getTypeFromJSDocNullableTypeNode(node);
+ case 307:
+ return addOptionality(getTypeFromTypeNode(node.type));
+ case 192:
+ return getTypeFromNamedTupleTypeNode(node);
+ case 186:
+ case 306:
+ case 301:
+ return getTypeFromTypeNode(node.type);
+ case 181:
+ return getTypeFromRestTypeNode(node);
+ case 309:
+ return getTypeFromJSDocVariadicType(node);
+ case 174:
+ case 175:
+ case 177:
+ case 312:
+ case 308:
+ case 313:
+ return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
+ case 188:
+ return getTypeFromTypeOperatorNode(node);
+ case 189:
+ return getTypeFromIndexedAccessTypeNode(node);
+ case 190:
+ return getTypeFromMappedTypeNode(node);
+ case 184:
+ return getTypeFromConditionalTypeNode(node);
+ case 185:
+ return getTypeFromInferTypeNode(node);
+ case 193:
+ return getTypeFromTemplateTypeNode(node);
+ case 195:
+ return getTypeFromImportTypeNode(node);
+ case 78:
+ case 157:
+ case 201:
+ var symbol = getSymbolAtLocation(node);
+ return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
+ default:
+ return errorType;
+ }
+ }
+ function instantiateList(items, mapper, instantiator) {
+ if (items && items.length) {
+ for (var i = 0; i < items.length; i++) {
+ var item = items[i];
+ var mapped = instantiator(item, mapper);
+ if (item !== mapped) {
+ var result = i === 0 ? [] : items.slice(0, i);
+ result.push(mapped);
+ for (i++; i < items.length; i++) {
+ result.push(instantiator(items[i], mapper));
}
+ return result;
}
- return related;
- }
- if (reportErrors) {
- reportError(ts.Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
- }
- return 0;
- }
- function indexTypesIdenticalTo(source, target, indexKind) {
- var targetInfo = getIndexInfoOfType(target, indexKind);
- var sourceInfo = getIndexInfoOfType(source, indexKind);
- if (!sourceInfo && !targetInfo) {
- return -1;
- }
- if (sourceInfo && targetInfo && sourceInfo.isReadonly === targetInfo.isReadonly) {
- return isRelatedTo(sourceInfo.type, targetInfo.type);
- }
- return 0;
- }
- function constructorVisibilitiesAreCompatible(sourceSignature, targetSignature, reportErrors) {
- if (!sourceSignature.declaration || !targetSignature.declaration) {
- return true;
- }
- var sourceAccessibility = ts.getSelectedModifierFlags(sourceSignature.declaration, 24);
- var targetAccessibility = ts.getSelectedModifierFlags(targetSignature.declaration, 24);
- if (targetAccessibility === 8) {
- return true;
- }
- if (targetAccessibility === 16 && sourceAccessibility !== 8) {
- return true;
}
- if (targetAccessibility !== 16 && !sourceAccessibility) {
- return true;
- }
- if (reportErrors) {
- reportError(ts.Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type, visibilityToString(sourceAccessibility), visibilityToString(targetAccessibility));
- }
- return false;
}
+ return items;
}
- function getBestMatchingType(source, target, isRelatedTo) {
- if (isRelatedTo === void 0) { isRelatedTo = compareTypesAssignable; }
- return findMatchingDiscriminantType(source, target, isRelatedTo, true) ||
- findMatchingTypeReferenceOrTypeAliasReference(source, target) ||
- findBestTypeForObjectLiteral(source, target) ||
- findBestTypeForInvokable(source, target) ||
- findMostOverlappyType(source, target);
+ function instantiateTypes(types, mapper) {
+ return instantiateList(types, mapper, instantiateType);
}
- function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue, skipPartial) {
- var discriminable = target.types.map(function (_) { return undefined; });
- for (var _i = 0, discriminators_1 = discriminators; _i < discriminators_1.length; _i++) {
- var _a = discriminators_1[_i], getDiscriminatingType = _a[0], propertyName = _a[1];
- var targetProp = getUnionOrIntersectionProperty(target, propertyName);
- if (skipPartial && targetProp && ts.getCheckFlags(targetProp) & 16) {
- continue;
- }
- var i = 0;
- for (var _b = 0, _c = target.types; _b < _c.length; _b++) {
- var type = _c[_b];
- var targetType = getTypeOfPropertyOfType(type, propertyName);
- if (targetType && related(getDiscriminatingType(), targetType)) {
- discriminable[i] = discriminable[i] === undefined ? true : discriminable[i];
- }
- else {
- discriminable[i] = false;
+ function instantiateSignatures(signatures, mapper) {
+ return instantiateList(signatures, mapper, instantiateSignature);
+ }
+ 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:
+ return type === mapper.source ? mapper.target : type;
+ case 1:
+ var sources = mapper.sources;
+ var targets = mapper.targets;
+ for (var i = 0; i < sources.length; i++) {
+ if (type === sources[i]) {
+ return targets ? targets[i] : anyType;
+ }
}
- i++;
- }
+ return type;
+ case 2:
+ return mapper.func(type);
+ case 3:
+ case 4:
+ var t1 = getMappedType(type, mapper.mapper1);
+ return t1 !== type && mapper.kind === 3 ? instantiateType(t1, mapper.mapper2) : getMappedType(t1, mapper.mapper2);
}
- var match = discriminable.indexOf(true);
- return match === -1 || discriminable.indexOf(true, match + 1) !== -1 ? defaultValue : target.types[match];
}
- function isWeakType(type) {
- if (type.flags & 524288) {
- var resolved = resolveStructuredTypeMembers(type);
- return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 &&
- !resolved.stringIndexInfo && !resolved.numberIndexInfo &&
- resolved.properties.length > 0 &&
- ts.every(resolved.properties, function (p) { return !!(p.flags & 16777216); });
- }
- if (type.flags & 2097152) {
- return ts.every(type.types, isWeakType);
- }
- return false;
+ function makeUnaryTypeMapper(source, target) {
+ return { kind: 0, source: source, target: target };
}
- function hasCommonProperties(source, target, isComparingJsxAttributes) {
- for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) {
- var prop = _a[_i];
- if (isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) {
- return true;
- }
- }
- return false;
+ function makeArrayTypeMapper(sources, targets) {
+ return { kind: 1, sources: sources, targets: targets };
}
- function getMarkerTypeReference(type, source, target) {
- var result = createTypeReference(type, ts.map(type.typeParameters, function (t) { return t === source ? target : t; }));
- result.objectFlags |= 8192;
+ function makeFunctionTypeMapper(func) {
+ return { kind: 2, func: func };
+ }
+ function makeCompositeTypeMapper(kind, mapper1, mapper2) {
+ return { kind: kind, mapper1: mapper1, mapper2: mapper2 };
+ }
+ function createTypeEraser(sources) {
+ return createTypeMapper(sources, undefined);
+ }
+ function createBackreferenceMapper(context, index) {
+ return makeFunctionTypeMapper(function (t) { return ts.findIndex(context.inferences, function (info) { return info.typeParameter === t; }) >= index ? unknownType : t; });
+ }
+ function combineTypeMappers(mapper1, mapper2) {
+ return mapper1 ? makeCompositeTypeMapper(3, mapper1, mapper2) : mapper2;
+ }
+ function mergeTypeMappers(mapper1, mapper2) {
+ return mapper1 ? makeCompositeTypeMapper(4, mapper1, mapper2) : mapper2;
+ }
+ function prependTypeMapping(source, target, mapper) {
+ return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(4, makeUnaryTypeMapper(source, target), mapper);
+ }
+ function appendTypeMapping(mapper, source, target) {
+ return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(4, mapper, makeUnaryTypeMapper(source, target));
+ }
+ function getRestrictiveTypeParameter(tp) {
+ return tp.constraint === unknownType ? tp : tp.restrictiveInstantiation || (tp.restrictiveInstantiation = createTypeParameter(tp.symbol),
+ tp.restrictiveInstantiation.constraint = unknownType,
+ tp.restrictiveInstantiation);
+ }
+ function cloneTypeParameter(typeParameter) {
+ var result = createTypeParameter(typeParameter.symbol);
+ result.target = typeParameter;
return result;
}
- function getAliasVariances(symbol) {
- var links = getSymbolLinks(symbol);
- return getVariancesWorker(links.typeParameters, links, function (_links, param, marker) {
- var type = getTypeAliasInstantiation(symbol, instantiateTypes(links.typeParameters, makeUnaryTypeMapper(param, marker)));
- type.aliasTypeArgumentsContainsMarker = true;
- return type;
- });
+ function instantiateTypePredicate(predicate, mapper) {
+ return createTypePredicate(predicate.kind, predicate.parameterName, predicate.parameterIndex, instantiateType(predicate.type, mapper));
}
- function getVariancesWorker(typeParameters, cache, createMarkerType) {
- if (typeParameters === void 0) { typeParameters = ts.emptyArray; }
- var variances = cache.variances;
- if (!variances) {
- cache.variances = ts.emptyArray;
- variances = [];
- var _loop_16 = function (tp) {
- var unmeasurable = false;
- var unreliable = false;
- var oldHandler = outofbandVarianceMarkerHandler;
- outofbandVarianceMarkerHandler = function (onlyUnreliable) { return onlyUnreliable ? unreliable = true : unmeasurable = true; };
- var typeWithSuper = createMarkerType(cache, tp, markerSuperType);
- var typeWithSub = createMarkerType(cache, tp, markerSubType);
- var variance = (isTypeAssignableTo(typeWithSub, typeWithSuper) ? 1 : 0) |
- (isTypeAssignableTo(typeWithSuper, typeWithSub) ? 2 : 0);
- if (variance === 3 && isTypeAssignableTo(createMarkerType(cache, tp, markerOtherType), typeWithSuper)) {
- variance = 4;
- }
- outofbandVarianceMarkerHandler = oldHandler;
- if (unmeasurable || unreliable) {
- if (unmeasurable) {
- variance |= 8;
- }
- if (unreliable) {
- variance |= 16;
- }
- }
- variances.push(variance);
- };
- for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) {
- var tp = typeParameters_1[_i];
- _loop_16(tp);
+ function instantiateSignature(signature, mapper, eraseTypeParameters) {
+ var freshTypeParameters;
+ if (signature.typeParameters && !eraseTypeParameters) {
+ freshTypeParameters = ts.map(signature.typeParameters, cloneTypeParameter);
+ mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper);
+ for (var _i = 0, freshTypeParameters_1 = freshTypeParameters; _i < freshTypeParameters_1.length; _i++) {
+ var tp = freshTypeParameters_1[_i];
+ tp.mapper = mapper;
}
- cache.variances = variances;
}
- return variances;
+ var result = createSignature(signature.declaration, freshTypeParameters, signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper), instantiateList(signature.parameters, mapper, instantiateSymbol), undefined, undefined, signature.minArgumentCount, signature.flags & 19);
+ result.target = signature;
+ result.mapper = mapper;
+ return result;
}
- function getVariances(type) {
- if (type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & 8) {
- return arrayVariances;
+ function instantiateSymbol(symbol, mapper) {
+ var links = getSymbolLinks(symbol);
+ if (links.type && !couldContainTypeVariables(links.type)) {
+ return symbol;
}
- return getVariancesWorker(type.typeParameters, type, getMarkerTypeReference);
+ if (ts.getCheckFlags(symbol) & 1) {
+ symbol = links.target;
+ mapper = combineTypeMappers(links.mapper, mapper);
+ }
+ var result = createSymbol(symbol.flags, symbol.escapedName, 1 | ts.getCheckFlags(symbol) & (8 | 4096 | 16384 | 32768));
+ 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 hasCovariantVoidArgument(typeArguments, variances) {
- for (var i = 0; i < variances.length; i++) {
- if ((variances[i] & 7) === 1 && typeArguments[i].flags & 16384) {
- return true;
+ function getObjectTypeInstantiation(type, mapper) {
+ var declaration = type.objectFlags & 4 ? type.node : type.symbol.declarations[0];
+ var links = getNodeLinks(declaration);
+ var target = type.objectFlags & 4 ? links.resolvedType :
+ type.objectFlags & 64 ? type.target : type;
+ var typeParameters = links.outerTypeParameters;
+ if (!typeParameters) {
+ var outerTypeParameters = getOuterTypeParameters(declaration, true);
+ if (isJSConstructor(declaration)) {
+ var templateTagParameters = getTypeParametersFromDeclaration(declaration);
+ outerTypeParameters = ts.addRange(outerTypeParameters, templateTagParameters);
}
+ typeParameters = outerTypeParameters || ts.emptyArray;
+ typeParameters = (target.objectFlags & 4 || target.symbol.flags & 2048) && !target.aliasTypeArguments ?
+ ts.filter(typeParameters, function (tp) { return isTypeParameterPossiblyReferenced(tp, declaration); }) :
+ typeParameters;
+ links.outerTypeParameters = typeParameters;
}
- return false;
- }
- function isUnconstrainedTypeParameter(type) {
- return type.flags & 262144 && !getConstraintOfTypeParameter(type);
- }
- function isNonDeferredTypeReference(type) {
- return !!(ts.getObjectFlags(type) & 4) && !type.node;
+ if (typeParameters.length) {
+ var combinedMapper_1 = combineTypeMappers(type.mapper, mapper);
+ var typeArguments = ts.map(typeParameters, function (t) { return getMappedType(t, combinedMapper_1); });
+ var id = getTypeListId(typeArguments);
+ if (!target.instantiations) {
+ target.instantiations = new ts.Map();
+ target.instantiations.set(getTypeListId(typeParameters), target);
+ }
+ var result = target.instantiations.get(id);
+ if (!result) {
+ var newMapper = createTypeMapper(typeParameters, typeArguments);
+ result = target.objectFlags & 4 ? createDeferredTypeReference(type.target, type.node, newMapper) :
+ target.objectFlags & 32 ? instantiateMappedType(target, newMapper) :
+ instantiateAnonymousType(target, newMapper);
+ target.instantiations.set(id, result);
+ }
+ return result;
+ }
+ return type;
}
- function isTypeReferenceWithGenericArguments(type) {
- return isNonDeferredTypeReference(type) && ts.some(getTypeArguments(type), function (t) { return isUnconstrainedTypeParameter(t) || isTypeReferenceWithGenericArguments(t); });
+ function maybeTypeParameterReference(node) {
+ return !(node.kind === 157 ||
+ node.parent.kind === 173 && node.parent.typeArguments && node === node.parent.typeName ||
+ node.parent.kind === 195 && node.parent.typeArguments && node === node.parent.qualifier);
}
- function getTypeReferenceId(type, typeParameters, depth) {
- if (depth === void 0) { depth = 0; }
- var result = "" + type.target.id;
- for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) {
- var t = _a[_i];
- if (isUnconstrainedTypeParameter(t)) {
- var index = typeParameters.indexOf(t);
- if (index < 0) {
- index = typeParameters.length;
- typeParameters.push(t);
+ function isTypeParameterPossiblyReferenced(tp, node) {
+ if (tp.symbol && tp.symbol.declarations && tp.symbol.declarations.length === 1) {
+ var container = tp.symbol.declarations[0].parent;
+ for (var n = node; n !== container; n = n.parent) {
+ if (!n || n.kind === 230 || n.kind === 184 && ts.forEachChild(n.extendsType, containsReference)) {
+ return true;
}
- result += "=" + index;
- }
- else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
- result += "<" + getTypeReferenceId(t, typeParameters, depth + 1) + ">";
}
- else {
- result += "-" + t.id;
+ return !!ts.forEachChild(node, containsReference);
+ }
+ return true;
+ function containsReference(node) {
+ switch (node.kind) {
+ case 187:
+ return !!tp.isThisType;
+ case 78:
+ return !tp.isThisType && ts.isPartOfTypeNode(node) && maybeTypeParameterReference(node) &&
+ getTypeFromTypeNodeWorker(node) === tp;
+ case 176:
+ return true;
}
+ return !!ts.forEachChild(node, containsReference);
}
- return result;
}
- function getRelationKey(source, target, intersectionState, relation) {
- if (relation === identityRelation && source.id > target.id) {
- var temp = source;
- source = target;
- target = temp;
- }
- var postFix = intersectionState ? ":" + intersectionState : "";
- if (isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target)) {
- var typeParameters = [];
- return getTypeReferenceId(source, typeParameters) + "," + getTypeReferenceId(target, typeParameters) + postFix;
+ function getHomomorphicTypeVariable(type) {
+ var constraintType = getConstraintTypeFromMappedType(type);
+ if (constraintType.flags & 4194304) {
+ var typeVariable = getActualTypeVariable(constraintType.type);
+ if (typeVariable.flags & 262144) {
+ return typeVariable;
+ }
}
- return source.id + "," + target.id + postFix;
+ return undefined;
}
- function forEachProperty(prop, callback) {
- if (ts.getCheckFlags(prop) & 6) {
- for (var _i = 0, _a = prop.containingType.types; _i < _a.length; _i++) {
- var t = _a[_i];
- var p = getPropertyOfType(t, prop.escapedName);
- var result = p && forEachProperty(p, callback);
- if (result) {
- return result;
- }
+ function instantiateMappedType(type, mapper) {
+ var typeVariable = getHomomorphicTypeVariable(type);
+ if (typeVariable) {
+ var mappedTypeVariable = instantiateType(typeVariable, mapper);
+ if (typeVariable !== mappedTypeVariable) {
+ return mapType(getReducedType(mappedTypeVariable), function (t) {
+ if (t.flags & (3 | 58982400 | 524288 | 2097152) && t !== wildcardType && t !== errorType) {
+ if (!type.declaration.nameType) {
+ if (isArrayType(t)) {
+ 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;
+ });
}
- return undefined;
}
- return callback(prop);
+ return instantiateAnonymousType(type, mapper);
}
- function getDeclaringClass(prop) {
- return prop.parent && prop.parent.flags & 32 ? getDeclaredTypeOfSymbol(getParentOfSymbol(prop)) : undefined;
+ function getModifiedReadonlyState(state, modifiers) {
+ return modifiers & 1 ? true : modifiers & 2 ? false : state;
}
- function isPropertyInClassDerivedFrom(prop, baseClass) {
- return forEachProperty(prop, function (sp) {
- var sourceClass = getDeclaringClass(sp);
- return sourceClass ? hasBaseType(sourceClass, baseClass) : false;
+ function instantiateMappedGenericTupleType(tupleType, mappedType, typeVariable, mapper) {
+ var elementFlags = tupleType.target.elementFlags;
+ var elementTypes = ts.map(getTypeArguments(tupleType), function (t, i) {
+ var singleton = elementFlags[i] & 8 ? t :
+ elementFlags[i] & 4 ? createArrayType(t) :
+ createTupleType([t], [elementFlags[i]]);
+ return instantiateMappedType(mappedType, prependTypeMapping(typeVariable, singleton, mapper));
});
+ var newReadonly = getModifiedReadonlyState(tupleType.target.readonly, getMappedTypeModifiers(mappedType));
+ return createTupleType(elementTypes, ts.map(elementTypes, function (_) { return 8; }), newReadonly);
}
- function isValidOverrideOf(sourceProp, targetProp) {
- return !forEachProperty(targetProp, function (tp) { return ts.getDeclarationModifierFlagsFromSymbol(tp) & 16 ?
- !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false; });
+ function instantiateMappedArrayType(arrayType, mappedType, mapper) {
+ var elementType = instantiateMappedTypeTemplate(mappedType, numberType, true, mapper);
+ return elementType === errorType ? errorType :
+ createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType)));
}
- function isClassDerivedFromDeclaringClasses(checkClass, prop) {
- return forEachProperty(prop, function (p) { return ts.getDeclarationModifierFlagsFromSymbol(p) & 16 ?
- !hasBaseType(checkClass, getDeclaringClass(p)) : false; }) ? undefined : checkClass;
+ function instantiateMappedTupleType(tupleType, mappedType, mapper) {
+ var elementFlags = tupleType.target.elementFlags;
+ var elementTypes = ts.map(getTypeArguments(tupleType), function (_, i) {
+ return instantiateMappedTypeTemplate(mappedType, getLiteralType("" + i), !!(elementFlags[i] & 2), mapper);
+ });
+ var modifiers = getMappedTypeModifiers(mappedType);
+ var newTupleModifiers = modifiers & 4 ? ts.map(elementFlags, function (f) { return f & 1 ? 2 : f; }) :
+ modifiers & 8 ? ts.map(elementFlags, function (f) { return f & 2 ? 1 : f; }) :
+ elementFlags;
+ var newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers);
+ return ts.contains(elementTypes, errorType) ? errorType :
+ createTupleType(elementTypes, newTupleModifiers, newReadonly, tupleType.target.labeledElementDeclarations);
}
- function isDeeplyNestedType(type, stack, depth) {
- if (depth >= 5 && type.flags & 524288 && !isObjectOrArrayLiteralType(type)) {
- var symbol = type.symbol;
- if (symbol) {
- var count = 0;
- for (var i = 0; i < depth; i++) {
- var t = stack[i];
- if (t.flags & 524288 && t.symbol === symbol) {
- count++;
- if (count >= 5)
- return true;
- }
- }
- }
- }
- if (depth >= 5 && type.flags & 8388608) {
- var root = getRootObjectTypeFromIndexedAccessChain(type);
- var count = 0;
- for (var i = 0; i < depth; i++) {
- var t = stack[i];
- if (getRootObjectTypeFromIndexedAccessChain(t) === root) {
- count++;
- if (count >= 5)
- return true;
- }
- }
- }
- return false;
+ function instantiateMappedTypeTemplate(type, key, isOptional, mapper) {
+ var templateMapper = appendTypeMapping(mapper, getTypeParameterFromMappedType(type), key);
+ var propType = instantiateType(getTemplateTypeFromMappedType(type.target || type), templateMapper);
+ var modifiers = getMappedTypeModifiers(type);
+ return strictNullChecks && modifiers & 4 && !maybeTypeOfKind(propType, 32768 | 16384) ? getOptionalType(propType) :
+ strictNullChecks && modifiers & 8 && isOptional ? getTypeWithFacts(propType, 524288) :
+ propType;
}
- function getRootObjectTypeFromIndexedAccessChain(type) {
- var t = type;
- while (t.flags & 8388608) {
- t = t.objectType;
+ function instantiateAnonymousType(type, mapper) {
+ var result = createObjectType(type.objectFlags | 64, type.symbol);
+ if (type.objectFlags & 32) {
+ result.declaration = type.declaration;
+ var origTypeParameter = getTypeParameterFromMappedType(type);
+ var freshTypeParameter = cloneTypeParameter(origTypeParameter);
+ result.typeParameter = freshTypeParameter;
+ mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper);
+ freshTypeParameter.mapper = mapper;
}
- return t;
- }
- function isPropertyIdenticalTo(sourceProp, targetProp) {
- return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== 0;
+ result.target = type;
+ result.mapper = mapper;
+ result.aliasSymbol = type.aliasSymbol;
+ result.aliasTypeArguments = instantiateTypes(type.aliasTypeArguments, mapper);
+ return result;
}
- function compareProperties(sourceProp, targetProp, compareTypes) {
- if (sourceProp === targetProp) {
- return -1;
- }
- var sourcePropAccessibility = ts.getDeclarationModifierFlagsFromSymbol(sourceProp) & 24;
- var targetPropAccessibility = ts.getDeclarationModifierFlagsFromSymbol(targetProp) & 24;
- if (sourcePropAccessibility !== targetPropAccessibility) {
- return 0;
- }
- if (sourcePropAccessibility) {
- if (getTargetSymbol(sourceProp) !== getTargetSymbol(targetProp)) {
- return 0;
+ function getConditionalTypeInstantiation(type, mapper) {
+ var root = type.root;
+ if (root.outerTypeParameters) {
+ var typeArguments = ts.map(root.outerTypeParameters, function (t) { return getMappedType(t, mapper); });
+ var id = getTypeListId(typeArguments);
+ var result = root.instantiations.get(id);
+ if (!result) {
+ var newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
+ result = instantiateConditionalType(root, newMapper);
+ root.instantiations.set(id, result);
}
+ return result;
}
- else {
- if ((sourceProp.flags & 16777216) !== (targetProp.flags & 16777216)) {
- return 0;
+ return type;
+ }
+ function instantiateConditionalType(root, mapper) {
+ if (root.isDistributive) {
+ var checkType_1 = root.checkType;
+ var instantiatedType = getMappedType(checkType_1, mapper);
+ if (checkType_1 !== instantiatedType && instantiatedType.flags & (1048576 | 131072)) {
+ return mapType(instantiatedType, function (t) { return getConditionalType(root, prependTypeMapping(checkType_1, t, mapper)); });
}
}
- if (isReadonlySymbol(sourceProp) !== isReadonlySymbol(targetProp)) {
- return 0;
- }
- return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
+ return getConditionalType(root, mapper);
}
- function isMatchingSignature(source, target, partialMatch) {
- var sourceParameterCount = getParameterCount(source);
- var targetParameterCount = getParameterCount(target);
- var sourceMinArgumentCount = getMinArgumentCount(source);
- var targetMinArgumentCount = getMinArgumentCount(target);
- var sourceHasRestParameter = hasEffectiveRestParameter(source);
- var targetHasRestParameter = hasEffectiveRestParameter(target);
- if (sourceParameterCount === targetParameterCount &&
- sourceMinArgumentCount === targetMinArgumentCount &&
- sourceHasRestParameter === targetHasRestParameter) {
- return true;
+ function instantiateType(type, mapper) {
+ if (!(type && mapper && couldContainTypeVariables(type))) {
+ return type;
}
- if (partialMatch && sourceMinArgumentCount <= targetMinArgumentCount) {
- return true;
+ if (instantiationDepth === 50 || instantiationCount >= 5000000) {
+ ts.tracing.instant("check", "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth: instantiationDepth, instantiationCount: instantiationCount });
+ error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
+ return errorType;
}
- return false;
+ totalInstantiationCount++;
+ instantiationCount++;
+ instantiationDepth++;
+ var result = instantiateTypeWorker(type, mapper);
+ instantiationDepth--;
+ return result;
}
- function compareSignaturesIdentical(source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypes) {
- if (source === target) {
- return -1;
- }
- if (!(isMatchingSignature(source, target, partialMatch))) {
- return 0;
- }
- if (ts.length(source.typeParameters) !== ts.length(target.typeParameters)) {
- return 0;
- }
- if (target.typeParameters) {
- var mapper = createTypeMapper(source.typeParameters, target.typeParameters);
- for (var i = 0; i < target.typeParameters.length; i++) {
- var s = source.typeParameters[i];
- var t = target.typeParameters[i];
- if (!(s === t || compareTypes(instantiateType(getConstraintFromTypeParameter(s), mapper) || unknownType, getConstraintFromTypeParameter(t) || unknownType) &&
- compareTypes(instantiateType(getDefaultFromTypeParameter(s), mapper) || unknownType, getDefaultFromTypeParameter(t) || unknownType))) {
- return 0;
- }
- }
- source = instantiateSignature(source, mapper, true);
+ function instantiateTypeWorker(type, mapper) {
+ var flags = type.flags;
+ if (flags & 262144) {
+ return getMappedType(type, mapper);
}
- var result = -1;
- if (!ignoreThisTypes) {
- var sourceThisType = getThisTypeOfSignature(source);
- if (sourceThisType) {
- var targetThisType = getThisTypeOfSignature(target);
- if (targetThisType) {
- var related = compareTypes(sourceThisType, targetThisType);
- if (!related) {
- return 0;
- }
- result &= related;
+ if (flags & 524288) {
+ var objectFlags = type.objectFlags;
+ if (objectFlags & (4 | 16 | 32)) {
+ if (objectFlags & 4 && !(type.node)) {
+ var resolvedTypeArguments = type.resolvedTypeArguments;
+ var newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper);
+ return newTypeArguments !== resolvedTypeArguments ? createNormalizedTypeReference(type.target, newTypeArguments) : type;
}
+ return getObjectTypeInstantiation(type, mapper);
}
+ return type;
}
- var targetLen = getParameterCount(target);
- for (var i = 0; i < targetLen; i++) {
- var s = getTypeAtPosition(source, i);
- var t = getTypeAtPosition(target, i);
- var related = compareTypes(t, s);
- if (!related) {
- return 0;
+ if (flags & 3145728) {
+ var types = type.types;
+ var newTypes = instantiateTypes(types, mapper);
+ return newTypes === types ? type :
+ flags & 2097152 ?
+ getIntersectionType(newTypes, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)) :
+ getUnionType(newTypes, 1, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper));
+ }
+ if (flags & 4194304) {
+ return getIndexType(instantiateType(type.type, mapper));
+ }
+ if (flags & 134217728) {
+ return getTemplateLiteralType(type.texts, instantiateTypes(type.types, mapper));
+ }
+ if (flags & 268435456) {
+ return getStringMappingType(type.symbol, instantiateType(type.type, mapper));
+ }
+ if (flags & 8388608) {
+ return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.noUncheckedIndexedAccessCandidate, undefined, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper));
+ }
+ if (flags & 16777216) {
+ return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper));
+ }
+ if (flags & 33554432) {
+ var maybeVariable = instantiateType(type.baseType, mapper);
+ if (maybeVariable.flags & 8650752) {
+ return getSubstitutionType(maybeVariable, instantiateType(type.substitute, mapper));
+ }
+ else {
+ var sub = instantiateType(type.substitute, mapper);
+ if (sub.flags & 3 || isTypeAssignableTo(getRestrictiveInstantiation(maybeVariable), getRestrictiveInstantiation(sub))) {
+ return maybeVariable;
+ }
+ return sub;
}
- result &= related;
}
- if (!ignoreReturnTypes) {
- var sourceTypePredicate = getTypePredicateOfSignature(source);
- var targetTypePredicate = getTypePredicateOfSignature(target);
- result &= sourceTypePredicate || targetTypePredicate ?
- compareTypePredicatesIdentical(sourceTypePredicate, targetTypePredicate, compareTypes) :
- compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
+ return type;
+ }
+ function getPermissiveInstantiation(type) {
+ return type.flags & (131068 | 3 | 131072) ? type :
+ type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
+ }
+ function getRestrictiveInstantiation(type) {
+ if (type.flags & (131068 | 3 | 131072)) {
+ return type;
}
- return result;
+ if (type.restrictiveInstantiation) {
+ return type.restrictiveInstantiation;
+ }
+ type.restrictiveInstantiation = instantiateType(type, restrictiveMapper);
+ type.restrictiveInstantiation.restrictiveInstantiation = type.restrictiveInstantiation;
+ return type.restrictiveInstantiation;
}
- function compareTypePredicatesIdentical(source, target, compareTypes) {
- return !(source && target && typePredicateKindsMatch(source, target)) ? 0 :
- source.type === target.type ? -1 :
- source.type && target.type ? compareTypes(source.type, target.type) :
- 0;
+ function instantiateIndexInfo(info, mapper) {
+ return info && createIndexInfo(instantiateType(info.type, mapper), info.isReadonly, info.declaration);
}
- function literalTypesWithSameBaseType(types) {
- var commonBaseType;
- for (var _i = 0, types_12 = types; _i < types_12.length; _i++) {
- var t = types_12[_i];
- var baseType = getBaseTypeOfLiteralType(t);
- if (!commonBaseType) {
- commonBaseType = baseType;
+ function isContextSensitive(node) {
+ ts.Debug.assert(node.kind !== 165 || ts.isObjectLiteralMethod(node));
+ switch (node.kind) {
+ case 208:
+ case 209:
+ case 165:
+ case 251:
+ return isContextSensitiveFunctionLikeDeclaration(node);
+ case 200:
+ return ts.some(node.properties, isContextSensitive);
+ case 199:
+ return ts.some(node.elements, isContextSensitive);
+ case 217:
+ return isContextSensitive(node.whenTrue) ||
+ isContextSensitive(node.whenFalse);
+ case 216:
+ return (node.operatorToken.kind === 56 || node.operatorToken.kind === 60) &&
+ (isContextSensitive(node.left) || isContextSensitive(node.right));
+ case 288:
+ return isContextSensitive(node.initializer);
+ case 207:
+ return isContextSensitive(node.expression);
+ case 281:
+ return ts.some(node.properties, isContextSensitive) || ts.isJsxOpeningElement(node.parent) && ts.some(node.parent.parent.children, isContextSensitive);
+ case 280: {
+ var initializer = node.initializer;
+ return !!initializer && isContextSensitive(initializer);
}
- if (baseType === t || baseType !== commonBaseType) {
- return false;
+ case 283: {
+ var expression = node.expression;
+ return !!expression && isContextSensitive(expression);
}
}
- return true;
+ return false;
}
- function getSupertypeOrUnion(types) {
- return literalTypesWithSameBaseType(types) ?
- getUnionType(types) :
- ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+ function isContextSensitiveFunctionLikeDeclaration(node) {
+ return (!ts.isFunctionDeclaration(node) || ts.isInJSFile(node) && !!getTypeForDeclarationFromJSDocComment(node)) &&
+ (hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node));
}
- function getCommonSupertype(types) {
- if (!strictNullChecks) {
- return getSupertypeOrUnion(types);
+ function hasContextSensitiveParameters(node) {
+ if (!node.typeParameters) {
+ if (ts.some(node.parameters, function (p) { return !ts.getEffectiveTypeAnnotationNode(p); })) {
+ return true;
+ }
+ if (node.kind !== 209) {
+ var parameter = ts.firstOrUndefined(node.parameters);
+ if (!(parameter && ts.parameterIsThisKeyword(parameter))) {
+ return true;
+ }
+ }
}
- var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304); });
- return primaryTypes.length ?
- getNullableType(getSupertypeOrUnion(primaryTypes), getFalsyFlagsOfTypes(types) & 98304) :
- getUnionType(types, 2);
+ return false;
}
- function getCommonSubtype(types) {
- return ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(t, s) ? t : s; });
+ function hasContextSensitiveReturnExpression(node) {
+ return !node.typeParameters && !ts.getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 230 && isContextSensitive(node.body);
}
- function isArrayType(type) {
- return !!(ts.getObjectFlags(type) & 4) && (type.target === globalArrayType || type.target === globalReadonlyArrayType);
+ function isContextSensitiveFunctionOrObjectLiteralMethod(func) {
+ return (ts.isInJSFile(func) && ts.isFunctionDeclaration(func) || isFunctionExpressionOrArrowFunction(func) || ts.isObjectLiteralMethod(func)) &&
+ isContextSensitiveFunctionLikeDeclaration(func);
}
- function isReadonlyArrayType(type) {
- return !!(ts.getObjectFlags(type) & 4) && type.target === globalReadonlyArrayType;
+ function getTypeWithoutSignatures(type) {
+ if (type.flags & 524288) {
+ var resolved = resolveStructuredTypeMembers(type);
+ if (resolved.constructSignatures.length || resolved.callSignatures.length) {
+ var result = createObjectType(16, type.symbol);
+ result.members = resolved.members;
+ result.properties = resolved.properties;
+ result.callSignatures = ts.emptyArray;
+ result.constructSignatures = ts.emptyArray;
+ return result;
+ }
+ }
+ else if (type.flags & 2097152) {
+ return getIntersectionType(ts.map(type.types, getTypeWithoutSignatures));
+ }
+ return type;
}
- function isMutableArrayOrTuple(type) {
- return isArrayType(type) && !isReadonlyArrayType(type) || isTupleType(type) && !type.target.readonly;
+ function isTypeIdenticalTo(source, target) {
+ return isTypeRelatedTo(source, target, identityRelation);
}
- function getElementTypeOfArrayType(type) {
- return isArrayType(type) ? getTypeArguments(type)[0] : undefined;
+ function compareTypesIdentical(source, target) {
+ return isTypeRelatedTo(source, target, identityRelation) ? -1 : 0;
}
- function isArrayLikeType(type) {
- return isArrayType(type) || !(type.flags & 98304) && isTypeAssignableTo(type, anyReadonlyArrayType);
+ function compareTypesAssignable(source, target) {
+ return isTypeRelatedTo(source, target, assignableRelation) ? -1 : 0;
}
- function isEmptyArrayLiteralType(type) {
- var elementType = isArrayType(type) ? getTypeArguments(type)[0] : undefined;
- return elementType === undefinedWideningType || elementType === implicitNeverType;
+ function compareTypesSubtypeOf(source, target) {
+ return isTypeRelatedTo(source, target, subtypeRelation) ? -1 : 0;
}
- function isTupleLikeType(type) {
- return isTupleType(type) || !!getPropertyOfType(type, "0");
+ function isTypeSubtypeOf(source, target) {
+ return isTypeRelatedTo(source, target, subtypeRelation);
}
- function isArrayOrTupleLikeType(type) {
- return isArrayLikeType(type) || isTupleLikeType(type);
+ function isTypeAssignableTo(source, target) {
+ return isTypeRelatedTo(source, target, assignableRelation);
}
- function getTupleElementType(type, index) {
- var propType = getTypeOfPropertyOfType(type, "" + index);
- if (propType) {
- return propType;
- }
- if (everyType(type, isTupleType)) {
- return mapType(type, function (t) { return getRestTypeOfTupleType(t) || undefinedType; });
- }
- return undefined;
+ function isTypeDerivedFrom(source, target) {
+ return source.flags & 1048576 ? ts.every(source.types, function (t) { return isTypeDerivedFrom(t, target); }) :
+ target.flags & 1048576 ? ts.some(target.types, function (t) { return isTypeDerivedFrom(source, t); }) :
+ source.flags & 58982400 ? isTypeDerivedFrom(getBaseConstraintOfType(source) || unknownType, target) :
+ target === globalObjectType ? !!(source.flags & (524288 | 67108864)) :
+ target === globalFunctionType ? !!(source.flags & 524288) && isFunctionObjectType(source) :
+ hasBaseType(source, getTargetType(target)) || (isArrayType(target) && !isReadonlyArrayType(target) && isTypeDerivedFrom(source, globalReadonlyArrayType));
}
- function isNeitherUnitTypeNorNever(type) {
- return !(type.flags & (109440 | 131072));
+ function isTypeComparableTo(source, target) {
+ return isTypeRelatedTo(source, target, comparableRelation);
}
- function isUnitType(type) {
- return !!(type.flags & 109440);
+ function areTypesComparable(type1, type2) {
+ return isTypeComparableTo(type1, type2) || isTypeComparableTo(type2, type1);
}
- function isLiteralType(type) {
- return type.flags & 16 ? true :
- type.flags & 1048576 ? type.flags & 1024 ? true : ts.every(type.types, isUnitType) :
- isUnitType(type);
+ function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain, errorOutputObject) {
+ return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain, errorOutputObject);
}
- function getBaseTypeOfLiteralType(type) {
- return type.flags & 1024 ? getBaseTypeOfEnumLiteralType(type) :
- type.flags & 128 ? stringType :
- type.flags & 256 ? numberType :
- type.flags & 2048 ? bigintType :
- type.flags & 512 ? booleanType :
- type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getBaseTypeOfLiteralType)) :
- type;
+ function checkTypeAssignableToAndOptionallyElaborate(source, target, errorNode, expr, headMessage, containingMessageChain) {
+ return checkTypeRelatedToAndOptionallyElaborate(source, target, assignableRelation, errorNode, expr, headMessage, containingMessageChain, undefined);
}
- function getWidenedLiteralType(type) {
- return type.flags & 1024 && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type) :
- type.flags & 128 && isFreshLiteralType(type) ? stringType :
- type.flags & 256 && isFreshLiteralType(type) ? numberType :
- type.flags & 2048 && isFreshLiteralType(type) ? bigintType :
- type.flags & 512 && isFreshLiteralType(type) ? booleanType :
- type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getWidenedLiteralType)) :
- type;
+ 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 getWidenedUniqueESSymbolType(type) {
- return type.flags & 8192 ? esSymbolType :
- type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getWidenedUniqueESSymbolType)) :
- type;
+ function isOrHasGenericConditional(type) {
+ return !!(type.flags & 16777216 || (type.flags & 2097152 && ts.some(type.types, isOrHasGenericConditional)));
}
- function getWidenedLiteralLikeTypeForContextualType(type, contextualType) {
- if (!isLiteralOfContextualType(type, contextualType)) {
- type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
+ function elaborateError(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) {
+ if (!node || isOrHasGenericConditional(target))
+ return false;
+ if (!checkTypeRelatedTo(source, target, relation, undefined)
+ && elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer)) {
+ return true;
}
- return type;
+ switch (node.kind) {
+ case 283:
+ case 207:
+ return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
+ case 216:
+ switch (node.operatorToken.kind) {
+ case 62:
+ case 27:
+ return elaborateError(node.right, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
+ }
+ break;
+ case 200:
+ return elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer);
+ case 199:
+ return elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer);
+ case 281:
+ return elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer);
+ case 209:
+ return elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer);
+ }
+ return false;
}
- function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
- if (type && isUnitType(type)) {
- var contextualType = !contextualSignatureReturnType ? undefined :
- isAsync ? getPromisedTypeOfPromise(contextualSignatureReturnType) :
- contextualSignatureReturnType;
- type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
+ function elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) {
+ var callSignatures = getSignaturesOfType(source, 0);
+ var constructSignatures = getSignaturesOfType(source, 1);
+ for (var _i = 0, _a = [constructSignatures, callSignatures]; _i < _a.length; _i++) {
+ var signatures = _a[_i];
+ if (ts.some(signatures, function (s) {
+ var returnType = getReturnTypeOfSignature(s);
+ return !(returnType.flags & (1 | 131072)) && checkTypeRelatedTo(returnType, target, relation, undefined);
+ })) {
+ var resultObj = errorOutputContainer || {};
+ checkTypeAssignableTo(source, target, node, headMessage, containingMessageChain, resultObj);
+ var diagnostic = resultObj.errors[resultObj.errors.length - 1];
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(node, signatures === constructSignatures ? ts.Diagnostics.Did_you_mean_to_use_new_with_this_expression : ts.Diagnostics.Did_you_mean_to_call_this_expression));
+ return true;
+ }
}
- return type;
+ return false;
}
- function getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(type, contextualSignatureReturnType, kind, isAsyncGenerator) {
- if (type && isUnitType(type)) {
- var contextualType = !contextualSignatureReturnType ? undefined :
- getIterationTypeOfGeneratorFunctionReturnType(kind, contextualSignatureReturnType, isAsyncGenerator);
- type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
+ function elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer) {
+ if (ts.isBlock(node.body)) {
+ return false;
}
- return type;
+ if (ts.some(node.parameters, ts.hasType)) {
+ return false;
+ }
+ var sourceSig = getSingleCallSignature(source);
+ if (!sourceSig) {
+ return false;
+ }
+ var targetSignatures = getSignaturesOfType(target, 0);
+ if (!ts.length(targetSignatures)) {
+ return false;
+ }
+ var returnExpression = node.body;
+ var sourceReturn = getReturnTypeOfSignature(sourceSig);
+ var targetReturn = getUnionType(ts.map(targetSignatures, getReturnTypeOfSignature));
+ if (!checkTypeRelatedTo(sourceReturn, targetReturn, relation, undefined)) {
+ var elaborated = returnExpression && elaborateError(returnExpression, sourceReturn, targetReturn, relation, undefined, containingMessageChain, errorOutputContainer);
+ if (elaborated) {
+ return elaborated;
+ }
+ var resultObj = errorOutputContainer || {};
+ checkTypeRelatedTo(sourceReturn, targetReturn, relation, returnExpression, undefined, containingMessageChain, resultObj);
+ if (resultObj.errors) {
+ if (target.symbol && ts.length(target.symbol.declarations)) {
+ ts.addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], ts.createDiagnosticForNode(target.symbol.declarations[0], ts.Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature));
+ }
+ if ((ts.getFunctionFlags(node) & 2) === 0
+ && !getTypeOfPropertyOfType(sourceReturn, "then")
+ && checkTypeRelatedTo(createPromiseType(sourceReturn), targetReturn, relation, undefined)) {
+ ts.addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], ts.createDiagnosticForNode(node, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async));
+ }
+ return true;
+ }
+ }
+ return false;
}
- function isTupleType(type) {
- return !!(ts.getObjectFlags(type) & 4 && type.target.objectFlags & 8);
+ function getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType) {
+ var idx = getIndexedAccessTypeOrUndefined(target, nameType);
+ if (idx) {
+ return idx;
+ }
+ if (target.flags & 1048576) {
+ var best = getBestMatchingType(source, target);
+ if (best) {
+ return getIndexedAccessTypeOrUndefined(best, nameType);
+ }
+ }
}
- function getRestTypeOfTupleType(type) {
- return type.target.hasRestElement ? getTypeArguments(type)[type.target.typeParameters.length - 1] : undefined;
+ function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
+ next.contextualType = sourcePropType;
+ try {
+ return checkExpressionForMutableLocation(next, 1, sourcePropType);
+ }
+ finally {
+ next.contextualType = undefined;
+ }
}
- function getRestArrayTypeOfTupleType(type) {
- var restType = getRestTypeOfTupleType(type);
- return restType && createArrayType(restType);
+ function elaborateElementwise(iterator, source, target, relation, containingMessageChain, errorOutputContainer) {
+ var reportedError = false;
+ for (var status = iterator.next(); !status.done; status = iterator.next()) {
+ var _a = status.value, prop = _a.errorNode, next = _a.innerExpression, nameType = _a.nameType, errorMessage = _a.errorMessage;
+ var targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType);
+ if (!targetPropType || targetPropType.flags & 8388608)
+ continue;
+ var sourcePropType = getIndexedAccessTypeOrUndefined(source, nameType);
+ if (sourcePropType && !checkTypeRelatedTo(sourcePropType, targetPropType, relation, undefined)) {
+ var elaborated = next && elaborateError(next, sourcePropType, targetPropType, relation, undefined, containingMessageChain, errorOutputContainer);
+ if (elaborated) {
+ reportedError = true;
+ }
+ else {
+ var resultObj = errorOutputContainer || {};
+ var specificSource = next ? checkExpressionForMutableLocationWithContextualType(next, sourcePropType) : sourcePropType;
+ var result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
+ if (result && specificSource !== sourcePropType) {
+ checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
+ }
+ if (resultObj.errors) {
+ var reportedDiag = resultObj.errors[resultObj.errors.length - 1];
+ var propertyName = isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined;
+ var targetProp = propertyName !== undefined ? getPropertyOfType(target, propertyName) : undefined;
+ var issuedElaboration = false;
+ if (!targetProp) {
+ var indexInfo = isTypeAssignableToKind(nameType, 296) && getIndexInfoOfType(target, 1) ||
+ getIndexInfoOfType(target, 0) ||
+ undefined;
+ if (indexInfo && indexInfo.declaration && !ts.getSourceFileOfNode(indexInfo.declaration).hasNoDefaultLib) {
+ issuedElaboration = true;
+ ts.addRelatedInfo(reportedDiag, ts.createDiagnosticForNode(indexInfo.declaration, ts.Diagnostics.The_expected_type_comes_from_this_index_signature));
+ }
+ }
+ if (!issuedElaboration && (targetProp && ts.length(targetProp.declarations) || target.symbol && ts.length(target.symbol.declarations))) {
+ var targetNode = targetProp && ts.length(targetProp.declarations) ? targetProp.declarations[0] : target.symbol.declarations[0];
+ if (!ts.getSourceFileOfNode(targetNode).hasNoDefaultLib) {
+ ts.addRelatedInfo(reportedDiag, ts.createDiagnosticForNode(targetNode, ts.Diagnostics.The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1, propertyName && !(nameType.flags & 8192) ? ts.unescapeLeadingUnderscores(propertyName) : typeToString(nameType), typeToString(target)));
+ }
+ }
+ }
+ reportedError = true;
+ }
+ }
+ }
+ return reportedError;
}
- function getLengthOfTupleType(type) {
- return getTypeReferenceArity(type) - (type.target.hasRestElement ? 1 : 0);
+ function generateJsxAttributes(node) {
+ var _i, _a, prop;
+ return __generator(this, function (_b) {
+ switch (_b.label) {
+ case 0:
+ if (!ts.length(node.properties))
+ return [2];
+ _i = 0, _a = node.properties;
+ _b.label = 1;
+ case 1:
+ if (!(_i < _a.length)) return [3, 4];
+ prop = _a[_i];
+ if (ts.isJsxSpreadAttribute(prop))
+ return [3, 3];
+ return [4, { errorNode: prop.name, innerExpression: prop.initializer, nameType: getLiteralType(ts.idText(prop.name)) }];
+ case 2:
+ _b.sent();
+ _b.label = 3;
+ case 3:
+ _i++;
+ return [3, 1];
+ case 4: return [2];
+ }
+ });
}
- function isZeroBigInt(_a) {
- var value = _a.value;
- return value.base10Value === "0";
+ function generateJsxChildren(node, getInvalidTextDiagnostic) {
+ var memberOffset, i, child, nameType, elem;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ if (!ts.length(node.children))
+ return [2];
+ memberOffset = 0;
+ i = 0;
+ _a.label = 1;
+ case 1:
+ if (!(i < node.children.length)) return [3, 5];
+ child = node.children[i];
+ nameType = getLiteralType(i - memberOffset);
+ elem = getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic);
+ if (!elem) return [3, 3];
+ return [4, elem];
+ case 2:
+ _a.sent();
+ return [3, 4];
+ case 3:
+ memberOffset++;
+ _a.label = 4;
+ case 4:
+ i++;
+ return [3, 1];
+ case 5: return [2];
+ }
+ });
}
- function getFalsyFlagsOfTypes(types) {
- var result = 0;
- for (var _i = 0, types_13 = types; _i < types_13.length; _i++) {
- var t = types_13[_i];
- result |= getFalsyFlags(t);
+ function getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic) {
+ switch (child.kind) {
+ case 283:
+ return { errorNode: child, innerExpression: child.expression, nameType: nameType };
+ case 11:
+ if (child.containsOnlyTriviaWhiteSpaces) {
+ break;
+ }
+ return { errorNode: child, innerExpression: undefined, nameType: nameType, errorMessage: getInvalidTextDiagnostic() };
+ case 273:
+ case 274:
+ case 277:
+ return { errorNode: child, innerExpression: child, nameType: nameType };
+ default:
+ return ts.Debug.assertNever(child, "Found invalid jsx child");
+ }
+ }
+ function elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer) {
+ var result = elaborateElementwise(generateJsxAttributes(node), source, target, relation, containingMessageChain, errorOutputContainer);
+ var invalidTextDiagnostic;
+ if (ts.isJsxOpeningElement(node.parent) && ts.isJsxElement(node.parent.parent)) {
+ var containingElement = node.parent.parent;
+ var childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
+ var childrenPropName = childPropName === undefined ? "children" : ts.unescapeLeadingUnderscores(childPropName);
+ var childrenNameType = getLiteralType(childrenPropName);
+ var childrenTargetType = getIndexedAccessType(target, childrenNameType);
+ var validChildren = ts.getSemanticJsxChildren(containingElement.children);
+ if (!ts.length(validChildren)) {
+ return result;
+ }
+ var moreThanOneRealChildren = ts.length(validChildren) > 1;
+ var arrayLikeTargetParts = filterType(childrenTargetType, isArrayOrTupleLikeType);
+ var nonArrayLikeTargetParts = filterType(childrenTargetType, function (t) { return !isArrayOrTupleLikeType(t); });
+ if (moreThanOneRealChildren) {
+ if (arrayLikeTargetParts !== neverType) {
+ var realSource = createTupleType(checkJsxChildren(containingElement, 0));
+ var children = generateJsxChildren(containingElement, getInvalidTextualChildDiagnostic);
+ result = elaborateElementwise(children, realSource, arrayLikeTargetParts, relation, containingMessageChain, errorOutputContainer) || result;
+ }
+ else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) {
+ result = true;
+ var diag = error(containingElement.openingElement.tagName, ts.Diagnostics.This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided, childrenPropName, typeToString(childrenTargetType));
+ if (errorOutputContainer && errorOutputContainer.skipLogging) {
+ (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
+ }
+ }
+ }
+ else {
+ if (nonArrayLikeTargetParts !== neverType) {
+ var child = validChildren[0];
+ var elem_1 = getElaborationElementForJsxChild(child, childrenNameType, getInvalidTextualChildDiagnostic);
+ if (elem_1) {
+ result = elaborateElementwise((function () { return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0: return [4, elem_1];
+ case 1:
+ _a.sent();
+ return [2];
+ }
+ }); })(), source, target, relation, containingMessageChain, errorOutputContainer) || result;
+ }
+ }
+ else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) {
+ result = true;
+ var diag = error(containingElement.openingElement.tagName, ts.Diagnostics.This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided, childrenPropName, typeToString(childrenTargetType));
+ if (errorOutputContainer && errorOutputContainer.skipLogging) {
+ (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
+ }
+ }
+ }
}
return result;
+ function getInvalidTextualChildDiagnostic() {
+ if (!invalidTextDiagnostic) {
+ var tagNameText = ts.getTextOfNode(node.parent.tagName);
+ var childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
+ var childrenPropName = childPropName === undefined ? "children" : ts.unescapeLeadingUnderscores(childPropName);
+ var childrenTargetType = getIndexedAccessType(target, getLiteralType(childrenPropName));
+ var diagnostic = ts.Diagnostics._0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2;
+ invalidTextDiagnostic = __assign(__assign({}, diagnostic), { key: "!!ALREADY FORMATTED!!", message: ts.formatMessage(undefined, diagnostic, tagNameText, childrenPropName, typeToString(childrenTargetType)) });
+ }
+ return invalidTextDiagnostic;
+ }
}
- function getFalsyFlags(type) {
- return type.flags & 1048576 ? getFalsyFlagsOfTypes(type.types) :
- type.flags & 128 ? type.value === "" ? 128 : 0 :
- type.flags & 256 ? type.value === 0 ? 256 : 0 :
- type.flags & 2048 ? isZeroBigInt(type) ? 2048 : 0 :
- type.flags & 512 ? (type === falseType || type === regularFalseType) ? 512 : 0 :
- type.flags & 117724;
- }
- function removeDefinitelyFalsyTypes(type) {
- return getFalsyFlags(type) & 117632 ?
- filterType(type, function (t) { return !(getFalsyFlags(t) & 117632); }) :
- type;
- }
- function extractDefinitelyFalsyTypes(type) {
- return mapType(type, getDefinitelyFalsyPartOfType);
- }
- function getDefinitelyFalsyPartOfType(type) {
- return type.flags & 4 ? emptyStringType :
- type.flags & 8 ? zeroType :
- type.flags & 64 ? zeroBigIntType :
- type === regularFalseType ||
- type === falseType ||
- type.flags & (16384 | 32768 | 65536) ||
- type.flags & 128 && type.value === "" ||
- type.flags & 256 && type.value === 0 ||
- type.flags & 2048 && isZeroBigInt(type) ? type :
- neverType;
- }
- function getNullableType(type, flags) {
- var missing = (flags & ~type.flags) & (32768 | 65536);
- return missing === 0 ? type :
- missing === 32768 ? getUnionType([type, undefinedType]) :
- missing === 65536 ? getUnionType([type, nullType]) :
- getUnionType([type, undefinedType, nullType]);
- }
- function getOptionalType(type) {
- ts.Debug.assert(strictNullChecks);
- return type.flags & 32768 ? type : getUnionType([type, undefinedType]);
+ function generateLimitedTupleElements(node, target) {
+ var len, i, elem, nameType;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ len = ts.length(node.elements);
+ if (!len)
+ return [2];
+ i = 0;
+ _a.label = 1;
+ case 1:
+ if (!(i < len)) return [3, 4];
+ if (isTupleLikeType(target) && !getPropertyOfType(target, ("" + i)))
+ return [3, 3];
+ elem = node.elements[i];
+ if (ts.isOmittedExpression(elem))
+ return [3, 3];
+ nameType = getLiteralType(i);
+ return [4, { errorNode: elem, innerExpression: elem, nameType: nameType }];
+ case 2:
+ _a.sent();
+ _a.label = 3;
+ case 3:
+ i++;
+ return [3, 1];
+ case 4: return [2];
+ }
+ });
}
- function getGlobalNonNullableTypeInstantiation(type) {
- if (!deferredGlobalNonNullableTypeAlias) {
- deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable", 524288, undefined) || unknownSymbol;
+ function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
+ if (target.flags & 131068)
+ return false;
+ if (isTupleLikeType(source)) {
+ return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
}
- if (deferredGlobalNonNullableTypeAlias !== unknownSymbol) {
- return getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]);
+ var oldContext = node.contextualType;
+ node.contextualType = target;
+ try {
+ var tupleizedType = checkArrayLiteral(node, 1, true);
+ node.contextualType = oldContext;
+ if (isTupleLikeType(tupleizedType)) {
+ return elaborateElementwise(generateLimitedTupleElements(node, target), tupleizedType, target, relation, containingMessageChain, errorOutputContainer);
+ }
+ return false;
+ }
+ finally {
+ node.contextualType = oldContext;
}
- return getTypeWithFacts(type, 2097152);
- }
- function getNonNullableType(type) {
- return strictNullChecks ? getGlobalNonNullableTypeInstantiation(type) : type;
- }
- function addOptionalTypeMarker(type) {
- return strictNullChecks ? getUnionType([type, optionalType]) : type;
- }
- function isNotOptionalTypeMarker(type) {
- return type !== optionalType;
}
- function removeOptionalTypeMarker(type) {
- return strictNullChecks ? filterType(type, isNotOptionalTypeMarker) : type;
+ function generateObjectLiteralElements(node) {
+ var _i, _a, prop, type, _b;
+ return __generator(this, function (_c) {
+ switch (_c.label) {
+ case 0:
+ if (!ts.length(node.properties))
+ return [2];
+ _i = 0, _a = node.properties;
+ _c.label = 1;
+ case 1:
+ if (!(_i < _a.length)) return [3, 8];
+ prop = _a[_i];
+ if (ts.isSpreadAssignment(prop))
+ return [3, 7];
+ type = getLiteralTypeFromProperty(getSymbolOfNode(prop), 8576);
+ if (!type || (type.flags & 131072)) {
+ return [3, 7];
+ }
+ _b = prop.kind;
+ switch (_b) {
+ case 168: return [3, 2];
+ case 167: return [3, 2];
+ case 165: return [3, 2];
+ case 289: return [3, 2];
+ case 288: return [3, 4];
+ }
+ return [3, 6];
+ case 2: return [4, { errorNode: prop.name, innerExpression: undefined, nameType: type }];
+ case 3:
+ _c.sent();
+ return [3, 7];
+ case 4: return [4, { errorNode: prop.name, innerExpression: prop.initializer, nameType: type, errorMessage: ts.isComputedNonLiteralName(prop.name) ? ts.Diagnostics.Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1 : undefined }];
+ case 5:
+ _c.sent();
+ return [3, 7];
+ case 6:
+ ts.Debug.assertNever(prop);
+ _c.label = 7;
+ case 7:
+ _i++;
+ return [3, 1];
+ case 8: return [2];
+ }
+ });
}
- function propagateOptionalTypeMarker(type, node, wasOptional) {
- return wasOptional ? ts.isOutermostOptionalChain(node) ? getOptionalType(type) : addOptionalTypeMarker(type) : type;
+ function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
+ if (target.flags & 131068)
+ return false;
+ return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
}
- function getOptionalExpressionType(exprType, expression) {
- return ts.isExpressionOfOptionalChainRoot(expression) ? getNonNullableType(exprType) :
- ts.isOptionalChain(expression) ? removeOptionalTypeMarker(exprType) :
- exprType;
+ function checkTypeComparableTo(source, target, errorNode, headMessage, containingMessageChain) {
+ return checkTypeRelatedTo(source, target, comparableRelation, errorNode, headMessage, containingMessageChain);
}
- function isCoercibleUnderDoubleEquals(source, target) {
- return ((source.flags & (8 | 4 | 512)) !== 0)
- && ((target.flags & (8 | 4 | 16)) !== 0);
+ function isSignatureAssignableTo(source, target, ignoreReturnTypes) {
+ return compareSignaturesRelated(source, target, ignoreReturnTypes ? 4 : 0, false, undefined, undefined, compareTypesAssignable, undefined) !== 0;
}
- function isObjectTypeWithInferableIndex(type) {
- return type.flags & 2097152 ? ts.every(type.types, isObjectTypeWithInferableIndex) :
- !!(type.symbol && (type.symbol.flags & (4096 | 2048 | 384 | 512)) !== 0 &&
- !typeHasCallOrConstructSignatures(type)) || !!(ts.getObjectFlags(type) & 2048 && isObjectTypeWithInferableIndex(type.source));
+ 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 createSymbolWithType(source, type) {
- var symbol = createSymbol(source.flags, source.escapedName, ts.getCheckFlags(source) & 8);
- symbol.declarations = source.declarations;
- symbol.parent = source.parent;
- symbol.type = type;
- symbol.target = source;
- if (source.valueDeclaration) {
- symbol.valueDeclaration = source.valueDeclaration;
+ function compareSignaturesRelated(source, target, checkMode, reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) {
+ if (source === target) {
+ return -1;
}
- var nameType = getSymbolLinks(source).nameType;
- if (nameType) {
- symbol.nameType = nameType;
+ if (isAnySignature(target)) {
+ return -1;
}
- return symbol;
- }
- function transformTypeOfMembers(type, f) {
- var members = ts.createSymbolTable();
- for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) {
- var property = _a[_i];
- var original = getTypeOfSymbol(property);
- var updated = f(original);
- members.set(property.escapedName, updated === original ? property : createSymbolWithType(property, updated));
+ var targetCount = getParameterCount(target);
+ var sourceHasMoreParameters = !hasEffectiveRestParameter(target) &&
+ (checkMode & 8 ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
+ if (sourceHasMoreParameters) {
+ return 0;
}
- return members;
- }
- function getRegularTypeOfObjectLiteral(type) {
- if (!(isObjectLiteralType(type) && ts.getObjectFlags(type) & 32768)) {
- return type;
+ if (source.typeParameters && source.typeParameters !== target.typeParameters) {
+ target = getCanonicalSignature(target);
+ source = instantiateSignatureInContextOf(source, target, undefined, compareTypes);
}
- var regularType = type.regularType;
- if (regularType) {
- return regularType;
+ var sourceCount = getParameterCount(source);
+ var sourceRestType = getNonArrayRestType(source);
+ var targetRestType = getNonArrayRestType(target);
+ if (sourceRestType || targetRestType) {
+ void instantiateType(sourceRestType || targetRestType, reportUnreliableMarkers);
}
- var resolved = type;
- var members = transformTypeOfMembers(type, getRegularTypeOfObjectLiteral);
- var regularNew = createAnonymousType(resolved.symbol, members, resolved.callSignatures, resolved.constructSignatures, resolved.stringIndexInfo, resolved.numberIndexInfo);
- regularNew.flags = resolved.flags;
- regularNew.objectFlags |= resolved.objectFlags & ~32768;
- type.regularType = regularNew;
- return regularNew;
- }
- function createWideningContext(parent, propertyName, siblings) {
- return { parent: parent, propertyName: propertyName, siblings: siblings, resolvedProperties: undefined };
- }
- function getSiblingsOfContext(context) {
- if (!context.siblings) {
- var siblings_1 = [];
- for (var _i = 0, _a = getSiblingsOfContext(context.parent); _i < _a.length; _i++) {
- var type = _a[_i];
- if (isObjectLiteralType(type)) {
- var prop = getPropertyOfObjectType(type, context.propertyName);
- if (prop) {
- forEachType(getTypeOfSymbol(prop), function (t) {
- siblings_1.push(t);
- });
- }
- }
- }
- context.siblings = siblings_1;
+ if (sourceRestType && targetRestType && sourceCount !== targetCount) {
+ return 0;
}
- return context.siblings;
- }
- function getPropertiesOfContext(context) {
- if (!context.resolvedProperties) {
- var names = ts.createMap();
- for (var _i = 0, _a = getSiblingsOfContext(context); _i < _a.length; _i++) {
- var t = _a[_i];
- if (isObjectLiteralType(t) && !(ts.getObjectFlags(t) & 1024)) {
- for (var _b = 0, _c = getPropertiesOfType(t); _b < _c.length; _b++) {
- var prop = _c[_b];
- names.set(prop.escapedName, prop);
+ var kind = target.declaration ? target.declaration.kind : 0;
+ var strictVariance = !(checkMode & 3) && strictFunctionTypes && kind !== 165 &&
+ kind !== 164 && kind !== 166;
+ var result = -1;
+ var sourceThisType = getThisTypeOfSignature(source);
+ if (sourceThisType && sourceThisType !== voidType) {
+ var targetThisType = getThisTypeOfSignature(target);
+ if (targetThisType) {
+ var related = !strictVariance && compareTypes(sourceThisType, targetThisType, false)
+ || compareTypes(targetThisType, sourceThisType, reportErrors);
+ if (!related) {
+ if (reportErrors) {
+ errorReporter(ts.Diagnostics.The_this_types_of_each_signature_are_incompatible);
}
+ return 0;
}
+ result &= related;
}
- context.resolvedProperties = ts.arrayFrom(names.values());
- }
- return context.resolvedProperties;
- }
- function getWidenedProperty(prop, context) {
- if (!(prop.flags & 4)) {
- return prop;
- }
- var original = getTypeOfSymbol(prop);
- var propContext = context && createWideningContext(context, prop.escapedName, undefined);
- var widened = getWidenedTypeWithContext(original, propContext);
- return widened === original ? prop : createSymbolWithType(prop, widened);
- }
- function getUndefinedProperty(prop) {
- var cached = undefinedProperties.get(prop.escapedName);
- if (cached) {
- return cached;
- }
- var result = createSymbolWithType(prop, undefinedType);
- result.flags |= 16777216;
- undefinedProperties.set(prop.escapedName, result);
- return result;
- }
- function getWidenedTypeOfObjectLiteral(type, context) {
- var members = ts.createSymbolTable();
- for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) {
- var prop = _a[_i];
- members.set(prop.escapedName, getWidenedProperty(prop, context));
}
- if (context) {
- for (var _b = 0, _c = getPropertiesOfContext(context); _b < _c.length; _b++) {
- var prop = _c[_b];
- if (!members.has(prop.escapedName)) {
- members.set(prop.escapedName, getUndefinedProperty(prop));
+ var paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount);
+ var restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
+ for (var i = 0; i < paramCount; i++) {
+ var sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
+ var targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
+ if (sourceType && targetType) {
+ var sourceSig = checkMode & 3 ? undefined : getSingleCallSignature(getNonNullableType(sourceType));
+ var targetSig = checkMode & 3 ? undefined : getSingleCallSignature(getNonNullableType(targetType));
+ var callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) &&
+ (getFalsyFlags(sourceType) & 98304) === (getFalsyFlags(targetType) & 98304);
+ var related = callbacks ?
+ compareSignaturesRelated(targetSig, sourceSig, (checkMode & 8) | (strictVariance ? 2 : 1), reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) :
+ !(checkMode & 3) && !strictVariance && compareTypes(sourceType, targetType, false) || compareTypes(targetType, sourceType, reportErrors);
+ if (related && checkMode & 8 && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes(sourceType, targetType, false)) {
+ related = 0;
+ }
+ if (!related) {
+ if (reportErrors) {
+ errorReporter(ts.Diagnostics.Types_of_parameters_0_and_1_are_incompatible, ts.unescapeLeadingUnderscores(getParameterNameAtPosition(source, i)), ts.unescapeLeadingUnderscores(getParameterNameAtPosition(target, i)));
+ }
+ return 0;
}
+ result &= related;
}
}
- var stringIndexInfo = getIndexInfoOfType(type, 0);
- var numberIndexInfo = getIndexInfoOfType(type, 1);
- var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly));
- result.objectFlags |= (ts.getObjectFlags(type) & (16384 | 2097152));
- return result;
- }
- function getWidenedType(type) {
- return getWidenedTypeWithContext(type, undefined);
- }
- function getWidenedTypeWithContext(type, context) {
- if (ts.getObjectFlags(type) & 1572864) {
- if (context === undefined && type.widened) {
- return type.widened;
- }
- var result = void 0;
- if (type.flags & (1 | 98304)) {
- result = anyType;
- }
- else if (isObjectLiteralType(type)) {
- result = getWidenedTypeOfObjectLiteral(type, context);
- }
- else if (type.flags & 1048576) {
- var unionContext_1 = context || createWideningContext(undefined, undefined, type.types);
- var widenedTypes = ts.sameMap(type.types, function (t) { return t.flags & 98304 ? t : getWidenedTypeWithContext(t, unionContext_1); });
- result = getUnionType(widenedTypes, ts.some(widenedTypes, isEmptyObjectType) ? 2 : 1);
- }
- else if (type.flags & 2097152) {
- result = getIntersectionType(ts.sameMap(type.types, getWidenedType));
- }
- else if (isArrayType(type) || isTupleType(type)) {
- result = createTypeReference(type.target, ts.sameMap(getTypeArguments(type), getWidenedType));
- }
- if (result && context === undefined) {
- type.widened = result;
+ if (!(checkMode & 4)) {
+ var targetReturnType = isResolvingReturnTypeOfSignature(target) ? anyType
+ : target.declaration && isJSConstructor(target.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(target.declaration.symbol))
+ : getReturnTypeOfSignature(target);
+ if (targetReturnType === voidType) {
+ return result;
}
- return result || type;
- }
- return type;
- }
- function reportWideningErrorsInType(type) {
- var errorReported = false;
- if (ts.getObjectFlags(type) & 524288) {
- if (type.flags & 1048576) {
- if (ts.some(type.types, isEmptyObjectType)) {
- errorReported = true;
+ var sourceReturnType = isResolvingReturnTypeOfSignature(source) ? anyType
+ : source.declaration && isJSConstructor(source.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(source.declaration.symbol))
+ : getReturnTypeOfSignature(source);
+ var targetTypePredicate = getTypePredicateOfSignature(target);
+ if (targetTypePredicate) {
+ var sourceTypePredicate = getTypePredicateOfSignature(source);
+ if (sourceTypePredicate) {
+ result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors, errorReporter, compareTypes);
}
- else {
- for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
- var t = _a[_i];
- if (reportWideningErrorsInType(t)) {
- errorReported = true;
- }
+ else if (ts.isIdentifierTypePredicate(targetTypePredicate)) {
+ if (reportErrors) {
+ errorReporter(ts.Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
}
+ return 0;
}
}
- if (isArrayType(type) || isTupleType(type)) {
- for (var _b = 0, _c = getTypeArguments(type); _b < _c.length; _b++) {
- var t = _c[_b];
- if (reportWideningErrorsInType(t)) {
- errorReported = true;
- }
+ else {
+ result &= checkMode & 1 && compareTypes(targetReturnType, sourceReturnType, false) ||
+ compareTypes(sourceReturnType, targetReturnType, reportErrors);
+ if (!result && reportErrors && incompatibleErrorReporter) {
+ incompatibleErrorReporter(sourceReturnType, targetReturnType);
}
}
- if (isObjectLiteralType(type)) {
- for (var _d = 0, _e = getPropertiesOfObjectType(type); _d < _e.length; _d++) {
- var p = _e[_d];
- var t = getTypeOfSymbol(p);
- if (ts.getObjectFlags(t) & 524288) {
- if (!reportWideningErrorsInType(t)) {
- error(p.valueDeclaration, ts.Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, symbolToString(p), typeToString(getWidenedType(t)));
- }
- errorReported = true;
- }
+ }
+ return result;
+ }
+ function compareTypePredicateRelatedTo(source, target, reportErrors, errorReporter, compareTypes) {
+ if (source.kind !== target.kind) {
+ if (reportErrors) {
+ errorReporter(ts.Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard);
+ errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
+ }
+ return 0;
+ }
+ if (source.kind === 1 || source.kind === 3) {
+ if (source.parameterIndex !== target.parameterIndex) {
+ if (reportErrors) {
+ errorReporter(ts.Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, source.parameterName, target.parameterName);
+ errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
}
+ return 0;
}
}
- return errorReported;
+ var related = source.type === target.type ? -1 :
+ source.type && target.type ? compareTypes(source.type, target.type, reportErrors) :
+ 0;
+ if (related === 0 && reportErrors) {
+ errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
+ }
+ return related;
}
- function reportImplicitAny(declaration, type, wideningKind) {
- var typeAsString = typeToString(getWidenedType(type));
- if (ts.isInJSFile(declaration) && !ts.isCheckJsEnabledForFile(ts.getSourceFileOfNode(declaration), compilerOptions)) {
- return;
+ function isImplementationCompatibleWithOverload(implementation, overload) {
+ var erasedSource = getErasedSignature(implementation);
+ var erasedTarget = getErasedSignature(overload);
+ var sourceReturnType = getReturnTypeOfSignature(erasedSource);
+ var targetReturnType = getReturnTypeOfSignature(erasedTarget);
+ if (targetReturnType === voidType
+ || isTypeRelatedTo(targetReturnType, sourceReturnType, assignableRelation)
+ || isTypeRelatedTo(sourceReturnType, targetReturnType, assignableRelation)) {
+ return isSignatureAssignableTo(erasedSource, erasedTarget, true);
}
- var diagnostic;
- switch (declaration.kind) {
- case 209:
- case 159:
- case 158:
- diagnostic = noImplicitAny ? ts.Diagnostics.Member_0_implicitly_has_an_1_type : ts.Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
- break;
- case 156:
- var param = declaration;
- if (ts.isIdentifier(param.name) &&
- (ts.isCallSignatureDeclaration(param.parent) || ts.isMethodSignature(param.parent) || ts.isFunctionTypeNode(param.parent)) &&
- param.parent.parameters.indexOf(param) > -1 &&
- (resolveName(param, param.name.escapedText, 788968, undefined, param.name.escapedText, true) ||
- param.name.originalKeywordKind && ts.isTypeNodeKind(param.name.originalKeywordKind))) {
- var newName = "arg" + param.parent.parameters.indexOf(param);
- errorOrSuggestion(noImplicitAny, declaration, ts.Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, ts.declarationNameToString(param.name));
- return;
- }
- diagnostic = declaration.dotDotDotToken ?
- noImplicitAny ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage :
- noImplicitAny ? ts.Diagnostics.Parameter_0_implicitly_has_an_1_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
- break;
- case 191:
- diagnostic = ts.Diagnostics.Binding_element_0_implicitly_has_an_1_type;
- if (!noImplicitAny) {
- return;
- }
- break;
- case 300:
- error(declaration, ts.Diagnostics.Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
- return;
- case 244:
- case 161:
- case 160:
- case 163:
- case 164:
- case 201:
- case 202:
- if (noImplicitAny && !declaration.name) {
- if (wideningKind === 3) {
- error(declaration, ts.Diagnostics.Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation, typeAsString);
+ return false;
+ }
+ function isEmptyResolvedType(t) {
+ return t !== anyFunctionType &&
+ t.properties.length === 0 &&
+ t.callSignatures.length === 0 &&
+ t.constructSignatures.length === 0 &&
+ !t.stringIndexInfo &&
+ !t.numberIndexInfo;
+ }
+ function isEmptyObjectType(type) {
+ return type.flags & 524288 ? !isGenericMappedType(type) && isEmptyResolvedType(resolveStructuredTypeMembers(type)) :
+ type.flags & 67108864 ? true :
+ type.flags & 1048576 ? ts.some(type.types, isEmptyObjectType) :
+ type.flags & 2097152 ? ts.every(type.types, isEmptyObjectType) :
+ false;
+ }
+ function isEmptyAnonymousObjectType(type) {
+ return !!(ts.getObjectFlags(type) & 16 && (type.members && isEmptyResolvedType(type) ||
+ type.symbol && type.symbol.flags & 2048 && getMembersOfSymbol(type.symbol).size === 0));
+ }
+ function isStringIndexSignatureOnlyType(type) {
+ return type.flags & 524288 && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfoOfType(type, 0) && !getIndexInfoOfType(type, 1) ||
+ type.flags & 3145728 && ts.every(type.types, isStringIndexSignatureOnlyType) ||
+ false;
+ }
+ function isEnumTypeRelatedTo(sourceSymbol, targetSymbol, errorReporter) {
+ if (sourceSymbol === targetSymbol) {
+ return true;
+ }
+ var id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol);
+ var entry = enumRelation.get(id);
+ if (entry !== undefined && !(!(entry & 4) && entry & 2 && errorReporter)) {
+ return !!(entry & 1);
+ }
+ if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256) || !(targetSymbol.flags & 256)) {
+ enumRelation.set(id, 2 | 4);
+ return false;
+ }
+ var targetEnumType = getTypeOfSymbol(targetSymbol);
+ for (var _i = 0, _a = getPropertiesOfType(getTypeOfSymbol(sourceSymbol)); _i < _a.length; _i++) {
+ var property = _a[_i];
+ if (property.flags & 8) {
+ var targetProperty = getPropertyOfType(targetEnumType, property.escapedName);
+ if (!targetProperty || !(targetProperty.flags & 8)) {
+ if (errorReporter) {
+ errorReporter(ts.Diagnostics.Property_0_is_missing_in_type_1, ts.symbolName(property), typeToString(getDeclaredTypeOfSymbol(targetSymbol), undefined, 64));
+ enumRelation.set(id, 2 | 4);
}
else {
- error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
+ enumRelation.set(id, 2);
}
- return;
- }
- diagnostic = !noImplicitAny ? ts.Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage :
- wideningKind === 3 ? ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type :
- ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type;
- break;
- case 186:
- if (noImplicitAny) {
- error(declaration, ts.Diagnostics.Mapped_object_type_implicitly_has_an_any_template_type);
+ return false;
}
- return;
- default:
- diagnostic = noImplicitAny ? ts.Diagnostics.Variable_0_implicitly_has_an_1_type : ts.Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
+ }
}
- errorOrSuggestion(noImplicitAny, declaration, diagnostic, ts.declarationNameToString(ts.getNameOfDeclaration(declaration)), typeAsString);
+ enumRelation.set(id, 1);
+ return true;
}
- function reportErrorsFromWidening(declaration, type, wideningKind) {
- if (produceDiagnostics && noImplicitAny && ts.getObjectFlags(type) & 524288 && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
- if (!reportWideningErrorsInType(type)) {
- reportImplicitAny(declaration, type, wideningKind);
- }
+ function isSimpleTypeRelatedTo(source, target, relation, errorReporter) {
+ var s = source.flags;
+ var t = target.flags;
+ if (t & 3 || s & 131072 || source === wildcardType)
+ return true;
+ if (t & 131072)
+ return false;
+ if (s & 402653316 && t & 4)
+ return true;
+ if (s & 128 && s & 1024 &&
+ t & 128 && !(t & 1024) &&
+ source.value === target.value)
+ return true;
+ if (s & 296 && t & 8)
+ return true;
+ if (s & 256 && s & 1024 &&
+ t & 256 && !(t & 1024) &&
+ source.value === target.value)
+ return true;
+ if (s & 2112 && t & 64)
+ return true;
+ if (s & 528 && t & 16)
+ return true;
+ if (s & 12288 && t & 4096)
+ return true;
+ if (s & 32 && t & 32 && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
+ return true;
+ if (s & 1024 && t & 1024) {
+ if (s & 1048576 && t & 1048576 && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
+ return true;
+ if (s & 2944 && t & 2944 &&
+ source.value === target.value &&
+ isEnumTypeRelatedTo(getParentOfSymbol(source.symbol), getParentOfSymbol(target.symbol), errorReporter))
+ return true;
+ }
+ if (s & 32768 && (!strictNullChecks || t & (32768 | 16384)))
+ return true;
+ if (s & 65536 && (!strictNullChecks || t & 65536))
+ return true;
+ if (s & 524288 && t & 67108864)
+ return true;
+ if (relation === assignableRelation || relation === comparableRelation) {
+ if (s & 1)
+ return true;
+ if (s & (8 | 256) && !(s & 1024) && (t & 32 || t & 256 && t & 1024))
+ return true;
}
+ return false;
}
- function applyToParameterTypes(source, target, callback) {
- var sourceCount = getParameterCount(source);
- var targetCount = getParameterCount(target);
- var sourceRestType = getEffectiveRestType(source);
- var targetRestType = getEffectiveRestType(target);
- var targetNonRestCount = targetRestType ? targetCount - 1 : targetCount;
- var paramCount = sourceRestType ? targetNonRestCount : Math.min(sourceCount, targetNonRestCount);
- var sourceThisType = getThisTypeOfSignature(source);
- if (sourceThisType) {
- var targetThisType = getThisTypeOfSignature(target);
- if (targetThisType) {
- callback(sourceThisType, targetThisType);
- }
+ function isTypeRelatedTo(source, target, relation) {
+ if (isFreshLiteralType(source)) {
+ source = source.regularType;
}
- for (var i = 0; i < paramCount; i++) {
- callback(getTypeAtPosition(source, i), getTypeAtPosition(target, i));
+ if (isFreshLiteralType(target)) {
+ target = target.regularType;
}
- if (targetRestType) {
- callback(getRestTypeAtPosition(source, paramCount), targetRestType);
+ if (source === target) {
+ return true;
}
- }
- function applyToReturnTypes(source, target, callback) {
- var sourceTypePredicate = getTypePredicateOfSignature(source);
- var targetTypePredicate = getTypePredicateOfSignature(target);
- if (sourceTypePredicate && targetTypePredicate && typePredicateKindsMatch(sourceTypePredicate, targetTypePredicate) && sourceTypePredicate.type && targetTypePredicate.type) {
- callback(sourceTypePredicate.type, targetTypePredicate.type);
+ if (relation !== identityRelation) {
+ if (relation === comparableRelation && !(target.flags & 131072) && isSimpleTypeRelatedTo(target, source, relation) || isSimpleTypeRelatedTo(source, target, relation)) {
+ return true;
+ }
}
else {
- callback(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
+ if (!(source.flags & 3145728) && !(target.flags & 3145728) &&
+ source.flags !== target.flags && !(source.flags & 469237760))
+ return false;
}
- }
- function createInferenceContext(typeParameters, signature, flags, compareTypes) {
- return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes || compareTypesAssignable);
- }
- function cloneInferenceContext(context, extraFlags) {
- if (extraFlags === void 0) { extraFlags = 0; }
- return context && createInferenceContextWorker(ts.map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
- }
- function createInferenceContextWorker(inferences, signature, flags, compareTypes) {
- var context = {
- inferences: inferences,
- signature: signature,
- flags: flags,
- compareTypes: compareTypes,
- mapper: makeFunctionTypeMapper(function (t) { return mapToInferredType(context, t, true); }),
- nonFixingMapper: makeFunctionTypeMapper(function (t) { return mapToInferredType(context, t, false); }),
- };
- return context;
- }
- function mapToInferredType(context, t, fix) {
- var inferences = context.inferences;
- for (var i = 0; i < inferences.length; i++) {
- var inference = inferences[i];
- if (t === inference.typeParameter) {
- if (fix && !inference.isFixed) {
- clearCachedInferences(inferences);
- inference.isFixed = true;
- }
- return getInferredType(context, i);
+ if (source.flags & 524288 && target.flags & 524288) {
+ var related = relation.get(getRelationKey(source, target, 0, relation));
+ if (related !== undefined) {
+ return !!(related & 1);
}
}
- return t;
- }
- function clearCachedInferences(inferences) {
- for (var _i = 0, inferences_1 = inferences; _i < inferences_1.length; _i++) {
- var inference = inferences_1[_i];
- if (!inference.isFixed) {
- inference.inferredType = undefined;
- }
+ if (source.flags & 469499904 || target.flags & 469499904) {
+ return checkTypeRelatedTo(source, target, relation, undefined);
}
+ return false;
}
- function createInferenceInfo(typeParameter) {
- return {
- typeParameter: typeParameter,
- candidates: undefined,
- contraCandidates: undefined,
- inferredType: undefined,
- priority: undefined,
- topLevel: true,
- isFixed: false
- };
- }
- 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
- };
- }
- function cloneInferredPartOfContext(context) {
- var inferences = ts.filter(context.inferences, hasInferenceCandidates);
- return inferences.length ?
- createInferenceContextWorker(ts.map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) :
- undefined;
+ function isIgnoredJsxProperty(source, sourceProp) {
+ return ts.getObjectFlags(source) & 4096 && !isUnhyphenatedJsxName(sourceProp.escapedName);
}
- function getMapperFromContext(context) {
- return context && context.mapper;
+ function getNormalizedType(type, writing) {
+ while (true) {
+ var t = isFreshLiteralType(type) ? type.regularType :
+ ts.getObjectFlags(type) & 4 && type.node ? createTypeReference(type.target, getTypeArguments(type)) :
+ type.flags & 3145728 ? getReducedType(type) :
+ type.flags & 33554432 ? writing ? type.baseType : type.substitute :
+ type.flags & 25165824 ? getSimplifiedType(type, writing) :
+ type;
+ if (t === type)
+ break;
+ type = t;
+ }
+ return type;
}
- function couldContainTypeVariables(type) {
- var objectFlags = ts.getObjectFlags(type);
- if (objectFlags & 67108864) {
- return !!(objectFlags & 134217728);
+ function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer) {
+ var errorInfo;
+ var relatedInfo;
+ var maybeKeys;
+ var sourceStack;
+ var targetStack;
+ var maybeCount = 0;
+ var depth = 0;
+ var expandingFlags = 0;
+ var overflow = false;
+ var overrideNextErrorInfo = 0;
+ var lastSkippedInfo;
+ var incompatibleStack = [];
+ var inPropertyCheck = false;
+ ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
+ var result = isRelatedTo(source, target, !!errorNode, headMessage);
+ if (incompatibleStack.length) {
+ reportIncompatibleStack();
}
- var result = !!(type.flags & 63176704 ||
- objectFlags & 4 && (type.node || ts.forEach(getTypeArguments(type), couldContainTypeVariables)) ||
- objectFlags & 16 && type.symbol && type.symbol.flags & (16 | 8192 | 32 | 2048 | 4096) && type.symbol.declarations ||
- objectFlags & (32 | 131072) ||
- type.flags & 3145728 && !(type.flags & 1024) && ts.some(type.types, couldContainTypeVariables));
- if (type.flags & 3899393) {
- type.objectFlags |= 67108864 | (result ? 134217728 : 0);
+ if (overflow) {
+ ts.tracing.instant("check", "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: depth });
+ var diag = error(errorNode || currentNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
+ if (errorOutputContainer) {
+ (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
+ }
}
- return result;
- }
- function isTypeParameterAtTopLevel(type, typeParameter) {
- return !!(type === typeParameter ||
- type.flags & 3145728 && ts.some(type.types, function (t) { return isTypeParameterAtTopLevel(t, typeParameter); }) ||
- type.flags & 16777216 && (isTypeParameterAtTopLevel(getTrueTypeFromConditionalType(type), typeParameter) ||
- isTypeParameterAtTopLevel(getFalseTypeFromConditionalType(type), typeParameter)));
- }
- function createEmptyObjectTypeFromStringLiteral(type) {
- var members = ts.createSymbolTable();
- forEachType(type, function (t) {
- if (!(t.flags & 128)) {
- return;
+ else if (errorInfo) {
+ if (containingMessageChain) {
+ var chain = containingMessageChain();
+ if (chain) {
+ ts.concatenateDiagnosticMessageChains(chain, errorInfo);
+ errorInfo = chain;
+ }
}
- var name = ts.escapeLeadingUnderscores(t.value);
- var literalProp = createSymbol(4, name);
- literalProp.type = anyType;
- if (t.symbol) {
- literalProp.declarations = t.symbol.declarations;
- literalProp.valueDeclaration = t.symbol.valueDeclaration;
+ var relatedInformation = void 0;
+ if (headMessage && errorNode && !result && source.symbol) {
+ var links = getSymbolLinks(source.symbol);
+ if (links.originatingImport && !ts.isImportCall(links.originatingImport)) {
+ var helpfulRetry = checkTypeRelatedTo(getTypeOfSymbol(links.target), target, relation, undefined);
+ if (helpfulRetry) {
+ var diag_1 = ts.createDiagnosticForNode(links.originatingImport, ts.Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead);
+ relatedInformation = ts.append(relatedInformation, diag_1);
+ }
+ }
+ }
+ var diag = ts.createDiagnosticForNodeFromMessageChain(errorNode, errorInfo, relatedInformation);
+ if (relatedInfo) {
+ ts.addRelatedInfo.apply(void 0, __spreadArrays([diag], relatedInfo));
+ }
+ if (errorOutputContainer) {
+ (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
+ }
+ if (!errorOutputContainer || !errorOutputContainer.skipLogging) {
+ diagnostics.add(diag);
}
- members.set(name, literalProp);
- });
- var indexInfo = type.flags & 4 ? createIndexInfo(emptyObjectType, false) : undefined;
- return createAnonymousType(undefined, members, ts.emptyArray, ts.emptyArray, indexInfo, undefined);
- }
- function inferTypeForHomomorphicMappedType(source, target, constraint) {
- var key = source.id + "," + target.id + "," + constraint.id;
- if (reverseMappedCache.has(key)) {
- return reverseMappedCache.get(key);
}
- reverseMappedCache.set(key, undefined);
- var type = createReverseMappedType(source, target, constraint);
- reverseMappedCache.set(key, type);
- return type;
- }
- function isPartiallyInferableType(type) {
- return !(ts.getObjectFlags(type) & 2097152) ||
- isObjectLiteralType(type) && ts.some(getPropertiesOfType(type), function (prop) { return isPartiallyInferableType(getTypeOfSymbol(prop)); });
- }
- function createReverseMappedType(source, target, constraint) {
- if (!(getIndexInfoOfType(source, 0) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) {
- return undefined;
+ if (errorNode && errorOutputContainer && errorOutputContainer.skipLogging && result === 0) {
+ ts.Debug.assert(!!errorOutputContainer.errors, "missed opportunity to interact with error.");
}
- if (isArrayType(source)) {
- return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source));
+ return result !== 0;
+ function resetErrorInfo(saved) {
+ errorInfo = saved.errorInfo;
+ lastSkippedInfo = saved.lastSkippedInfo;
+ incompatibleStack = saved.incompatibleStack;
+ overrideNextErrorInfo = saved.overrideNextErrorInfo;
+ relatedInfo = saved.relatedInfo;
}
- if (isTupleType(source)) {
- var elementTypes = ts.map(getTypeArguments(source), function (t) { return inferReverseMappedType(t, target, constraint); });
- var minLength = getMappedTypeModifiers(target) & 4 ?
- getTypeReferenceArity(source) - (source.target.hasRestElement ? 1 : 0) : source.target.minLength;
- return createTupleType(elementTypes, minLength, source.target.hasRestElement, source.target.readonly, source.target.associatedNames);
+ function captureErrorCalculationState() {
+ return {
+ errorInfo: errorInfo,
+ lastSkippedInfo: lastSkippedInfo,
+ incompatibleStack: incompatibleStack.slice(),
+ overrideNextErrorInfo: overrideNextErrorInfo,
+ relatedInfo: !relatedInfo ? undefined : relatedInfo.slice()
+ };
}
- var reversed = createObjectType(2048 | 16, undefined);
- reversed.source = source;
- reversed.mappedType = target;
- reversed.constraintType = constraint;
- return reversed;
- }
- function getTypeOfReverseMappedSymbol(symbol) {
- return inferReverseMappedType(symbol.propertyType, symbol.mappedType, symbol.constraintType);
- }
- function inferReverseMappedType(sourceType, target, constraint) {
- var typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
- var templateType = getTemplateTypeFromMappedType(target);
- var inference = createInferenceInfo(typeParameter);
- inferTypes([inference], sourceType, templateType);
- return getTypeFromInference(inference) || unknownType;
- }
- function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {
- var properties, _i, properties_2, targetProp, sourceProp, targetType, sourceType;
- return __generator(this, function (_a) {
- switch (_a.label) {
- case 0:
- properties = getPropertiesOfType(target);
- _i = 0, properties_2 = properties;
- _a.label = 1;
- case 1:
- if (!(_i < properties_2.length)) return [3, 6];
- targetProp = properties_2[_i];
- if (isStaticPrivateIdentifierProperty(targetProp)) {
- return [3, 5];
+ function reportIncompatibleError(message, arg0, arg1, arg2, arg3) {
+ overrideNextErrorInfo++;
+ lastSkippedInfo = undefined;
+ incompatibleStack.push([message, arg0, arg1, arg2, arg3]);
+ }
+ function reportIncompatibleStack() {
+ var stack = incompatibleStack;
+ incompatibleStack = [];
+ var info = lastSkippedInfo;
+ lastSkippedInfo = undefined;
+ if (stack.length === 1) {
+ reportError.apply(void 0, stack[0]);
+ if (info) {
+ reportRelationError.apply(void 0, __spreadArrays([undefined], info));
+ }
+ return;
+ }
+ var path = "";
+ var secondaryRootErrors = [];
+ while (stack.length) {
+ var _a = stack.pop(), msg = _a[0], args = _a.slice(1);
+ switch (msg.code) {
+ case ts.Diagnostics.Types_of_property_0_are_incompatible.code: {
+ if (path.indexOf("new ") === 0) {
+ path = "(" + path + ")";
+ }
+ var str = "" + args[0];
+ if (path.length === 0) {
+ path = "" + str;
+ }
+ else if (ts.isIdentifierText(str, compilerOptions.target)) {
+ path = path + "." + str;
+ }
+ else if (str[0] === "[" && str[str.length - 1] === "]") {
+ path = "" + path + str;
+ }
+ else {
+ path = path + "[" + str + "]";
+ }
+ break;
}
- if (!(requireOptionalProperties || !(targetProp.flags & 16777216 || ts.getCheckFlags(targetProp) & 48))) return [3, 5];
- sourceProp = getPropertyOfType(source, targetProp.escapedName);
- if (!!sourceProp) return [3, 3];
- return [4, targetProp];
- case 2:
- _a.sent();
- return [3, 5];
- case 3:
- if (!matchDiscriminantProperties) return [3, 5];
- targetType = getTypeOfSymbol(targetProp);
- if (!(targetType.flags & 109440)) return [3, 5];
- sourceType = getTypeOfSymbol(sourceProp);
- if (!!(sourceType.flags & 1 || getRegularTypeOfLiteralType(sourceType) === getRegularTypeOfLiteralType(targetType))) return [3, 5];
- return [4, targetProp];
- case 4:
- _a.sent();
- _a.label = 5;
- case 5:
- _i++;
- return [3, 1];
- case 6: return [2];
+ case ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible.code:
+ case ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code:
+ case ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code:
+ case ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: {
+ if (path.length === 0) {
+ var mappedMsg = msg;
+ if (msg.code === ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
+ mappedMsg = ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible;
+ }
+ else if (msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
+ mappedMsg = ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible;
+ }
+ secondaryRootErrors.unshift([mappedMsg, args[0], args[1]]);
+ }
+ else {
+ var prefix = (msg.code === ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code ||
+ msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code)
+ ? "new "
+ : "";
+ var params = (msg.code === ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ||
+ msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code)
+ ? ""
+ : "...";
+ path = "" + prefix + path + "(" + params + ")";
+ }
+ break;
+ }
+ default:
+ return ts.Debug.fail("Unhandled Diagnostic: " + msg.code);
+ }
}
- });
- }
- function getUnmatchedProperty(source, target, requireOptionalProperties, matchDiscriminantProperties) {
- var result = getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties).next();
- if (!result.done)
- return result.value;
- }
- function tupleTypesDefinitelyUnrelated(source, target) {
- return target.target.minLength > source.target.minLength ||
- !getRestTypeOfTupleType(target) && (!!getRestTypeOfTupleType(source) || getLengthOfTupleType(target) < getLengthOfTupleType(source));
- }
- function typesDefinitelyUnrelated(source, target) {
- return isTupleType(source) && isTupleType(target) && tupleTypesDefinitelyUnrelated(source, target) ||
- !!getUnmatchedProperty(source, target, false, true) &&
- !!getUnmatchedProperty(target, source, false, true);
- }
- function getTypeFromInference(inference) {
- return inference.candidates ? getUnionType(inference.candidates, 2) :
- inference.contraCandidates ? getIntersectionType(inference.contraCandidates) :
- undefined;
- }
- function hasSkipDirectInferenceFlag(node) {
- return !!getNodeLinks(node).skipDirectInference;
- }
- function isFromInferenceBlockedSource(type) {
- return !!(type.symbol && ts.some(type.symbol.declarations, hasSkipDirectInferenceFlag));
- }
- function inferTypes(inferences, originalSource, originalTarget, priority, contravariant) {
- if (priority === void 0) { priority = 0; }
- if (contravariant === void 0) { contravariant = false; }
- var symbolOrTypeStack;
- var visited;
- var bivariant = false;
- var propagationType;
- var inferencePriority = 512;
- var allowComplexConstraintInference = true;
- inferFromTypes(originalSource, originalTarget);
- function inferFromTypes(source, target) {
- if (!couldContainTypeVariables(target)) {
- return;
+ if (path) {
+ reportError(path[path.length - 1] === ")"
+ ? ts.Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types
+ : ts.Diagnostics.The_types_of_0_are_incompatible_between_these_types, path);
+ }
+ else {
+ secondaryRootErrors.shift();
+ }
+ for (var _i = 0, secondaryRootErrors_1 = secondaryRootErrors; _i < secondaryRootErrors_1.length; _i++) {
+ var _b = secondaryRootErrors_1[_i], msg = _b[0], args = _b.slice(1);
+ var originalValue = msg.elidedInCompatabilityPyramid;
+ msg.elidedInCompatabilityPyramid = false;
+ reportError.apply(void 0, __spreadArrays([msg], args));
+ msg.elidedInCompatabilityPyramid = originalValue;
+ }
+ if (info) {
+ reportRelationError.apply(void 0, __spreadArrays([undefined], info));
}
- if (source === wildcardType) {
- var savePropagationType = propagationType;
- propagationType = source;
- inferFromTypes(target, target);
- propagationType = savePropagationType;
+ }
+ function reportError(message, arg0, arg1, arg2, arg3) {
+ ts.Debug.assert(!!errorNode);
+ if (incompatibleStack.length)
+ reportIncompatibleStack();
+ if (message.elidedInCompatabilityPyramid)
return;
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2, arg3);
+ }
+ function associateRelatedInfo(info) {
+ ts.Debug.assert(!!errorInfo);
+ if (!relatedInfo) {
+ relatedInfo = [info];
}
- if (source.aliasSymbol && source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) {
- inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
- return;
+ else {
+ relatedInfo.push(info);
}
- if (source === target && source.flags & 3145728) {
- for (var _i = 0, _a = source.types; _i < _a.length; _i++) {
- var t = _a[_i];
- inferFromTypes(t, t);
- }
- return;
+ }
+ function reportRelationError(message, source, target) {
+ if (incompatibleStack.length)
+ reportIncompatibleStack();
+ var _a = getTypeNamesForErrorDisplay(source, target), sourceType = _a[0], targetType = _a[1];
+ var generalizedSource = source;
+ var generalizedSourceType = sourceType;
+ if (isLiteralType(source) && !typeCouldHaveTopLevelSingletonTypes(target)) {
+ generalizedSource = getBaseTypeOfLiteralType(source);
+ ts.Debug.assert(!isTypeAssignableTo(generalizedSource, target), "generalized source shouldn't be assignable");
+ generalizedSourceType = getTypeNameForErrorDisplay(generalizedSource);
}
- if (target.flags & 1048576) {
- var _b = inferFromMatchingTypes(source.flags & 1048576 ? source.types : [source], target.types, isTypeOrBaseIdenticalTo), tempSources = _b[0], tempTargets = _b[1];
- var _c = inferFromMatchingTypes(tempSources, tempTargets, isTypeCloselyMatchedBy), sources = _c[0], targets = _c[1];
- if (targets.length === 0) {
- return;
- }
- target = getUnionType(targets);
- if (sources.length === 0) {
- inferWithPriority(source, target, 1);
- return;
+ if (target.flags & 262144) {
+ var constraint = getBaseConstraintOfType(target);
+ var needsOriginalSource = void 0;
+ if (constraint && (isTypeAssignableTo(generalizedSource, constraint) || (needsOriginalSource = isTypeAssignableTo(source, constraint)))) {
+ reportError(ts.Diagnostics._0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2, needsOriginalSource ? sourceType : generalizedSourceType, targetType, typeToString(constraint));
}
- source = getUnionType(sources);
- }
- else if (target.flags & 2097152 && ts.some(target.types, function (t) { return !!getInferenceInfoForType(t) || (isGenericMappedType(t) && !!getInferenceInfoForType(getHomomorphicTypeVariable(t) || neverType)); })) {
- if (!(source.flags & 1048576)) {
- var _d = inferFromMatchingTypes(source.flags & 2097152 ? source.types : [source], target.types, isTypeIdenticalTo), sources = _d[0], targets = _d[1];
- if (sources.length === 0 || targets.length === 0) {
- return;
- }
- source = getIntersectionType(sources);
- target = getIntersectionType(targets);
+ else {
+ reportError(ts.Diagnostics._0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1, targetType, generalizedSourceType);
}
}
- else if (target.flags & (8388608 | 33554432)) {
- target = getActualTypeVariable(target);
- }
- if (target.flags & 8650752) {
- if (ts.getObjectFlags(source) & 2097152 || source === nonInferrableAnyType || source === silentNeverType ||
- (priority & 32 && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
- return;
+ if (!message) {
+ if (relation === comparableRelation) {
+ message = ts.Diagnostics.Type_0_is_not_comparable_to_type_1;
}
- var inference = getInferenceInfoForType(target);
- if (inference) {
- if (!inference.isFixed) {
- if (inference.priority === undefined || priority < inference.priority) {
- inference.candidates = undefined;
- inference.contraCandidates = undefined;
- inference.topLevel = true;
- inference.priority = priority;
- }
- if (priority === inference.priority) {
- var candidate = propagationType || source;
- if (contravariant && !bivariant) {
- if (!ts.contains(inference.contraCandidates, candidate)) {
- inference.contraCandidates = ts.append(inference.contraCandidates, candidate);
- clearCachedInferences(inferences);
- }
- }
- else if (!ts.contains(inference.candidates, candidate)) {
- inference.candidates = ts.append(inference.candidates, candidate);
- clearCachedInferences(inferences);
- }
- }
- if (!(priority & 32) && target.flags & 262144 && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) {
- inference.topLevel = false;
- clearCachedInferences(inferences);
- }
- }
- inferencePriority = Math.min(inferencePriority, priority);
- return;
+ else if (sourceType === targetType) {
+ message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated;
}
else {
- var simplified = getSimplifiedType(target, false);
- if (simplified !== target) {
- invokeOnce(source, simplified, inferFromTypes);
- }
- else if (target.flags & 8388608) {
- var indexType = getSimplifiedType(target.indexType, false);
- if (indexType.flags & 63176704) {
- var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, false), indexType, false);
- if (simplified_1 && simplified_1 !== target) {
- invokeOnce(source, simplified_1, inferFromTypes);
- }
- }
+ message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1;
+ }
+ }
+ reportError(message, generalizedSourceType, targetType);
+ }
+ function tryElaborateErrorsForPrimitivesAndObjects(source, target) {
+ var sourceType = symbolValueDeclarationIsContextSensitive(source.symbol) ? typeToString(source, source.symbol.valueDeclaration) : typeToString(source);
+ var targetType = symbolValueDeclarationIsContextSensitive(target.symbol) ? typeToString(target, target.symbol.valueDeclaration) : typeToString(target);
+ if ((globalStringType === source && stringType === target) ||
+ (globalNumberType === source && numberType === target) ||
+ (globalBooleanType === source && booleanType === target) ||
+ (getGlobalESSymbolType(false) === source && esSymbolType === target)) {
+ reportError(ts.Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType);
+ }
+ }
+ function tryElaborateArrayLikeErrors(source, target, reportErrors) {
+ if (isTupleType(source)) {
+ if (source.target.readonly && isMutableArrayOrTuple(target)) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source), typeToString(target));
}
+ return false;
}
+ return isTupleType(target) || isArrayType(target);
}
- if (ts.getObjectFlags(source) & 4 && ts.getObjectFlags(target) & 4 && (source.target === target.target || isArrayType(source) && isArrayType(target)) &&
- !(source.node && target.node)) {
- inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
+ if (isReadonlyArrayType(source) && isMutableArrayOrTuple(target)) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source), typeToString(target));
+ }
+ return false;
}
- else if (source.flags & 4194304 && target.flags & 4194304) {
- contravariant = !contravariant;
- inferFromTypes(source.type, target.type);
- contravariant = !contravariant;
+ if (isTupleType(target)) {
+ return isArrayType(source);
}
- else if ((isLiteralType(source) || source.flags & 4) && target.flags & 4194304) {
- var empty = createEmptyObjectTypeFromStringLiteral(source);
- contravariant = !contravariant;
- inferWithPriority(empty, target.type, 64);
- contravariant = !contravariant;
+ return true;
+ }
+ function isRelatedTo(originalSource, originalTarget, reportErrors, headMessage, intersectionState) {
+ if (reportErrors === void 0) { reportErrors = false; }
+ if (intersectionState === void 0) { intersectionState = 0; }
+ if (originalSource.flags & 524288 && originalTarget.flags & 131068) {
+ if (isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors ? reportError : undefined)) {
+ return -1;
+ }
+ reportErrorResults(originalSource, originalTarget, 0, !!(ts.getObjectFlags(originalSource) & 4096));
+ return 0;
}
- else if (source.flags & 8388608 && target.flags & 8388608) {
- inferFromTypes(source.objectType, target.objectType);
- inferFromTypes(source.indexType, target.indexType);
+ var source = getNormalizedType(originalSource, false);
+ var target = getNormalizedType(originalTarget, true);
+ if (source === target)
+ return -1;
+ if (relation === identityRelation) {
+ return isIdenticalTo(source, target);
}
- else if (source.flags & 16777216 && target.flags & 16777216) {
- inferFromTypes(source.checkType, target.checkType);
- inferFromTypes(source.extendsType, target.extendsType);
- inferFromTypes(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target));
- inferFromTypes(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target));
+ if (source.flags & 262144 && getConstraintOfType(source) === target) {
+ return -1;
}
- else if (target.flags & 16777216) {
- var savePriority = priority;
- priority |= contravariant ? 16 : 0;
- var targetTypes = [getTrueTypeFromConditionalType(target), getFalseTypeFromConditionalType(target)];
- inferToMultipleTypes(source, targetTypes, target.flags);
- priority = savePriority;
+ if (target.flags & 1048576 && source.flags & 524288 &&
+ target.types.length <= 3 && maybeTypeOfKind(target, 98304)) {
+ var nullStrippedTarget = extractTypesOfKind(target, ~98304);
+ if (!(nullStrippedTarget.flags & (1048576 | 131072))) {
+ if (source === nullStrippedTarget)
+ return -1;
+ target = nullStrippedTarget;
+ }
}
- else if (target.flags & 3145728) {
- inferToMultipleTypes(source, target.types, target.flags);
+ if (relation === comparableRelation && !(target.flags & 131072) && isSimpleTypeRelatedTo(target, source, relation) ||
+ isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined))
+ return -1;
+ var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 4096);
+ var isPerformingExcessPropertyChecks = !(intersectionState & 2) && (isObjectLiteralType(source) && ts.getObjectFlags(source) & 32768);
+ if (isPerformingExcessPropertyChecks) {
+ if (hasExcessProperties(source, target, reportErrors)) {
+ if (reportErrors) {
+ reportRelationError(headMessage, source, target);
+ }
+ return 0;
+ }
}
- else if (source.flags & 1048576) {
- var sourceTypes = source.types;
- for (var _e = 0, sourceTypes_2 = sourceTypes; _e < sourceTypes_2.length; _e++) {
- var sourceType = sourceTypes_2[_e];
- inferFromTypes(sourceType, target);
+ var isPerformingCommonPropertyChecks = relation !== comparableRelation && !(intersectionState & 2) &&
+ source.flags & (131068 | 524288 | 2097152) && source !== globalObjectType &&
+ target.flags & (524288 | 2097152) && isWeakType(target) &&
+ (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source));
+ if (isPerformingCommonPropertyChecks && !hasCommonProperties(source, target, isComparingJsxAttributes)) {
+ if (reportErrors) {
+ var calls = getSignaturesOfType(source, 0);
+ var constructs = getSignaturesOfType(source, 1);
+ if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, false) ||
+ constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, false)) {
+ reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, typeToString(source), typeToString(target));
+ }
+ else {
+ reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, typeToString(source), typeToString(target));
+ }
}
+ return 0;
+ }
+ var result = 0;
+ var saveErrorInfo = captureErrorCalculationState();
+ if (source.flags & 1048576) {
+ result = relation === comparableRelation ?
+ someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068), intersectionState) :
+ eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068), intersectionState);
}
else {
- source = getReducedType(source);
- if (!(priority & 128 && source.flags & (2097152 | 63176704))) {
- var apparentSource = getApparentType(source);
- if (apparentSource !== source && allowComplexConstraintInference && !(apparentSource.flags & (524288 | 2097152))) {
- allowComplexConstraintInference = false;
- return inferFromTypes(apparentSource, target);
+ if (target.flags & 1048576) {
+ result = typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068) && !(target.flags & 131068));
+ }
+ else if (target.flags & 2097152) {
+ result = typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2);
+ }
+ else if (source.flags & 2097152) {
+ result = someTypeRelatedToType(source, target, false, 1);
+ }
+ if (!result && (source.flags & 469499904 || target.flags & 469499904)) {
+ if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState)) {
+ resetErrorInfo(saveErrorInfo);
}
- source = apparentSource;
}
- if (source.flags & (524288 | 2097152)) {
- invokeOnce(source, target, inferFromObjectTypes);
+ }
+ if (!result && source.flags & (2097152 | 262144)) {
+ var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 ? source.types : [source], !!(target.flags & 1048576));
+ if (constraint && (source.flags & 2097152 || target.flags & 1048576)) {
+ if (everyType(constraint, function (c) { return c !== source; })) {
+ if (result = isRelatedTo(constraint, target, false, undefined, intersectionState)) {
+ resetErrorInfo(saveErrorInfo);
+ }
+ }
}
}
- if (source.flags & 25165824) {
- var simplified = getSimplifiedType(source, contravariant);
- if (simplified !== source) {
- inferFromTypes(simplified, target);
+ if (result && !inPropertyCheck && (target.flags & 2097152 && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
+ isNonGenericObjectType(target) && !isArrayType(target) && !isTupleType(target) && source.flags & 2097152 && getApparentType(source).flags & 3670016 && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 2097152); }))) {
+ inPropertyCheck = true;
+ result &= recursiveTypeRelatedTo(source, target, reportErrors, 4);
+ inPropertyCheck = false;
+ }
+ reportErrorResults(source, target, result, isComparingJsxAttributes);
+ return result;
+ function reportErrorResults(source, target, result, isComparingJsxAttributes) {
+ if (!result && reportErrors) {
+ source = originalSource.aliasSymbol ? originalSource : source;
+ target = originalTarget.aliasSymbol ? originalTarget : target;
+ var maybeSuppress = overrideNextErrorInfo > 0;
+ if (maybeSuppress) {
+ overrideNextErrorInfo--;
+ }
+ if (source.flags & 524288 && target.flags & 524288) {
+ var currentError = errorInfo;
+ tryElaborateArrayLikeErrors(source, target, reportErrors);
+ if (errorInfo !== currentError) {
+ maybeSuppress = !!errorInfo;
+ }
+ }
+ if (source.flags & 524288 && target.flags & 131068) {
+ tryElaborateErrorsForPrimitivesAndObjects(source, target);
+ }
+ else if (source.symbol && source.flags & 524288 && globalObjectType === source) {
+ reportError(ts.Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
+ }
+ else if (isComparingJsxAttributes && target.flags & 2097152) {
+ var targetTypes = target.types;
+ var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
+ var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
+ if (intrinsicAttributes !== errorType && intrinsicClassAttributes !== errorType &&
+ (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) {
+ return result;
+ }
+ }
+ else {
+ errorInfo = elaborateNeverIntersection(errorInfo, originalTarget);
+ }
+ if (!headMessage && maybeSuppress) {
+ lastSkippedInfo = [source, target];
+ return result;
+ }
+ reportRelationError(headMessage, source, target);
}
}
}
- function inferWithPriority(source, target, newPriority) {
- var savePriority = priority;
- priority |= newPriority;
- inferFromTypes(source, target);
- priority = savePriority;
- }
- function invokeOnce(source, target, action) {
- var key = source.id + "," + target.id;
- var status = visited && visited.get(key);
- if (status !== undefined) {
- inferencePriority = Math.min(inferencePriority, status);
- return;
+ function isIdenticalTo(source, target) {
+ var flags = source.flags & target.flags;
+ if (!(flags & 469237760)) {
+ return 0;
}
- (visited || (visited = ts.createMap())).set(key, -1);
- var saveInferencePriority = inferencePriority;
- inferencePriority = 512;
- action(source, target);
- visited.set(key, inferencePriority);
- inferencePriority = Math.min(inferencePriority, saveInferencePriority);
+ if (flags & 3145728) {
+ var result_6 = eachTypeRelatedToSomeType(source, target);
+ if (result_6) {
+ result_6 &= eachTypeRelatedToSomeType(target, source);
+ }
+ return result_6;
+ }
+ return recursiveTypeRelatedTo(source, target, false, 0);
}
- function inferFromMatchingTypes(sources, targets, matches) {
- var matchedSources;
- var matchedTargets;
- for (var _i = 0, targets_1 = targets; _i < targets_1.length; _i++) {
- var t = targets_1[_i];
- for (var _a = 0, sources_1 = sources; _a < sources_1.length; _a++) {
- var s = sources_1[_a];
- if (matches(s, t)) {
- inferFromTypes(s, t);
- matchedSources = ts.appendIfUnique(matchedSources, s);
- matchedTargets = ts.appendIfUnique(matchedTargets, t);
+ function getTypeOfPropertyInTypes(types, name) {
+ var appendPropType = function (propTypes, type) {
+ type = getApparentType(type);
+ var prop = type.flags & 3145728 ? getPropertyOfUnionOrIntersectionType(type, name) : getPropertyOfObjectType(type, name);
+ var propType = prop && getTypeOfSymbol(prop) || isNumericLiteralName(name) && getIndexTypeOfType(type, 1) || getIndexTypeOfType(type, 0) || undefinedType;
+ return ts.append(propTypes, propType);
+ };
+ return getUnionType(ts.reduceLeft(types, appendPropType, undefined) || ts.emptyArray);
+ }
+ function hasExcessProperties(source, target, reportErrors) {
+ if (!isExcessPropertyCheckTarget(target) || !noImplicitAny && ts.getObjectFlags(target) & 16384) {
+ return false;
+ }
+ var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 4096);
+ if ((relation === assignableRelation || relation === comparableRelation) &&
+ (isTypeSubsetOf(globalObjectType, target) || (!isComparingJsxAttributes && isEmptyObjectType(target)))) {
+ return false;
+ }
+ var reducedTarget = target;
+ var checkTypes;
+ if (target.flags & 1048576) {
+ reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target);
+ checkTypes = reducedTarget.flags & 1048576 ? reducedTarget.types : [reducedTarget];
+ }
+ var _loop_16 = function (prop) {
+ if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) {
+ if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
+ if (reportErrors) {
+ var errorTarget = filterType(reducedTarget, isExcessPropertyCheckTarget);
+ if (!errorNode)
+ return { value: ts.Debug.fail() };
+ if (ts.isJsxAttributes(errorNode) || ts.isJsxOpeningLikeElement(errorNode) || ts.isJsxOpeningLikeElement(errorNode.parent)) {
+ if (prop.valueDeclaration && ts.isJsxAttribute(prop.valueDeclaration) && ts.getSourceFileOfNode(errorNode) === ts.getSourceFileOfNode(prop.valueDeclaration.name)) {
+ errorNode = prop.valueDeclaration.name;
+ }
+ var propName = symbolToString(prop);
+ var suggestionSymbol = getSuggestedSymbolForNonexistentJSXAttribute(propName, errorTarget);
+ var suggestion = suggestionSymbol ? symbolToString(suggestionSymbol) : undefined;
+ if (suggestion) {
+ reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(errorTarget), suggestion);
+ }
+ else {
+ reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1, propName, typeToString(errorTarget));
+ }
+ }
+ else {
+ var objectLiteralDeclaration_1 = source.symbol && ts.firstOrUndefined(source.symbol.declarations);
+ var suggestion = void 0;
+ if (prop.valueDeclaration && ts.findAncestor(prop.valueDeclaration, function (d) { return d === objectLiteralDeclaration_1; }) && ts.getSourceFileOfNode(objectLiteralDeclaration_1) === ts.getSourceFileOfNode(errorNode)) {
+ var propDeclaration = prop.valueDeclaration;
+ ts.Debug.assertNode(propDeclaration, ts.isObjectLiteralElementLike);
+ errorNode = propDeclaration;
+ var name = propDeclaration.name;
+ if (ts.isIdentifier(name)) {
+ suggestion = getSuggestionForNonexistentProperty(name, errorTarget);
+ }
+ }
+ if (suggestion !== undefined) {
+ reportError(ts.Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2, symbolToString(prop), typeToString(errorTarget), suggestion);
+ }
+ else {
+ reportError(ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(errorTarget));
+ }
+ }
+ }
+ return { value: true };
+ }
+ if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), reportErrors)) {
+ if (reportErrors) {
+ reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(prop));
+ }
+ return { value: true };
}
}
+ };
+ for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) {
+ var prop = _a[_i];
+ var state_5 = _loop_16(prop);
+ if (typeof state_5 === "object")
+ return state_5.value;
}
- return [
- matchedSources ? ts.filter(sources, function (t) { return !ts.contains(matchedSources, t); }) : sources,
- matchedTargets ? ts.filter(targets, function (t) { return !ts.contains(matchedTargets, t); }) : targets,
- ];
+ return false;
}
- function inferFromTypeArguments(sourceTypes, targetTypes, variances) {
- var count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length;
- for (var i = 0; i < count; i++) {
- if (i < variances.length && (variances[i] & 7) === 2) {
- inferFromContravariantTypes(sourceTypes[i], targetTypes[i]);
- }
- else {
- inferFromTypes(sourceTypes[i], targetTypes[i]);
+ function shouldCheckAsExcessProperty(prop, container) {
+ return prop.valueDeclaration && container.valueDeclaration && prop.valueDeclaration.parent === container.valueDeclaration;
+ }
+ function eachTypeRelatedToSomeType(source, target) {
+ var result = -1;
+ var sourceTypes = source.types;
+ for (var _i = 0, sourceTypes_1 = sourceTypes; _i < sourceTypes_1.length; _i++) {
+ var sourceType = sourceTypes_1[_i];
+ var related = typeRelatedToSomeType(sourceType, target, false);
+ if (!related) {
+ return 0;
}
+ result &= related;
}
+ return result;
}
- function inferFromContravariantTypes(source, target) {
- if (strictFunctionTypes || priority & 256) {
- contravariant = !contravariant;
- inferFromTypes(source, target);
- contravariant = !contravariant;
- }
- else {
- inferFromTypes(source, target);
+ function typeRelatedToSomeType(source, target, reportErrors) {
+ var targetTypes = target.types;
+ if (target.flags & 1048576 && containsType(targetTypes, source)) {
+ return -1;
}
- }
- function getInferenceInfoForType(type) {
- if (type.flags & 8650752) {
- for (var _i = 0, inferences_2 = inferences; _i < inferences_2.length; _i++) {
- var inference = inferences_2[_i];
- if (type === inference.typeParameter) {
- return inference;
- }
+ for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) {
+ var type = targetTypes_1[_i];
+ var related = isRelatedTo(source, type, false);
+ if (related) {
+ return related;
}
}
- return undefined;
+ if (reportErrors) {
+ var bestMatchingType = getBestMatchingType(source, target, isRelatedTo);
+ isRelatedTo(source, bestMatchingType || targetTypes[targetTypes.length - 1], true);
+ }
+ return 0;
}
- function getSingleTypeVariableFromIntersectionTypes(types) {
- var typeVariable;
- for (var _i = 0, types_14 = types; _i < types_14.length; _i++) {
- var type = types_14[_i];
- var t = type.flags & 2097152 && ts.find(type.types, function (t) { return !!getInferenceInfoForType(t); });
- if (!t || typeVariable && t !== typeVariable) {
- return undefined;
+ function typeRelatedToEachType(source, target, reportErrors, intersectionState) {
+ var result = -1;
+ var targetTypes = target.types;
+ for (var _i = 0, targetTypes_2 = targetTypes; _i < targetTypes_2.length; _i++) {
+ var targetType = targetTypes_2[_i];
+ var related = isRelatedTo(source, targetType, reportErrors, undefined, intersectionState);
+ if (!related) {
+ return 0;
}
- typeVariable = t;
+ result &= related;
}
- return typeVariable;
+ return result;
}
- function inferToMultipleTypes(source, targets, targetFlags) {
- var typeVariableCount = 0;
- if (targetFlags & 1048576) {
- var nakedTypeVariable = void 0;
- var sources = source.flags & 1048576 ? source.types : [source];
- var matched_1 = new Array(sources.length);
- var inferenceCircularity = false;
- for (var _i = 0, targets_2 = targets; _i < targets_2.length; _i++) {
- var t = targets_2[_i];
- if (getInferenceInfoForType(t)) {
- nakedTypeVariable = t;
- typeVariableCount++;
- }
- else {
- for (var i = 0; i < sources.length; i++) {
- var saveInferencePriority = inferencePriority;
- inferencePriority = 512;
- inferFromTypes(sources[i], t);
- if (inferencePriority === priority)
- matched_1[i] = true;
- inferenceCircularity = inferenceCircularity || inferencePriority === -1;
- inferencePriority = Math.min(inferencePriority, saveInferencePriority);
- }
- }
+ function someTypeRelatedToType(source, target, reportErrors, intersectionState) {
+ var sourceTypes = source.types;
+ if (source.flags & 1048576 && containsType(sourceTypes, target)) {
+ return -1;
+ }
+ var len = sourceTypes.length;
+ for (var i = 0; i < len; i++) {
+ var related = isRelatedTo(sourceTypes[i], target, reportErrors && i === len - 1, undefined, intersectionState);
+ if (related) {
+ return related;
}
- if (typeVariableCount === 0) {
- var intersectionTypeVariable = getSingleTypeVariableFromIntersectionTypes(targets);
- if (intersectionTypeVariable) {
- inferWithPriority(source, intersectionTypeVariable, 1);
+ }
+ return 0;
+ }
+ function eachTypeRelatedToType(source, target, reportErrors, intersectionState) {
+ var result = -1;
+ var sourceTypes = source.types;
+ for (var i = 0; i < sourceTypes.length; i++) {
+ var sourceType = sourceTypes[i];
+ if (target.flags & 1048576 && target.types.length === sourceTypes.length) {
+ var related_1 = isRelatedTo(sourceType, target.types[i], false, undefined, intersectionState);
+ if (related_1) {
+ result &= related_1;
+ continue;
}
- return;
}
- if (typeVariableCount === 1 && !inferenceCircularity) {
- var unmatched = ts.flatMap(sources, function (s, i) { return matched_1[i] ? undefined : s; });
- if (unmatched.length) {
- inferFromTypes(getUnionType(unmatched), nakedTypeVariable);
- return;
- }
+ var related = isRelatedTo(sourceType, target, reportErrors, undefined, intersectionState);
+ if (!related) {
+ return 0;
}
+ result &= related;
}
- else {
- for (var _a = 0, targets_3 = targets; _a < targets_3.length; _a++) {
- var t = targets_3[_a];
- if (getInferenceInfoForType(t)) {
- typeVariableCount++;
+ return result;
+ }
+ function typeArgumentsRelatedTo(sources, targets, variances, reportErrors, intersectionState) {
+ if (sources === void 0) { sources = ts.emptyArray; }
+ if (targets === void 0) { targets = ts.emptyArray; }
+ if (variances === void 0) { variances = ts.emptyArray; }
+ if (sources.length !== targets.length && relation === identityRelation) {
+ return 0;
+ }
+ var length = sources.length <= targets.length ? sources.length : targets.length;
+ var result = -1;
+ for (var i = 0; i < length; i++) {
+ var varianceFlags = i < variances.length ? variances[i] : 1;
+ var variance = varianceFlags & 7;
+ if (variance !== 4) {
+ var s = sources[i];
+ var t = targets[i];
+ var related = -1;
+ if (varianceFlags & 8) {
+ related = relation === identityRelation ? isRelatedTo(s, t, false) : compareTypesIdentical(s, t);
+ }
+ else if (variance === 1) {
+ related = isRelatedTo(s, t, reportErrors, undefined, intersectionState);
+ }
+ else if (variance === 2) {
+ related = isRelatedTo(t, s, reportErrors, undefined, intersectionState);
+ }
+ else if (variance === 3) {
+ related = isRelatedTo(t, s, false);
+ if (!related) {
+ related = isRelatedTo(s, t, reportErrors, undefined, intersectionState);
+ }
}
else {
- inferFromTypes(source, t);
+ related = isRelatedTo(s, t, reportErrors, undefined, intersectionState);
+ if (related) {
+ related &= isRelatedTo(t, s, reportErrors, undefined, intersectionState);
+ }
}
- }
- }
- if (targetFlags & 2097152 ? typeVariableCount === 1 : typeVariableCount > 0) {
- for (var _b = 0, targets_4 = targets; _b < targets_4.length; _b++) {
- var t = targets_4[_b];
- if (getInferenceInfoForType(t)) {
- inferWithPriority(source, t, 1);
+ if (!related) {
+ return 0;
}
+ result &= related;
}
}
+ return result;
}
- function inferToMappedType(source, target, constraintType) {
- if (constraintType.flags & 1048576) {
- var result = false;
- for (var _i = 0, _a = constraintType.types; _i < _a.length; _i++) {
- var type = _a[_i];
- result = inferToMappedType(source, target, type) || result;
- }
- return result;
+ function recursiveTypeRelatedTo(source, target, reportErrors, intersectionState) {
+ if (overflow) {
+ return 0;
}
- if (constraintType.flags & 4194304) {
- var inference = getInferenceInfoForType(constraintType.type);
- if (inference && !inference.isFixed && !isFromInferenceBlockedSource(source)) {
- var inferredType = inferTypeForHomomorphicMappedType(source, target, constraintType);
- if (inferredType) {
- inferWithPriority(inferredType, inference.typeParameter, ts.getObjectFlags(source) & 2097152 ?
- 4 :
- 2);
- }
+ var id = getRelationKey(source, target, intersectionState | (inPropertyCheck ? 8 : 0), relation);
+ var entry = relation.get(id);
+ if (entry !== undefined) {
+ if (reportErrors && entry & 2 && !(entry & 4)) {
}
- return true;
- }
- if (constraintType.flags & 262144) {
- inferWithPriority(getIndexType(source), constraintType, 8);
- var extendedConstraint = getConstraintOfType(constraintType);
- if (extendedConstraint && inferToMappedType(source, target, extendedConstraint)) {
- return true;
+ else {
+ if (outofbandVarianceMarkerHandler) {
+ var saved = entry & 24;
+ if (saved & 8) {
+ instantiateType(source, makeFunctionTypeMapper(reportUnmeasurableMarkers));
+ }
+ if (saved & 16) {
+ instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers));
+ }
+ }
+ return entry & 1 ? -1 : 0;
}
- var propTypes = ts.map(getPropertiesOfType(source), getTypeOfSymbol);
- var stringIndexType = getIndexTypeOfType(source, 0);
- var numberIndexInfo = getNonEnumNumberIndexInfo(source);
- var numberIndexType = numberIndexInfo && numberIndexInfo.type;
- inferFromTypes(getUnionType(ts.append(ts.append(propTypes, stringIndexType), numberIndexType)), getTemplateTypeFromMappedType(target));
- return true;
}
- return false;
- }
- function inferFromObjectTypes(source, target) {
- var isNonConstructorObject = target.flags & 524288 &&
- !(ts.getObjectFlags(target) & 16 && target.symbol && target.symbol.flags & 32);
- var symbolOrType = isNonConstructorObject ? isTupleType(target) ? target.target : target.symbol : undefined;
- if (symbolOrType) {
- if (ts.contains(symbolOrTypeStack, symbolOrType)) {
- inferencePriority = -1;
- return;
- }
- (symbolOrTypeStack || (symbolOrTypeStack = [])).push(symbolOrType);
- inferFromObjectTypesWorker(source, target);
- symbolOrTypeStack.pop();
+ if (!maybeKeys) {
+ maybeKeys = [];
+ sourceStack = [];
+ targetStack = [];
}
else {
- inferFromObjectTypesWorker(source, target);
+ for (var i = 0; i < maybeCount; i++) {
+ if (id === maybeKeys[i]) {
+ return 3;
+ }
+ }
+ if (depth === 100) {
+ overflow = true;
+ return 0;
+ }
}
- }
- function inferFromObjectTypesWorker(source, target) {
- if (ts.getObjectFlags(source) & 4 && ts.getObjectFlags(target) & 4 && (source.target === target.target || isArrayType(source) && isArrayType(target))) {
- inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
- return;
+ var maybeStart = maybeCount;
+ maybeKeys[maybeCount] = id;
+ maybeCount++;
+ sourceStack[depth] = source;
+ targetStack[depth] = target;
+ depth++;
+ var saveExpandingFlags = expandingFlags;
+ if (!(expandingFlags & 1) && isDeeplyNestedType(source, sourceStack, depth))
+ expandingFlags |= 1;
+ if (!(expandingFlags & 2) && isDeeplyNestedType(target, targetStack, depth))
+ expandingFlags |= 2;
+ var originalHandler;
+ var propagatingVarianceFlags = 0;
+ if (outofbandVarianceMarkerHandler) {
+ originalHandler = outofbandVarianceMarkerHandler;
+ outofbandVarianceMarkerHandler = function (onlyUnreliable) {
+ propagatingVarianceFlags |= onlyUnreliable ? 16 : 8;
+ return originalHandler(onlyUnreliable);
+ };
}
- if (isGenericMappedType(source) && isGenericMappedType(target)) {
- inferFromTypes(getConstraintTypeFromMappedType(source), getConstraintTypeFromMappedType(target));
- inferFromTypes(getTemplateTypeFromMappedType(source), getTemplateTypeFromMappedType(target));
+ if (expandingFlags === 3) {
+ ts.tracing.instant("check", "recursiveTypeRelatedTo_DepthLimit", {
+ sourceId: source.id,
+ sourceIdStack: sourceStack.map(function (t) { return t.id; }),
+ targetId: target.id,
+ targetIdStack: targetStack.map(function (t) { return t.id; }),
+ depth: depth,
+ });
}
- if (ts.getObjectFlags(target) & 32) {
- var constraintType = getConstraintTypeFromMappedType(target);
- if (inferToMappedType(source, target, constraintType)) {
- return;
- }
+ var result = expandingFlags !== 3 ? structuredTypeRelatedTo(source, target, reportErrors, intersectionState) : 3;
+ if (outofbandVarianceMarkerHandler) {
+ outofbandVarianceMarkerHandler = originalHandler;
}
- if (!typesDefinitelyUnrelated(source, target)) {
- if (isArrayType(source) || isTupleType(source)) {
- if (isTupleType(target)) {
- var sourceLength = isTupleType(source) ? getLengthOfTupleType(source) : 0;
- var targetLength = getLengthOfTupleType(target);
- var sourceRestType = isTupleType(source) ? getRestTypeOfTupleType(source) : getElementTypeOfArrayType(source);
- var targetRestType = getRestTypeOfTupleType(target);
- var fixedLength = targetLength < sourceLength || sourceRestType ? targetLength : sourceLength;
- for (var i = 0; i < fixedLength; i++) {
- inferFromTypes(i < sourceLength ? getTypeArguments(source)[i] : sourceRestType, getTypeArguments(target)[i]);
- }
- if (targetRestType) {
- var types = fixedLength < sourceLength ? getTypeArguments(source).slice(fixedLength, sourceLength) : [];
- if (sourceRestType) {
- types.push(sourceRestType);
- }
- if (types.length) {
- inferFromTypes(getUnionType(types), targetRestType);
- }
+ expandingFlags = saveExpandingFlags;
+ depth--;
+ if (result) {
+ if (result === -1 || depth === 0) {
+ if (result === -1 || result === 3) {
+ for (var i = maybeStart; i < maybeCount; i++) {
+ relation.set(maybeKeys[i], 1 | propagatingVarianceFlags);
}
- return;
- }
- if (isArrayType(target)) {
- inferFromIndexTypes(source, target);
- return;
}
+ maybeCount = maybeStart;
}
- inferFromProperties(source, target);
- inferFromSignatures(source, target, 0);
- inferFromSignatures(source, target, 1);
- inferFromIndexTypes(source, target);
}
- }
- function inferFromProperties(source, target) {
- var properties = getPropertiesOfObjectType(target);
- for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
- var targetProp = properties_3[_i];
- var sourceProp = getPropertyOfType(source, targetProp.escapedName);
- if (sourceProp) {
- inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
- }
+ else {
+ relation.set(id, (reportErrors ? 4 : 0) | 2 | propagatingVarianceFlags);
+ maybeCount = maybeStart;
}
+ return result;
}
- function inferFromSignatures(source, target, kind) {
- var sourceSignatures = getSignaturesOfType(source, kind);
- var targetSignatures = getSignaturesOfType(target, kind);
- var sourceLen = sourceSignatures.length;
- var targetLen = targetSignatures.length;
- var len = sourceLen < targetLen ? sourceLen : targetLen;
- var skipParameters = !!(ts.getObjectFlags(source) & 2097152);
- for (var i = 0; i < len; i++) {
- inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]), skipParameters);
- }
+ function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
+ ts.tracing.push("check", "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id });
+ var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState);
+ ts.tracing.pop();
+ return result;
}
- function inferFromSignature(source, target, skipParameters) {
- if (!skipParameters) {
- var saveBivariant = bivariant;
- var kind = target.declaration ? target.declaration.kind : 0;
- bivariant = bivariant || kind === 161 || kind === 160 || kind === 162;
- applyToParameterTypes(source, target, inferFromContravariantTypes);
- bivariant = saveBivariant;
+ function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState) {
+ if (intersectionState & 4) {
+ return propertiesRelatedTo(source, target, reportErrors, undefined, 0);
}
- applyToReturnTypes(source, target, inferFromTypes);
- }
- function inferFromIndexTypes(source, target) {
- var targetStringIndexType = getIndexTypeOfType(target, 0);
- if (targetStringIndexType) {
- var sourceIndexType = getIndexTypeOfType(source, 0) ||
- getImplicitIndexTypeOfType(source, 0);
- if (sourceIndexType) {
- inferFromTypes(sourceIndexType, targetStringIndexType);
+ var flags = source.flags & target.flags;
+ if (relation === identityRelation && !(flags & 524288)) {
+ if (flags & 4194304) {
+ return isRelatedTo(source.type, target.type, false);
}
- }
- var targetNumberIndexType = getIndexTypeOfType(target, 1);
- if (targetNumberIndexType) {
- var sourceIndexType = getIndexTypeOfType(source, 1) ||
- getIndexTypeOfType(source, 0) ||
- getImplicitIndexTypeOfType(source, 1);
- if (sourceIndexType) {
- inferFromTypes(sourceIndexType, targetNumberIndexType);
+ var result_7 = 0;
+ if (flags & 8388608) {
+ if (result_7 = isRelatedTo(source.objectType, target.objectType, false)) {
+ if (result_7 &= isRelatedTo(source.indexType, target.indexType, false)) {
+ return result_7;
+ }
+ }
}
- }
- }
- }
- function isTypeOrBaseIdenticalTo(s, t) {
- return isTypeIdenticalTo(s, t) || !!(t.flags & 4 && s.flags & 128 || t.flags & 8 && s.flags & 256);
- }
- function isTypeCloselyMatchedBy(s, t) {
- return !!(s.flags & 524288 && t.flags & 524288 && s.symbol && s.symbol === t.symbol ||
- s.aliasSymbol && s.aliasTypeArguments && s.aliasSymbol === t.aliasSymbol);
- }
- function hasPrimitiveConstraint(type) {
- var constraint = getConstraintOfTypeParameter(type);
- return !!constraint && maybeTypeOfKind(constraint.flags & 16777216 ? getDefaultConstraintOfConditionalType(constraint) : constraint, 131068 | 4194304);
- }
- function isObjectLiteralType(type) {
- return !!(ts.getObjectFlags(type) & 128);
- }
- function isObjectOrArrayLiteralType(type) {
- return !!(ts.getObjectFlags(type) & (128 | 65536));
- }
- function unionObjectAndArrayLiteralCandidates(candidates) {
- if (candidates.length > 1) {
- var objectLiterals = ts.filter(candidates, isObjectOrArrayLiteralType);
- if (objectLiterals.length) {
- var literalsType = getUnionType(objectLiterals, 2);
- return ts.concatenate(ts.filter(candidates, function (t) { return !isObjectOrArrayLiteralType(t); }), [literalsType]);
- }
- }
- return candidates;
- }
- function getContravariantInference(inference) {
- return inference.priority & 104 ? getIntersectionType(inference.contraCandidates) : getCommonSubtype(inference.contraCandidates);
- }
- function getCovariantInference(inference, signature) {
- var candidates = unionObjectAndArrayLiteralCandidates(inference.candidates);
- var primitiveConstraint = hasPrimitiveConstraint(inference.typeParameter);
- var widenLiteralTypes = !primitiveConstraint && inference.topLevel &&
- (inference.isFixed || !isTypeParameterAtTopLevel(getReturnTypeOfSignature(signature), inference.typeParameter));
- var baseCandidates = primitiveConstraint ? ts.sameMap(candidates, getRegularTypeOfLiteralType) :
- widenLiteralTypes ? ts.sameMap(candidates, getWidenedLiteralType) :
- candidates;
- var unwidenedType = inference.priority & 104 ?
- getUnionType(baseCandidates, 2) :
- getCommonSupertype(baseCandidates);
- return getWidenedType(unwidenedType);
- }
- function getInferredType(context, index) {
- var inference = context.inferences[index];
- if (!inference.inferredType) {
- var inferredType = void 0;
- var signature = context.signature;
- if (signature) {
- var inferredCovariantType = inference.candidates ? getCovariantInference(inference, signature) : undefined;
- if (inference.contraCandidates) {
- var inferredContravariantType = getContravariantInference(inference);
- inferredType = inferredCovariantType && !(inferredCovariantType.flags & 131072) &&
- isTypeSubtypeOf(inferredCovariantType, inferredContravariantType) ?
- inferredCovariantType : inferredContravariantType;
+ if (flags & 16777216) {
+ if (source.root.isDistributive === target.root.isDistributive) {
+ if (result_7 = isRelatedTo(source.checkType, target.checkType, false)) {
+ if (result_7 &= isRelatedTo(source.extendsType, target.extendsType, false)) {
+ if (result_7 &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), false)) {
+ if (result_7 &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), false)) {
+ return result_7;
+ }
+ }
+ }
+ }
+ }
}
- else if (inferredCovariantType) {
- inferredType = inferredCovariantType;
+ if (flags & 33554432) {
+ return isRelatedTo(source.substitute, target.substitute, false);
}
- else if (context.flags & 1) {
- inferredType = silentNeverType;
+ return 0;
+ }
+ var result;
+ var originalErrorInfo;
+ var varianceCheckFailed = false;
+ var saveErrorInfo = captureErrorCalculationState();
+ if (source.flags & (524288 | 16777216) && source.aliasSymbol &&
+ source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol &&
+ !(source.aliasTypeArgumentsContainsMarker || target.aliasTypeArgumentsContainsMarker)) {
+ var variances = getAliasVariances(source.aliasSymbol);
+ if (variances === ts.emptyArray) {
+ return 1;
}
- else {
- var defaultType = getDefaultFromTypeParameter(inference.typeParameter);
- if (defaultType) {
- inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
- }
+ var varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances, intersectionState);
+ if (varianceResult !== undefined) {
+ return varianceResult;
}
}
- else {
- inferredType = getTypeFromInference(inference);
+ if (isSingleElementGenericTupleType(source) && !source.target.readonly && (result = isRelatedTo(getTypeArguments(source)[0], target)) ||
+ isSingleElementGenericTupleType(target) && (target.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source) || source)) && (result = isRelatedTo(source, getTypeArguments(target)[0]))) {
+ return result;
}
- inference.inferredType = inferredType || getDefaultTypeArgumentType(!!(context.flags & 2));
- var constraint = getConstraintOfTypeParameter(inference.typeParameter);
- if (constraint) {
- var instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
- if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
- inference.inferredType = inferredType = instantiatedConstraint;
+ if (target.flags & 262144) {
+ if (ts.getObjectFlags(source) & 32 && !source.declaration.nameType && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source))) {
+ if (!(getMappedTypeModifiers(source) & 4)) {
+ var templateType = getTemplateTypeFromMappedType(source);
+ var indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(source));
+ if (result = isRelatedTo(templateType, indexedAccessType, reportErrors)) {
+ return result;
+ }
+ }
}
}
- }
- return inference.inferredType;
- }
- function getDefaultTypeArgumentType(isInJavaScriptFile) {
- return isInJavaScriptFile ? anyType : unknownType;
- }
- function getInferredTypes(context) {
- var result = [];
- for (var i = 0; i < context.inferences.length; i++) {
- result.push(getInferredType(context, i));
- }
- return result;
- }
- function getCannotFindNameDiagnosticForName(node) {
- switch (node.escapedText) {
- case "document":
- case "console":
- return ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom;
- case "$":
- return compilerOptions.types
- ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig
- : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery;
- case "describe":
- case "suite":
- case "it":
- case "test":
- return compilerOptions.types
- ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig
- : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha;
- case "process":
- case "require":
- case "Buffer":
- case "module":
- return compilerOptions.types
- ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig
- : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode;
- case "Map":
- case "Set":
- case "Promise":
- case "Symbol":
- case "WeakMap":
- case "WeakSet":
- case "Iterator":
- case "AsyncIterator":
- return ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later;
- default:
- if (node.parent.kind === 282) {
- return ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer;
- }
- else {
- return ts.Diagnostics.Cannot_find_name_0;
+ else if (target.flags & 4194304) {
+ var targetType = target.type;
+ if (source.flags & 4194304) {
+ if (result = isRelatedTo(targetType, source.type, false)) {
+ return result;
+ }
}
- }
- }
- function getResolvedSymbol(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedSymbol) {
- links.resolvedSymbol = !ts.nodeIsMissing(node) &&
- resolveName(node, node.escapedText, 111551 | 1048576, getCannotFindNameDiagnosticForName(node), node, !ts.isWriteOnlyAccess(node), false, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_1) || unknownSymbol;
- }
- return links.resolvedSymbol;
- }
- function isInTypeQuery(node) {
- return !!ts.findAncestor(node, function (n) { return n.kind === 172 ? true : n.kind === 75 || n.kind === 153 ? false : "quit"; });
- }
- function getFlowCacheKey(node, declaredType, initialType, flowContainer) {
- switch (node.kind) {
- case 75:
- var symbol = getResolvedSymbol(node);
- return symbol !== unknownSymbol ? (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType) + "|" + (isConstraintPosition(node) ? "@" : "") + getSymbolId(symbol) : undefined;
- case 104:
- return "0";
- case 218:
- case 200:
- return getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
- case 194:
- case 195:
- var propName = getAccessedPropertyName(node);
- if (propName !== undefined) {
- var key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
- return key && key + "." + propName;
+ if (isTupleType(targetType)) {
+ if (result = isRelatedTo(source, getKnownKeysOfTupleType(targetType), reportErrors)) {
+ return result;
+ }
}
- }
- return undefined;
- }
- function isMatchingReference(source, target) {
- switch (target.kind) {
- case 200:
- case 218:
- return isMatchingReference(source, target.expression);
- }
- switch (source.kind) {
- case 75:
- return target.kind === 75 && getResolvedSymbol(source) === getResolvedSymbol(target) ||
- (target.kind === 242 || target.kind === 191) &&
- getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(source)) === getSymbolOfNode(target);
- case 104:
- return target.kind === 104;
- case 102:
- return target.kind === 102;
- case 218:
- case 200:
- return isMatchingReference(source.expression, target);
- case 194:
- case 195:
- return ts.isAccessExpression(target) &&
- getAccessedPropertyName(source) === getAccessedPropertyName(target) &&
- isMatchingReference(source.expression, target.expression);
- }
- return false;
- }
- function containsTruthyCheck(source, target) {
- return isMatchingReference(source, target) ||
- (target.kind === 209 && target.operatorToken.kind === 55 &&
- (containsTruthyCheck(source, target.left) || containsTruthyCheck(source, target.right)));
- }
- function getAccessedPropertyName(access) {
- return access.kind === 194 ? access.name.escapedText :
- ts.isStringOrNumericLiteralLike(access.argumentExpression) ? ts.escapeLeadingUnderscores(access.argumentExpression.text) :
- undefined;
- }
- function containsMatchingReference(source, target) {
- while (ts.isAccessExpression(source)) {
- source = source.expression;
- if (isMatchingReference(source, target)) {
- return true;
- }
- }
- return false;
- }
- function optionalChainContainsReference(source, target) {
- while (ts.isOptionalChain(source)) {
- source = source.expression;
- if (isMatchingReference(source, target)) {
- return true;
- }
- }
- return false;
- }
- function isDiscriminantProperty(type, name) {
- if (type && type.flags & 1048576) {
- var prop = getUnionOrIntersectionProperty(type, name);
- if (prop && ts.getCheckFlags(prop) & 2) {
- if (prop.isDiscriminantProperty === undefined) {
- prop.isDiscriminantProperty =
- (prop.checkFlags & 192) === 192 &&
- !maybeTypeOfKind(getTypeOfSymbol(prop), 63176704);
+ else {
+ var constraint = getSimplifiedTypeOrConstraint(targetType);
+ if (constraint) {
+ if (isRelatedTo(source, getIndexType(constraint, target.stringsOnly), reportErrors) === -1) {
+ return -1;
+ }
+ }
}
- return !!prop.isDiscriminantProperty;
}
- }
- return false;
- }
- function findDiscriminantProperties(sourceProperties, target) {
- var result;
- for (var _i = 0, sourceProperties_2 = sourceProperties; _i < sourceProperties_2.length; _i++) {
- var sourceProperty = sourceProperties_2[_i];
- if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
- if (result) {
- result.push(sourceProperty);
- continue;
+ else if (target.flags & 8388608) {
+ if (relation === assignableRelation || relation === comparableRelation) {
+ var objectType = target.objectType;
+ var indexType = target.indexType;
+ var baseObjectType = getBaseConstraintOfType(objectType) || objectType;
+ var baseIndexType = getBaseConstraintOfType(indexType) || indexType;
+ if (!isGenericObjectType(baseObjectType) && !isGenericIndexType(baseIndexType)) {
+ var accessFlags = 2 | (baseObjectType !== objectType ? 1 : 0);
+ var constraint = getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, target.noUncheckedIndexedAccessCandidate, undefined, accessFlags);
+ if (constraint && (result = isRelatedTo(source, constraint, reportErrors))) {
+ return result;
+ }
+ }
}
- result = [sourceProperty];
}
- }
- return result;
- }
- function isOrContainsMatchingReference(source, target) {
- return isMatchingReference(source, target) || containsMatchingReference(source, target);
- }
- function hasMatchingArgument(callExpression, reference) {
- if (callExpression.arguments) {
- for (var _i = 0, _a = callExpression.arguments; _i < _a.length; _i++) {
- var argument = _a[_i];
- if (isOrContainsMatchingReference(reference, argument)) {
- return true;
+ else if (isGenericMappedType(target) && !target.declaration.nameType) {
+ var template = getTemplateTypeFromMappedType(target);
+ var modifiers = getMappedTypeModifiers(target);
+ if (!(modifiers & 8)) {
+ if (template.flags & 8388608 && template.objectType === source &&
+ template.indexType === getTypeParameterFromMappedType(target)) {
+ return -1;
+ }
+ if (!isGenericMappedType(source)) {
+ var targetConstraint = getConstraintTypeFromMappedType(target);
+ var sourceKeys = getIndexType(source, undefined, true);
+ var includeOptional = modifiers & 4;
+ var filteredByApplicability = includeOptional ? intersectTypes(targetConstraint, sourceKeys) : undefined;
+ if (includeOptional
+ ? !(filteredByApplicability.flags & 131072)
+ : isRelatedTo(targetConstraint, sourceKeys)) {
+ var templateType = getTemplateTypeFromMappedType(target);
+ var typeParameter = getTypeParameterFromMappedType(target);
+ var nonNullComponent = extractTypesOfKind(templateType, ~98304);
+ if (nonNullComponent.flags & 8388608 && nonNullComponent.indexType === typeParameter) {
+ if (result = isRelatedTo(source, nonNullComponent.objectType, reportErrors)) {
+ return result;
+ }
+ }
+ else {
+ var indexingType = filteredByApplicability ? getIntersectionType([filteredByApplicability, typeParameter]) : typeParameter;
+ var indexedAccessType = getIndexedAccessType(source, indexingType);
+ if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) {
+ return result;
+ }
+ }
+ }
+ originalErrorInfo = errorInfo;
+ resetErrorInfo(saveErrorInfo);
+ }
}
}
- }
- if (callExpression.expression.kind === 194 &&
- isOrContainsMatchingReference(reference, callExpression.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)) {
- return isTypeAssignableTo(source, target);
- }
- for (var _i = 0, _a = source.types; _i < _a.length; _i++) {
- var t = _a[_i];
- if (isTypeAssignableTo(t, target)) {
- return true;
+ else if (target.flags & 134217728 && source.flags & 128) {
+ if (isPatternLiteralType(target)) {
+ var result_8 = inferLiteralsFromTemplateLiteralType(source, target);
+ if (result_8 && ts.every(result_8, function (r, i) { return isStringLiteralTypeValueParsableAsType(r, target.types[i]); })) {
+ return -1;
+ }
+ }
}
- }
- return false;
- }
- function getAssignmentReducedType(declaredType, assignedType) {
- if (declaredType !== assignedType) {
- if (assignedType.flags & 131072) {
- return assignedType;
+ if (source.flags & 8650752) {
+ if (source.flags & 8388608 && target.flags & 8388608) {
+ if (result = isRelatedTo(source.objectType, target.objectType, reportErrors)) {
+ result &= isRelatedTo(source.indexType, target.indexType, reportErrors);
+ }
+ if (result) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
+ }
+ else {
+ var constraint = getConstraintOfType(source);
+ if (!constraint || (source.flags & 262144 && constraint.flags & 1)) {
+ if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864))) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
+ }
+ else if (result = isRelatedTo(constraint, target, false, undefined, intersectionState)) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
+ else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, reportErrors, undefined, intersectionState)) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
+ }
}
- var reducedType = filterType(declaredType, function (t) { return typeMaybeAssignableTo(assignedType, t); });
- if (assignedType.flags & 512 && isFreshLiteralType(assignedType)) {
- reducedType = mapType(reducedType, getFreshTypeOfLiteralType);
+ else if (source.flags & 4194304) {
+ if (result = isRelatedTo(keyofConstraintType, target, reportErrors)) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
}
- if (isTypeAssignableTo(assignedType, reducedType)) {
- return reducedType;
+ else if (source.flags & 134217728) {
+ if (target.flags & 134217728 &&
+ source.texts.length === target.texts.length &&
+ source.types.length === target.types.length &&
+ ts.every(source.texts, function (t, i) { return t === target.texts[i]; }) &&
+ ts.every(instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers)).types, function (t, i) { return !!(target.types[i].flags & (1 | 4)) || !!isRelatedTo(t, target.types[i], false); })) {
+ return -1;
+ }
+ var constraint = getBaseConstraintOfType(source);
+ if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, reportErrors))) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
}
- }
- return declaredType;
- }
- function getTypeFactsOfTypes(types) {
- var result = 0;
- for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
- var t = types_15[_i];
- result |= getTypeFacts(t);
- }
- return result;
- }
- function isFunctionObjectType(type) {
- var resolved = resolveStructuredTypeMembers(type);
- return !!(resolved.callSignatures.length || resolved.constructSignatures.length ||
- resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
- }
- function getTypeFacts(type) {
- var flags = type.flags;
- if (flags & 4) {
- return strictNullChecks ? 16317953 : 16776705;
- }
- if (flags & 128) {
- var isEmpty = type.value === "";
- return strictNullChecks ?
- isEmpty ? 12123649 : 7929345 :
- isEmpty ? 12582401 : 16776705;
- }
- if (flags & (8 | 32)) {
- return strictNullChecks ? 16317698 : 16776450;
- }
- if (flags & 256) {
- var isZero = type.value === 0;
- return strictNullChecks ?
- isZero ? 12123394 : 7929090 :
- isZero ? 12582146 : 16776450;
- }
- if (flags & 64) {
- return strictNullChecks ? 16317188 : 16775940;
- }
- if (flags & 2048) {
- var isZero = isZeroBigInt(type);
- return strictNullChecks ?
- isZero ? 12122884 : 7928580 :
- isZero ? 12581636 : 16775940;
- }
- if (flags & 16) {
- return strictNullChecks ? 16316168 : 16774920;
- }
- if (flags & 528) {
- return strictNullChecks ?
- (type === falseType || type === regularFalseType) ? 12121864 : 7927560 :
- (type === falseType || type === regularFalseType) ? 12580616 : 16774920;
- }
- if (flags & 524288) {
- return ts.getObjectFlags(type) & 16 && isEmptyObjectType(type) ?
- strictNullChecks ? 16318463 : 16777215 :
- isFunctionObjectType(type) ?
- strictNullChecks ? 7880640 : 16728000 :
- strictNullChecks ? 7888800 : 16736160;
- }
- if (flags & (16384 | 32768)) {
- return 9830144;
- }
- if (flags & 65536) {
- return 9363232;
- }
- if (flags & 12288) {
- return strictNullChecks ? 7925520 : 16772880;
- }
- if (flags & 67108864) {
- return strictNullChecks ? 7888800 : 16736160;
- }
- if (flags & 131072) {
- return 0;
- }
- if (flags & 63176704) {
- return getTypeFacts(getBaseConstraintOfType(type) || unknownType);
- }
- if (flags & 3145728) {
- return getTypeFactsOfTypes(type.types);
- }
- return 16777215;
- }
- function getTypeWithFacts(type, include) {
- return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; });
- }
- function getTypeWithDefault(type, defaultExpression) {
- if (defaultExpression) {
- var defaultType = getTypeOfExpression(defaultExpression);
- return getUnionType([getTypeWithFacts(type, 524288), defaultType]);
- }
- return type;
- }
- function getTypeOfDestructuredProperty(type, name) {
- var nameType = getLiteralTypeFromPropertyName(name);
- if (!isTypeUsableAsPropertyName(nameType))
- return errorType;
- var text = getPropertyNameFromType(nameType);
- return getConstraintForLocation(getTypeOfPropertyOfType(type, text), name) ||
- isNumericLiteralName(text) && getIndexTypeOfType(type, 1) ||
- getIndexTypeOfType(type, 0) ||
- errorType;
- }
- function getTypeOfDestructuredArrayElement(type, index) {
- return everyType(type, isTupleLikeType) && getTupleElementType(type, index) ||
- checkIteratedTypeOrElementType(65, type, undefinedType, undefined) ||
- errorType;
- }
- function getTypeOfDestructuredSpreadExpression(type) {
- return createArrayType(checkIteratedTypeOrElementType(65, type, undefinedType, undefined) || errorType);
- }
- function getAssignedTypeOfBinaryExpression(node) {
- var isDestructuringDefaultAssignment = node.parent.kind === 192 && isDestructuringAssignmentTarget(node.parent) ||
- node.parent.kind === 281 && isDestructuringAssignmentTarget(node.parent.parent);
- return isDestructuringDefaultAssignment ?
- getTypeWithDefault(getAssignedType(node), node.right) :
- getTypeOfExpression(node.right);
- }
- function isDestructuringAssignmentTarget(parent) {
- return parent.parent.kind === 209 && parent.parent.left === parent ||
- parent.parent.kind === 232 && parent.parent.initializer === parent;
- }
- function getAssignedTypeOfArrayLiteralElement(node, element) {
- return getTypeOfDestructuredArrayElement(getAssignedType(node), node.elements.indexOf(element));
- }
- function getAssignedTypeOfSpreadExpression(node) {
- return getTypeOfDestructuredSpreadExpression(getAssignedType(node.parent));
- }
- function getAssignedTypeOfPropertyAssignment(node) {
- return getTypeOfDestructuredProperty(getAssignedType(node.parent), node.name);
- }
- function getAssignedTypeOfShorthandPropertyAssignment(node) {
- return getTypeWithDefault(getAssignedTypeOfPropertyAssignment(node), node.objectAssignmentInitializer);
- }
- function getAssignedType(node) {
- var parent = node.parent;
- switch (parent.kind) {
- case 231:
- return stringType;
- case 232:
- return checkRightHandSideOfForOf(parent) || errorType;
- case 209:
- return getAssignedTypeOfBinaryExpression(parent);
- case 203:
- return undefinedType;
- case 192:
- return getAssignedTypeOfArrayLiteralElement(parent, node);
- case 213:
- return getAssignedTypeOfSpreadExpression(parent);
- case 281:
- return getAssignedTypeOfPropertyAssignment(parent);
- case 282:
- return getAssignedTypeOfShorthandPropertyAssignment(parent);
- }
- return errorType;
- }
- function getInitialTypeOfBindingElement(node) {
- var pattern = node.parent;
- var parentType = getInitialType(pattern.parent);
- var type = pattern.kind === 189 ?
- getTypeOfDestructuredProperty(parentType, node.propertyName || node.name) :
- !node.dotDotDotToken ?
- getTypeOfDestructuredArrayElement(parentType, pattern.elements.indexOf(node)) :
- getTypeOfDestructuredSpreadExpression(parentType);
- return getTypeWithDefault(type, node.initializer);
- }
- function getTypeOfInitializer(node) {
- var links = getNodeLinks(node);
- return links.resolvedType || getTypeOfExpression(node);
- }
- function getInitialTypeOfVariableDeclaration(node) {
- if (node.initializer) {
- return getTypeOfInitializer(node.initializer);
- }
- if (node.parent.parent.kind === 231) {
- return stringType;
- }
- if (node.parent.parent.kind === 232) {
- return checkRightHandSideOfForOf(node.parent.parent) || errorType;
- }
- return errorType;
- }
- function getInitialType(node) {
- return node.kind === 242 ?
- getInitialTypeOfVariableDeclaration(node) :
- getInitialTypeOfBindingElement(node);
- }
- function isEmptyArrayAssignment(node) {
- return node.kind === 242 && node.initializer &&
- isEmptyArrayLiteral(node.initializer) ||
- node.kind !== 191 && node.parent.kind === 209 &&
- isEmptyArrayLiteral(node.parent.right);
- }
- function getReferenceCandidate(node) {
- switch (node.kind) {
- case 200:
- return getReferenceCandidate(node.expression);
- case 209:
- switch (node.operatorToken.kind) {
- case 62:
- return getReferenceCandidate(node.left);
- case 27:
- return getReferenceCandidate(node.right);
+ else if (source.flags & 268435456) {
+ if (target.flags & 268435456 && source.symbol === target.symbol) {
+ if (result = isRelatedTo(source.type, target.type, reportErrors)) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
+ }
+ else {
+ var constraint = getBaseConstraintOfType(source);
+ if (constraint && (result = isRelatedTo(constraint, target, reportErrors))) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
}
- }
- return node;
- }
- function getReferenceRoot(node) {
- var parent = node.parent;
- return parent.kind === 200 ||
- parent.kind === 209 && parent.operatorToken.kind === 62 && parent.left === node ||
- parent.kind === 209 && parent.operatorToken.kind === 27 && parent.right === node ?
- getReferenceRoot(parent) : node;
- }
- function getTypeOfSwitchClause(clause) {
- if (clause.kind === 277) {
- return getRegularTypeOfLiteralType(getTypeOfExpression(clause.expression));
- }
- return neverType;
- }
- function getSwitchClauseTypes(switchStatement) {
- var links = getNodeLinks(switchStatement);
- if (!links.switchTypes) {
- links.switchTypes = [];
- for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) {
- var clause = _a[_i];
- links.switchTypes.push(getTypeOfSwitchClause(clause));
}
- }
- return links.switchTypes;
- }
- function getSwitchClauseTypeOfWitnesses(switchStatement, retainDefault) {
- var witnesses = [];
- for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) {
- var clause = _a[_i];
- if (clause.kind === 277) {
- if (ts.isStringLiteralLike(clause.expression)) {
- witnesses.push(clause.expression.text);
- continue;
+ else if (source.flags & 16777216) {
+ if (target.flags & 16777216) {
+ var sourceParams = source.root.inferTypeParameters;
+ var sourceExtends = source.extendsType;
+ var mapper = void 0;
+ if (sourceParams) {
+ var ctx = createInferenceContext(sourceParams, undefined, 0, isRelatedTo);
+ inferTypes(ctx.inferences, target.extendsType, sourceExtends, 256 | 512);
+ sourceExtends = instantiateType(sourceExtends, ctx.mapper);
+ mapper = ctx.mapper;
+ }
+ if (isTypeIdenticalTo(sourceExtends, target.extendsType) &&
+ (isRelatedTo(source.checkType, target.checkType) || isRelatedTo(target.checkType, source.checkType))) {
+ if (result = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source), mapper), getTrueTypeFromConditionalType(target), reportErrors)) {
+ result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), reportErrors);
+ }
+ if (result) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
+ }
+ }
+ else {
+ var distributiveConstraint = getConstraintOfDistributiveConditionalType(source);
+ if (distributiveConstraint) {
+ if (result = isRelatedTo(distributiveConstraint, target, reportErrors)) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
+ }
+ }
+ var defaultConstraint = getDefaultConstraintOfConditionalType(source);
+ if (defaultConstraint) {
+ if (result = isRelatedTo(defaultConstraint, target, reportErrors)) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
}
- return ts.emptyArray;
}
- if (retainDefault)
- witnesses.push(undefined);
- }
- return witnesses;
- }
- function eachTypeContainedIn(source, types) {
- return source.flags & 1048576 ? !ts.forEach(source.types, function (t) { return !ts.contains(types, t); }) : ts.contains(types, source);
- }
- function isTypeSubsetOf(source, target) {
- return source === target || target.flags & 1048576 && isTypeSubsetOfUnion(source, target);
- }
- function isTypeSubsetOfUnion(source, target) {
- if (source.flags & 1048576) {
- for (var _i = 0, _a = source.types; _i < _a.length; _i++) {
- var t = _a[_i];
- if (!containsType(target.types, t)) {
- return false;
+ else {
+ if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target) && isEmptyObjectType(source)) {
+ return -1;
+ }
+ if (isGenericMappedType(target)) {
+ if (isGenericMappedType(source)) {
+ if (result = mappedTypeRelatedTo(source, target, reportErrors)) {
+ resetErrorInfo(saveErrorInfo);
+ return result;
+ }
+ }
+ return 0;
+ }
+ var sourceIsPrimitive = !!(source.flags & 131068);
+ if (relation !== identityRelation) {
+ source = getApparentType(source);
+ }
+ else if (isGenericMappedType(source)) {
+ return 0;
+ }
+ if (ts.getObjectFlags(source) & 4 && ts.getObjectFlags(target) & 4 && source.target === target.target &&
+ !(ts.getObjectFlags(source) & 8192 || ts.getObjectFlags(target) & 8192)) {
+ var variances = getVariances(source.target);
+ if (variances === ts.emptyArray) {
+ return 1;
+ }
+ var varianceResult = relateVariances(getTypeArguments(source), getTypeArguments(target), variances, intersectionState);
+ if (varianceResult !== undefined) {
+ return varianceResult;
+ }
+ }
+ else if (isReadonlyArrayType(target) ? isArrayType(source) || isTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) {
+ if (relation !== identityRelation) {
+ return isRelatedTo(getIndexTypeOfType(source, 1) || anyType, getIndexTypeOfType(target, 1) || anyType, reportErrors);
+ }
+ else {
+ return 0;
+ }
+ }
+ else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target) && ts.getObjectFlags(target) & 32768 && !isEmptyObjectType(source)) {
+ return 0;
+ }
+ if (source.flags & (524288 | 2097152) && target.flags & 524288) {
+ var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo.errorInfo && !sourceIsPrimitive;
+ result = propertiesRelatedTo(source, target, reportStructuralErrors, undefined, intersectionState);
+ if (result) {
+ result &= signaturesRelatedTo(source, target, 0, reportStructuralErrors);
+ if (result) {
+ result &= signaturesRelatedTo(source, target, 1, reportStructuralErrors);
+ if (result) {
+ result &= indexTypesRelatedTo(source, target, 0, sourceIsPrimitive, reportStructuralErrors, intersectionState);
+ if (result) {
+ result &= indexTypesRelatedTo(source, target, 1, sourceIsPrimitive, reportStructuralErrors, intersectionState);
+ }
+ }
+ }
+ }
+ if (varianceCheckFailed && result) {
+ errorInfo = originalErrorInfo || errorInfo || saveErrorInfo.errorInfo;
+ }
+ else if (result) {
+ return result;
+ }
+ }
+ if (source.flags & (524288 | 2097152) && target.flags & 1048576) {
+ var objectOnlyTarget = extractTypesOfKind(target, 524288 | 2097152 | 33554432);
+ if (objectOnlyTarget.flags & 1048576) {
+ var result_9 = typeRelatedToDiscriminatedType(source, objectOnlyTarget);
+ if (result_9) {
+ return result_9;
+ }
+ }
}
}
- return true;
- }
- if (source.flags & 1024 && getBaseTypeOfEnumLiteralType(source) === target) {
- return true;
- }
- return containsType(target.types, source);
- }
- function forEachType(type, f) {
- return type.flags & 1048576 ? ts.forEach(type.types, f) : f(type);
- }
- function everyType(type, f) {
- return type.flags & 1048576 ? ts.every(type.types, f) : f(type);
- }
- function filterType(type, f) {
- if (type.flags & 1048576) {
- var types = type.types;
- var filtered = ts.filter(types, f);
- return filtered === types ? type : getUnionTypeFromSortedList(filtered, type.objectFlags);
- }
- return type.flags & 131072 || f(type) ? type : neverType;
- }
- function countTypes(type) {
- return type.flags & 1048576 ? type.types.length : 1;
- }
- function mapType(type, mapper, noReductions) {
- if (type.flags & 131072) {
- return type;
- }
- if (!(type.flags & 1048576)) {
- return mapper(type);
- }
- var mappedTypes;
- for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
- var t = _a[_i];
- var mapped = mapper(t);
- if (mapped) {
- if (!mappedTypes) {
- mappedTypes = [mapped];
+ return 0;
+ function relateVariances(sourceTypeArguments, targetTypeArguments, variances, intersectionState) {
+ if (result = typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, variances, reportErrors, intersectionState)) {
+ return result;
+ }
+ if (ts.some(variances, function (v) { return !!(v & 24); })) {
+ originalErrorInfo = undefined;
+ resetErrorInfo(saveErrorInfo);
+ return undefined;
}
- else {
- mappedTypes.push(mapped);
+ var allowStructuralFallback = targetTypeArguments && hasCovariantVoidArgument(targetTypeArguments, variances);
+ varianceCheckFailed = !allowStructuralFallback;
+ if (variances !== ts.emptyArray && !allowStructuralFallback) {
+ if (varianceCheckFailed && !(reportErrors && ts.some(variances, function (v) { return (v & 7) === 0; }))) {
+ return 0;
+ }
+ originalErrorInfo = errorInfo;
+ resetErrorInfo(saveErrorInfo);
}
}
}
- return mappedTypes && getUnionType(mappedTypes, noReductions ? 0 : 1);
- }
- function extractTypesOfKind(type, kind) {
- return filterType(type, function (t) { return (t.flags & kind) !== 0; });
- }
- function replacePrimitivesWithLiterals(typeWithPrimitives, typeWithLiterals) {
- if (isTypeSubsetOf(stringType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 128) ||
- isTypeSubsetOf(numberType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 256) ||
- isTypeSubsetOf(bigintType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 2048)) {
- return mapType(typeWithPrimitives, function (t) {
- return t.flags & 4 ? extractTypesOfKind(typeWithLiterals, 4 | 128) :
- t.flags & 8 ? extractTypesOfKind(typeWithLiterals, 8 | 256) :
- t.flags & 64 ? extractTypesOfKind(typeWithLiterals, 64 | 2048) : t;
- });
+ function reportUnmeasurableMarkers(p) {
+ if (outofbandVarianceMarkerHandler && (p === markerSuperType || p === markerSubType || p === markerOtherType)) {
+ outofbandVarianceMarkerHandler(false);
+ }
+ return p;
}
- 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 } : type;
- }
- function createEvolvingArrayType(elementType) {
- var result = createObjectType(256);
- result.elementType = elementType;
- return result;
- }
- function getEvolvingArrayType(elementType) {
- return evolvingArrayTypes[elementType.id] || (evolvingArrayTypes[elementType.id] = createEvolvingArrayType(elementType));
- }
- function addEvolvingArrayElementType(evolvingArrayType, node) {
- var elementType = getBaseTypeOfLiteralType(getContextFreeTypeOfExpression(node));
- return isTypeSubsetOf(elementType, evolvingArrayType.elementType) ? evolvingArrayType : getEvolvingArrayType(getUnionType([evolvingArrayType.elementType, elementType]));
- }
- function createFinalArrayType(elementType) {
- return elementType.flags & 131072 ?
- autoArrayType :
- createArrayType(elementType.flags & 1048576 ?
- getUnionType(elementType.types, 2) :
- elementType);
- }
- function getFinalArrayType(evolvingArrayType) {
- return evolvingArrayType.finalArrayType || (evolvingArrayType.finalArrayType = createFinalArrayType(evolvingArrayType.elementType));
- }
- function finalizeEvolvingArrayType(type) {
- return ts.getObjectFlags(type) & 256 ? getFinalArrayType(type) : type;
- }
- function getElementTypeOfEvolvingArrayType(type) {
- return ts.getObjectFlags(type) & 256 ? type.elementType : neverType;
- }
- function isEvolvingArrayTypeList(types) {
- var hasEvolvingArrayType = false;
- for (var _i = 0, types_16 = types; _i < types_16.length; _i++) {
- var t = types_16[_i];
- if (!(t.flags & 131072)) {
- if (!(ts.getObjectFlags(t) & 256)) {
- return false;
- }
- hasEvolvingArrayType = true;
+ function reportUnreliableMarkers(p) {
+ if (outofbandVarianceMarkerHandler && (p === markerSuperType || p === markerSubType || p === markerOtherType)) {
+ outofbandVarianceMarkerHandler(true);
}
+ return p;
}
- return hasEvolvingArrayType;
- }
- function getUnionOrEvolvingArrayType(types, subtypeReduction) {
- return isEvolvingArrayTypeList(types) ?
- getEvolvingArrayType(getUnionType(ts.map(types, getElementTypeOfEvolvingArrayType))) :
- getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction);
- }
- function isEvolvingArrayOperationTarget(node) {
- var root = getReferenceRoot(node);
- var parent = root.parent;
- var isLengthPushOrUnshift = ts.isPropertyAccessExpression(parent) && (parent.name.escapedText === "length" ||
- parent.parent.kind === 196
- && ts.isIdentifier(parent.name)
- && ts.isPushOrUnshiftIdentifier(parent.name));
- var isElementAssignment = parent.kind === 195 &&
- parent.expression === root &&
- parent.parent.kind === 209 &&
- parent.parent.operatorToken.kind === 62 &&
- parent.parent.left === parent &&
- !ts.isAssignmentTarget(parent.parent) &&
- isTypeAssignableToKind(getTypeOfExpression(parent.argumentExpression), 296);
- return isLengthPushOrUnshift || isElementAssignment;
- }
- function isDeclarationWithExplicitTypeAnnotation(declaration) {
- return (declaration.kind === 242 || declaration.kind === 156 ||
- declaration.kind === 159 || declaration.kind === 158) &&
- !!ts.getEffectiveTypeAnnotationNode(declaration);
- }
- function getExplicitTypeOfSymbol(symbol, diagnostic) {
- if (symbol.flags & (16 | 8192 | 32 | 512)) {
- return getTypeOfSymbol(symbol);
+ function mappedTypeRelatedTo(source, target, reportErrors) {
+ var modifiersRelated = relation === comparableRelation || (relation === identityRelation ? getMappedTypeModifiers(source) === getMappedTypeModifiers(target) :
+ getCombinedMappedTypeOptionality(source) <= getCombinedMappedTypeOptionality(target));
+ if (modifiersRelated) {
+ var result_10;
+ var targetConstraint = getConstraintTypeFromMappedType(target);
+ var sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source), makeFunctionTypeMapper(getCombinedMappedTypeOptionality(source) < 0 ? reportUnmeasurableMarkers : reportUnreliableMarkers));
+ if (result_10 = isRelatedTo(targetConstraint, sourceConstraint, reportErrors)) {
+ var mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]);
+ if (instantiateType(getNameTypeFromMappedType(source), mapper) === instantiateType(getNameTypeFromMappedType(target), mapper)) {
+ return result_10 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), reportErrors);
+ }
+ }
+ }
+ return 0;
}
- if (symbol.flags & (3 | 4)) {
- var declaration = symbol.valueDeclaration;
- if (declaration) {
- if (isDeclarationWithExplicitTypeAnnotation(declaration)) {
- return getTypeOfSymbol(symbol);
+ function typeRelatedToDiscriminatedType(source, target) {
+ var sourceProperties = getPropertiesOfType(source);
+ var sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
+ if (!sourcePropertiesFiltered)
+ return 0;
+ var numCombinations = 1;
+ for (var _i = 0, sourcePropertiesFiltered_1 = sourcePropertiesFiltered; _i < sourcePropertiesFiltered_1.length; _i++) {
+ var sourceProperty = sourcePropertiesFiltered_1[_i];
+ numCombinations *= countTypes(getTypeOfSymbol(sourceProperty));
+ if (numCombinations > 25) {
+ ts.tracing.instant("check", "typeRelatedToDiscriminatedType_DepthLimit", { sourceId: source.id, targetId: target.id, numCombinations: numCombinations });
+ return 0;
}
- if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 232) {
- var statement = declaration.parent.parent;
- var expressionType = getTypeOfDottedName(statement.expression, undefined);
- if (expressionType) {
- var use = statement.awaitModifier ? 15 : 13;
- return checkIteratedTypeOrElementType(use, expressionType, undefinedType, undefined);
+ }
+ var sourceDiscriminantTypes = new Array(sourcePropertiesFiltered.length);
+ var excludedProperties = new ts.Set();
+ for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
+ var sourceProperty = sourcePropertiesFiltered[i];
+ var sourcePropertyType = getTypeOfSymbol(sourceProperty);
+ sourceDiscriminantTypes[i] = sourcePropertyType.flags & 1048576
+ ? sourcePropertyType.types
+ : [sourcePropertyType];
+ excludedProperties.add(sourceProperty.escapedName);
+ }
+ var discriminantCombinations = ts.cartesianProduct(sourceDiscriminantTypes);
+ var matchingTypes = [];
+ var _loop_17 = function (combination) {
+ var hasMatch = false;
+ outer: for (var _i = 0, _a = target.types; _i < _a.length; _i++) {
+ var type = _a[_i];
+ var _loop_18 = function (i) {
+ var sourceProperty = sourcePropertiesFiltered[i];
+ var targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
+ if (!targetProperty)
+ return "continue-outer";
+ if (sourceProperty === targetProperty)
+ return "continue";
+ var related = propertyRelatedTo(source, target, sourceProperty, targetProperty, function (_) { return combination[i]; }, false, 0, strictNullChecks || relation === comparableRelation);
+ if (!related) {
+ return "continue-outer";
+ }
+ };
+ for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
+ var state_7 = _loop_18(i);
+ switch (state_7) {
+ case "continue-outer": continue outer;
+ }
}
+ ts.pushIfUnique(matchingTypes, type, ts.equateValues);
+ hasMatch = true;
}
- if (diagnostic) {
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(declaration, ts.Diagnostics._0_needs_an_explicit_type_annotation, symbolToString(symbol)));
+ if (!hasMatch) {
+ return { value: 0 };
}
+ };
+ for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) {
+ var combination = discriminantCombinations_1[_a];
+ var state_6 = _loop_17(combination);
+ if (typeof state_6 === "object")
+ return state_6.value;
}
- }
- }
- function getTypeOfDottedName(node, diagnostic) {
- if (!(node.flags & 16777216)) {
- switch (node.kind) {
- case 75:
- var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
- return getExplicitTypeOfSymbol(symbol.flags & 2097152 ? resolveAlias(symbol) : symbol, diagnostic);
- case 104:
- return getExplicitThisType(node);
- case 102:
- return checkSuperExpression(node);
- case 194:
- var type = getTypeOfDottedName(node.expression, diagnostic);
- var prop = type && getPropertyOfType(type, node.name.escapedText);
- return prop && getExplicitTypeOfSymbol(prop, diagnostic);
- case 200:
- return getTypeOfDottedName(node.expression, diagnostic);
+ var result = -1;
+ for (var _b = 0, matchingTypes_1 = matchingTypes; _b < matchingTypes_1.length; _b++) {
+ var type = matchingTypes_1[_b];
+ result &= propertiesRelatedTo(source, type, false, excludedProperties, 0);
+ if (result) {
+ result &= signaturesRelatedTo(source, type, 0, false);
+ if (result) {
+ result &= signaturesRelatedTo(source, type, 1, false);
+ if (result) {
+ result &= indexTypesRelatedTo(source, type, 0, false, false, 0);
+ if (result && !(isTupleType(source) && isTupleType(type))) {
+ result &= indexTypesRelatedTo(source, type, 1, false, false, 0);
+ }
+ }
+ }
+ }
+ if (!result) {
+ return result;
+ }
}
+ return result;
}
- }
- function getEffectsSignature(node) {
- var links = getNodeLinks(node);
- var signature = links.effectsSignature;
- if (signature === undefined) {
- var funcType = void 0;
- if (node.parent.kind === 226) {
- funcType = getTypeOfDottedName(node.expression, undefined);
- }
- else if (node.expression.kind !== 102) {
- if (ts.isOptionalChain(node)) {
- funcType = checkNonNullType(getOptionalExpressionType(checkExpression(node.expression), node.expression), node.expression);
+ function excludeProperties(properties, excludedProperties) {
+ if (!excludedProperties || properties.length === 0)
+ return properties;
+ var result;
+ for (var i = 0; i < properties.length; i++) {
+ if (!excludedProperties.has(properties[i].escapedName)) {
+ if (result) {
+ result.push(properties[i]);
+ }
}
- else {
- funcType = checkNonNullExpression(node.expression);
+ else if (!result) {
+ result = properties.slice(0, i);
}
}
- var signatures = getSignaturesOfType(funcType && getApparentType(funcType) || unknownType, 0);
- var candidate = signatures.length === 1 && !signatures[0].typeParameters ? signatures[0] :
- ts.some(signatures, hasTypePredicateOrNeverReturnType) ? getResolvedSignature(node) :
- undefined;
- signature = links.effectsSignature = candidate && hasTypePredicateOrNeverReturnType(candidate) ? candidate : unknownSignature;
- }
- return signature === unknownSignature ? undefined : signature;
- }
- function hasTypePredicateOrNeverReturnType(signature) {
- return !!(getTypePredicateOfSignature(signature) ||
- signature.declaration && (getReturnTypeFromAnnotation(signature.declaration) || unknownType).flags & 131072);
- }
- function getTypePredicateArgument(predicate, callExpression) {
- if (predicate.kind === 1 || predicate.kind === 3) {
- return callExpression.arguments[predicate.parameterIndex];
+ return result || properties;
}
- var invokedExpression = ts.skipParentheses(callExpression.expression);
- return ts.isAccessExpression(invokedExpression) ? ts.skipParentheses(invokedExpression.expression) : undefined;
- }
- function reportFlowControlError(node) {
- var block = ts.findAncestor(node, ts.isFunctionOrModuleBlock);
- var sourceFile = ts.getSourceFileOfNode(node);
- var span = ts.getSpanOfTokenAtPosition(sourceFile, block.statements.pos);
- diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis));
- }
- function isReachableFlowNode(flow) {
- var result = isReachableFlowNodeWorker(flow, false);
- lastFlowNode = flow;
- lastFlowNodeReachable = result;
- return result;
- }
- function isFalseExpression(expr) {
- var node = ts.skipParentheses(expr);
- return node.kind === 91 || node.kind === 209 && (node.operatorToken.kind === 55 && (isFalseExpression(node.left) || isFalseExpression(node.right)) ||
- node.operatorToken.kind === 56 && isFalseExpression(node.left) && isFalseExpression(node.right));
- }
- function isReachableFlowNodeWorker(flow, noCacheCheck) {
- while (true) {
- if (flow === lastFlowNode) {
- return lastFlowNodeReachable;
- }
- var flags = flow.flags;
- if (flags & 4096) {
- if (!noCacheCheck) {
- var id = getFlowNodeId(flow);
- var reachable = flowNodeReachable[id];
- return reachable !== undefined ? reachable : (flowNodeReachable[id] = isReachableFlowNodeWorker(flow, true));
+ function isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState) {
+ var targetIsOptional = strictNullChecks && !!(ts.getCheckFlags(targetProp) & 48);
+ var source = getTypeOfSourceProperty(sourceProp);
+ if (ts.getCheckFlags(targetProp) & 65536 && !getSymbolLinks(targetProp).type) {
+ var links = getSymbolLinks(targetProp);
+ ts.Debug.assertIsDefined(links.deferralParent);
+ ts.Debug.assertIsDefined(links.deferralConstituents);
+ var unionParent = !!(links.deferralParent.flags & 1048576);
+ var result_11 = unionParent ? 0 : -1;
+ var targetTypes = links.deferralConstituents;
+ for (var _i = 0, targetTypes_3 = targetTypes; _i < targetTypes_3.length; _i++) {
+ var targetType = targetTypes_3[_i];
+ var related = isRelatedTo(source, targetType, false, undefined, unionParent ? 0 : 2);
+ if (!unionParent) {
+ if (!related) {
+ return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors);
+ }
+ result_11 &= related;
+ }
+ else {
+ if (related) {
+ return related;
+ }
+ }
}
- noCacheCheck = false;
+ if (unionParent && !result_11 && targetIsOptional) {
+ result_11 = isRelatedTo(source, undefinedType);
+ }
+ if (unionParent && !result_11 && reportErrors) {
+ return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors);
+ }
+ return result_11;
}
- if (flags & (16 | 96 | 256)) {
- flow = flow.antecedent;
+ else {
+ return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors, undefined, intersectionState);
}
- else if (flags & 512) {
- var signature = getEffectsSignature(flow.node);
- if (signature) {
- var predicate = getTypePredicateOfSignature(signature);
- if (predicate && predicate.kind === 3) {
- var predicateArgument = flow.node.arguments[predicate.parameterIndex];
- if (predicateArgument && isFalseExpression(predicateArgument)) {
- return false;
+ }
+ function propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState, skipOptional) {
+ var sourcePropFlags = ts.getDeclarationModifierFlagsFromSymbol(sourceProp);
+ var targetPropFlags = ts.getDeclarationModifierFlagsFromSymbol(targetProp);
+ if (sourcePropFlags & 8 || targetPropFlags & 8) {
+ if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
+ if (reportErrors) {
+ if (sourcePropFlags & 8 && targetPropFlags & 8) {
+ reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
+ }
+ else {
+ reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 8 ? source : target), typeToString(sourcePropFlags & 8 ? target : source));
}
}
- if (getReturnTypeOfSignature(signature).flags & 131072) {
- return false;
- }
+ return 0;
}
- flow = flow.antecedent;
- }
- else if (flags & 4) {
- return ts.some(flow.antecedents, function (f) { return isReachableFlowNodeWorker(f, false); });
}
- else if (flags & 8) {
- flow = flow.antecedents[0];
+ else if (targetPropFlags & 16) {
+ if (!isValidOverrideOf(sourceProp, targetProp)) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, symbolToString(targetProp), typeToString(getDeclaringClass(sourceProp) || source), typeToString(getDeclaringClass(targetProp) || target));
+ }
+ return 0;
+ }
}
- else if (flags & 128) {
- if (flow.clauseStart === flow.clauseEnd && isExhaustiveSwitchStatement(flow.switchStatement)) {
- return false;
+ else if (sourcePropFlags & 16) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
}
- flow = flow.antecedent;
+ return 0;
}
- else if (flags & 1024) {
- lastFlowNode = undefined;
- var target = flow.target;
- var saveAntecedents = target.antecedents;
- target.antecedents = flow.antecedents;
- var result = isReachableFlowNodeWorker(flow.antecedent, false);
- target.antecedents = saveAntecedents;
- return result;
+ var related = isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState);
+ if (!related) {
+ if (reportErrors) {
+ reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
+ }
+ return 0;
}
- else {
- return !(flags & 1);
+ if (!skipOptional && sourceProp.flags & 16777216 && !(targetProp.flags & 16777216)) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
+ }
+ return 0;
}
+ return related;
}
- }
- function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer, couldBeUninitialized) {
- if (initialType === void 0) { initialType = declaredType; }
- var key;
- var keySet = false;
- var flowDepth = 0;
- if (flowAnalysisDisabled) {
- return errorType;
- }
- if (!reference.flowNode || !couldBeUninitialized && !(declaredType.flags & 133970943)) {
- return declaredType;
- }
- flowInvocationCount++;
- var sharedFlowStart = sharedFlowCount;
- var evolvedType = getTypeFromFlowType(getTypeAtFlowNode(reference.flowNode));
- sharedFlowCount = sharedFlowStart;
- var resultType = ts.getObjectFlags(evolvedType) & 256 && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
- if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === 218 && getTypeWithFacts(resultType, 2097152).flags & 131072) {
- return declaredType;
- }
- return resultType;
- function getOrSetCacheKey() {
- if (keySet) {
- return key;
+ function reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties) {
+ var shouldSkipElaboration = false;
+ if (unmatchedProperty.valueDeclaration
+ && ts.isNamedDeclaration(unmatchedProperty.valueDeclaration)
+ && ts.isPrivateIdentifier(unmatchedProperty.valueDeclaration.name)
+ && source.symbol
+ && source.symbol.flags & 32) {
+ var privateIdentifierDescription = unmatchedProperty.valueDeclaration.name.escapedText;
+ var symbolTableKey = ts.getSymbolNameForPrivateIdentifier(source.symbol, privateIdentifierDescription);
+ if (symbolTableKey && getPropertyOfType(source, symbolTableKey)) {
+ var sourceName = ts.factory.getDeclarationName(source.symbol.valueDeclaration);
+ var targetName = ts.factory.getDeclarationName(target.symbol.valueDeclaration);
+ reportError(ts.Diagnostics.Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2, diagnosticName(privateIdentifierDescription), diagnosticName(sourceName.escapedText === "" ? anon : sourceName), diagnosticName(targetName.escapedText === "" ? anon : targetName));
+ return;
+ }
}
- keySet = true;
- return key = getFlowCacheKey(reference, declaredType, initialType, flowContainer);
- }
- function getTypeAtFlowNode(flow) {
- if (flowDepth === 2000) {
- flowAnalysisDisabled = true;
- reportFlowControlError(reference);
- return errorType;
+ var props = ts.arrayFrom(getUnmatchedProperties(source, target, requireOptionalProperties, false));
+ if (!headMessage || (headMessage.code !== ts.Diagnostics.Class_0_incorrectly_implements_interface_1.code &&
+ headMessage.code !== ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code)) {
+ shouldSkipElaboration = true;
}
- flowDepth++;
- while (true) {
- var flags = flow.flags;
- if (flags & 4096) {
- for (var i = sharedFlowStart; i < sharedFlowCount; i++) {
- if (sharedFlowNodes[i] === flow) {
- flowDepth--;
- return sharedFlowTypes[i];
- }
- }
+ if (props.length === 1) {
+ var propName = symbolToString(unmatchedProperty);
+ reportError.apply(void 0, __spreadArrays([ts.Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2, propName], getTypeNamesForErrorDisplay(source, target)));
+ if (ts.length(unmatchedProperty.declarations)) {
+ associateRelatedInfo(ts.createDiagnosticForNode(unmatchedProperty.declarations[0], ts.Diagnostics._0_is_declared_here, propName));
}
- var type = void 0;
- if (flags & 16) {
- type = getTypeAtFlowAssignment(flow);
- if (!type) {
- flow = flow.antecedent;
- continue;
- }
+ if (shouldSkipElaboration && errorInfo) {
+ overrideNextErrorInfo++;
}
- else if (flags & 512) {
- type = getTypeAtFlowCall(flow);
- if (!type) {
- flow = flow.antecedent;
- continue;
- }
+ }
+ else if (tryElaborateArrayLikeErrors(source, target, false)) {
+ if (props.length > 5) {
+ reportError(ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more, typeToString(source), typeToString(target), ts.map(props.slice(0, 4), function (p) { return symbolToString(p); }).join(", "), props.length - 4);
}
- else if (flags & 96) {
- type = getTypeAtFlowCondition(flow);
+ else {
+ reportError(ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2, typeToString(source), typeToString(target), ts.map(props, function (p) { return symbolToString(p); }).join(", "));
}
- else if (flags & 128) {
- type = getTypeAtSwitchClause(flow);
+ if (shouldSkipElaboration && errorInfo) {
+ overrideNextErrorInfo++;
}
- else if (flags & 12) {
- if (flow.antecedents.length === 1) {
- flow = flow.antecedents[0];
- continue;
+ }
+ }
+ function propertiesRelatedTo(source, target, reportErrors, excludedProperties, intersectionState) {
+ if (relation === identityRelation) {
+ return propertiesIdenticalTo(source, target, excludedProperties);
+ }
+ var result = -1;
+ if (isTupleType(target)) {
+ if (isArrayType(source) || isTupleType(source)) {
+ if (!target.target.readonly && (isReadonlyArrayType(source) || isTupleType(source) && source.target.readonly)) {
+ return 0;
}
- type = flags & 4 ?
- getTypeAtFlowBranchLabel(flow) :
- getTypeAtFlowLoopLabel(flow);
- }
- else if (flags & 256) {
- type = getTypeAtFlowArrayMutation(flow);
- if (!type) {
- flow = flow.antecedent;
- continue;
+ var sourceArity = getTypeReferenceArity(source);
+ var targetArity = getTypeReferenceArity(target);
+ var sourceRestFlag = isTupleType(source) ? source.target.combinedFlags & 4 : 4;
+ var targetRestFlag = target.target.combinedFlags & 4;
+ var sourceMinLength = isTupleType(source) ? source.target.minLength : 0;
+ var targetMinLength = target.target.minLength;
+ if (!sourceRestFlag && sourceArity < targetMinLength) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Source_has_0_element_s_but_target_requires_1, sourceArity, targetMinLength);
+ }
+ return 0;
+ }
+ if (!targetRestFlag && targetArity < sourceMinLength) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Source_has_0_element_s_but_target_allows_only_1, sourceMinLength, targetArity);
+ }
+ return 0;
+ }
+ if (!targetRestFlag && sourceRestFlag) {
+ if (reportErrors) {
+ if (sourceMinLength < targetMinLength) {
+ reportError(ts.Diagnostics.Target_requires_0_element_s_but_source_may_have_fewer, targetMinLength);
+ }
+ else {
+ reportError(ts.Diagnostics.Target_allows_only_0_element_s_but_source_may_have_more, targetArity);
+ }
+ }
+ return 0;
+ }
+ var maxArity = Math.max(sourceArity, targetArity);
+ for (var i = 0; i < maxArity; i++) {
+ var targetFlags = i < targetArity ? target.target.elementFlags[i] : targetRestFlag;
+ var sourceFlags = isTupleType(source) && i < sourceArity ? source.target.elementFlags[i] : sourceRestFlag;
+ var canExcludeDiscriminants = !!excludedProperties;
+ if (sourceFlags && targetFlags) {
+ if (targetFlags & 8 && !(sourceFlags & 8) ||
+ (sourceFlags & 8 && !(targetFlags & 12))) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Element_at_index_0_is_variadic_in_one_type_but_not_in_the_other, i);
+ }
+ return 0;
+ }
+ if (targetFlags & 1) {
+ if (!(sourceFlags & 1)) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2, i, typeToString(source), typeToString(target));
+ }
+ return 0;
+ }
+ }
+ if (canExcludeDiscriminants) {
+ if (sourceFlags & 12 || targetFlags & 12) {
+ canExcludeDiscriminants = false;
+ }
+ if (canExcludeDiscriminants && (excludedProperties === null || excludedProperties === void 0 ? void 0 : excludedProperties.has(("" + i)))) {
+ continue;
+ }
+ }
+ var sourceType = getTypeArguments(source)[Math.min(i, sourceArity - 1)];
+ var targetType = getTypeArguments(target)[Math.min(i, targetArity - 1)];
+ var targetCheckType = sourceFlags & 8 && targetFlags & 4 ? createArrayType(targetType) : targetType;
+ var related = isRelatedTo(sourceType, targetCheckType, reportErrors, undefined, intersectionState);
+ if (!related) {
+ if (reportErrors) {
+ reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, i);
+ }
+ return 0;
+ }
+ result &= related;
+ }
}
+ return result;
}
- else if (flags & 1024) {
- var target = flow.target;
- var saveAntecedents = target.antecedents;
- target.antecedents = flow.antecedents;
- type = getTypeAtFlowNode(flow.antecedent);
- target.antecedents = saveAntecedents;
+ if (target.target.combinedFlags & 12) {
+ return 0;
}
- else if (flags & 2) {
- var container = flow.node;
- if (container && container !== flowContainer &&
- reference.kind !== 194 &&
- reference.kind !== 195 &&
- reference.kind !== 104) {
- flow = container.flowNode;
- continue;
- }
- type = initialType;
+ }
+ var requireOptionalProperties = (relation === subtypeRelation || relation === strictSubtypeRelation) && !isObjectLiteralType(source) && !isEmptyArrayLiteralType(source) && !isTupleType(source);
+ var unmatchedProperty = getUnmatchedProperty(source, target, requireOptionalProperties, false);
+ if (unmatchedProperty) {
+ if (reportErrors) {
+ reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties);
}
- else {
- type = convertAutoToAny(declaredType);
+ return 0;
+ }
+ if (isObjectLiteralType(target)) {
+ for (var _i = 0, _a = excludeProperties(getPropertiesOfType(source), excludedProperties); _i < _a.length; _i++) {
+ var sourceProp = _a[_i];
+ if (!getPropertyOfObjectType(target, sourceProp.escapedName)) {
+ var sourceType = getTypeOfSymbol(sourceProp);
+ if (!(sourceType === undefinedType || sourceType === undefinedWideningType || sourceType === optionalType)) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target));
+ }
+ return 0;
+ }
+ }
}
- if (flags & 4096) {
- sharedFlowNodes[sharedFlowCount] = flow;
- sharedFlowTypes[sharedFlowCount] = type;
- sharedFlowCount++;
+ }
+ var properties = getPropertiesOfType(target);
+ var numericNamesOnly = isTupleType(source) && isTupleType(target);
+ for (var _b = 0, _c = excludeProperties(properties, excludedProperties); _b < _c.length; _b++) {
+ var targetProp = _c[_b];
+ var name = targetProp.escapedName;
+ if (!(targetProp.flags & 4194304) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length")) {
+ var sourceProp = getPropertyOfType(source, name);
+ if (sourceProp && sourceProp !== targetProp) {
+ var related = propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSymbol, reportErrors, intersectionState, relation === comparableRelation);
+ if (!related) {
+ return 0;
+ }
+ result &= related;
+ }
}
- flowDepth--;
- return type;
}
+ return result;
}
- function getInitialOrAssignedType(flow) {
- var node = flow.node;
- return getConstraintForLocation(node.kind === 242 || node.kind === 191 ?
- getInitialType(node) :
- getAssignedType(node), reference);
- }
- function getTypeAtFlowAssignment(flow) {
- var node = flow.node;
- if (isMatchingReference(reference, node)) {
- if (!isReachableFlowNode(flow)) {
- return unreachableNeverType;
+ function propertiesIdenticalTo(source, target, excludedProperties) {
+ if (!(source.flags & 524288 && target.flags & 524288)) {
+ return 0;
+ }
+ var sourceProperties = excludeProperties(getPropertiesOfObjectType(source), excludedProperties);
+ var targetProperties = excludeProperties(getPropertiesOfObjectType(target), excludedProperties);
+ if (sourceProperties.length !== targetProperties.length) {
+ return 0;
+ }
+ var result = -1;
+ for (var _i = 0, sourceProperties_1 = sourceProperties; _i < sourceProperties_1.length; _i++) {
+ var sourceProp = sourceProperties_1[_i];
+ var targetProp = getPropertyOfObjectType(target, sourceProp.escapedName);
+ if (!targetProp) {
+ return 0;
}
- if (ts.getAssignmentTargetKind(node) === 2) {
- var flowType = getTypeAtFlowNode(flow.antecedent);
- return createFlowType(getBaseTypeOfLiteralType(getTypeFromFlowType(flowType)), isIncomplete(flowType));
+ var related = compareProperties(sourceProp, targetProp, isRelatedTo);
+ if (!related) {
+ return 0;
}
- if (declaredType === autoType || declaredType === autoArrayType) {
- if (isEmptyArrayAssignment(node)) {
- return getEvolvingArrayType(neverType);
+ result &= related;
+ }
+ return result;
+ }
+ function signaturesRelatedTo(source, target, kind, reportErrors) {
+ var _a, _b;
+ if (relation === identityRelation) {
+ return signaturesIdenticalTo(source, target, kind);
+ }
+ if (target === anyFunctionType || source === anyFunctionType) {
+ return -1;
+ }
+ var sourceIsJSConstructor = source.symbol && isJSConstructor(source.symbol.valueDeclaration);
+ var targetIsJSConstructor = target.symbol && isJSConstructor(target.symbol.valueDeclaration);
+ var sourceSignatures = getSignaturesOfType(source, (sourceIsJSConstructor && kind === 1) ?
+ 0 : kind);
+ var targetSignatures = getSignaturesOfType(target, (targetIsJSConstructor && kind === 1) ?
+ 0 : kind);
+ if (kind === 1 && sourceSignatures.length && targetSignatures.length) {
+ if (ts.isAbstractConstructorType(source) && !ts.isAbstractConstructorType(target)) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type);
}
- var assignedType = getBaseTypeOfLiteralType(getInitialOrAssignedType(flow));
- return isTypeAssignableTo(assignedType, declaredType) ? assignedType : anyArrayType;
+ return 0;
}
- if (declaredType.flags & 1048576) {
- return getAssignmentReducedType(declaredType, getInitialOrAssignedType(flow));
+ if (!constructorVisibilitiesAreCompatible(sourceSignatures[0], targetSignatures[0], reportErrors)) {
+ return 0;
}
- return declaredType;
}
- if (containsMatchingReference(reference, node)) {
- if (!isReachableFlowNode(flow)) {
- return unreachableNeverType;
+ var result = -1;
+ var saveErrorInfo = captureErrorCalculationState();
+ var incompatibleReporter = kind === 1 ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
+ var sourceObjectFlags = ts.getObjectFlags(source);
+ var targetObjectFlags = ts.getObjectFlags(target);
+ if (sourceObjectFlags & 64 && targetObjectFlags & 64 && source.symbol === target.symbol) {
+ for (var i = 0; i < targetSignatures.length; i++) {
+ var related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], true, reportErrors, incompatibleReporter(sourceSignatures[i], targetSignatures[i]));
+ if (!related) {
+ return 0;
+ }
+ result &= related;
}
- if (ts.isVariableDeclaration(node) && (ts.isInJSFile(node) || ts.isVarConst(node))) {
- var init = ts.getDeclaredExpandoInitializer(node);
- if (init && (init.kind === 201 || init.kind === 202)) {
- return getTypeAtFlowNode(flow.antecedent);
+ }
+ else if (sourceSignatures.length === 1 && targetSignatures.length === 1) {
+ var eraseGenerics = relation === comparableRelation || !!compilerOptions.noStrictGenericChecks;
+ var sourceSignature = ts.first(sourceSignatures);
+ var targetSignature = ts.first(targetSignatures);
+ result = signatureRelatedTo(sourceSignature, targetSignature, eraseGenerics, reportErrors, incompatibleReporter(sourceSignature, targetSignature));
+ if (!result && reportErrors && kind === 1 && (sourceObjectFlags & targetObjectFlags) &&
+ (((_a = targetSignature.declaration) === null || _a === void 0 ? void 0 : _a.kind) === 166 || ((_b = sourceSignature.declaration) === null || _b === void 0 ? void 0 : _b.kind) === 166)) {
+ var constructSignatureToString = function (signature) {
+ return signatureToString(signature, undefined, 262144, kind);
+ };
+ reportError(ts.Diagnostics.Type_0_is_not_assignable_to_type_1, constructSignatureToString(sourceSignature), constructSignatureToString(targetSignature));
+ reportError(ts.Diagnostics.Types_of_construct_signatures_are_incompatible);
+ return result;
+ }
+ }
+ else {
+ outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) {
+ var t = targetSignatures_1[_i];
+ var shouldElaborateErrors = reportErrors;
+ for (var _c = 0, sourceSignatures_1 = sourceSignatures; _c < sourceSignatures_1.length; _c++) {
+ var s = sourceSignatures_1[_c];
+ var related = signatureRelatedTo(s, t, true, shouldElaborateErrors, incompatibleReporter(s, t));
+ if (related) {
+ result &= related;
+ resetErrorInfo(saveErrorInfo);
+ continue outer;
+ }
+ shouldElaborateErrors = false;
+ }
+ if (shouldElaborateErrors) {
+ reportError(ts.Diagnostics.Type_0_provides_no_match_for_the_signature_1, typeToString(source), signatureToString(t, undefined, undefined, kind));
}
+ return 0;
}
- return declaredType;
}
- if (ts.isVariableDeclaration(node) && node.parent.parent.kind === 231 && isMatchingReference(reference, node.parent.parent.expression)) {
- return getNonNullableTypeIfNeeded(getTypeFromFlowType(getTypeAtFlowNode(flow.antecedent)));
+ return result;
+ }
+ function reportIncompatibleCallSignatureReturn(siga, sigb) {
+ if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
+ return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); };
}
- return undefined;
+ return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target)); };
}
- function narrowTypeByAssertion(type, expr) {
- var node = ts.skipParentheses(expr);
- if (node.kind === 91) {
- return unreachableNeverType;
+ function reportIncompatibleConstructSignatureReturn(siga, sigb) {
+ if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
+ return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); };
}
- if (node.kind === 209) {
- if (node.operatorToken.kind === 55) {
- return narrowTypeByAssertion(narrowTypeByAssertion(type, node.left), node.right);
- }
- if (node.operatorToken.kind === 56) {
- return getUnionType([narrowTypeByAssertion(type, node.left), narrowTypeByAssertion(type, node.right)]);
+ return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target)); };
+ }
+ function signatureRelatedTo(source, target, erase, reportErrors, incompatibleReporter) {
+ return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 : 0, reportErrors, reportError, incompatibleReporter, isRelatedTo, makeFunctionTypeMapper(reportUnreliableMarkers));
+ }
+ function signaturesIdenticalTo(source, target, kind) {
+ var sourceSignatures = getSignaturesOfType(source, kind);
+ var targetSignatures = getSignaturesOfType(target, kind);
+ if (sourceSignatures.length !== targetSignatures.length) {
+ return 0;
+ }
+ var result = -1;
+ for (var i = 0; i < sourceSignatures.length; i++) {
+ var related = compareSignaturesIdentical(sourceSignatures[i], targetSignatures[i], false, false, false, isRelatedTo);
+ if (!related) {
+ return 0;
}
+ result &= related;
}
- return narrowType(type, node, true);
+ return result;
}
- function getTypeAtFlowCall(flow) {
- var signature = getEffectsSignature(flow.node);
- if (signature) {
- var predicate = getTypePredicateOfSignature(signature);
- if (predicate && (predicate.kind === 2 || predicate.kind === 3)) {
- var flowType = getTypeAtFlowNode(flow.antecedent);
- var type = finalizeEvolvingArrayType(getTypeFromFlowType(flowType));
- var narrowedType = predicate.type ? narrowTypeByTypePredicate(type, predicate, flow.node, true) :
- predicate.kind === 3 && 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));
+ function eachPropertyRelatedTo(source, target, kind, reportErrors) {
+ var result = -1;
+ var props = source.flags & 2097152 ? getPropertiesOfUnionOrIntersectionType(source) : getPropertiesOfObjectType(source);
+ for (var _i = 0, props_2 = props; _i < props_2.length; _i++) {
+ var prop = props_2[_i];
+ if (isIgnoredJsxProperty(source, prop)) {
+ continue;
}
- if (getReturnTypeOfSignature(signature).flags & 131072) {
- return unreachableNeverType;
+ var nameType = getSymbolLinks(prop).nameType;
+ if (nameType && nameType.flags & 8192) {
+ continue;
}
- }
- return undefined;
- }
- function getTypeAtFlowArrayMutation(flow) {
- if (declaredType === autoType || declaredType === autoArrayType) {
- var node = flow.node;
- var expr = node.kind === 196 ?
- node.expression.expression :
- node.left.expression;
- if (isMatchingReference(reference, getReferenceCandidate(expr))) {
- var flowType = getTypeAtFlowNode(flow.antecedent);
- var type = getTypeFromFlowType(flowType);
- if (ts.getObjectFlags(type) & 256) {
- var evolvedType_1 = type;
- if (node.kind === 196) {
- for (var _i = 0, _a = node.arguments; _i < _a.length; _i++) {
- var arg = _a[_i];
- evolvedType_1 = addEvolvingArrayElementType(evolvedType_1, arg);
- }
- }
- else {
- var indexType = getContextFreeTypeOfExpression(node.left.argumentExpression);
- if (isTypeAssignableToKind(indexType, 296)) {
- evolvedType_1 = addEvolvingArrayElementType(evolvedType_1, node.right);
- }
+ if (kind === 0 || isNumericLiteralName(prop.escapedName)) {
+ var related = isRelatedTo(getTypeOfSymbol(prop), target, reportErrors);
+ if (!related) {
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop));
}
- return evolvedType_1 === type ? flowType : createFlowType(evolvedType_1, isIncomplete(flowType));
+ return 0;
}
- return flowType;
+ result &= related;
}
}
- return undefined;
+ return result;
}
- function getTypeAtFlowCondition(flow) {
- var flowType = getTypeAtFlowNode(flow.antecedent);
- var type = getTypeFromFlowType(flowType);
- if (type.flags & 131072) {
- return flowType;
- }
- var assumeTrue = (flow.flags & 32) !== 0;
- var nonEvolvingType = finalizeEvolvingArrayType(type);
- var narrowedType = narrowType(nonEvolvingType, flow.node, assumeTrue);
- if (narrowedType === nonEvolvingType) {
- return flowType;
+ function indexTypeRelatedTo(sourceType, targetType, reportErrors) {
+ var related = isRelatedTo(sourceType, targetType, reportErrors);
+ if (!related && reportErrors) {
+ reportError(ts.Diagnostics.Index_signatures_are_incompatible);
}
- var incomplete = isIncomplete(flowType);
- var resultType = incomplete && narrowedType.flags & 131072 ? silentNeverType : narrowedType;
- return createFlowType(resultType, incomplete);
+ return related;
}
- function getTypeAtSwitchClause(flow) {
- var expr = flow.switchStatement.expression;
- var flowType = getTypeAtFlowNode(flow.antecedent);
- var type = getTypeFromFlowType(flowType);
- if (isMatchingReference(reference, expr)) {
- type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+ function indexTypesRelatedTo(source, target, kind, sourceIsPrimitive, reportErrors, intersectionState) {
+ if (relation === identityRelation) {
+ return indexTypesIdenticalTo(source, target, kind);
}
- else if (expr.kind === 204 && isMatchingReference(reference, expr.expression)) {
- type = narrowBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+ var targetType = getIndexTypeOfType(target, kind);
+ if (!targetType || targetType.flags & 1 && !sourceIsPrimitive) {
+ return -1;
}
- else {
- if (strictNullChecks) {
- if (optionalChainContainsReference(expr, reference)) {
- type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, function (t) { return !(t.flags & (32768 | 131072)); });
- }
- else if (expr.kind === 204 && optionalChainContainsReference(expr.expression, reference)) {
- type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, function (t) { return !(t.flags & 131072 || t.flags & 128 && t.value === "undefined"); });
+ if (isGenericMappedType(source)) {
+ return getIndexTypeOfType(target, 0) ? isRelatedTo(getTemplateTypeFromMappedType(source), targetType, reportErrors) : 0;
+ }
+ var indexType = getIndexTypeOfType(source, kind) || kind === 1 && getIndexTypeOfType(source, 0);
+ if (indexType) {
+ return indexTypeRelatedTo(indexType, targetType, reportErrors);
+ }
+ if (!(intersectionState & 1) && isObjectTypeWithInferableIndex(source)) {
+ var related = eachPropertyRelatedTo(source, targetType, kind, reportErrors);
+ if (related && kind === 0) {
+ var numberIndexType = getIndexTypeOfType(source, 1);
+ if (numberIndexType) {
+ related &= indexTypeRelatedTo(numberIndexType, targetType, reportErrors);
}
}
- if (isMatchingReferenceDiscriminant(expr, type)) {
- type = narrowTypeByDiscriminant(type, expr, function (t) { return narrowTypeBySwitchOnDiscriminant(t, flow.switchStatement, flow.clauseStart, flow.clauseEnd); });
- }
+ return related;
}
- return createFlowType(type, isIncomplete(flowType));
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
+ }
+ return 0;
}
- function getTypeAtFlowBranchLabel(flow) {
- var antecedentTypes = [];
- var subtypeReduction = false;
- var seenIncomplete = false;
- var bypassFlow;
- for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) {
- var antecedent = _a[_i];
- if (!bypassFlow && antecedent.flags & 128 && antecedent.clauseStart === antecedent.clauseEnd) {
- bypassFlow = antecedent;
- continue;
- }
- var flowType = getTypeAtFlowNode(antecedent);
- var type = getTypeFromFlowType(flowType);
- if (type === declaredType && declaredType === initialType) {
- return type;
- }
- ts.pushIfUnique(antecedentTypes, type);
- if (!isTypeSubsetOf(type, declaredType)) {
- subtypeReduction = true;
+ function indexTypesIdenticalTo(source, target, indexKind) {
+ var targetInfo = getIndexInfoOfType(target, indexKind);
+ var sourceInfo = getIndexInfoOfType(source, indexKind);
+ if (!sourceInfo && !targetInfo) {
+ return -1;
+ }
+ if (sourceInfo && targetInfo && sourceInfo.isReadonly === targetInfo.isReadonly) {
+ return isRelatedTo(sourceInfo.type, targetInfo.type);
+ }
+ return 0;
+ }
+ function constructorVisibilitiesAreCompatible(sourceSignature, targetSignature, reportErrors) {
+ if (!sourceSignature.declaration || !targetSignature.declaration) {
+ return true;
+ }
+ var sourceAccessibility = ts.getSelectedEffectiveModifierFlags(sourceSignature.declaration, 24);
+ var targetAccessibility = ts.getSelectedEffectiveModifierFlags(targetSignature.declaration, 24);
+ if (targetAccessibility === 8) {
+ return true;
+ }
+ if (targetAccessibility === 16 && sourceAccessibility !== 8) {
+ return true;
+ }
+ if (targetAccessibility !== 16 && !sourceAccessibility) {
+ return true;
+ }
+ if (reportErrors) {
+ reportError(ts.Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type, visibilityToString(sourceAccessibility), visibilityToString(targetAccessibility));
+ }
+ return false;
+ }
+ }
+ function typeCouldHaveTopLevelSingletonTypes(type) {
+ if (type.flags & 16) {
+ return false;
+ }
+ if (type.flags & 3145728) {
+ return !!ts.forEach(type.types, typeCouldHaveTopLevelSingletonTypes);
+ }
+ if (type.flags & 465829888) {
+ var constraint = getConstraintOfType(type);
+ if (constraint && constraint !== type) {
+ return typeCouldHaveTopLevelSingletonTypes(constraint);
+ }
+ }
+ return isUnitType(type) || !!(type.flags & 134217728);
+ }
+ function getBestMatchingType(source, target, isRelatedTo) {
+ if (isRelatedTo === void 0) { 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) {
+ var discriminable = target.types.map(function (_) { return undefined; });
+ for (var _i = 0, discriminators_1 = discriminators; _i < discriminators_1.length; _i++) {
+ var _a = discriminators_1[_i], getDiscriminatingType = _a[0], propertyName = _a[1];
+ var targetProp = getUnionOrIntersectionProperty(target, propertyName);
+ if (skipPartial && targetProp && ts.getCheckFlags(targetProp) & 16) {
+ continue;
+ }
+ var i = 0;
+ for (var _b = 0, _c = target.types; _b < _c.length; _b++) {
+ var type = _c[_b];
+ var targetType = getTypeOfPropertyOfType(type, propertyName);
+ if (targetType && related(getDiscriminatingType(), targetType)) {
+ discriminable[i] = discriminable[i] === undefined ? true : discriminable[i];
}
- if (isIncomplete(flowType)) {
- seenIncomplete = true;
+ else {
+ discriminable[i] = false;
}
+ i++;
}
- if (bypassFlow) {
- var flowType = getTypeAtFlowNode(bypassFlow);
- var type = getTypeFromFlowType(flowType);
- if (!ts.contains(antecedentTypes, type) && !isExhaustiveSwitchStatement(bypassFlow.switchStatement)) {
- if (type === declaredType && declaredType === initialType) {
- return type;
- }
- antecedentTypes.push(type);
- if (!isTypeSubsetOf(type, declaredType)) {
- subtypeReduction = true;
+ }
+ var match = discriminable.indexOf(true);
+ if (match === -1) {
+ return defaultValue;
+ }
+ var 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) {
+ var resolved = resolveStructuredTypeMembers(type);
+ return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 &&
+ !resolved.stringIndexInfo && !resolved.numberIndexInfo &&
+ resolved.properties.length > 0 &&
+ ts.every(resolved.properties, function (p) { return !!(p.flags & 16777216); });
+ }
+ if (type.flags & 2097152) {
+ return ts.every(type.types, isWeakType);
+ }
+ return false;
+ }
+ function hasCommonProperties(source, target, isComparingJsxAttributes) {
+ for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) {
+ var prop = _a[_i];
+ if (isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ function getMarkerTypeReference(type, source, target) {
+ var result = createTypeReference(type, ts.map(type.typeParameters, function (t) { return t === source ? target : t; }));
+ result.objectFlags |= 8192;
+ return result;
+ }
+ function getAliasVariances(symbol) {
+ var links = getSymbolLinks(symbol);
+ return getVariancesWorker(links.typeParameters, links, function (_links, param, marker) {
+ var type = getTypeAliasInstantiation(symbol, instantiateTypes(links.typeParameters, makeUnaryTypeMapper(param, marker)));
+ type.aliasTypeArgumentsContainsMarker = true;
+ return type;
+ });
+ }
+ function getVariancesWorker(typeParameters, cache, createMarkerType) {
+ var _a, _b, _c;
+ if (typeParameters === void 0) { typeParameters = ts.emptyArray; }
+ var variances = cache.variances;
+ if (!variances) {
+ ts.tracing.push("check", "getVariancesWorker", { arity: typeParameters.length, id: (_c = (_a = cache.id) !== null && _a !== void 0 ? _a : (_b = cache.declaredType) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : -1 });
+ cache.variances = ts.emptyArray;
+ variances = [];
+ var _loop_19 = function (tp) {
+ var unmeasurable = false;
+ var unreliable = false;
+ var oldHandler = outofbandVarianceMarkerHandler;
+ outofbandVarianceMarkerHandler = function (onlyUnreliable) { return onlyUnreliable ? unreliable = true : unmeasurable = true; };
+ var typeWithSuper = createMarkerType(cache, tp, markerSuperType);
+ var typeWithSub = createMarkerType(cache, tp, markerSubType);
+ var variance = (isTypeAssignableTo(typeWithSub, typeWithSuper) ? 1 : 0) |
+ (isTypeAssignableTo(typeWithSuper, typeWithSub) ? 2 : 0);
+ if (variance === 3 && isTypeAssignableTo(createMarkerType(cache, tp, markerOtherType), typeWithSuper)) {
+ variance = 4;
+ }
+ outofbandVarianceMarkerHandler = oldHandler;
+ if (unmeasurable || unreliable) {
+ if (unmeasurable) {
+ variance |= 8;
}
- if (isIncomplete(flowType)) {
- seenIncomplete = true;
+ if (unreliable) {
+ variance |= 16;
}
}
+ variances.push(variance);
+ };
+ for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) {
+ var tp = typeParameters_1[_i];
+ _loop_19(tp);
+ }
+ cache.variances = variances;
+ ts.tracing.pop();
+ }
+ return variances;
+ }
+ function getVariances(type) {
+ if (type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & 8) {
+ return arrayVariances;
+ }
+ return getVariancesWorker(type.typeParameters, type, getMarkerTypeReference);
+ }
+ function hasCovariantVoidArgument(typeArguments, variances) {
+ for (var i = 0; i < variances.length; i++) {
+ if ((variances[i] & 7) === 1 && typeArguments[i].flags & 16384) {
+ return true;
+ }
+ }
+ return false;
+ }
+ function isUnconstrainedTypeParameter(type) {
+ return type.flags & 262144 && !getConstraintOfTypeParameter(type);
+ }
+ function isNonDeferredTypeReference(type) {
+ return !!(ts.getObjectFlags(type) & 4) && !type.node;
+ }
+ function isTypeReferenceWithGenericArguments(type) {
+ return isNonDeferredTypeReference(type) && ts.some(getTypeArguments(type), function (t) { return isUnconstrainedTypeParameter(t) || isTypeReferenceWithGenericArguments(t); });
+ }
+ function getTypeReferenceId(type, typeParameters, depth) {
+ if (depth === void 0) { depth = 0; }
+ var result = "" + type.target.id;
+ for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) {
+ var t = _a[_i];
+ if (isUnconstrainedTypeParameter(t)) {
+ var index = typeParameters.indexOf(t);
+ if (index < 0) {
+ index = typeParameters.length;
+ typeParameters.push(t);
+ }
+ result += "=" + index;
}
- return createFlowType(getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 : 1), seenIncomplete);
- }
- function getTypeAtFlowLoopLabel(flow) {
- var id = getFlowNodeId(flow);
- var cache = flowLoopCaches[id] || (flowLoopCaches[id] = ts.createMap());
- var key = getOrSetCacheKey();
- if (!key) {
- return declaredType;
+ else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
+ result += "<" + getTypeReferenceId(t, typeParameters, depth + 1) + ">";
}
- var cached = cache.get(key);
- if (cached) {
- return cached;
+ else {
+ result += "-" + t.id;
}
- for (var i = flowLoopStart; i < flowLoopCount; i++) {
- if (flowLoopNodes[i] === flow && flowLoopKeys[i] === key && flowLoopTypes[i].length) {
- return createFlowType(getUnionOrEvolvingArrayType(flowLoopTypes[i], 1), true);
+ }
+ return result;
+ }
+ function getRelationKey(source, target, intersectionState, relation) {
+ if (relation === identityRelation && source.id > target.id) {
+ var temp = source;
+ source = target;
+ target = temp;
+ }
+ var postFix = intersectionState ? ":" + intersectionState : "";
+ if (isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target)) {
+ var typeParameters = [];
+ return getTypeReferenceId(source, typeParameters) + "," + getTypeReferenceId(target, typeParameters) + postFix;
+ }
+ return source.id + "," + target.id + postFix;
+ }
+ function forEachProperty(prop, callback) {
+ if (ts.getCheckFlags(prop) & 6) {
+ for (var _i = 0, _a = prop.containingType.types; _i < _a.length; _i++) {
+ var t = _a[_i];
+ var p = getPropertyOfType(t, prop.escapedName);
+ var result = p && forEachProperty(p, callback);
+ if (result) {
+ return result;
}
}
- var antecedentTypes = [];
- var subtypeReduction = false;
- var firstAntecedentType;
- for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) {
- var antecedent = _a[_i];
- var flowType = void 0;
- if (!firstAntecedentType) {
- flowType = firstAntecedentType = getTypeAtFlowNode(antecedent);
- }
- else {
- flowLoopNodes[flowLoopCount] = flow;
- flowLoopKeys[flowLoopCount] = key;
- flowLoopTypes[flowLoopCount] = antecedentTypes;
- flowLoopCount++;
- var saveFlowTypeCache = flowTypeCache;
- flowTypeCache = undefined;
- flowType = getTypeAtFlowNode(antecedent);
- flowTypeCache = saveFlowTypeCache;
- flowLoopCount--;
- var cached_1 = cache.get(key);
- if (cached_1) {
- return cached_1;
+ return undefined;
+ }
+ return callback(prop);
+ }
+ function getDeclaringClass(prop) {
+ return prop.parent && prop.parent.flags & 32 ? getDeclaredTypeOfSymbol(getParentOfSymbol(prop)) : undefined;
+ }
+ function getTypeOfPropertyInBaseClass(property) {
+ var classType = getDeclaringClass(property);
+ var baseClassType = classType && getBaseTypes(classType)[0];
+ return baseClassType && getTypeOfPropertyOfType(baseClassType, property.escapedName);
+ }
+ function isPropertyInClassDerivedFrom(prop, baseClass) {
+ return forEachProperty(prop, function (sp) {
+ var sourceClass = getDeclaringClass(sp);
+ return sourceClass ? hasBaseType(sourceClass, baseClass) : false;
+ });
+ }
+ function isValidOverrideOf(sourceProp, targetProp) {
+ return !forEachProperty(targetProp, function (tp) { return ts.getDeclarationModifierFlagsFromSymbol(tp) & 16 ?
+ !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false; });
+ }
+ function isClassDerivedFromDeclaringClasses(checkClass, prop) {
+ return forEachProperty(prop, function (p) { return ts.getDeclarationModifierFlagsFromSymbol(p) & 16 ?
+ !hasBaseType(checkClass, getDeclaringClass(p)) : false; }) ? undefined : checkClass;
+ }
+ function isDeeplyNestedType(type, stack, depth) {
+ if (depth >= 5) {
+ var identity_1 = getRecursionIdentity(type);
+ if (identity_1) {
+ var count = 0;
+ for (var i = 0; i < depth; i++) {
+ if (getRecursionIdentity(stack[i]) === identity_1) {
+ count++;
+ if (count >= 5) {
+ return true;
+ }
}
}
- var type = getTypeFromFlowType(flowType);
- ts.pushIfUnique(antecedentTypes, type);
- if (!isTypeSubsetOf(type, declaredType)) {
- subtypeReduction = true;
- }
- if (type === declaredType) {
- break;
- }
- }
- var result = getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 : 1);
- if (isIncomplete(firstAntecedentType)) {
- return createFlowType(result, true);
}
- cache.set(key, result);
- return result;
}
- function isMatchingReferenceDiscriminant(expr, computedType) {
- if (!(computedType.flags & 1048576) || !ts.isAccessExpression(expr)) {
- return false;
+ return false;
+ }
+ function getRecursionIdentity(type) {
+ if (type.flags & 524288 && !isObjectOrArrayLiteralType(type)) {
+ if (ts.getObjectFlags(type) && 4 && type.node) {
+ return type.node;
}
- var name = getAccessedPropertyName(expr);
- if (name === undefined) {
- return false;
+ if (type.symbol && !(ts.getObjectFlags(type) & 16 && type.symbol.flags & 32)) {
+ return type.symbol;
+ }
+ if (isTupleType(type)) {
+ return type.target;
}
- return isMatchingReference(reference, expr.expression) && isDiscriminantProperty(computedType, name);
}
- function narrowTypeByDiscriminant(type, access, narrowType) {
- var propName = getAccessedPropertyName(access);
- if (propName === undefined) {
- return type;
+ if (type.flags & 8388608) {
+ do {
+ type = type.objectType;
+ } while (type.flags & 8388608);
+ return type;
+ }
+ if (type.flags & 16777216) {
+ return type.root;
+ }
+ return undefined;
+ }
+ function isPropertyIdenticalTo(sourceProp, targetProp) {
+ return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== 0;
+ }
+ function compareProperties(sourceProp, targetProp, compareTypes) {
+ if (sourceProp === targetProp) {
+ return -1;
+ }
+ var sourcePropAccessibility = ts.getDeclarationModifierFlagsFromSymbol(sourceProp) & 24;
+ var targetPropAccessibility = ts.getDeclarationModifierFlagsFromSymbol(targetProp) & 24;
+ if (sourcePropAccessibility !== targetPropAccessibility) {
+ return 0;
+ }
+ if (sourcePropAccessibility) {
+ if (getTargetSymbol(sourceProp) !== getTargetSymbol(targetProp)) {
+ return 0;
}
- var propType = getTypeOfPropertyOfType(type, propName);
- if (!propType) {
- return type;
+ }
+ else {
+ if ((sourceProp.flags & 16777216) !== (targetProp.flags & 16777216)) {
+ return 0;
}
- var narrowedPropType = narrowType(propType);
- return filterType(type, function (t) {
- var discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
- return !(discriminantType.flags & 131072) && isTypeComparableTo(discriminantType, narrowedPropType);
- });
}
- function narrowTypeByTruthiness(type, expr, assumeTrue) {
- if (isMatchingReference(reference, expr)) {
- return getTypeWithFacts(type, assumeTrue ? 4194304 : 8388608);
+ if (isReadonlySymbol(sourceProp) !== isReadonlySymbol(targetProp)) {
+ return 0;
+ }
+ return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
+ }
+ function isMatchingSignature(source, target, partialMatch) {
+ var sourceParameterCount = getParameterCount(source);
+ var targetParameterCount = getParameterCount(target);
+ var sourceMinArgumentCount = getMinArgumentCount(source);
+ var targetMinArgumentCount = getMinArgumentCount(target);
+ var sourceHasRestParameter = hasEffectiveRestParameter(source);
+ var targetHasRestParameter = hasEffectiveRestParameter(target);
+ 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;
+ }
+ if (!(isMatchingSignature(source, target, partialMatch))) {
+ return 0;
+ }
+ if (ts.length(source.typeParameters) !== ts.length(target.typeParameters)) {
+ return 0;
+ }
+ if (target.typeParameters) {
+ var mapper = createTypeMapper(source.typeParameters, target.typeParameters);
+ for (var i = 0; i < target.typeParameters.length; i++) {
+ var s = source.typeParameters[i];
+ var t = target.typeParameters[i];
+ if (!(s === t || compareTypes(instantiateType(getConstraintFromTypeParameter(s), mapper) || unknownType, getConstraintFromTypeParameter(t) || unknownType) &&
+ compareTypes(instantiateType(getDefaultFromTypeParameter(s), mapper) || unknownType, getDefaultFromTypeParameter(t) || unknownType))) {
+ return 0;
+ }
}
- if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) {
- type = getTypeWithFacts(type, 2097152);
+ source = instantiateSignature(source, mapper, true);
+ }
+ var result = -1;
+ if (!ignoreThisTypes) {
+ var sourceThisType = getThisTypeOfSignature(source);
+ if (sourceThisType) {
+ var targetThisType = getThisTypeOfSignature(target);
+ if (targetThisType) {
+ var related = compareTypes(sourceThisType, targetThisType);
+ if (!related) {
+ return 0;
+ }
+ result &= related;
+ }
}
- if (isMatchingReferenceDiscriminant(expr, declaredType)) {
- return narrowTypeByDiscriminant(type, expr, function (t) { return getTypeWithFacts(t, assumeTrue ? 4194304 : 8388608); });
+ }
+ var targetLen = getParameterCount(target);
+ for (var i = 0; i < targetLen; i++) {
+ var s = getTypeAtPosition(source, i);
+ var t = getTypeAtPosition(target, i);
+ var related = compareTypes(t, s);
+ if (!related) {
+ return 0;
}
- return type;
+ result &= related;
}
- function isTypePresencePossible(type, propName, assumeTrue) {
- if (getIndexInfoOfType(type, 0)) {
- return true;
+ if (!ignoreReturnTypes) {
+ var sourceTypePredicate = getTypePredicateOfSignature(source);
+ var targetTypePredicate = getTypePredicateOfSignature(target);
+ result &= sourceTypePredicate || targetTypePredicate ?
+ compareTypePredicatesIdentical(sourceTypePredicate, targetTypePredicate, compareTypes) :
+ compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
+ }
+ return result;
+ }
+ function compareTypePredicatesIdentical(source, target, compareTypes) {
+ return !(source && target && typePredicateKindsMatch(source, target)) ? 0 :
+ source.type === target.type ? -1 :
+ source.type && target.type ? compareTypes(source.type, target.type) :
+ 0;
+ }
+ function literalTypesWithSameBaseType(types) {
+ var commonBaseType;
+ for (var _i = 0, types_13 = types; _i < types_13.length; _i++) {
+ var t = types_13[_i];
+ var baseType = getBaseTypeOfLiteralType(t);
+ if (!commonBaseType) {
+ commonBaseType = baseType;
}
- var prop = getPropertyOfType(type, propName);
- if (prop) {
- return prop.flags & 16777216 ? true : assumeTrue;
+ if (baseType === t || baseType !== commonBaseType) {
+ return false;
}
- return !assumeTrue;
}
- function narrowByInKeyword(type, literal, assumeTrue) {
- if (type.flags & (1048576 | 524288) || isThisTypeParameter(type)) {
- var propName_1 = ts.escapeLeadingUnderscores(literal.text);
- return filterType(type, function (t) { return isTypePresencePossible(t, propName_1, assumeTrue); });
- }
- return type;
+ return true;
+ }
+ function getSupertypeOrUnion(types) {
+ return literalTypesWithSameBaseType(types) ?
+ getUnionType(types) :
+ ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+ }
+ function getCommonSupertype(types) {
+ if (!strictNullChecks) {
+ return getSupertypeOrUnion(types);
}
- function narrowTypeByBinaryExpression(type, expr, assumeTrue) {
- switch (expr.operatorToken.kind) {
- case 62:
- return narrowTypeByTruthiness(narrowType(type, expr.right, assumeTrue), expr.left, assumeTrue);
- case 34:
- case 35:
- case 36:
- case 37:
- var operator_1 = expr.operatorToken.kind;
- var left_1 = getReferenceCandidate(expr.left);
- var right_1 = getReferenceCandidate(expr.right);
- if (left_1.kind === 204 && ts.isStringLiteralLike(right_1)) {
- return narrowTypeByTypeof(type, left_1, operator_1, right_1, assumeTrue);
- }
- if (right_1.kind === 204 && ts.isStringLiteralLike(left_1)) {
- return narrowTypeByTypeof(type, right_1, operator_1, left_1, assumeTrue);
- }
- if (isMatchingReference(reference, left_1)) {
- return narrowTypeByEquality(type, operator_1, right_1, assumeTrue);
- }
- if (isMatchingReference(reference, right_1)) {
- return narrowTypeByEquality(type, operator_1, left_1, assumeTrue);
- }
- if (strictNullChecks) {
- if (optionalChainContainsReference(left_1, reference)) {
- type = narrowTypeByOptionalChainContainment(type, operator_1, right_1, assumeTrue);
- }
- else if (optionalChainContainsReference(right_1, reference)) {
- type = narrowTypeByOptionalChainContainment(type, operator_1, left_1, assumeTrue);
- }
- }
- if (isMatchingReferenceDiscriminant(left_1, declaredType)) {
- return narrowTypeByDiscriminant(type, left_1, function (t) { return narrowTypeByEquality(t, operator_1, right_1, assumeTrue); });
- }
- if (isMatchingReferenceDiscriminant(right_1, declaredType)) {
- return narrowTypeByDiscriminant(type, right_1, function (t) { return narrowTypeByEquality(t, operator_1, left_1, assumeTrue); });
- }
- if (isMatchingConstructorReference(left_1)) {
- return narrowTypeByConstructor(type, operator_1, right_1, assumeTrue);
- }
- if (isMatchingConstructorReference(right_1)) {
- return narrowTypeByConstructor(type, operator_1, left_1, assumeTrue);
- }
- break;
- case 98:
- return narrowTypeByInstanceof(type, expr, assumeTrue);
- case 97:
- var target = getReferenceCandidate(expr.right);
- if (ts.isStringLiteralLike(expr.left) && isMatchingReference(reference, target)) {
- return narrowByInKeyword(type, expr.left, assumeTrue);
- }
- break;
- case 27:
- return narrowType(type, expr.right, assumeTrue);
+ var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304); });
+ return primaryTypes.length ?
+ getNullableType(getSupertypeOrUnion(primaryTypes), getFalsyFlagsOfTypes(types) & 98304) :
+ getUnionType(types, 2);
+ }
+ function getCommonSubtype(types) {
+ return ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(t, s) ? t : s; });
+ }
+ function isArrayType(type) {
+ return !!(ts.getObjectFlags(type) & 4) && (type.target === globalArrayType || type.target === globalReadonlyArrayType);
+ }
+ function isReadonlyArrayType(type) {
+ return !!(ts.getObjectFlags(type) & 4) && type.target === globalReadonlyArrayType;
+ }
+ function isMutableArrayOrTuple(type) {
+ return isArrayType(type) && !isReadonlyArrayType(type) || isTupleType(type) && !type.target.readonly;
+ }
+ function getElementTypeOfArrayType(type) {
+ return isArrayType(type) ? getTypeArguments(type)[0] : undefined;
+ }
+ function isArrayLikeType(type) {
+ return isArrayType(type) || !(type.flags & 98304) && isTypeAssignableTo(type, anyReadonlyArrayType);
+ }
+ function isEmptyArrayLiteralType(type) {
+ var elementType = isArrayType(type) ? getTypeArguments(type)[0] : undefined;
+ return elementType === undefinedWideningType || elementType === implicitNeverType;
+ }
+ function isTupleLikeType(type) {
+ return isTupleType(type) || !!getPropertyOfType(type, "0");
+ }
+ function isArrayOrTupleLikeType(type) {
+ return isArrayLikeType(type) || isTupleLikeType(type);
+ }
+ function getTupleElementType(type, index) {
+ var propType = getTypeOfPropertyOfType(type, "" + index);
+ if (propType) {
+ return propType;
+ }
+ if (everyType(type, isTupleType)) {
+ return mapType(type, function (t) { return getRestTypeOfTupleType(t) || undefinedType; });
+ }
+ return undefined;
+ }
+ function isNeitherUnitTypeNorNever(type) {
+ return !(type.flags & (109440 | 131072));
+ }
+ function isUnitType(type) {
+ return !!(type.flags & 109440);
+ }
+ function isLiteralType(type) {
+ return type.flags & 16 ? true :
+ type.flags & 1048576 ? type.flags & 1024 ? true : ts.every(type.types, isUnitType) :
+ isUnitType(type);
+ }
+ function getBaseTypeOfLiteralType(type) {
+ return type.flags & 1024 ? getBaseTypeOfEnumLiteralType(type) :
+ type.flags & 128 ? stringType :
+ type.flags & 256 ? numberType :
+ type.flags & 2048 ? bigintType :
+ type.flags & 512 ? booleanType :
+ type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getBaseTypeOfLiteralType)) :
+ type;
+ }
+ function getWidenedLiteralType(type) {
+ return type.flags & 1024 && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type) :
+ type.flags & 128 && isFreshLiteralType(type) ? stringType :
+ type.flags & 256 && isFreshLiteralType(type) ? numberType :
+ type.flags & 2048 && isFreshLiteralType(type) ? bigintType :
+ type.flags & 512 && isFreshLiteralType(type) ? booleanType :
+ type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getWidenedLiteralType)) :
+ type;
+ }
+ function getWidenedUniqueESSymbolType(type) {
+ return type.flags & 8192 ? esSymbolType :
+ type.flags & 1048576 ? getUnionType(ts.sameMap(type.types, getWidenedUniqueESSymbolType)) :
+ type;
+ }
+ function getWidenedLiteralLikeTypeForContextualType(type, contextualType) {
+ if (!isLiteralOfContextualType(type, contextualType)) {
+ type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
+ }
+ return type;
+ }
+ function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
+ if (type && isUnitType(type)) {
+ var contextualType = !contextualSignatureReturnType ? undefined :
+ isAsync ? getPromisedTypeOfPromise(contextualSignatureReturnType) :
+ contextualSignatureReturnType;
+ type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
+ }
+ return type;
+ }
+ function getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(type, contextualSignatureReturnType, kind, isAsyncGenerator) {
+ if (type && isUnitType(type)) {
+ var contextualType = !contextualSignatureReturnType ? undefined :
+ getIterationTypeOfGeneratorFunctionReturnType(kind, contextualSignatureReturnType, isAsyncGenerator);
+ type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
+ }
+ return type;
+ }
+ function isTupleType(type) {
+ return !!(ts.getObjectFlags(type) & 4 && type.target.objectFlags & 8);
+ }
+ function isGenericTupleType(type) {
+ return isTupleType(type) && !!(type.target.combinedFlags & 8);
+ }
+ function isSingleElementGenericTupleType(type) {
+ return isGenericTupleType(type) && type.target.elementFlags.length === 1;
+ }
+ function getRestTypeOfTupleType(type) {
+ return getElementTypeOfSliceOfTupleType(type, type.target.fixedLength);
+ }
+ function getRestArrayTypeOfTupleType(type) {
+ var restType = getRestTypeOfTupleType(type);
+ return restType && createArrayType(restType);
+ }
+ function getEndLengthOfType(type) {
+ return isTupleType(type) ? getTypeReferenceArity(type) - ts.findLastIndex(type.target.elementFlags, function (f) { return !(f & (1 | 2)); }) - 1 : 0;
+ }
+ function getElementTypeOfSliceOfTupleType(type, index, endSkipCount, writing) {
+ if (endSkipCount === void 0) { endSkipCount = 0; }
+ if (writing === void 0) { writing = false; }
+ var length = getTypeReferenceArity(type) - endSkipCount;
+ if (index < length) {
+ var typeArguments = getTypeArguments(type);
+ var elementTypes = [];
+ for (var i = index; i < length; i++) {
+ var t = typeArguments[i];
+ elementTypes.push(type.target.elementFlags[i] & 8 ? getIndexedAccessType(t, numberType) : t);
}
- return type;
+ return writing ? getIntersectionType(elementTypes) : getUnionType(elementTypes);
+ }
+ return undefined;
+ }
+ function isTupleTypeStructureMatching(t1, t2) {
+ return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) &&
+ ts.every(t1.target.elementFlags, function (f, i) { return (f & 12) === (t2.target.elementFlags[i] & 12); });
+ }
+ function isZeroBigInt(_a) {
+ var value = _a.value;
+ return value.base10Value === "0";
+ }
+ function getFalsyFlagsOfTypes(types) {
+ var result = 0;
+ for (var _i = 0, types_14 = types; _i < types_14.length; _i++) {
+ var t = types_14[_i];
+ result |= getFalsyFlags(t);
+ }
+ return result;
+ }
+ function getFalsyFlags(type) {
+ return type.flags & 1048576 ? getFalsyFlagsOfTypes(type.types) :
+ type.flags & 128 ? type.value === "" ? 128 : 0 :
+ type.flags & 256 ? type.value === 0 ? 256 : 0 :
+ type.flags & 2048 ? isZeroBigInt(type) ? 2048 : 0 :
+ type.flags & 512 ? (type === falseType || type === regularFalseType) ? 512 : 0 :
+ type.flags & 117724;
+ }
+ function removeDefinitelyFalsyTypes(type) {
+ return getFalsyFlags(type) & 117632 ?
+ filterType(type, function (t) { return !(getFalsyFlags(t) & 117632); }) :
+ type;
+ }
+ function extractDefinitelyFalsyTypes(type) {
+ return mapType(type, getDefinitelyFalsyPartOfType);
+ }
+ function getDefinitelyFalsyPartOfType(type) {
+ return type.flags & 4 ? emptyStringType :
+ type.flags & 8 ? zeroType :
+ type.flags & 64 ? zeroBigIntType :
+ type === regularFalseType ||
+ type === falseType ||
+ type.flags & (16384 | 32768 | 65536 | 3) ||
+ type.flags & 128 && type.value === "" ||
+ type.flags & 256 && type.value === 0 ||
+ type.flags & 2048 && isZeroBigInt(type) ? type :
+ neverType;
+ }
+ function getNullableType(type, flags) {
+ var missing = (flags & ~type.flags) & (32768 | 65536);
+ return missing === 0 ? type :
+ missing === 32768 ? getUnionType([type, undefinedType]) :
+ missing === 65536 ? getUnionType([type, nullType]) :
+ getUnionType([type, undefinedType, nullType]);
+ }
+ function getOptionalType(type) {
+ ts.Debug.assert(strictNullChecks);
+ return type.flags & 32768 ? type : getUnionType([type, undefinedType]);
+ }
+ function getGlobalNonNullableTypeInstantiation(type) {
+ if (!deferredGlobalNonNullableTypeAlias) {
+ deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable", 524288, undefined) || unknownSymbol;
+ }
+ if (deferredGlobalNonNullableTypeAlias !== unknownSymbol) {
+ return getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]);
+ }
+ return getTypeWithFacts(type, 2097152);
+ }
+ function getNonNullableType(type) {
+ return strictNullChecks ? getGlobalNonNullableTypeInstantiation(type) : type;
+ }
+ function addOptionalTypeMarker(type) {
+ return strictNullChecks ? getUnionType([type, optionalType]) : type;
+ }
+ function isNotOptionalTypeMarker(type) {
+ return type !== optionalType;
+ }
+ function removeOptionalTypeMarker(type) {
+ return strictNullChecks ? filterType(type, isNotOptionalTypeMarker) : type;
+ }
+ function propagateOptionalTypeMarker(type, node, wasOptional) {
+ return wasOptional ? ts.isOutermostOptionalChain(node) ? getOptionalType(type) : addOptionalTypeMarker(type) : type;
+ }
+ function getOptionalExpressionType(exprType, expression) {
+ return ts.isExpressionOfOptionalChainRoot(expression) ? getNonNullableType(exprType) :
+ ts.isOptionalChain(expression) ? removeOptionalTypeMarker(exprType) :
+ exprType;
+ }
+ function isCoercibleUnderDoubleEquals(source, target) {
+ return ((source.flags & (8 | 4 | 512)) !== 0)
+ && ((target.flags & (8 | 4 | 16)) !== 0);
+ }
+ function isObjectTypeWithInferableIndex(type) {
+ return type.flags & 2097152 ? ts.every(type.types, isObjectTypeWithInferableIndex) :
+ !!(type.symbol && (type.symbol.flags & (4096 | 2048 | 384 | 512)) !== 0 &&
+ !typeHasCallOrConstructSignatures(type)) || !!(ts.getObjectFlags(type) & 2048 && isObjectTypeWithInferableIndex(type.source));
+ }
+ function createSymbolWithType(source, type) {
+ var symbol = createSymbol(source.flags, source.escapedName, ts.getCheckFlags(source) & 8);
+ symbol.declarations = source.declarations;
+ symbol.parent = source.parent;
+ symbol.type = type;
+ symbol.target = source;
+ if (source.valueDeclaration) {
+ symbol.valueDeclaration = source.valueDeclaration;
}
- function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) {
- var equalsOperator = operator === 34 || operator === 36;
- var nullableFlags = operator === 34 || operator === 35 ? 98304 : 32768;
- var valueType = getTypeOfExpression(value);
- var removeNullable = equalsOperator !== assumeTrue && everyType(valueType, function (t) { return !!(t.flags & nullableFlags); }) ||
- equalsOperator === assumeTrue && everyType(valueType, function (t) { return !(t.flags & (3 | nullableFlags)); });
- return removeNullable ? getTypeWithFacts(type, 2097152) : type;
+ var nameType = getSymbolLinks(source).nameType;
+ if (nameType) {
+ symbol.nameType = nameType;
}
- function narrowTypeByEquality(type, operator, value, assumeTrue) {
- if (type.flags & 1) {
- return type;
- }
- if (operator === 35 || operator === 37) {
- assumeTrue = !assumeTrue;
- }
- var valueType = getTypeOfExpression(value);
- if ((type.flags & 2) && assumeTrue && (operator === 36 || operator === 37)) {
- if (valueType.flags & (131068 | 67108864)) {
- return valueType;
- }
- if (valueType.flags & 524288) {
- return nonPrimitiveType;
- }
- return type;
- }
- if (valueType.flags & 98304) {
- if (!strictNullChecks) {
- return type;
- }
- var doubleEquals = operator === 34 || operator === 35;
- var facts = doubleEquals ?
- assumeTrue ? 262144 : 2097152 :
- valueType.flags & 65536 ?
- assumeTrue ? 131072 : 1048576 :
- assumeTrue ? 65536 : 524288;
- return getTypeWithFacts(type, facts);
- }
- if (type.flags & 67637251) {
- return type;
- }
- if (assumeTrue) {
- var filterFn = operator === 34 ?
- (function (t) { return areTypesComparable(t, valueType) || isCoercibleUnderDoubleEquals(t, valueType); }) :
- function (t) { return areTypesComparable(t, valueType); };
- var narrowedType = filterType(type, filterFn);
- return narrowedType.flags & 131072 ? type : replacePrimitivesWithLiterals(narrowedType, valueType);
- }
- if (isUnitType(valueType)) {
- var regularType_1 = getRegularTypeOfLiteralType(valueType);
- return filterType(type, function (t) { return isUnitType(t) ? !areTypesComparable(t, valueType) : getRegularTypeOfLiteralType(t) !== regularType_1; });
- }
+ return symbol;
+ }
+ function transformTypeOfMembers(type, f) {
+ var members = ts.createSymbolTable();
+ for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) {
+ var property = _a[_i];
+ var original = getTypeOfSymbol(property);
+ var updated = f(original);
+ members.set(property.escapedName, updated === original ? property : createSymbolWithType(property, updated));
+ }
+ return members;
+ }
+ function getRegularTypeOfObjectLiteral(type) {
+ if (!(isObjectLiteralType(type) && ts.getObjectFlags(type) & 32768)) {
return type;
}
- function narrowTypeByTypeof(type, typeOfExpr, operator, literal, assumeTrue) {
- if (operator === 35 || operator === 37) {
- assumeTrue = !assumeTrue;
- }
- var target = getReferenceCandidate(typeOfExpr.expression);
- if (!isMatchingReference(reference, target)) {
- if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
- return getTypeWithFacts(type, 2097152);
- }
- return type;
- }
- if (type.flags & 1 && literal.text === "function") {
- return type;
- }
- if (assumeTrue && type.flags & 2 && literal.text === "object") {
- if (typeOfExpr.parent.parent.kind === 209) {
- var expr = typeOfExpr.parent.parent;
- if (expr.operatorToken.kind === 55 && expr.right === typeOfExpr.parent && containsTruthyCheck(reference, expr.left)) {
- return nonPrimitiveType;
+ var regularType = type.regularType;
+ if (regularType) {
+ return regularType;
+ }
+ var resolved = type;
+ var members = transformTypeOfMembers(type, getRegularTypeOfObjectLiteral);
+ var regularNew = createAnonymousType(resolved.symbol, members, resolved.callSignatures, resolved.constructSignatures, resolved.stringIndexInfo, resolved.numberIndexInfo);
+ regularNew.flags = resolved.flags;
+ regularNew.objectFlags |= resolved.objectFlags & ~32768;
+ type.regularType = regularNew;
+ return regularNew;
+ }
+ function createWideningContext(parent, propertyName, siblings) {
+ return { parent: parent, propertyName: propertyName, siblings: siblings, resolvedProperties: undefined };
+ }
+ function getSiblingsOfContext(context) {
+ if (!context.siblings) {
+ var siblings_1 = [];
+ for (var _i = 0, _a = getSiblingsOfContext(context.parent); _i < _a.length; _i++) {
+ var type = _a[_i];
+ if (isObjectLiteralType(type)) {
+ var prop = getPropertyOfObjectType(type, context.propertyName);
+ if (prop) {
+ forEachType(getTypeOfSymbol(prop), function (t) {
+ siblings_1.push(t);
+ });
}
}
- return getUnionType([nonPrimitiveType, nullType]);
}
- var facts = assumeTrue ?
- typeofEQFacts.get(literal.text) || 128 :
- typeofNEFacts.get(literal.text) || 32768;
- return getTypeWithFacts(assumeTrue ? mapType(type, narrowTypeForTypeof) : type, facts);
- function narrowTypeForTypeof(type) {
- var targetType = literal.text === "function" ? globalFunctionType : typeofTypesByName.get(literal.text);
- if (targetType) {
- if (isTypeSubtypeOf(type, targetType)) {
- return type;
- }
- if (isTypeSubtypeOf(targetType, type)) {
- return targetType;
- }
- if (type.flags & 63176704) {
- var constraint = getBaseConstraintOfType(type) || anyType;
- if (isTypeSubtypeOf(targetType, constraint)) {
- return getIntersectionType([type, targetType]);
- }
+ context.siblings = siblings_1;
+ }
+ return context.siblings;
+ }
+ function getPropertiesOfContext(context) {
+ if (!context.resolvedProperties) {
+ var names = new ts.Map();
+ for (var _i = 0, _a = getSiblingsOfContext(context); _i < _a.length; _i++) {
+ var t = _a[_i];
+ if (isObjectLiteralType(t) && !(ts.getObjectFlags(t) & 1024)) {
+ for (var _b = 0, _c = getPropertiesOfType(t); _b < _c.length; _b++) {
+ var prop = _c[_b];
+ names.set(prop.escapedName, prop);
}
}
- return type;
}
+ context.resolvedProperties = ts.arrayFrom(names.values());
}
- function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
- var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
- return everyClauseChecks ? getTypeWithFacts(type, 2097152) : type;
+ return context.resolvedProperties;
+ }
+ function getWidenedProperty(prop, context) {
+ if (!(prop.flags & 4)) {
+ return prop;
}
- function narrowTypeBySwitchOnDiscriminant(type, switchStatement, clauseStart, clauseEnd) {
- var switchTypes = getSwitchClauseTypes(switchStatement);
- if (!switchTypes.length) {
- return type;
- }
- var clauseTypes = switchTypes.slice(clauseStart, clauseEnd);
- var hasDefaultClause = clauseStart === clauseEnd || ts.contains(clauseTypes, neverType);
- if ((type.flags & 2) && !hasDefaultClause) {
- var groundClauseTypes = void 0;
- for (var i = 0; i < clauseTypes.length; i += 1) {
- var t = clauseTypes[i];
- if (t.flags & (131068 | 67108864)) {
- if (groundClauseTypes !== undefined) {
- groundClauseTypes.push(t);
- }
- }
- else if (t.flags & 524288) {
- if (groundClauseTypes === undefined) {
- groundClauseTypes = clauseTypes.slice(0, i);
- }
- groundClauseTypes.push(nonPrimitiveType);
- }
- else {
- return type;
- }
- }
- return getUnionType(groundClauseTypes === undefined ? clauseTypes : groundClauseTypes);
- }
- var discriminantType = getUnionType(clauseTypes);
- var caseType = discriminantType.flags & 131072 ? neverType :
- replacePrimitivesWithLiterals(filterType(type, function (t) { return areTypesComparable(discriminantType, t); }), discriminantType);
- if (!hasDefaultClause) {
- return caseType;
- }
- var defaultType = filterType(type, function (t) { return !(isUnitType(t) && ts.contains(switchTypes, getRegularTypeOfLiteralType(t))); });
- return caseType.flags & 131072 ? defaultType : getUnionType([caseType, defaultType]);
+ var original = getTypeOfSymbol(prop);
+ var propContext = context && createWideningContext(context, prop.escapedName, undefined);
+ var widened = getWidenedTypeWithContext(original, propContext);
+ return widened === original ? prop : createSymbolWithType(prop, widened);
+ }
+ function getUndefinedProperty(prop) {
+ var cached = undefinedProperties.get(prop.escapedName);
+ if (cached) {
+ return cached;
}
- function getImpliedTypeFromTypeofCase(type, text) {
- switch (text) {
- case "function":
- return type.flags & 1 ? type : globalFunctionType;
- case "object":
- return type.flags & 2 ? getUnionType([nonPrimitiveType, nullType]) : type;
- default:
- return typeofTypesByName.get(text) || type;
- }
+ var result = createSymbolWithType(prop, undefinedType);
+ result.flags |= 16777216;
+ undefinedProperties.set(prop.escapedName, result);
+ return result;
+ }
+ function getWidenedTypeOfObjectLiteral(type, context) {
+ var members = ts.createSymbolTable();
+ for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) {
+ var prop = _a[_i];
+ members.set(prop.escapedName, getWidenedProperty(prop, context));
}
- function narrowTypeForTypeofSwitch(candidate) {
- return function (type) {
- if (isTypeSubtypeOf(candidate, type)) {
- return candidate;
- }
- if (type.flags & 63176704) {
- var constraint = getBaseConstraintOfType(type) || anyType;
- if (isTypeSubtypeOf(candidate, constraint)) {
- return getIntersectionType([type, candidate]);
- }
+ if (context) {
+ for (var _b = 0, _c = getPropertiesOfContext(context); _b < _c.length; _b++) {
+ var prop = _c[_b];
+ if (!members.has(prop.escapedName)) {
+ members.set(prop.escapedName, getUndefinedProperty(prop));
}
- return type;
- };
- }
- function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
- var switchWitnesses = getSwitchClauseTypeOfWitnesses(switchStatement, true);
- if (!switchWitnesses.length) {
- return type;
- }
- var defaultCaseLocation = ts.findIndex(switchWitnesses, function (elem) { return elem === undefined; });
- var hasDefaultClause = clauseStart === clauseEnd || (defaultCaseLocation >= clauseStart && defaultCaseLocation < clauseEnd);
- var clauseWitnesses;
- var switchFacts;
- if (defaultCaseLocation > -1) {
- var witnesses = switchWitnesses.filter(function (witness) { return witness !== undefined; });
- var fixedClauseStart = defaultCaseLocation < clauseStart ? clauseStart - 1 : clauseStart;
- var fixedClauseEnd = defaultCaseLocation < clauseEnd ? clauseEnd - 1 : clauseEnd;
- clauseWitnesses = witnesses.slice(fixedClauseStart, fixedClauseEnd);
- switchFacts = getFactsFromTypeofSwitch(fixedClauseStart, fixedClauseEnd, witnesses, hasDefaultClause);
}
- else {
- clauseWitnesses = switchWitnesses.slice(clauseStart, clauseEnd);
- switchFacts = getFactsFromTypeofSwitch(clauseStart, clauseEnd, switchWitnesses, hasDefaultClause);
- }
- if (hasDefaultClause) {
- return filterType(type, function (t) { return (getTypeFacts(t) & switchFacts) === switchFacts; });
- }
- var impliedType = getTypeWithFacts(getUnionType(clauseWitnesses.map(function (text) { return getImpliedTypeFromTypeofCase(type, text); })), switchFacts);
- if (impliedType.flags & 1048576) {
- impliedType = getAssignmentReducedType(impliedType, getBaseConstraintOrType(type));
- }
- return getTypeWithFacts(mapType(type, narrowTypeForTypeofSwitch(impliedType)), switchFacts);
}
- function isMatchingConstructorReference(expr) {
- return (ts.isPropertyAccessExpression(expr) && ts.idText(expr.name) === "constructor" ||
- ts.isElementAccessExpression(expr) && ts.isStringLiteralLike(expr.argumentExpression) && expr.argumentExpression.text === "constructor") &&
- isMatchingReference(reference, expr.expression);
- }
- function narrowTypeByConstructor(type, operator, identifier, assumeTrue) {
- if (assumeTrue ? (operator !== 34 && operator !== 36) : (operator !== 35 && operator !== 37)) {
- return type;
+ var stringIndexInfo = getIndexInfoOfType(type, 0);
+ var numberIndexInfo = getIndexInfoOfType(type, 1);
+ var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly));
+ result.objectFlags |= (ts.getObjectFlags(type) & (16384 | 2097152));
+ return result;
+ }
+ function getWidenedType(type) {
+ return getWidenedTypeWithContext(type, undefined);
+ }
+ function getWidenedTypeWithContext(type, context) {
+ if (ts.getObjectFlags(type) & 1572864) {
+ if (context === undefined && type.widened) {
+ return type.widened;
}
- var identifierType = getTypeOfExpression(identifier);
- if (!isFunctionType(identifierType) && !isConstructorType(identifierType)) {
- return type;
+ var result = void 0;
+ if (type.flags & (1 | 98304)) {
+ result = anyType;
}
- var prototypeProperty = getPropertyOfType(identifierType, "prototype");
- if (!prototypeProperty) {
- return type;
+ else if (isObjectLiteralType(type)) {
+ result = getWidenedTypeOfObjectLiteral(type, context);
}
- var prototypeType = getTypeOfSymbol(prototypeProperty);
- var candidate = !isTypeAny(prototypeType) ? prototypeType : undefined;
- if (!candidate || candidate === globalObjectType || candidate === globalFunctionType) {
- return type;
+ else if (type.flags & 1048576) {
+ var unionContext_1 = context || createWideningContext(undefined, undefined, type.types);
+ var widenedTypes = ts.sameMap(type.types, function (t) { return t.flags & 98304 ? t : getWidenedTypeWithContext(t, unionContext_1); });
+ result = getUnionType(widenedTypes, ts.some(widenedTypes, isEmptyObjectType) ? 2 : 1);
}
- if (isTypeAny(type)) {
- return candidate;
+ else if (type.flags & 2097152) {
+ result = getIntersectionType(ts.sameMap(type.types, getWidenedType));
}
- return filterType(type, function (t) { return isConstructedBy(t, candidate); });
- function isConstructedBy(source, target) {
- if (source.flags & 524288 && ts.getObjectFlags(source) & 1 ||
- target.flags & 524288 && ts.getObjectFlags(target) & 1) {
- return source.symbol === target.symbol;
- }
- return isTypeSubtypeOf(source, target);
+ else if (isArrayType(type) || isTupleType(type)) {
+ result = createTypeReference(type.target, ts.sameMap(getTypeArguments(type), getWidenedType));
+ }
+ if (result && context === undefined) {
+ type.widened = result;
}
+ return result || type;
}
- function narrowTypeByInstanceof(type, expr, assumeTrue) {
- var left = getReferenceCandidate(expr.left);
- if (!isMatchingReference(reference, left)) {
- if (assumeTrue && strictNullChecks && optionalChainContainsReference(left, reference)) {
- return getTypeWithFacts(type, 2097152);
+ return type;
+ }
+ function reportWideningErrorsInType(type) {
+ var errorReported = false;
+ if (ts.getObjectFlags(type) & 524288) {
+ if (type.flags & 1048576) {
+ if (ts.some(type.types, isEmptyObjectType)) {
+ errorReported = true;
}
- return type;
- }
- var rightType = getTypeOfExpression(expr.right);
- if (!isTypeDerivedFrom(rightType, globalFunctionType)) {
- return type;
- }
- var targetType;
- var prototypeProperty = getPropertyOfType(rightType, "prototype");
- if (prototypeProperty) {
- var prototypePropertyType = getTypeOfSymbol(prototypeProperty);
- if (!isTypeAny(prototypePropertyType)) {
- targetType = prototypePropertyType;
+ else {
+ for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+ var t = _a[_i];
+ if (reportWideningErrorsInType(t)) {
+ errorReported = true;
+ }
+ }
}
}
- if (isTypeAny(type) && (targetType === globalObjectType || targetType === globalFunctionType)) {
- return type;
- }
- if (!targetType) {
- var constructSignatures = getSignaturesOfType(rightType, 1);
- targetType = constructSignatures.length ?
- getUnionType(ts.map(constructSignatures, function (signature) { return getReturnTypeOfSignature(getErasedSignature(signature)); })) :
- emptyObjectType;
- }
- return getNarrowedType(type, targetType, assumeTrue, isTypeDerivedFrom);
- }
- function getNarrowedType(type, candidate, assumeTrue, isRelated) {
- if (!assumeTrue) {
- return filterType(type, function (t) { return !isRelated(t, candidate); });
- }
- if (type.flags & 1048576) {
- var assignableType = filterType(type, function (t) { return isRelated(t, candidate); });
- if (!(assignableType.flags & 131072)) {
- return assignableType;
+ if (isArrayType(type) || isTupleType(type)) {
+ for (var _b = 0, _c = getTypeArguments(type); _b < _c.length; _b++) {
+ var t = _c[_b];
+ if (reportWideningErrorsInType(t)) {
+ errorReported = true;
+ }
}
}
- return isTypeSubtypeOf(candidate, type) ? candidate :
- isTypeAssignableTo(type, candidate) ? type :
- isTypeAssignableTo(candidate, type) ? candidate :
- getIntersectionType([type, candidate]);
- }
- function narrowTypeByCallExpression(type, callExpression, assumeTrue) {
- if (hasMatchingArgument(callExpression, reference)) {
- var signature = assumeTrue || !ts.isCallChain(callExpression) ? getEffectsSignature(callExpression) : undefined;
- var predicate = signature && getTypePredicateOfSignature(signature);
- if (predicate && (predicate.kind === 0 || predicate.kind === 1)) {
- return narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue);
+ if (isObjectLiteralType(type)) {
+ for (var _d = 0, _e = getPropertiesOfObjectType(type); _d < _e.length; _d++) {
+ var p = _e[_d];
+ var t = getTypeOfSymbol(p);
+ if (ts.getObjectFlags(t) & 524288) {
+ if (!reportWideningErrorsInType(t)) {
+ error(p.valueDeclaration, ts.Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, symbolToString(p), typeToString(getWidenedType(t)));
+ }
+ errorReported = true;
+ }
}
}
- return type;
}
- function narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue) {
- if (predicate.type && !(isTypeAny(type) && (predicate.type === globalObjectType || predicate.type === globalFunctionType))) {
- var predicateArgument = getTypePredicateArgument(predicate, callExpression);
- if (predicateArgument) {
- if (isMatchingReference(reference, predicateArgument)) {
- return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);
- }
- if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) &&
- !(getTypeFacts(predicate.type) & 65536)) {
- type = getTypeWithFacts(type, 2097152);
+ return errorReported;
+ }
+ function reportImplicitAny(declaration, type, wideningKind) {
+ var typeAsString = typeToString(getWidenedType(type));
+ if (ts.isInJSFile(declaration) && !ts.isCheckJsEnabledForFile(ts.getSourceFileOfNode(declaration), compilerOptions)) {
+ return;
+ }
+ var diagnostic;
+ switch (declaration.kind) {
+ case 216:
+ case 163:
+ case 162:
+ diagnostic = noImplicitAny ? ts.Diagnostics.Member_0_implicitly_has_an_1_type : ts.Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
+ break;
+ case 160:
+ var param = declaration;
+ if (ts.isIdentifier(param.name) &&
+ (ts.isCallSignatureDeclaration(param.parent) || ts.isMethodSignature(param.parent) || ts.isFunctionTypeNode(param.parent)) &&
+ param.parent.parameters.indexOf(param) > -1 &&
+ (resolveName(param, param.name.escapedText, 788968, undefined, param.name.escapedText, true) ||
+ param.name.originalKeywordKind && ts.isTypeNodeKind(param.name.originalKeywordKind))) {
+ var newName = "arg" + param.parent.parameters.indexOf(param);
+ errorOrSuggestion(noImplicitAny, declaration, ts.Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, ts.declarationNameToString(param.name));
+ return;
+ }
+ diagnostic = declaration.dotDotDotToken ?
+ noImplicitAny ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage :
+ noImplicitAny ? ts.Diagnostics.Parameter_0_implicitly_has_an_1_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
+ break;
+ case 198:
+ diagnostic = ts.Diagnostics.Binding_element_0_implicitly_has_an_1_type;
+ if (!noImplicitAny) {
+ return;
+ }
+ break;
+ case 308:
+ error(declaration, ts.Diagnostics.Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
+ return;
+ case 251:
+ case 165:
+ case 164:
+ case 167:
+ case 168:
+ case 208:
+ case 209:
+ if (noImplicitAny && !declaration.name) {
+ if (wideningKind === 3) {
+ error(declaration, ts.Diagnostics.Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation, typeAsString);
}
- if (isMatchingReferenceDiscriminant(predicateArgument, declaredType)) {
- return narrowTypeByDiscriminant(type, predicateArgument, function (t) { return getNarrowedType(t, predicate.type, assumeTrue, isTypeSubtypeOf); });
+ else {
+ error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
}
+ return;
}
- }
- return type;
+ diagnostic = !noImplicitAny ? ts.Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage :
+ wideningKind === 3 ? ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type :
+ ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type;
+ break;
+ case 190:
+ if (noImplicitAny) {
+ error(declaration, ts.Diagnostics.Mapped_object_type_implicitly_has_an_any_template_type);
+ }
+ return;
+ default:
+ diagnostic = noImplicitAny ? ts.Diagnostics.Variable_0_implicitly_has_an_1_type : ts.Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
}
- function narrowType(type, expr, assumeTrue) {
- if (ts.isExpressionOfOptionalChainRoot(expr) ||
- ts.isBinaryExpression(expr.parent) && expr.parent.operatorToken.kind === 60 && expr.parent.left === expr) {
- return narrowTypeByOptionality(type, expr, assumeTrue);
- }
- switch (expr.kind) {
- case 75:
- case 104:
- case 102:
- case 194:
- case 195:
- return narrowTypeByTruthiness(type, expr, assumeTrue);
- case 196:
- return narrowTypeByCallExpression(type, expr, assumeTrue);
- case 200:
- return narrowType(type, expr.expression, assumeTrue);
- case 209:
- return narrowTypeByBinaryExpression(type, expr, assumeTrue);
- case 207:
- if (expr.operator === 53) {
- return narrowType(type, expr.operand, !assumeTrue);
- }
- break;
+ errorOrSuggestion(noImplicitAny, declaration, diagnostic, ts.declarationNameToString(ts.getNameOfDeclaration(declaration)), typeAsString);
+ }
+ function reportErrorsFromWidening(declaration, type, wideningKind) {
+ if (produceDiagnostics && noImplicitAny && ts.getObjectFlags(type) & 524288 && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
+ if (!reportWideningErrorsInType(type)) {
+ reportImplicitAny(declaration, type, wideningKind);
}
- return type;
}
- function narrowTypeByOptionality(type, expr, assumePresent) {
- if (isMatchingReference(reference, expr)) {
- return getTypeWithFacts(type, assumePresent ? 2097152 : 262144);
- }
- if (isMatchingReferenceDiscriminant(expr, declaredType)) {
- return narrowTypeByDiscriminant(type, expr, function (t) { return getTypeWithFacts(t, assumePresent ? 2097152 : 262144); });
+ }
+ function applyToParameterTypes(source, target, callback) {
+ var sourceCount = getParameterCount(source);
+ var targetCount = getParameterCount(target);
+ var sourceRestType = getEffectiveRestType(source);
+ var targetRestType = getEffectiveRestType(target);
+ var targetNonRestCount = targetRestType ? targetCount - 1 : targetCount;
+ var paramCount = sourceRestType ? targetNonRestCount : Math.min(sourceCount, targetNonRestCount);
+ var sourceThisType = getThisTypeOfSignature(source);
+ if (sourceThisType) {
+ var targetThisType = getThisTypeOfSignature(target);
+ if (targetThisType) {
+ callback(sourceThisType, targetThisType);
}
- return type;
+ }
+ for (var i = 0; i < paramCount; i++) {
+ callback(getTypeAtPosition(source, i), getTypeAtPosition(target, i));
+ }
+ if (targetRestType) {
+ callback(getRestTypeAtPosition(source, paramCount), targetRestType);
}
}
- function getTypeOfSymbolAtLocation(symbol, location) {
- symbol = symbol.exportSymbol || symbol;
- if (location.kind === 75) {
- if (ts.isRightSideOfQualifiedNameOrPropertyAccess(location)) {
- location = location.parent;
- }
- if (ts.isExpressionNode(location) && !ts.isAssignmentTarget(location)) {
- var type = getTypeOfExpression(location);
- if (getExportSymbolOfValueSymbolIfExported(getNodeLinks(location).resolvedSymbol) === symbol) {
- return type;
- }
- }
+ function applyToReturnTypes(source, target, callback) {
+ var sourceTypePredicate = getTypePredicateOfSignature(source);
+ var targetTypePredicate = getTypePredicateOfSignature(target);
+ if (sourceTypePredicate && targetTypePredicate && typePredicateKindsMatch(sourceTypePredicate, targetTypePredicate) && sourceTypePredicate.type && targetTypePredicate.type) {
+ callback(sourceTypePredicate.type, targetTypePredicate.type);
+ }
+ else {
+ callback(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
}
- return getTypeOfSymbol(symbol);
}
- function getControlFlowContainer(node) {
- return ts.findAncestor(node.parent, function (node) {
- return ts.isFunctionLike(node) && !ts.getImmediatelyInvokedFunctionExpression(node) ||
- node.kind === 250 ||
- node.kind === 290 ||
- node.kind === 159;
- });
+ function createInferenceContext(typeParameters, signature, flags, compareTypes) {
+ return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes || compareTypesAssignable);
}
- function isParameterAssigned(symbol) {
- var func = ts.getRootDeclaration(symbol.valueDeclaration).parent;
- var links = getNodeLinks(func);
- if (!(links.flags & 8388608)) {
- links.flags |= 8388608;
- if (!hasParentWithAssignmentsMarked(func)) {
- markParameterAssignments(func);
- }
- }
- return symbol.isAssigned || false;
+ function cloneInferenceContext(context, extraFlags) {
+ if (extraFlags === void 0) { extraFlags = 0; }
+ return context && createInferenceContextWorker(ts.map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
}
- function hasParentWithAssignmentsMarked(node) {
- return !!ts.findAncestor(node.parent, function (node) { return ts.isFunctionLike(node) && !!(getNodeLinks(node).flags & 8388608); });
+ function createInferenceContextWorker(inferences, signature, flags, compareTypes) {
+ var context = {
+ inferences: inferences,
+ signature: signature,
+ flags: flags,
+ compareTypes: compareTypes,
+ mapper: makeFunctionTypeMapper(function (t) { return mapToInferredType(context, t, true); }),
+ nonFixingMapper: makeFunctionTypeMapper(function (t) { return mapToInferredType(context, t, false); }),
+ };
+ return context;
}
- function markParameterAssignments(node) {
- if (node.kind === 75) {
- if (ts.isAssignmentTarget(node)) {
- var symbol = getResolvedSymbol(node);
- if (symbol.valueDeclaration && ts.getRootDeclaration(symbol.valueDeclaration).kind === 156) {
- symbol.isAssigned = true;
+ function mapToInferredType(context, t, fix) {
+ var inferences = context.inferences;
+ for (var i = 0; i < inferences.length; i++) {
+ var inference = inferences[i];
+ if (t === inference.typeParameter) {
+ if (fix && !inference.isFixed) {
+ clearCachedInferences(inferences);
+ inference.isFixed = true;
}
+ return getInferredType(context, i);
}
}
- else {
- ts.forEachChild(node, markParameterAssignments);
+ return t;
+ }
+ function clearCachedInferences(inferences) {
+ for (var _i = 0, inferences_1 = inferences; _i < inferences_1.length; _i++) {
+ var inference = inferences_1[_i];
+ if (!inference.isFixed) {
+ inference.inferredType = undefined;
+ }
}
}
- function isConstVariable(symbol) {
- return symbol.flags & 3 && (getDeclarationNodeFlagsFromSymbol(symbol) & 2) !== 0 && getTypeOfSymbol(symbol) !== autoArrayType;
+ function createInferenceInfo(typeParameter) {
+ return {
+ typeParameter: typeParameter,
+ candidates: undefined,
+ contraCandidates: undefined,
+ inferredType: undefined,
+ priority: undefined,
+ topLevel: true,
+ isFixed: false,
+ impliedArity: undefined
+ };
}
- function removeOptionalityFromDeclaredType(declaredType, declaration) {
- if (pushTypeResolution(declaration.symbol, 2)) {
- var annotationIncludesUndefined = strictNullChecks &&
- declaration.kind === 156 &&
- declaration.initializer &&
- getFalsyFlags(declaredType) & 32768 &&
- !(getFalsyFlags(checkExpression(declaration.initializer)) & 32768);
- popTypeResolution();
- return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288) : declaredType;
+ function cloneInferenceInfo(inference) {
+ return {
+ typeParameter: inference.typeParameter,
+ candidates: inference.candidates && inference.candidates.slice(),
+ contraCandidates: inference.contraCandidates && inference.contraCandidates.slice(),
+ inferredType: inference.inferredType,
+ priority: inference.priority,
+ topLevel: inference.topLevel,
+ isFixed: inference.isFixed,
+ impliedArity: inference.impliedArity
+ };
+ }
+ function cloneInferredPartOfContext(context) {
+ var inferences = ts.filter(context.inferences, hasInferenceCandidates);
+ return inferences.length ?
+ createInferenceContextWorker(ts.map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) :
+ undefined;
+ }
+ function getMapperFromContext(context) {
+ return context && context.mapper;
+ }
+ function couldContainTypeVariables(type) {
+ var objectFlags = ts.getObjectFlags(type);
+ if (objectFlags & 67108864) {
+ return !!(objectFlags & 134217728);
}
- else {
- reportCircularityError(declaration.symbol);
- return declaredType;
+ var result = !!(type.flags & 465829888 ||
+ type.flags & 524288 && !isNonGenericTopLevelType(type) && (objectFlags & 4 && (type.node || ts.forEach(getTypeArguments(type), couldContainTypeVariables)) ||
+ objectFlags & 16 && type.symbol && type.symbol.flags & (16 | 8192 | 32 | 2048 | 4096) && type.symbol.declarations ||
+ objectFlags & (32 | 131072)) ||
+ type.flags & 3145728 && !(type.flags & 1024) && !isNonGenericTopLevelType(type) && ts.some(type.types, couldContainTypeVariables));
+ if (type.flags & 3899393) {
+ type.objectFlags |= 67108864 | (result ? 134217728 : 0);
}
+ return result;
}
- function isConstraintPosition(node) {
- var parent = node.parent;
- return parent.kind === 194 ||
- parent.kind === 196 && parent.expression === node ||
- parent.kind === 195 && parent.expression === node ||
- parent.kind === 191 && parent.name === node && !!parent.initializer;
+ function isNonGenericTopLevelType(type) {
+ if (type.aliasSymbol && !type.aliasTypeArguments) {
+ var declaration = ts.getDeclarationOfKind(type.aliasSymbol, 254);
+ return !!(declaration && ts.findAncestor(declaration.parent, function (n) { return n.kind === 297 ? true : n.kind === 256 ? false : "quit"; }));
+ }
+ return false;
}
- function typeHasNullableConstraint(type) {
- return type.flags & 58982400 && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 98304);
+ function isTypeParameterAtTopLevel(type, typeParameter) {
+ return !!(type === typeParameter ||
+ type.flags & 3145728 && ts.some(type.types, function (t) { return isTypeParameterAtTopLevel(t, typeParameter); }) ||
+ type.flags & 16777216 && (getTrueTypeFromConditionalType(type) === typeParameter || getFalseTypeFromConditionalType(type) === typeParameter));
}
- function getConstraintForLocation(type, node) {
- if (type && isConstraintPosition(node) && forEachType(type, typeHasNullableConstraint)) {
- return mapType(getWidenedType(type), getBaseConstraintOrType);
+ function createEmptyObjectTypeFromStringLiteral(type) {
+ var members = ts.createSymbolTable();
+ forEachType(type, function (t) {
+ if (!(t.flags & 128)) {
+ return;
+ }
+ var name = ts.escapeLeadingUnderscores(t.value);
+ var literalProp = createSymbol(4, name);
+ literalProp.type = anyType;
+ if (t.symbol) {
+ literalProp.declarations = t.symbol.declarations;
+ literalProp.valueDeclaration = t.symbol.valueDeclaration;
+ }
+ members.set(name, literalProp);
+ });
+ var indexInfo = type.flags & 4 ? createIndexInfo(emptyObjectType, false) : undefined;
+ return createAnonymousType(undefined, members, ts.emptyArray, ts.emptyArray, indexInfo, undefined);
+ }
+ function inferTypeForHomomorphicMappedType(source, target, constraint) {
+ if (inInferTypeForHomomorphicMappedType) {
+ return undefined;
+ }
+ var key = source.id + "," + target.id + "," + constraint.id;
+ if (reverseMappedCache.has(key)) {
+ return reverseMappedCache.get(key);
}
+ inInferTypeForHomomorphicMappedType = true;
+ var type = createReverseMappedType(source, target, constraint);
+ inInferTypeForHomomorphicMappedType = false;
+ reverseMappedCache.set(key, type);
return type;
}
- function isExportOrExportExpression(location) {
- return !!ts.findAncestor(location, function (e) { return e.parent && ts.isExportAssignment(e.parent) && e.parent.expression === e && ts.isEntityNameExpression(e); });
+ function isPartiallyInferableType(type) {
+ return !(ts.getObjectFlags(type) & 2097152) ||
+ isObjectLiteralType(type) && ts.some(getPropertiesOfType(type), function (prop) { return isPartiallyInferableType(getTypeOfSymbol(prop)); }) ||
+ isTupleType(type) && ts.some(getTypeArguments(type), isPartiallyInferableType);
}
- function markAliasReferenced(symbol, location) {
- if (isNonLocalAlias(symbol, 111551) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol)) {
- if (compilerOptions.preserveConstEnums && isExportOrExportExpression(location) || !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) {
- markAliasSymbolAsReferenced(symbol);
- }
- else {
- markConstEnumAliasAsReferenced(symbol);
+ function createReverseMappedType(source, target, constraint) {
+ if (!(getIndexInfoOfType(source, 0) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) {
+ return undefined;
+ }
+ if (isArrayType(source)) {
+ return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source));
+ }
+ if (isTupleType(source)) {
+ var elementTypes = ts.map(getTypeArguments(source), function (t) { return inferReverseMappedType(t, target, constraint); });
+ var elementFlags = getMappedTypeModifiers(target) & 4 ?
+ ts.sameMap(source.target.elementFlags, function (f) { return f & 2 ? 1 : f; }) :
+ source.target.elementFlags;
+ return createTupleType(elementTypes, elementFlags, source.target.readonly, source.target.labeledElementDeclarations);
+ }
+ var reversed = createObjectType(2048 | 16, undefined);
+ reversed.source = source;
+ reversed.mappedType = target;
+ reversed.constraintType = constraint;
+ return reversed;
+ }
+ function getTypeOfReverseMappedSymbol(symbol) {
+ return inferReverseMappedType(symbol.propertyType, symbol.mappedType, symbol.constraintType);
+ }
+ function inferReverseMappedType(sourceType, target, constraint) {
+ var typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
+ var templateType = getTemplateTypeFromMappedType(target);
+ var inference = createInferenceInfo(typeParameter);
+ inferTypes([inference], sourceType, templateType);
+ return getTypeFromInference(inference) || unknownType;
+ }
+ function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {
+ var properties, _i, properties_2, targetProp, sourceProp, targetType, sourceType;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ properties = getPropertiesOfType(target);
+ _i = 0, properties_2 = properties;
+ _a.label = 1;
+ case 1:
+ if (!(_i < properties_2.length)) return [3, 6];
+ targetProp = properties_2[_i];
+ if (isStaticPrivateIdentifierProperty(targetProp)) {
+ return [3, 5];
+ }
+ if (!(requireOptionalProperties || !(targetProp.flags & 16777216 || ts.getCheckFlags(targetProp) & 48))) return [3, 5];
+ sourceProp = getPropertyOfType(source, targetProp.escapedName);
+ if (!!sourceProp) return [3, 3];
+ return [4, targetProp];
+ case 2:
+ _a.sent();
+ return [3, 5];
+ case 3:
+ if (!matchDiscriminantProperties) return [3, 5];
+ targetType = getTypeOfSymbol(targetProp);
+ if (!(targetType.flags & 109440)) return [3, 5];
+ sourceType = getTypeOfSymbol(sourceProp);
+ if (!!(sourceType.flags & 1 || getRegularTypeOfLiteralType(sourceType) === getRegularTypeOfLiteralType(targetType))) return [3, 5];
+ return [4, targetProp];
+ case 4:
+ _a.sent();
+ _a.label = 5;
+ case 5:
+ _i++;
+ return [3, 1];
+ case 6: return [2];
}
+ });
+ }
+ function getUnmatchedProperty(source, target, requireOptionalProperties, matchDiscriminantProperties) {
+ var result = getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties).next();
+ if (!result.done)
+ return result.value;
+ }
+ function tupleTypesDefinitelyUnrelated(source, target) {
+ return !(target.target.combinedFlags & 8) && 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, true);
+ }
+ function getTypeFromInference(inference) {
+ return inference.candidates ? getUnionType(inference.candidates, 2) :
+ inference.contraCandidates ? getIntersectionType(inference.contraCandidates) :
+ undefined;
+ }
+ function hasSkipDirectInferenceFlag(node) {
+ return !!getNodeLinks(node).skipDirectInference;
+ }
+ function isFromInferenceBlockedSource(type) {
+ return !!(type.symbol && ts.some(type.symbol.declarations, hasSkipDirectInferenceFlag));
+ }
+ function isValidBigIntString(s) {
+ var scanner = ts.createScanner(99, false);
+ var success = true;
+ scanner.setOnError(function () { return success = false; });
+ scanner.setText(s + "n");
+ var result = scanner.scan();
+ if (result === 40) {
+ result = scanner.scan();
}
+ var flags = scanner.getTokenFlags();
+ return success && result === 9 && scanner.getTextPos() === (s.length + 1) && !(flags & 512);
}
- function checkIdentifier(node) {
- var symbol = getResolvedSymbol(node);
- if (symbol === unknownSymbol) {
- return errorType;
+ function isStringLiteralTypeValueParsableAsType(s, target) {
+ if (target.flags & 1048576) {
+ return !!forEachType(target, function (t) { return isStringLiteralTypeValueParsableAsType(s, t); });
+ }
+ switch (target) {
+ case stringType: return true;
+ case numberType: return s.value !== "" && isFinite(+(s.value));
+ case bigintType: return s.value !== "" && isValidBigIntString(s.value);
+ case trueType: return s.value === "true";
+ case falseType: return s.value === "false";
+ case undefinedType: return s.value === "undefined";
+ case nullType: return s.value === "null";
+ default: return !!(target.flags & 1);
+ }
+ }
+ function inferLiteralsFromTemplateLiteralType(source, target) {
+ var value = source.value;
+ var texts = target.texts;
+ var lastIndex = texts.length - 1;
+ var startText = texts[0];
+ var endText = texts[lastIndex];
+ if (!(value.startsWith(startText) && value.slice(startText.length).endsWith(endText)))
+ return undefined;
+ var matches = [];
+ var str = value.slice(startText.length, value.length - endText.length);
+ var pos = 0;
+ for (var i = 1; i < lastIndex; i++) {
+ var delim = texts[i];
+ var delimPos = delim.length > 0 ? str.indexOf(delim, pos) : pos < str.length ? pos + 1 : -1;
+ if (delimPos < 0)
+ return undefined;
+ matches.push(getLiteralType(str.slice(pos, delimPos)));
+ pos = delimPos + delim.length;
}
- if (symbol === argumentsSymbol) {
- var container = ts.getContainingFunction(node);
- if (languageVersion < 2) {
- if (container.kind === 202) {
- error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
- }
- else if (ts.hasModifier(container, 256)) {
- error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method);
+ matches.push(getLiteralType(str.slice(pos)));
+ return matches;
+ }
+ function inferTypes(inferences, originalSource, originalTarget, priority, contravariant) {
+ if (priority === void 0) { priority = 0; }
+ if (contravariant === void 0) { contravariant = false; }
+ var bivariant = false;
+ var propagationType;
+ var inferencePriority = 1024;
+ var allowComplexConstraintInference = true;
+ var visited;
+ var sourceStack;
+ var targetStack;
+ var expandingFlags = 0;
+ inferFromTypes(originalSource, originalTarget);
+ function inferFromTypes(source, target) {
+ if (!couldContainTypeVariables(target)) {
+ return;
+ }
+ if (source === wildcardType) {
+ var savePropagationType = propagationType;
+ propagationType = source;
+ inferFromTypes(target, target);
+ propagationType = savePropagationType;
+ return;
+ }
+ if (source.aliasSymbol && source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) {
+ inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
+ return;
+ }
+ if (source === target && source.flags & 3145728) {
+ for (var _i = 0, _a = source.types; _i < _a.length; _i++) {
+ var t = _a[_i];
+ inferFromTypes(t, t);
}
+ return;
}
- getNodeLinks(container).flags |= 8192;
- return getTypeOfSymbol(symbol);
- }
- if (!(node.parent && ts.isPropertyAccessExpression(node.parent) && node.parent.expression === node)) {
- markAliasReferenced(symbol, node);
- }
- var localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
- var declaration = localOrExportSymbol.valueDeclaration;
- if (localOrExportSymbol.flags & 32) {
- if (declaration.kind === 245
- && ts.nodeIsDecorated(declaration)) {
- var container = ts.getContainingClass(node);
- while (container !== undefined) {
- if (container === declaration && container.name !== node) {
- getNodeLinks(declaration).flags |= 16777216;
- getNodeLinks(node).flags |= 33554432;
- break;
- }
- container = ts.getContainingClass(container);
+ if (target.flags & 1048576) {
+ var _b = inferFromMatchingTypes(source.flags & 1048576 ? source.types : [source], target.types, isTypeOrBaseIdenticalTo), tempSources = _b[0], tempTargets = _b[1];
+ var _c = inferFromMatchingTypes(tempSources, tempTargets, isTypeCloselyMatchedBy), sources = _c[0], targets = _c[1];
+ if (targets.length === 0) {
+ return;
+ }
+ target = getUnionType(targets);
+ if (sources.length === 0) {
+ inferWithPriority(source, target, 1);
+ return;
}
+ source = getUnionType(sources);
}
- else if (declaration.kind === 214) {
- var container = ts.getThisContainer(node, false);
- while (container.kind !== 290) {
- if (container.parent === declaration) {
- if (container.kind === 159 && ts.hasModifier(container, 32)) {
- getNodeLinks(declaration).flags |= 16777216;
- getNodeLinks(node).flags |= 33554432;
- }
- break;
+ else if (target.flags & 2097152 && ts.some(target.types, function (t) { return !!getInferenceInfoForType(t) || (isGenericMappedType(t) && !!getInferenceInfoForType(getHomomorphicTypeVariable(t) || neverType)); })) {
+ if (!(source.flags & 1048576)) {
+ var _d = inferFromMatchingTypes(source.flags & 2097152 ? source.types : [source], target.types, isTypeIdenticalTo), sources = _d[0], targets = _d[1];
+ if (sources.length === 0 || targets.length === 0) {
+ return;
}
- container = ts.getThisContainer(container, false);
+ source = getIntersectionType(sources);
+ target = getIntersectionType(targets);
}
}
- }
- checkNestedBlockScopedBinding(node, symbol);
- var type = getConstraintForLocation(getTypeOfSymbol(localOrExportSymbol), node);
- var assignmentKind = ts.getAssignmentTargetKind(node);
- if (assignmentKind) {
- if (!(localOrExportSymbol.flags & 3) &&
- !(ts.isInJSFile(node) && localOrExportSymbol.flags & 512)) {
- error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_not_a_variable, symbolToString(symbol));
- return errorType;
+ else if (target.flags & (8388608 | 33554432)) {
+ target = getActualTypeVariable(target);
}
- if (isReadonlySymbol(localOrExportSymbol)) {
- if (localOrExportSymbol.flags & 3) {
- error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_constant, symbolToString(symbol));
+ if (target.flags & 8650752) {
+ if (ts.getObjectFlags(source) & 2097152 || source === nonInferrableAnyType || source === silentNeverType ||
+ (priority & 64 && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
+ return;
+ }
+ var inference = getInferenceInfoForType(target);
+ if (inference) {
+ if (!inference.isFixed) {
+ if (inference.priority === undefined || priority < inference.priority) {
+ inference.candidates = undefined;
+ inference.contraCandidates = undefined;
+ inference.topLevel = true;
+ inference.priority = priority;
+ }
+ if (priority === inference.priority) {
+ var candidate = propagationType || source;
+ if (contravariant && !bivariant) {
+ if (!ts.contains(inference.contraCandidates, candidate)) {
+ inference.contraCandidates = ts.append(inference.contraCandidates, candidate);
+ clearCachedInferences(inferences);
+ }
+ }
+ else if (!ts.contains(inference.candidates, candidate)) {
+ inference.candidates = ts.append(inference.candidates, candidate);
+ clearCachedInferences(inferences);
+ }
+ }
+ if (!(priority & 64) && target.flags & 262144 && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) {
+ inference.topLevel = false;
+ clearCachedInferences(inferences);
+ }
+ }
+ inferencePriority = Math.min(inferencePriority, priority);
+ return;
}
else {
- error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(symbol));
+ var simplified = getSimplifiedType(target, false);
+ if (simplified !== target) {
+ invokeOnce(source, simplified, inferFromTypes);
+ }
+ else if (target.flags & 8388608) {
+ var indexType = getSimplifiedType(target.indexType, false);
+ if (indexType.flags & 465829888) {
+ var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, false), indexType, false);
+ if (simplified_1 && simplified_1 !== target) {
+ invokeOnce(source, simplified_1, inferFromTypes);
+ }
+ }
+ }
}
- return errorType;
}
- }
- var isAlias = localOrExportSymbol.flags & 2097152;
- if (localOrExportSymbol.flags & 3) {
- if (assignmentKind === 1) {
- return type;
+ if (ts.getObjectFlags(source) & 4 && ts.getObjectFlags(target) & 4 && (source.target === target.target || isArrayType(source) && isArrayType(target)) &&
+ !(source.node && target.node)) {
+ inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
}
- }
- else if (isAlias) {
- declaration = ts.find(symbol.declarations, isSomeImportDeclaration);
- }
- else {
- return type;
- }
- if (!declaration) {
- return type;
- }
- var isParameter = ts.getRootDeclaration(declaration).kind === 156;
- var declarationContainer = getControlFlowContainer(declaration);
- var flowContainer = getControlFlowContainer(node);
- var isOuterVariable = flowContainer !== declarationContainer;
- var isSpreadDestructuringAssignmentTarget = node.parent && node.parent.parent && ts.isSpreadAssignment(node.parent) && isDestructuringAssignmentTarget(node.parent.parent);
- var isModuleExports = symbol.flags & 134217728;
- while (flowContainer !== declarationContainer && (flowContainer.kind === 201 ||
- flowContainer.kind === 202 || ts.isObjectLiteralOrClassExpressionMethod(flowContainer)) &&
- (isConstVariable(localOrExportSymbol) || isParameter && !isParameterAssigned(localOrExportSymbol))) {
- flowContainer = getControlFlowContainer(flowContainer);
- }
- var assumeInitialized = isParameter || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || ts.isBindingElement(declaration) ||
- type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 | 16384)) !== 0 ||
- isInTypeQuery(node) || node.parent.kind === 263) ||
- node.parent.kind === 218 ||
- declaration.kind === 242 && declaration.exclamationToken ||
- declaration.flags & 8388608;
- var initialType = assumeInitialized ? (isParameter ? removeOptionalityFromDeclaredType(type, declaration) : type) :
- type === autoType || type === autoArrayType ? undefinedType :
- getOptionalType(type);
- var flowType = getFlowTypeOfReference(node, type, initialType, flowContainer, !assumeInitialized);
- if (!isEvolvingArrayOperationTarget(node) && (type === autoType || type === autoArrayType)) {
- if (flowType === autoType || flowType === autoArrayType) {
- if (noImplicitAny) {
- error(ts.getNameOfDeclaration(declaration), ts.Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined, symbolToString(symbol), typeToString(flowType));
- error(node, ts.Diagnostics.Variable_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType));
- }
- return convertAutoToAny(flowType);
+ else if (source.flags & 4194304 && target.flags & 4194304) {
+ contravariant = !contravariant;
+ inferFromTypes(source.type, target.type);
+ contravariant = !contravariant;
}
- }
- else if (!assumeInitialized && !(getFalsyFlags(type) & 32768) && getFalsyFlags(flowType) & 32768) {
- error(node, ts.Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
- return type;
- }
- return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
- }
- function isInsideFunction(node, threshold) {
- return !!ts.findAncestor(node, function (n) { return n === threshold ? "quit" : ts.isFunctionLike(n); });
- }
- function getPartOfForStatementContainingNode(node, container) {
- return ts.findAncestor(node, function (n) { return n === container ? "quit" : n === container.initializer || n === container.condition || n === container.incrementor || n === container.statement; });
- }
- function checkNestedBlockScopedBinding(node, symbol) {
- if (languageVersion >= 2 ||
- (symbol.flags & (2 | 32)) === 0 ||
- ts.isSourceFile(symbol.valueDeclaration) ||
- symbol.valueDeclaration.parent.kind === 280) {
- return;
- }
- var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration);
- var usedInFunction = isInsideFunction(node.parent, container);
- var current = container;
- var containedInIterationStatement = false;
- while (current && !ts.nodeStartsNewLexicalEnvironment(current)) {
- if (ts.isIterationStatement(current, false)) {
- containedInIterationStatement = true;
- break;
+ else if ((isLiteralType(source) || source.flags & 4) && target.flags & 4194304) {
+ var empty = createEmptyObjectTypeFromStringLiteral(source);
+ contravariant = !contravariant;
+ inferWithPriority(empty, target.type, 128);
+ contravariant = !contravariant;
}
- current = current.parent;
- }
- if (containedInIterationStatement) {
- if (usedInFunction) {
- var capturesBlockScopeBindingInLoopBody = true;
- if (ts.isForStatement(container)) {
- var varDeclList = ts.getAncestor(symbol.valueDeclaration, 243);
- if (varDeclList && varDeclList.parent === container) {
- var part = getPartOfForStatementContainingNode(node.parent, container);
- if (part) {
- var links = getNodeLinks(part);
- links.flags |= 131072;
- var capturedBindings = links.capturedBlockScopeBindings || (links.capturedBlockScopeBindings = []);
- ts.pushIfUnique(capturedBindings, symbol);
- if (part === container.initializer) {
- capturesBlockScopeBindingInLoopBody = false;
- }
- }
+ else if (source.flags & 8388608 && target.flags & 8388608) {
+ inferFromTypes(source.objectType, target.objectType);
+ inferFromTypes(source.indexType, target.indexType);
+ }
+ else if (source.flags & 268435456 && target.flags & 268435456) {
+ if (source.symbol === target.symbol) {
+ inferFromTypes(source.type, target.type);
+ }
+ }
+ else if (target.flags & 16777216) {
+ invokeOnce(source, target, inferToConditionalType);
+ }
+ else if (target.flags & 3145728) {
+ inferToMultipleTypes(source, target.types, target.flags);
+ }
+ else if (source.flags & 1048576) {
+ var sourceTypes = source.types;
+ for (var _e = 0, sourceTypes_2 = sourceTypes; _e < sourceTypes_2.length; _e++) {
+ var sourceType = sourceTypes_2[_e];
+ inferFromTypes(sourceType, target);
+ }
+ }
+ else if (target.flags & 134217728) {
+ inferToTemplateLiteralType(source, target);
+ }
+ else {
+ source = getReducedType(source);
+ if (!(priority & 256 && source.flags & (2097152 | 465829888))) {
+ var apparentSource = getApparentType(source);
+ if (apparentSource !== source && allowComplexConstraintInference && !(apparentSource.flags & (524288 | 2097152))) {
+ allowComplexConstraintInference = false;
+ return inferFromTypes(apparentSource, target);
}
+ source = apparentSource;
}
- if (capturesBlockScopeBindingInLoopBody) {
- getNodeLinks(current).flags |= 65536;
+ if (source.flags & (524288 | 2097152)) {
+ invokeOnce(source, target, inferFromObjectTypes);
}
}
- if (ts.isForStatement(container)) {
- var varDeclList = ts.getAncestor(symbol.valueDeclaration, 243);
- if (varDeclList && varDeclList.parent === container && isAssignedInBodyOfForStatement(node, container)) {
- getNodeLinks(symbol.valueDeclaration).flags |= 4194304;
+ if (source.flags & 25165824) {
+ var simplified = getSimplifiedType(source, contravariant);
+ if (simplified !== source) {
+ inferFromTypes(simplified, target);
}
}
- getNodeLinks(symbol.valueDeclaration).flags |= 524288;
- }
- if (usedInFunction) {
- getNodeLinks(symbol.valueDeclaration).flags |= 262144;
- }
- }
- function isBindingCapturedByNode(node, decl) {
- var links = getNodeLinks(node);
- return !!links && ts.contains(links.capturedBlockScopeBindings, getSymbolOfNode(decl));
- }
- function isAssignedInBodyOfForStatement(node, container) {
- var current = node;
- while (current.parent.kind === 200) {
- current = current.parent;
- }
- var isAssigned = false;
- if (ts.isAssignmentTarget(current)) {
- isAssigned = true;
}
- else if ((current.parent.kind === 207 || current.parent.kind === 208)) {
- var expr = current.parent;
- isAssigned = expr.operator === 45 || expr.operator === 46;
+ function inferWithPriority(source, target, newPriority) {
+ var savePriority = priority;
+ priority |= newPriority;
+ inferFromTypes(source, target);
+ priority = savePriority;
}
- if (!isAssigned) {
- return false;
+ function invokeOnce(source, target, action) {
+ var key = source.id + "," + target.id;
+ var status = visited && visited.get(key);
+ if (status !== undefined) {
+ inferencePriority = Math.min(inferencePriority, status);
+ return;
+ }
+ (visited || (visited = new ts.Map())).set(key, -1);
+ var saveInferencePriority = inferencePriority;
+ inferencePriority = 1024;
+ var saveExpandingFlags = expandingFlags;
+ var sourceIdentity = getRecursionIdentity(source) || source;
+ var targetIdentity = getRecursionIdentity(target) || target;
+ if (sourceIdentity && ts.contains(sourceStack, sourceIdentity))
+ expandingFlags |= 1;
+ if (targetIdentity && ts.contains(targetStack, targetIdentity))
+ expandingFlags |= 2;
+ if (expandingFlags !== 3) {
+ if (sourceIdentity)
+ (sourceStack || (sourceStack = [])).push(sourceIdentity);
+ if (targetIdentity)
+ (targetStack || (targetStack = [])).push(targetIdentity);
+ action(source, target);
+ if (targetIdentity)
+ targetStack.pop();
+ if (sourceIdentity)
+ sourceStack.pop();
+ }
+ else {
+ inferencePriority = -1;
+ }
+ expandingFlags = saveExpandingFlags;
+ visited.set(key, inferencePriority);
+ inferencePriority = Math.min(inferencePriority, saveInferencePriority);
}
- return !!ts.findAncestor(current, function (n) { return n === container ? "quit" : n === container.statement; });
- }
- function captureLexicalThis(node, container) {
- getNodeLinks(node).flags |= 2;
- if (container.kind === 159 || container.kind === 162) {
- var classNode = container.parent;
- getNodeLinks(classNode).flags |= 4;
+ function inferFromMatchingTypes(sources, targets, matches) {
+ var matchedSources;
+ var matchedTargets;
+ for (var _i = 0, targets_1 = targets; _i < targets_1.length; _i++) {
+ var t = targets_1[_i];
+ for (var _a = 0, sources_1 = sources; _a < sources_1.length; _a++) {
+ var s = sources_1[_a];
+ if (matches(s, t)) {
+ inferFromTypes(s, t);
+ matchedSources = ts.appendIfUnique(matchedSources, s);
+ matchedTargets = ts.appendIfUnique(matchedTargets, t);
+ }
+ }
+ }
+ return [
+ matchedSources ? ts.filter(sources, function (t) { return !ts.contains(matchedSources, t); }) : sources,
+ matchedTargets ? ts.filter(targets, function (t) { return !ts.contains(matchedTargets, t); }) : targets,
+ ];
}
- else {
- getNodeLinks(container).flags |= 4;
+ function inferFromTypeArguments(sourceTypes, targetTypes, variances) {
+ var count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length;
+ for (var i = 0; i < count; i++) {
+ if (i < variances.length && (variances[i] & 7) === 2) {
+ inferFromContravariantTypes(sourceTypes[i], targetTypes[i]);
+ }
+ else {
+ inferFromTypes(sourceTypes[i], targetTypes[i]);
+ }
+ }
}
- }
- function findFirstSuperCall(n) {
- if (ts.isSuperCall(n)) {
- return n;
+ function inferFromContravariantTypes(source, target) {
+ if (strictFunctionTypes || priority & 512) {
+ contravariant = !contravariant;
+ inferFromTypes(source, target);
+ contravariant = !contravariant;
+ }
+ else {
+ inferFromTypes(source, target);
+ }
}
- else if (ts.isFunctionLike(n)) {
+ function getInferenceInfoForType(type) {
+ if (type.flags & 8650752) {
+ for (var _i = 0, inferences_2 = inferences; _i < inferences_2.length; _i++) {
+ var inference = inferences_2[_i];
+ if (type === inference.typeParameter) {
+ return inference;
+ }
+ }
+ }
return undefined;
}
- return ts.forEachChild(n, findFirstSuperCall);
- }
- function getSuperCallInConstructor(constructor) {
- var links = getNodeLinks(constructor);
- if (links.hasSuperCall === undefined) {
- links.superCall = findFirstSuperCall(constructor.body);
- links.hasSuperCall = links.superCall ? true : false;
- }
- return links.superCall;
- }
- function classDeclarationExtendsNull(classDecl) {
- var classSymbol = getSymbolOfNode(classDecl);
- var classInstanceType = getDeclaredTypeOfSymbol(classSymbol);
- var baseConstructorType = getBaseConstructorTypeOfClass(classInstanceType);
- return baseConstructorType === nullWideningType;
- }
- function checkThisBeforeSuper(node, container, diagnosticMessage) {
- var containingClassDecl = container.parent;
- var baseTypeNode = ts.getClassExtendsHeritageElement(containingClassDecl);
- if (baseTypeNode && !classDeclarationExtendsNull(containingClassDecl)) {
- var superCall = getSuperCallInConstructor(container);
- if (!superCall || superCall.end > node.pos) {
- error(node, diagnosticMessage);
+ function getSingleTypeVariableFromIntersectionTypes(types) {
+ var typeVariable;
+ for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
+ var type = types_15[_i];
+ var t = type.flags & 2097152 && ts.find(type.types, function (t) { return !!getInferenceInfoForType(t); });
+ if (!t || typeVariable && t !== typeVariable) {
+ return undefined;
+ }
+ typeVariable = t;
}
+ return typeVariable;
}
- }
- function checkThisExpression(node) {
- var container = ts.getThisContainer(node, true);
- var capturedByArrowFunction = false;
- if (container.kind === 162) {
- checkThisBeforeSuper(node, container, ts.Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class);
- }
- if (container.kind === 202) {
- container = ts.getThisContainer(container, false);
- capturedByArrowFunction = true;
- }
- switch (container.kind) {
- case 249:
- error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body);
- break;
- case 248:
- error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location);
- break;
- case 162:
- if (isInConstructorArgumentInitializer(node, container)) {
- error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments);
+ function inferToMultipleTypes(source, targets, targetFlags) {
+ var typeVariableCount = 0;
+ if (targetFlags & 1048576) {
+ var nakedTypeVariable = void 0;
+ var sources = source.flags & 1048576 ? source.types : [source];
+ var matched_1 = new Array(sources.length);
+ var inferenceCircularity = false;
+ for (var _i = 0, targets_2 = targets; _i < targets_2.length; _i++) {
+ var t = targets_2[_i];
+ if (getInferenceInfoForType(t)) {
+ nakedTypeVariable = t;
+ typeVariableCount++;
+ }
+ else {
+ for (var i = 0; i < sources.length; i++) {
+ var saveInferencePriority = inferencePriority;
+ inferencePriority = 1024;
+ inferFromTypes(sources[i], t);
+ if (inferencePriority === priority)
+ matched_1[i] = true;
+ inferenceCircularity = inferenceCircularity || inferencePriority === -1;
+ inferencePriority = Math.min(inferencePriority, saveInferencePriority);
+ }
+ }
}
- break;
- case 159:
- case 158:
- if (ts.hasModifier(container, 32) && !(compilerOptions.target === 99 && compilerOptions.useDefineForClassFields)) {
- error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer);
+ if (typeVariableCount === 0) {
+ var intersectionTypeVariable = getSingleTypeVariableFromIntersectionTypes(targets);
+ if (intersectionTypeVariable) {
+ inferWithPriority(source, intersectionTypeVariable, 1);
+ }
+ return;
}
- break;
- case 154:
- error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name);
- break;
- }
- if (capturedByArrowFunction && languageVersion < 2) {
- captureLexicalThis(node, container);
- }
- var type = tryGetThisTypeAt(node, true, container);
- if (noImplicitThis) {
- var globalThisType_1 = getTypeOfSymbol(globalThisSymbol);
- if (type === globalThisType_1 && capturedByArrowFunction) {
- error(node, ts.Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this);
- }
- else if (!type) {
- var diag = error(node, ts.Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);
- if (!ts.isSourceFile(container)) {
- var outsideThis = tryGetThisTypeAt(container);
- if (outsideThis && outsideThis !== globalThisType_1) {
- ts.addRelatedInfo(diag, ts.createDiagnosticForNode(container, ts.Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container));
+ if (typeVariableCount === 1 && !inferenceCircularity) {
+ var unmatched = ts.flatMap(sources, function (s, i) { return matched_1[i] ? undefined : s; });
+ if (unmatched.length) {
+ inferFromTypes(getUnionType(unmatched), nakedTypeVariable);
+ return;
}
}
}
- }
- return type || anyType;
- }
- function tryGetThisTypeAt(node, includeGlobalThis, container) {
- if (includeGlobalThis === void 0) { includeGlobalThis = true; }
- if (container === void 0) { container = ts.getThisContainer(node, false); }
- var isInJS = ts.isInJSFile(node);
- if (ts.isFunctionLike(container) &&
- (!isInParameterInitializerBeforeContainingFunction(node) || ts.getThisParameter(container))) {
- var className = getClassNameFromPrototypeMethod(container);
- if (isInJS && className) {
- var classSymbol = checkExpression(className).symbol;
- if (classSymbol && classSymbol.members && (classSymbol.flags & 16)) {
- var classType = getDeclaredTypeOfSymbol(classSymbol).thisType;
- if (classType) {
- return getFlowTypeOfReference(node, classType);
+ else {
+ for (var _a = 0, targets_3 = targets; _a < targets_3.length; _a++) {
+ var t = targets_3[_a];
+ if (getInferenceInfoForType(t)) {
+ typeVariableCount++;
+ }
+ else {
+ inferFromTypes(source, t);
}
}
}
- else if (isInJS &&
- (container.kind === 201 || container.kind === 244) &&
- ts.getJSDocClassTag(container)) {
- var classType = getDeclaredTypeOfSymbol(getMergedSymbol(container.symbol)).thisType;
- return getFlowTypeOfReference(node, classType);
- }
- var thisType = getThisTypeOfDeclaration(container) || getContextualThisParameterType(container);
- if (thisType) {
- return getFlowTypeOfReference(node, thisType);
+ if (targetFlags & 2097152 ? typeVariableCount === 1 : typeVariableCount > 0) {
+ for (var _b = 0, targets_4 = targets; _b < targets_4.length; _b++) {
+ var t = targets_4[_b];
+ if (getInferenceInfoForType(t)) {
+ inferWithPriority(source, t, 1);
+ }
+ }
}
}
- if (ts.isClassLike(container.parent)) {
- var symbol = getSymbolOfNode(container.parent);
- var type = ts.hasModifier(container, 32) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
- return getFlowTypeOfReference(node, type);
- }
- if (isInJS) {
- var type = getTypeForThisExpressionFromJSDoc(container);
- if (type && type !== errorType) {
- return getFlowTypeOfReference(node, type);
+ function inferToMappedType(source, target, constraintType) {
+ if (constraintType.flags & 1048576) {
+ var result = false;
+ for (var _i = 0, _a = constraintType.types; _i < _a.length; _i++) {
+ var type = _a[_i];
+ result = inferToMappedType(source, target, type) || result;
+ }
+ return result;
}
- }
- if (ts.isSourceFile(container)) {
- if (container.commonJsModuleIndicator) {
- var fileSymbol = getSymbolOfNode(container);
- return fileSymbol && getTypeOfSymbol(fileSymbol);
+ if (constraintType.flags & 4194304) {
+ var inference = getInferenceInfoForType(constraintType.type);
+ if (inference && !inference.isFixed && !isFromInferenceBlockedSource(source)) {
+ var inferredType = inferTypeForHomomorphicMappedType(source, target, constraintType);
+ if (inferredType) {
+ inferWithPriority(inferredType, inference.typeParameter, ts.getObjectFlags(source) & 2097152 ?
+ 8 :
+ 4);
+ }
+ }
+ return true;
}
- else if (includeGlobalThis) {
- return getTypeOfSymbol(globalThisSymbol);
+ if (constraintType.flags & 262144) {
+ inferWithPriority(getIndexType(source), constraintType, 16);
+ var extendedConstraint = getConstraintOfType(constraintType);
+ if (extendedConstraint && inferToMappedType(source, target, extendedConstraint)) {
+ return true;
+ }
+ var propTypes = ts.map(getPropertiesOfType(source), getTypeOfSymbol);
+ var stringIndexType = getIndexTypeOfType(source, 0);
+ var numberIndexInfo = getNonEnumNumberIndexInfo(source);
+ var numberIndexType = numberIndexInfo && numberIndexInfo.type;
+ inferFromTypes(getUnionType(ts.append(ts.append(propTypes, stringIndexType), numberIndexType)), getTemplateTypeFromMappedType(target));
+ return true;
}
+ return false;
}
- }
- function getExplicitThisType(node) {
- var container = ts.getThisContainer(node, false);
- if (ts.isFunctionLike(container)) {
- var signature = getSignatureFromDeclaration(container);
- if (signature.thisParameter) {
- return getExplicitTypeOfSymbol(signature.thisParameter);
+ function inferToConditionalType(source, target) {
+ if (source.flags & 16777216) {
+ inferFromTypes(source.checkType, target.checkType);
+ inferFromTypes(source.extendsType, target.extendsType);
+ inferFromTypes(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target));
+ inferFromTypes(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target));
}
- }
- if (ts.isClassLike(container.parent)) {
- var symbol = getSymbolOfNode(container.parent);
- return ts.hasModifier(container, 32) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
- }
- }
- function getClassNameFromPrototypeMethod(container) {
- if (container.kind === 201 &&
- ts.isBinaryExpression(container.parent) &&
- ts.getAssignmentDeclarationKind(container.parent) === 3) {
- return container.parent
- .left
- .expression
- .expression;
- }
- else if (container.kind === 161 &&
- container.parent.kind === 193 &&
- ts.isBinaryExpression(container.parent.parent) &&
- ts.getAssignmentDeclarationKind(container.parent.parent) === 6) {
- return container.parent.parent.left.expression;
- }
- else if (container.kind === 201 &&
- container.parent.kind === 281 &&
- container.parent.parent.kind === 193 &&
- ts.isBinaryExpression(container.parent.parent.parent) &&
- ts.getAssignmentDeclarationKind(container.parent.parent.parent) === 6) {
- return container.parent.parent.parent.left.expression;
- }
- else if (container.kind === 201 &&
- ts.isPropertyAssignment(container.parent) &&
- ts.isIdentifier(container.parent.name) &&
- (container.parent.name.escapedText === "value" || container.parent.name.escapedText === "get" || container.parent.name.escapedText === "set") &&
- ts.isObjectLiteralExpression(container.parent.parent) &&
- ts.isCallExpression(container.parent.parent.parent) &&
- container.parent.parent.parent.arguments[2] === container.parent.parent &&
- ts.getAssignmentDeclarationKind(container.parent.parent.parent) === 9) {
- return container.parent.parent.parent.arguments[0].expression;
- }
- else if (ts.isMethodDeclaration(container) &&
- ts.isIdentifier(container.name) &&
- (container.name.escapedText === "value" || container.name.escapedText === "get" || container.name.escapedText === "set") &&
- ts.isObjectLiteralExpression(container.parent) &&
- ts.isCallExpression(container.parent.parent) &&
- container.parent.parent.arguments[2] === container.parent &&
- ts.getAssignmentDeclarationKind(container.parent.parent) === 9) {
- return container.parent.parent.arguments[0].expression;
- }
- }
- function getTypeForThisExpressionFromJSDoc(node) {
- var jsdocType = ts.getJSDocType(node);
- if (jsdocType && jsdocType.kind === 300) {
- var jsDocFunctionType = jsdocType;
- if (jsDocFunctionType.parameters.length > 0 &&
- jsDocFunctionType.parameters[0].name &&
- jsDocFunctionType.parameters[0].name.escapedText === "this") {
- return getTypeFromTypeNode(jsDocFunctionType.parameters[0].type);
+ else {
+ var savePriority = priority;
+ priority |= contravariant ? 32 : 0;
+ var targetTypes = [getTrueTypeFromConditionalType(target), getFalseTypeFromConditionalType(target)];
+ inferToMultipleTypes(source, targetTypes, target.flags);
+ priority = savePriority;
}
}
- var thisTag = ts.getJSDocThisTag(node);
- if (thisTag && thisTag.typeExpression) {
- return getTypeFromTypeNode(thisTag.typeExpression);
- }
- }
- function isInConstructorArgumentInitializer(node, constructorDecl) {
- return !!ts.findAncestor(node, function (n) { return ts.isFunctionLikeDeclaration(n) ? "quit" : n.kind === 156 && n.parent === constructorDecl; });
- }
- function checkSuperExpression(node) {
- var isCallExpression = node.parent.kind === 196 && node.parent.expression === node;
- var container = ts.getSuperContainer(node, true);
- var needToCaptureLexicalThis = false;
- if (!isCallExpression) {
- while (container && container.kind === 202) {
- container = ts.getSuperContainer(container, true);
- needToCaptureLexicalThis = languageVersion < 2;
+ function inferToTemplateLiteralType(source, target) {
+ var matches = source.flags & 128 ? inferLiteralsFromTemplateLiteralType(source, target) :
+ source.flags & 134217728 && ts.arraysEqual(source.texts, target.texts) ? source.types :
+ undefined;
+ var types = target.types;
+ for (var i = 0; i < types.length; i++) {
+ inferFromTypes(matches ? matches[i] : neverType, types[i]);
}
}
- var canUseSuperExpression = isLegalUsageOfSuperExpression(container);
- var nodeCheckFlag = 0;
- if (!canUseSuperExpression) {
- var current = ts.findAncestor(node, function (n) { return n === container ? "quit" : n.kind === 154; });
- if (current && current.kind === 154) {
- error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);
+ function inferFromObjectTypes(source, target) {
+ if (ts.getObjectFlags(source) & 4 && ts.getObjectFlags(target) & 4 && (source.target === target.target || isArrayType(source) && isArrayType(target))) {
+ inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
+ return;
}
- else if (isCallExpression) {
- error(node, ts.Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors);
+ if (isGenericMappedType(source) && isGenericMappedType(target)) {
+ inferFromTypes(getConstraintTypeFromMappedType(source), getConstraintTypeFromMappedType(target));
+ inferFromTypes(getTemplateTypeFromMappedType(source), getTemplateTypeFromMappedType(target));
+ var sourceNameType = getNameTypeFromMappedType(source);
+ var targetNameType = getNameTypeFromMappedType(target);
+ if (sourceNameType && targetNameType)
+ inferFromTypes(sourceNameType, targetNameType);
}
- else if (!container || !container.parent || !(ts.isClassLike(container.parent) || container.parent.kind === 193)) {
- error(node, ts.Diagnostics.super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions);
+ if (ts.getObjectFlags(target) & 32 && !target.declaration.nameType) {
+ var constraintType = getConstraintTypeFromMappedType(target);
+ if (inferToMappedType(source, target, constraintType)) {
+ return;
+ }
}
- else {
- error(node, ts.Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class);
+ if (!typesDefinitelyUnrelated(source, target)) {
+ if (isArrayType(source) || isTupleType(source)) {
+ if (isTupleType(target)) {
+ var sourceArity = getTypeReferenceArity(source);
+ var targetArity = getTypeReferenceArity(target);
+ var elementTypes = getTypeArguments(target);
+ var elementFlags = target.target.elementFlags;
+ if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
+ for (var i = 0; i < targetArity; i++) {
+ inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
+ }
+ return;
+ }
+ var startLength = isTupleType(source) ? Math.min(source.target.fixedLength, target.target.fixedLength) : 0;
+ var sourceRestType = !isTupleType(source) || sourceArity > 0 && source.target.elementFlags[sourceArity - 1] & 4 ?
+ getTypeArguments(source)[sourceArity - 1] : undefined;
+ var endLength = !(target.target.combinedFlags & 12) ? 0 :
+ sourceRestType ? getEndLengthOfType(target) :
+ Math.min(getEndLengthOfType(source), getEndLengthOfType(target));
+ var sourceEndLength = sourceRestType ? 0 : endLength;
+ for (var i = 0; i < startLength; i++) {
+ inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
+ }
+ if (sourceRestType && sourceArity - startLength === 1) {
+ for (var i = startLength; i < targetArity - endLength; i++) {
+ inferFromTypes(elementFlags[i] & 8 ? createArrayType(sourceRestType) : sourceRestType, elementTypes[i]);
+ }
+ }
+ else {
+ var middleLength = targetArity - startLength - endLength;
+ if (middleLength === 2 && elementFlags[startLength] & elementFlags[startLength + 1] & 8 && isTupleType(source)) {
+ var targetInfo = getInferenceInfoForType(elementTypes[startLength]);
+ if (targetInfo && targetInfo.impliedArity !== undefined) {
+ inferFromTypes(sliceTupleType(source, startLength, sourceEndLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]);
+ inferFromTypes(sliceTupleType(source, startLength + targetInfo.impliedArity, sourceEndLength), elementTypes[startLength + 1]);
+ }
+ }
+ else if (middleLength === 1 && elementFlags[startLength] & 8) {
+ var endsInOptional = target.target.elementFlags[targetArity - 1] & 2;
+ var sourceSlice = isTupleType(source) ? sliceTupleType(source, startLength, sourceEndLength) : createArrayType(sourceRestType);
+ inferWithPriority(sourceSlice, elementTypes[startLength], endsInOptional ? 2 : 0);
+ }
+ else if (middleLength === 1 && elementFlags[startLength] & 4) {
+ var restType = isTupleType(source) ? getElementTypeOfSliceOfTupleType(source, startLength, sourceEndLength) : sourceRestType;
+ if (restType) {
+ inferFromTypes(restType, elementTypes[startLength]);
+ }
+ }
+ }
+ for (var i = 0; i < endLength; i++) {
+ inferFromTypes(sourceRestType || getTypeArguments(source)[sourceArity - i - 1], elementTypes[targetArity - i - 1]);
+ }
+ return;
+ }
+ if (isArrayType(target)) {
+ inferFromIndexTypes(source, target);
+ return;
+ }
+ }
+ inferFromProperties(source, target);
+ inferFromSignatures(source, target, 0);
+ inferFromSignatures(source, target, 1);
+ inferFromIndexTypes(source, target);
}
- return errorType;
- }
- if (!isCallExpression && container.kind === 162) {
- checkThisBeforeSuper(node, container, ts.Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class);
- }
- if (ts.hasModifier(container, 32) || isCallExpression) {
- nodeCheckFlag = 512;
- }
- else {
- nodeCheckFlag = 256;
}
- getNodeLinks(node).flags |= nodeCheckFlag;
- if (container.kind === 161 && ts.hasModifier(container, 256)) {
- if (ts.isSuperProperty(node.parent) && ts.isAssignmentTarget(node.parent)) {
- getNodeLinks(container).flags |= 4096;
- }
- else {
- getNodeLinks(container).flags |= 2048;
+ function inferFromProperties(source, target) {
+ var properties = getPropertiesOfObjectType(target);
+ for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
+ var targetProp = properties_3[_i];
+ var sourceProp = getPropertyOfType(source, targetProp.escapedName);
+ if (sourceProp) {
+ inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
+ }
}
}
- if (needToCaptureLexicalThis) {
- captureLexicalThis(node.parent, container);
- }
- if (container.parent.kind === 193) {
- if (languageVersion < 2) {
- error(node, ts.Diagnostics.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher);
- return errorType;
- }
- else {
- return anyType;
+ function inferFromSignatures(source, target, kind) {
+ var sourceSignatures = getSignaturesOfType(source, kind);
+ var targetSignatures = getSignaturesOfType(target, kind);
+ var sourceLen = sourceSignatures.length;
+ var targetLen = targetSignatures.length;
+ var len = sourceLen < targetLen ? sourceLen : targetLen;
+ var skipParameters = !!(ts.getObjectFlags(source) & 2097152);
+ for (var i = 0; i < len; i++) {
+ inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]), skipParameters);
}
}
- var classLikeDeclaration = container.parent;
- if (!ts.getClassExtendsHeritageElement(classLikeDeclaration)) {
- error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class);
- return errorType;
- }
- var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classLikeDeclaration));
- var baseClassType = classType && getBaseTypes(classType)[0];
- if (!baseClassType) {
- return errorType;
- }
- if (container.kind === 162 && isInConstructorArgumentInitializer(node, container)) {
- error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments);
- return errorType;
- }
- return nodeCheckFlag === 512
- ? getBaseConstructorTypeOfClass(classType)
- : getTypeWithThisArgument(baseClassType, classType.thisType);
- function isLegalUsageOfSuperExpression(container) {
- if (!container) {
- return false;
+ function inferFromSignature(source, target, skipParameters) {
+ if (!skipParameters) {
+ var saveBivariant = bivariant;
+ var kind = target.declaration ? target.declaration.kind : 0;
+ bivariant = bivariant || kind === 165 || kind === 164 || kind === 166;
+ applyToParameterTypes(source, target, inferFromContravariantTypes);
+ bivariant = saveBivariant;
}
- if (isCallExpression) {
- return container.kind === 162;
+ applyToReturnTypes(source, target, inferFromTypes);
+ }
+ function inferFromIndexTypes(source, target) {
+ var targetStringIndexType = getIndexTypeOfType(target, 0);
+ if (targetStringIndexType) {
+ var sourceIndexType = getIndexTypeOfType(source, 0) ||
+ getImplicitIndexTypeOfType(source, 0);
+ if (sourceIndexType) {
+ inferFromTypes(sourceIndexType, targetStringIndexType);
+ }
}
- else {
- if (ts.isClassLike(container.parent) || container.parent.kind === 193) {
- if (ts.hasModifier(container, 32)) {
- return container.kind === 161 ||
- container.kind === 160 ||
- container.kind === 163 ||
- container.kind === 164;
- }
- else {
- return container.kind === 161 ||
- container.kind === 160 ||
- container.kind === 163 ||
- container.kind === 164 ||
- container.kind === 159 ||
- container.kind === 158 ||
- container.kind === 162;
- }
+ var targetNumberIndexType = getIndexTypeOfType(target, 1);
+ if (targetNumberIndexType) {
+ var sourceIndexType = getIndexTypeOfType(source, 1) ||
+ getIndexTypeOfType(source, 0) ||
+ getImplicitIndexTypeOfType(source, 1);
+ if (sourceIndexType) {
+ inferFromTypes(sourceIndexType, targetNumberIndexType);
}
}
- return false;
}
}
- function getContainingObjectLiteral(func) {
- return (func.kind === 161 ||
- func.kind === 163 ||
- func.kind === 164) && func.parent.kind === 193 ? func.parent :
- func.kind === 201 && func.parent.kind === 281 ? func.parent.parent :
- undefined;
+ function isTypeOrBaseIdenticalTo(s, t) {
+ return isTypeIdenticalTo(s, t) || !!(t.flags & 4 && s.flags & 128 || t.flags & 8 && s.flags & 256);
}
- function getThisTypeArgument(type) {
- return ts.getObjectFlags(type) & 4 && type.target === globalThisType ? getTypeArguments(type)[0] : undefined;
+ function isTypeCloselyMatchedBy(s, t) {
+ return !!(s.flags & 524288 && t.flags & 524288 && s.symbol && s.symbol === t.symbol ||
+ s.aliasSymbol && s.aliasTypeArguments && s.aliasSymbol === t.aliasSymbol);
}
- function getThisTypeFromContextualType(type) {
- return mapType(type, function (t) {
- return t.flags & 2097152 ? ts.forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t);
- });
+ function hasPrimitiveConstraint(type) {
+ var constraint = getConstraintOfTypeParameter(type);
+ return !!constraint && maybeTypeOfKind(constraint.flags & 16777216 ? getDefaultConstraintOfConditionalType(constraint) : constraint, 131068 | 4194304 | 134217728 | 268435456);
}
- function getContextualThisParameterType(func) {
- if (func.kind === 202) {
- return undefined;
- }
- if (isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
- var contextualSignature = getContextualSignature(func);
- if (contextualSignature) {
- var thisParameter = contextualSignature.thisParameter;
- if (thisParameter) {
- return getTypeOfSymbol(thisParameter);
- }
+ function isObjectLiteralType(type) {
+ return !!(ts.getObjectFlags(type) & 128);
+ }
+ function isObjectOrArrayLiteralType(type) {
+ return !!(ts.getObjectFlags(type) & (128 | 65536));
+ }
+ function unionObjectAndArrayLiteralCandidates(candidates) {
+ if (candidates.length > 1) {
+ var objectLiterals = ts.filter(candidates, isObjectOrArrayLiteralType);
+ if (objectLiterals.length) {
+ var literalsType = getUnionType(objectLiterals, 2);
+ return ts.concatenate(ts.filter(candidates, function (t) { return !isObjectOrArrayLiteralType(t); }), [literalsType]);
}
}
- var inJs = ts.isInJSFile(func);
- if (noImplicitThis || inJs) {
- var containingLiteral = getContainingObjectLiteral(func);
- if (containingLiteral) {
- var contextualType = getApparentTypeOfContextualType(containingLiteral);
- var literal = containingLiteral;
- var type = contextualType;
- while (type) {
- var thisType = getThisTypeFromContextualType(type);
- if (thisType) {
- return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
- }
- if (literal.parent.kind !== 281) {
- break;
+ return candidates;
+ }
+ function getContravariantInference(inference) {
+ return inference.priority & 208 ? getIntersectionType(inference.contraCandidates) : getCommonSubtype(inference.contraCandidates);
+ }
+ function getCovariantInference(inference, signature) {
+ var candidates = unionObjectAndArrayLiteralCandidates(inference.candidates);
+ var primitiveConstraint = hasPrimitiveConstraint(inference.typeParameter);
+ var widenLiteralTypes = !primitiveConstraint && inference.topLevel &&
+ (inference.isFixed || !isTypeParameterAtTopLevel(getReturnTypeOfSignature(signature), inference.typeParameter));
+ var baseCandidates = primitiveConstraint ? ts.sameMap(candidates, getRegularTypeOfLiteralType) :
+ widenLiteralTypes ? ts.sameMap(candidates, getWidenedLiteralType) :
+ candidates;
+ var unwidenedType = inference.priority & 208 ?
+ getUnionType(baseCandidates, 2) :
+ getCommonSupertype(baseCandidates);
+ return getWidenedType(unwidenedType);
+ }
+ function getInferredType(context, index) {
+ var inference = context.inferences[index];
+ if (!inference.inferredType) {
+ var inferredType = void 0;
+ var signature = context.signature;
+ if (signature) {
+ var inferredCovariantType = inference.candidates ? getCovariantInference(inference, signature) : undefined;
+ if (inference.contraCandidates) {
+ var inferredContravariantType = getContravariantInference(inference);
+ inferredType = inferredCovariantType && !(inferredCovariantType.flags & 131072) &&
+ isTypeSubtypeOf(inferredCovariantType, inferredContravariantType) ?
+ inferredCovariantType : inferredContravariantType;
+ }
+ else if (inferredCovariantType) {
+ inferredType = inferredCovariantType;
+ }
+ else if (context.flags & 1) {
+ inferredType = silentNeverType;
+ }
+ else {
+ var defaultType = getDefaultFromTypeParameter(inference.typeParameter);
+ if (defaultType) {
+ inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
}
- literal = literal.parent.parent;
- type = getApparentTypeOfContextualType(literal);
}
- return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral));
}
- var parent = ts.walkUpParenthesizedExpressions(func.parent);
- if (parent.kind === 209 && parent.operatorToken.kind === 62) {
- var target = parent.left;
- if (ts.isAccessExpression(target)) {
- var expression = target.expression;
- if (inJs && ts.isIdentifier(expression)) {
- var sourceFile = ts.getSourceFileOfNode(parent);
- if (sourceFile.commonJsModuleIndicator && getResolvedSymbol(expression) === sourceFile.symbol) {
- return undefined;
- }
- }
- return getWidenedType(checkExpressionCached(expression));
+ else {
+ inferredType = getTypeFromInference(inference);
+ }
+ inference.inferredType = inferredType || getDefaultTypeArgumentType(!!(context.flags & 2));
+ var constraint = getConstraintOfTypeParameter(inference.typeParameter);
+ if (constraint) {
+ var instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
+ if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
+ inference.inferredType = inferredType = instantiatedConstraint;
}
}
}
- return undefined;
+ return inference.inferredType;
}
- function getContextuallyTypedParameterType(parameter) {
- var func = parameter.parent;
- if (!isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
- return undefined;
+ function getDefaultTypeArgumentType(isInJavaScriptFile) {
+ return isInJavaScriptFile ? anyType : unknownType;
+ }
+ function getInferredTypes(context) {
+ var result = [];
+ for (var i = 0; i < context.inferences.length; i++) {
+ result.push(getInferredType(context, i));
}
- var iife = ts.getImmediatelyInvokedFunctionExpression(func);
- if (iife && iife.arguments) {
- var args = getEffectiveCallArguments(iife);
- var indexOfParameter = func.parameters.indexOf(parameter);
- if (parameter.dotDotDotToken) {
- return getSpreadArgumentType(args, indexOfParameter, args.length, anyType, undefined);
- }
- var links = getNodeLinks(iife);
- var cached = links.resolvedSignature;
- links.resolvedSignature = anySignature;
- var type = indexOfParameter < args.length ?
- getWidenedLiteralType(checkExpression(args[indexOfParameter])) :
- parameter.initializer ? undefined : undefinedWideningType;
- links.resolvedSignature = cached;
- return type;
+ return result;
+ }
+ function getCannotFindNameDiagnosticForName(node) {
+ switch (node.escapedText) {
+ case "document":
+ case "console":
+ return ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom;
+ case "$":
+ return compilerOptions.types
+ ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig
+ : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery;
+ case "describe":
+ case "suite":
+ case "it":
+ case "test":
+ return compilerOptions.types
+ ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig
+ : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha;
+ case "process":
+ case "require":
+ case "Buffer":
+ case "module":
+ return compilerOptions.types
+ ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig
+ : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode;
+ case "Map":
+ case "Set":
+ case "Promise":
+ case "Symbol":
+ case "WeakMap":
+ case "WeakSet":
+ case "Iterator":
+ case "AsyncIterator":
+ case "SharedArrayBuffer":
+ case "Atomics":
+ case "AsyncIterable":
+ case "AsyncIterableIterator":
+ case "AsyncGenerator":
+ case "AsyncGeneratorFunction":
+ case "BigInt":
+ case "Reflect":
+ case "BigInt64Array":
+ case "BigUint64Array":
+ return ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later;
+ default:
+ if (node.parent.kind === 289) {
+ return ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer;
+ }
+ else {
+ return ts.Diagnostics.Cannot_find_name_0;
+ }
}
- var contextualSignature = getContextualSignature(func);
- if (contextualSignature) {
- var index = func.parameters.indexOf(parameter) - (ts.getThisParameter(func) ? 1 : 0);
- return parameter.dotDotDotToken && ts.lastOrUndefined(func.parameters) === parameter ?
- getRestTypeAtPosition(contextualSignature, index) :
- tryGetTypeAtPosition(contextualSignature, index);
+ }
+ function getResolvedSymbol(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedSymbol) {
+ links.resolvedSymbol = !ts.nodeIsMissing(node) &&
+ resolveName(node, node.escapedText, 111551 | 1048576, getCannotFindNameDiagnosticForName(node), node, !ts.isWriteOnlyAccess(node), false, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_1) || unknownSymbol;
}
+ return links.resolvedSymbol;
}
- function getContextualTypeForVariableLikeDeclaration(declaration) {
- var typeNode = ts.getEffectiveTypeAnnotationNode(declaration);
- if (typeNode) {
- return getTypeFromTypeNode(typeNode);
+ function isInTypeQuery(node) {
+ return !!ts.findAncestor(node, function (n) { return n.kind === 176 ? true : n.kind === 78 || n.kind === 157 ? false : "quit"; });
+ }
+ function getFlowCacheKey(node, declaredType, initialType, flowContainer) {
+ switch (node.kind) {
+ case 78:
+ var symbol = getResolvedSymbol(node);
+ return symbol !== unknownSymbol ? (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType) + "|" + (isConstraintPosition(node) ? "@" : "") + getSymbolId(symbol) : undefined;
+ case 107:
+ return "0|" + (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType);
+ case 225:
+ case 207:
+ return getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
+ case 201:
+ case 202:
+ var propName = getAccessedPropertyName(node);
+ if (propName !== undefined) {
+ var key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
+ return key && key + "." + propName;
+ }
}
- switch (declaration.kind) {
- case 156:
- return getContextuallyTypedParameterType(declaration);
- case 191:
- return getContextualTypeForBindingElement(declaration);
+ return undefined;
+ }
+ function isMatchingReference(source, target) {
+ switch (target.kind) {
+ case 207:
+ case 225:
+ return isMatchingReference(source, target.expression);
+ case 216:
+ return (ts.isAssignmentExpression(target) && isMatchingReference(source, target.left)) ||
+ (ts.isBinaryExpression(target) && target.operatorToken.kind === 27 && isMatchingReference(source, target.right));
+ }
+ switch (source.kind) {
+ case 78:
+ case 79:
+ return target.kind === 78 && getResolvedSymbol(source) === getResolvedSymbol(target) ||
+ (target.kind === 249 || target.kind === 198) &&
+ getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(source)) === getSymbolOfNode(target);
+ case 107:
+ return target.kind === 107;
+ case 105:
+ return target.kind === 105;
+ case 225:
+ case 207:
+ return isMatchingReference(source.expression, target);
+ case 201:
+ case 202:
+ return ts.isAccessExpression(target) &&
+ getAccessedPropertyName(source) === getAccessedPropertyName(target) &&
+ isMatchingReference(source.expression, target.expression);
}
+ return false;
}
- function getContextualTypeForBindingElement(declaration) {
- var parent = declaration.parent.parent;
- var name = declaration.propertyName || declaration.name;
- var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
- parent.kind !== 191 && parent.initializer && checkDeclarationInitializer(parent);
- if (parentType && !ts.isBindingPattern(name) && !ts.isComputedNonLiteralName(name)) {
- var nameType = getLiteralTypeFromPropertyName(name);
- if (isTypeUsableAsPropertyName(nameType)) {
- var text = getPropertyNameFromType(nameType);
- return getTypeOfPropertyOfType(parentType, text);
+ function containsTruthyCheck(source, target) {
+ return isMatchingReference(source, target) ||
+ (target.kind === 216 && target.operatorToken.kind === 55 &&
+ (containsTruthyCheck(source, target.left) || containsTruthyCheck(source, target.right)));
+ }
+ function getAccessedPropertyName(access) {
+ return access.kind === 201 ? access.name.escapedText :
+ ts.isStringOrNumericLiteralLike(access.argumentExpression) ? ts.escapeLeadingUnderscores(access.argumentExpression.text) :
+ undefined;
+ }
+ function containsMatchingReference(source, target) {
+ while (ts.isAccessExpression(source)) {
+ source = source.expression;
+ if (isMatchingReference(source, target)) {
+ return true;
}
}
+ return false;
}
- function getContextualTypeForInitializerExpression(node) {
- var declaration = node.parent;
- if (ts.hasInitializer(declaration) && node === declaration.initializer) {
- var result = getContextualTypeForVariableLikeDeclaration(declaration);
- if (result) {
- return result;
- }
- if (ts.isBindingPattern(declaration.name)) {
- return getTypeFromBindingPattern(declaration.name, true, false);
+ function optionalChainContainsReference(source, target) {
+ while (ts.isOptionalChain(source)) {
+ source = source.expression;
+ if (isMatchingReference(source, target)) {
+ return true;
}
}
- return undefined;
+ return false;
}
- function getContextualTypeForReturnExpression(node) {
- var func = ts.getContainingFunction(node);
- if (func) {
- var functionFlags = ts.getFunctionFlags(func);
- if (functionFlags & 1) {
- return undefined;
- }
- var contextualReturnType = getContextualReturnType(func);
- if (contextualReturnType) {
- if (functionFlags & 2) {
- var contextualAwaitedType = mapType(contextualReturnType, getAwaitedTypeOfPromise);
- return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
+ function isDiscriminantProperty(type, name) {
+ if (type && type.flags & 1048576) {
+ var prop = getUnionOrIntersectionProperty(type, name);
+ if (prop && ts.getCheckFlags(prop) & 2) {
+ if (prop.isDiscriminantProperty === undefined) {
+ prop.isDiscriminantProperty =
+ (prop.checkFlags & 192) === 192 &&
+ !maybeTypeOfKind(getTypeOfSymbol(prop), 465829888);
}
- return contextualReturnType;
+ return !!prop.isDiscriminantProperty;
}
}
- return undefined;
+ return false;
}
- function getContextualTypeForAwaitOperand(node) {
- var contextualType = getContextualType(node);
- if (contextualType) {
- var contextualAwaitedType = getAwaitedType(contextualType);
- return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
+ function findDiscriminantProperties(sourceProperties, target) {
+ var result;
+ for (var _i = 0, sourceProperties_2 = sourceProperties; _i < sourceProperties_2.length; _i++) {
+ var sourceProperty = sourceProperties_2[_i];
+ if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
+ if (result) {
+ result.push(sourceProperty);
+ continue;
+ }
+ result = [sourceProperty];
+ }
}
- return undefined;
+ return result;
}
- function getContextualTypeForYieldOperand(node) {
- var func = ts.getContainingFunction(node);
- if (func) {
- var functionFlags = ts.getFunctionFlags(func);
- var contextualReturnType = getContextualReturnType(func);
- if (contextualReturnType) {
- return node.asteriskToken
- ? contextualReturnType
- : getIterationTypeOfGeneratorFunctionReturnType(0, contextualReturnType, (functionFlags & 2) !== 0);
+ function isOrContainsMatchingReference(source, target) {
+ return isMatchingReference(source, target) || containsMatchingReference(source, target);
+ }
+ function hasMatchingArgument(callExpression, reference) {
+ if (callExpression.arguments) {
+ for (var _i = 0, _a = callExpression.arguments; _i < _a.length; _i++) {
+ var argument = _a[_i];
+ if (isOrContainsMatchingReference(reference, argument)) {
+ return true;
+ }
}
}
- return undefined;
+ if (callExpression.expression.kind === 201 &&
+ isOrContainsMatchingReference(reference, callExpression.expression.expression)) {
+ return true;
+ }
+ return false;
}
- function isInParameterInitializerBeforeContainingFunction(node) {
- var inBindingInitializer = false;
- while (node.parent && !ts.isFunctionLike(node.parent)) {
- if (ts.isParameter(node.parent) && (inBindingInitializer || node.parent.initializer === node)) {
+ function getFlowNodeId(flow) {
+ if (!flow.id || flow.id < 0) {
+ flow.id = nextFlowId;
+ nextFlowId++;
+ }
+ return flow.id;
+ }
+ function typeMaybeAssignableTo(source, target) {
+ if (!(source.flags & 1048576)) {
+ return isTypeAssignableTo(source, target);
+ }
+ for (var _i = 0, _a = source.types; _i < _a.length; _i++) {
+ var t = _a[_i];
+ if (isTypeAssignableTo(t, target)) {
return true;
}
- if (ts.isBindingElement(node.parent) && node.parent.initializer === node) {
- inBindingInitializer = true;
- }
- node = node.parent;
}
return false;
}
- function getContextualIterationType(kind, functionDecl) {
- var isAsync = !!(ts.getFunctionFlags(functionDecl) & 2);
- var contextualReturnType = getContextualReturnType(functionDecl);
- if (contextualReturnType) {
- return getIterationTypeOfGeneratorFunctionReturnType(kind, contextualReturnType, isAsync)
- || undefined;
+ function getAssignmentReducedType(declaredType, assignedType) {
+ if (declaredType !== assignedType) {
+ if (assignedType.flags & 131072) {
+ return assignedType;
+ }
+ var reducedType = filterType(declaredType, function (t) { return typeMaybeAssignableTo(assignedType, t); });
+ if (assignedType.flags & 512 && isFreshLiteralType(assignedType)) {
+ reducedType = mapType(reducedType, getFreshTypeOfLiteralType);
+ }
+ if (isTypeAssignableTo(assignedType, reducedType)) {
+ return reducedType;
+ }
}
- return undefined;
+ return declaredType;
}
- function getContextualReturnType(functionDecl) {
- var returnType = getReturnTypeFromAnnotation(functionDecl);
- if (returnType) {
- return returnType;
- }
- var signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl);
- if (signature && !isResolvingReturnTypeOfSignature(signature)) {
- return getReturnTypeOfSignature(signature);
+ function getTypeFactsOfTypes(types) {
+ var result = 0;
+ for (var _i = 0, types_16 = types; _i < types_16.length; _i++) {
+ var t = types_16[_i];
+ result |= getTypeFacts(t);
}
- return undefined;
+ return result;
}
- function getContextualTypeForArgument(callTarget, arg) {
- var args = getEffectiveCallArguments(callTarget);
- var argIndex = args.indexOf(arg);
- return argIndex === -1 ? undefined : getContextualTypeForArgumentAtIndex(callTarget, argIndex);
+ function isFunctionObjectType(type) {
+ var resolved = resolveStructuredTypeMembers(type);
+ return !!(resolved.callSignatures.length || resolved.constructSignatures.length ||
+ resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
}
- function getContextualTypeForArgumentAtIndex(callTarget, argIndex) {
- var signature = getNodeLinks(callTarget).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(callTarget);
- if (ts.isJsxOpeningLikeElement(callTarget) && argIndex === 0) {
- return getEffectiveFirstArgumentForJsxSignature(signature, callTarget);
+ function getTypeFacts(type) {
+ var flags = type.flags;
+ if (flags & 4) {
+ return strictNullChecks ? 16317953 : 16776705;
}
- return getTypeAtPosition(signature, argIndex);
- }
- function getContextualTypeForSubstitutionExpression(template, substitutionExpression) {
- if (template.parent.kind === 198) {
- return getContextualTypeForArgument(template.parent, substitutionExpression);
+ if (flags & 128) {
+ var isEmpty = type.value === "";
+ return strictNullChecks ?
+ isEmpty ? 12123649 : 7929345 :
+ isEmpty ? 12582401 : 16776705;
}
- return undefined;
- }
- function getContextualTypeForBinaryOperand(node, contextFlags) {
- var binaryExpression = node.parent;
- var left = binaryExpression.left, operatorToken = binaryExpression.operatorToken, right = binaryExpression.right;
- switch (operatorToken.kind) {
- case 62:
- if (node !== right) {
- return undefined;
- }
- var contextSensitive = getIsContextSensitiveAssignmentOrContextType(binaryExpression);
- if (!contextSensitive) {
- return undefined;
- }
- return contextSensitive === true ? getTypeOfExpression(left) : contextSensitive;
- case 56:
- case 60:
- var type = getContextualType(binaryExpression, contextFlags);
- return node === right && (type && type.pattern || !type && !ts.isDefaultedExpandoInitializer(binaryExpression)) ?
- getTypeOfExpression(left) : type;
- case 55:
- case 27:
- return node === right ? getContextualType(binaryExpression, contextFlags) : undefined;
- default:
- return undefined;
+ if (flags & (8 | 32)) {
+ return strictNullChecks ? 16317698 : 16776450;
}
- }
- function getIsContextSensitiveAssignmentOrContextType(binaryExpression) {
- var kind = ts.getAssignmentDeclarationKind(binaryExpression);
- switch (kind) {
- case 0:
- return true;
- case 5:
- case 1:
- case 6:
- case 3:
- if (!binaryExpression.left.symbol) {
- return true;
- }
- else {
- var decl = binaryExpression.left.symbol.valueDeclaration;
- if (!decl) {
- return false;
- }
- var lhs = ts.cast(binaryExpression.left, ts.isAccessExpression);
- var overallAnnotation = ts.getEffectiveTypeAnnotationNode(decl);
- if (overallAnnotation) {
- return getTypeFromTypeNode(overallAnnotation);
- }
- else if (ts.isIdentifier(lhs.expression)) {
- var id = lhs.expression;
- var parentSymbol = resolveName(id, id.escapedText, 111551, undefined, id.escapedText, true);
- if (parentSymbol) {
- var annotated = ts.getEffectiveTypeAnnotationNode(parentSymbol.valueDeclaration);
- if (annotated) {
- var nameStr_1 = ts.getElementOrPropertyAccessName(lhs);
- if (nameStr_1 !== undefined) {
- var type = getTypeOfPropertyOfContextualType(getTypeFromTypeNode(annotated), nameStr_1);
- return type || false;
- }
- }
- return false;
- }
- }
- return !ts.isInJSFile(decl);
- }
- case 2:
- case 4:
- if (!binaryExpression.symbol)
- return true;
- if (binaryExpression.symbol.valueDeclaration) {
- var annotated = ts.getEffectiveTypeAnnotationNode(binaryExpression.symbol.valueDeclaration);
- if (annotated) {
- var type = getTypeFromTypeNode(annotated);
- if (type) {
- return type;
- }
- }
- }
- if (kind === 2)
- return false;
- var thisAccess = ts.cast(binaryExpression.left, ts.isAccessExpression);
- if (!ts.isObjectLiteralMethod(ts.getThisContainer(thisAccess.expression, false))) {
- return false;
- }
- var thisType = checkThisExpression(thisAccess.expression);
- var nameStr = ts.getElementOrPropertyAccessName(thisAccess);
- return nameStr !== undefined && thisType && getTypeOfPropertyOfContextualType(thisType, nameStr) || false;
- case 7:
- case 8:
- case 9:
- return ts.Debug.fail("Does not apply");
- default:
- return ts.Debug.assertNever(kind);
+ if (flags & 256) {
+ var isZero = type.value === 0;
+ return strictNullChecks ?
+ isZero ? 12123394 : 7929090 :
+ isZero ? 12582146 : 16776450;
+ }
+ if (flags & 64) {
+ return strictNullChecks ? 16317188 : 16775940;
+ }
+ if (flags & 2048) {
+ var isZero = isZeroBigInt(type);
+ return strictNullChecks ?
+ isZero ? 12122884 : 7928580 :
+ isZero ? 12581636 : 16775940;
+ }
+ if (flags & 16) {
+ return strictNullChecks ? 16316168 : 16774920;
+ }
+ if (flags & 528) {
+ return strictNullChecks ?
+ (type === falseType || type === regularFalseType) ? 12121864 : 7927560 :
+ (type === falseType || type === regularFalseType) ? 12580616 : 16774920;
+ }
+ if (flags & 524288) {
+ return ts.getObjectFlags(type) & 16 && isEmptyObjectType(type) ?
+ strictNullChecks ? 16318463 : 16777215 :
+ isFunctionObjectType(type) ?
+ strictNullChecks ? 7880640 : 16728000 :
+ strictNullChecks ? 7888800 : 16736160;
+ }
+ if (flags & (16384 | 32768)) {
+ return 9830144;
+ }
+ if (flags & 65536) {
+ return 9363232;
}
+ if (flags & 12288) {
+ return strictNullChecks ? 7925520 : 16772880;
+ }
+ if (flags & 67108864) {
+ return strictNullChecks ? 7888800 : 16736160;
+ }
+ if (flags & 131072) {
+ return 0;
+ }
+ if (flags & 465829888) {
+ return getTypeFacts(getBaseConstraintOfType(type) || unknownType);
+ }
+ if (flags & 3145728) {
+ return getTypeFactsOfTypes(type.types);
+ }
+ return 16777215;
}
- function getTypeOfPropertyOfContextualType(type, name) {
- return mapType(type, function (t) {
- if (isGenericMappedType(t)) {
- var constraint = getConstraintTypeFromMappedType(t);
- var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
- var propertyNameType = getLiteralType(ts.unescapeLeadingUnderscores(name));
- if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
- return substituteIndexedMappedType(t, propertyNameType);
- }
- }
- else if (t.flags & 3670016) {
- var prop = getPropertyOfType(t, name);
- if (prop) {
- return getTypeOfSymbol(prop);
- }
- if (isTupleType(t)) {
- var restType = getRestTypeOfTupleType(t);
- if (restType && isNumericLiteralName(name) && +name >= 0) {
- return restType;
- }
- }
- return isNumericLiteralName(name) && getIndexTypeOfContextualType(t, 1) ||
- getIndexTypeOfContextualType(t, 0);
- }
- return undefined;
- }, true);
- }
- function getIndexTypeOfContextualType(type, kind) {
- return mapType(type, function (t) { return getIndexTypeOfStructuredType(t, kind); }, true);
+ function getTypeWithFacts(type, include) {
+ return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; });
}
- function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
- ts.Debug.assert(ts.isObjectLiteralMethod(node));
- if (node.flags & 16777216) {
- return undefined;
+ function getTypeWithDefault(type, defaultExpression) {
+ if (defaultExpression) {
+ var defaultType = getTypeOfExpression(defaultExpression);
+ return getUnionType([getTypeWithFacts(type, 524288), defaultType]);
}
- return getContextualTypeForObjectLiteralElement(node, contextFlags);
+ return type;
}
- function getContextualTypeForObjectLiteralElement(element, contextFlags) {
- var objectLiteral = element.parent;
- var type = getApparentTypeOfContextualType(objectLiteral, contextFlags);
- if (type) {
- if (!hasNonBindableDynamicName(element)) {
- var symbolName_3 = getSymbolOfNode(element).escapedName;
- var propertyType = getTypeOfPropertyOfContextualType(type, symbolName_3);
- if (propertyType) {
- return propertyType;
- }
- }
- return isNumericName(element.name) && getIndexTypeOfContextualType(type, 1) ||
- getIndexTypeOfContextualType(type, 0);
- }
- return undefined;
+ function getTypeOfDestructuredProperty(type, name) {
+ var nameType = getLiteralTypeFromPropertyName(name);
+ if (!isTypeUsableAsPropertyName(nameType))
+ return errorType;
+ var text = getPropertyNameFromType(nameType);
+ return getConstraintForLocation(getTypeOfPropertyOfType(type, text), name) ||
+ isNumericLiteralName(text) && includeUndefinedInIndexSignature(getIndexTypeOfType(type, 1)) ||
+ includeUndefinedInIndexSignature(getIndexTypeOfType(type, 0)) ||
+ errorType;
}
- function getContextualTypeForElementExpression(arrayContextualType, index) {
- return arrayContextualType && (getTypeOfPropertyOfContextualType(arrayContextualType, "" + index)
- || getIteratedTypeOrElementType(1, arrayContextualType, undefinedType, undefined, false));
+ function getTypeOfDestructuredArrayElement(type, index) {
+ return everyType(type, isTupleLikeType) && getTupleElementType(type, index) ||
+ includeUndefinedInIndexSignature(checkIteratedTypeOrElementType(65, type, undefinedType, undefined)) ||
+ errorType;
}
- function getContextualTypeForConditionalOperand(node, contextFlags) {
- var conditional = node.parent;
- return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined;
+ function includeUndefinedInIndexSignature(type) {
+ if (!type)
+ return type;
+ return compilerOptions.noUncheckedIndexedAccess ?
+ getUnionType([type, undefinedType]) :
+ type;
}
- function getContextualTypeForChildJsxExpression(node, child) {
- var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName);
- var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
- if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
- return undefined;
+ function getTypeOfDestructuredSpreadExpression(type) {
+ return createArrayType(checkIteratedTypeOrElementType(65, type, undefinedType, undefined) || errorType);
+ }
+ function getAssignedTypeOfBinaryExpression(node) {
+ var isDestructuringDefaultAssignment = node.parent.kind === 199 && isDestructuringAssignmentTarget(node.parent) ||
+ node.parent.kind === 288 && isDestructuringAssignmentTarget(node.parent.parent);
+ return isDestructuringDefaultAssignment ?
+ getTypeWithDefault(getAssignedType(node), node.right) :
+ getTypeOfExpression(node.right);
+ }
+ function isDestructuringAssignmentTarget(parent) {
+ return parent.parent.kind === 216 && parent.parent.left === parent ||
+ parent.parent.kind === 239 && parent.parent.initializer === parent;
+ }
+ function getAssignedTypeOfArrayLiteralElement(node, element) {
+ return getTypeOfDestructuredArrayElement(getAssignedType(node), node.elements.indexOf(element));
+ }
+ function getAssignedTypeOfSpreadExpression(node) {
+ return getTypeOfDestructuredSpreadExpression(getAssignedType(node.parent));
+ }
+ function getAssignedTypeOfPropertyAssignment(node) {
+ return getTypeOfDestructuredProperty(getAssignedType(node.parent), node.name);
+ }
+ function getAssignedTypeOfShorthandPropertyAssignment(node) {
+ return getTypeWithDefault(getAssignedTypeOfPropertyAssignment(node), node.objectAssignmentInitializer);
+ }
+ function getAssignedType(node) {
+ var parent = node.parent;
+ switch (parent.kind) {
+ case 238:
+ return stringType;
+ case 239:
+ return checkRightHandSideOfForOf(parent) || errorType;
+ case 216:
+ return getAssignedTypeOfBinaryExpression(parent);
+ case 210:
+ return undefinedType;
+ case 199:
+ return getAssignedTypeOfArrayLiteralElement(parent, node);
+ case 220:
+ return getAssignedTypeOfSpreadExpression(parent);
+ case 288:
+ return getAssignedTypeOfPropertyAssignment(parent);
+ case 289:
+ return getAssignedTypeOfShorthandPropertyAssignment(parent);
}
- var realChildren = getSemanticJsxChildren(node.children);
- var childIndex = realChildren.indexOf(child);
- var childFieldType = getTypeOfPropertyOfContextualType(attributesType, jsxChildrenPropertyName);
- return childFieldType && (realChildren.length === 1 ? childFieldType : mapType(childFieldType, function (t) {
- if (isArrayLikeType(t)) {
- return getIndexedAccessType(t, getLiteralType(childIndex));
- }
- else {
- return t;
- }
- }, true));
+ return errorType;
}
- function getContextualTypeForJsxExpression(node) {
- var exprParent = node.parent;
- return ts.isJsxAttributeLike(exprParent)
- ? getContextualType(node)
- : ts.isJsxElement(exprParent)
- ? getContextualTypeForChildJsxExpression(exprParent, node)
- : undefined;
+ function getInitialTypeOfBindingElement(node) {
+ var pattern = node.parent;
+ var parentType = getInitialType(pattern.parent);
+ var type = pattern.kind === 196 ?
+ getTypeOfDestructuredProperty(parentType, node.propertyName || node.name) :
+ !node.dotDotDotToken ?
+ getTypeOfDestructuredArrayElement(parentType, pattern.elements.indexOf(node)) :
+ getTypeOfDestructuredSpreadExpression(parentType);
+ return getTypeWithDefault(type, node.initializer);
}
- function getContextualTypeForJsxAttribute(attribute) {
- if (ts.isJsxAttribute(attribute)) {
- var attributesType = getApparentTypeOfContextualType(attribute.parent);
- if (!attributesType || isTypeAny(attributesType)) {
- return undefined;
- }
- return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
+ function getTypeOfInitializer(node) {
+ var links = getNodeLinks(node);
+ return links.resolvedType || getTypeOfExpression(node);
+ }
+ function getInitialTypeOfVariableDeclaration(node) {
+ if (node.initializer) {
+ return getTypeOfInitializer(node.initializer);
}
- else {
- return getContextualType(attribute.parent);
+ if (node.parent.parent.kind === 238) {
+ return stringType;
}
+ if (node.parent.parent.kind === 239) {
+ return checkRightHandSideOfForOf(node.parent.parent) || errorType;
+ }
+ return errorType;
}
- function isPossiblyDiscriminantValue(node) {
+ function getInitialType(node) {
+ return node.kind === 249 ?
+ getInitialTypeOfVariableDeclaration(node) :
+ getInitialTypeOfBindingElement(node);
+ }
+ function isEmptyArrayAssignment(node) {
+ return node.kind === 249 && node.initializer &&
+ isEmptyArrayLiteral(node.initializer) ||
+ node.kind !== 198 && node.parent.kind === 216 &&
+ isEmptyArrayLiteral(node.parent.right);
+ }
+ function getReferenceCandidate(node) {
switch (node.kind) {
- case 10:
- case 8:
- case 9:
- case 14:
- case 106:
- case 91:
- case 100:
- case 75:
- case 146:
- return true;
- case 194:
- case 200:
- return isPossiblyDiscriminantValue(node.expression);
- case 276:
- return !node.expression || isPossiblyDiscriminantValue(node.expression);
+ case 207:
+ return getReferenceCandidate(node.expression);
+ case 216:
+ switch (node.operatorToken.kind) {
+ case 62:
+ case 74:
+ case 75:
+ case 76:
+ return getReferenceCandidate(node.left);
+ case 27:
+ return getReferenceCandidate(node.right);
+ }
}
- return false;
+ return node;
}
- function discriminateContextualTypeByObjectMembers(node, contextualType) {
- return discriminateTypeByDiscriminableItems(contextualType, ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 281 && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return checkExpression(prop.initializer); }, prop.symbol.escapedName]; }), isTypeAssignableTo, contextualType);
+ function getReferenceRoot(node) {
+ var parent = node.parent;
+ return parent.kind === 207 ||
+ parent.kind === 216 && parent.operatorToken.kind === 62 && parent.left === node ||
+ parent.kind === 216 && parent.operatorToken.kind === 27 && parent.right === node ?
+ getReferenceRoot(parent) : node;
}
- function discriminateContextualTypeByJSXAttributes(node, contextualType) {
- return discriminateTypeByDiscriminableItems(contextualType, ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 273 && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return checkExpression(prop.initializer); }), prop.symbol.escapedName]; }), isTypeAssignableTo, contextualType);
+ function getTypeOfSwitchClause(clause) {
+ if (clause.kind === 284) {
+ return getRegularTypeOfLiteralType(getTypeOfExpression(clause.expression));
+ }
+ return neverType;
}
- function getApparentTypeOfContextualType(node, contextFlags) {
- var contextualType = ts.isObjectLiteralMethod(node) ?
- getContextualTypeForObjectLiteralMethod(node, contextFlags) :
- getContextualType(node, contextFlags);
- var instantiatedType = instantiateContextualType(contextualType, node, contextFlags);
- if (instantiatedType && !(contextFlags && contextFlags & 2 && instantiatedType.flags & 8650752)) {
- var apparentType = mapType(instantiatedType, getApparentType, true);
- if (apparentType.flags & 1048576) {
- if (ts.isObjectLiteralExpression(node)) {
- return discriminateContextualTypeByObjectMembers(node, apparentType);
- }
- else if (ts.isJsxAttributes(node)) {
- return discriminateContextualTypeByJSXAttributes(node, apparentType);
- }
+ function getSwitchClauseTypes(switchStatement) {
+ var links = getNodeLinks(switchStatement);
+ if (!links.switchTypes) {
+ links.switchTypes = [];
+ for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) {
+ var clause = _a[_i];
+ links.switchTypes.push(getTypeOfSwitchClause(clause));
}
- return apparentType;
}
+ return links.switchTypes;
}
- function instantiateContextualType(contextualType, node, contextFlags) {
- if (contextualType && maybeTypeOfKind(contextualType, 63176704)) {
- var inferenceContext = getInferenceContext(node);
- if (inferenceContext && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
- if (contextFlags && contextFlags & 1) {
- return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
- }
- if (inferenceContext.returnMapper) {
- return instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+ function getSwitchClauseTypeOfWitnesses(switchStatement, retainDefault) {
+ var witnesses = [];
+ for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) {
+ var clause = _a[_i];
+ if (clause.kind === 284) {
+ if (ts.isStringLiteralLike(clause.expression)) {
+ witnesses.push(clause.expression.text);
+ continue;
}
+ return ts.emptyArray;
}
+ if (retainDefault)
+ witnesses.push(undefined);
}
- return contextualType;
+ return witnesses;
}
- function instantiateInstantiableTypes(type, mapper) {
- if (type.flags & 63176704) {
- return instantiateType(type, mapper);
- }
- if (type.flags & 1048576) {
- return getUnionType(ts.map(type.types, function (t) { return instantiateInstantiableTypes(t, mapper); }), 0);
- }
- if (type.flags & 2097152) {
- return getIntersectionType(ts.map(type.types, function (t) { return instantiateInstantiableTypes(t, mapper); }));
- }
- return type;
+ function eachTypeContainedIn(source, types) {
+ return source.flags & 1048576 ? !ts.forEach(source.types, function (t) { return !ts.contains(types, t); }) : ts.contains(types, source);
}
- function getContextualType(node, contextFlags) {
- if (node.flags & 16777216) {
- return undefined;
- }
- if (node.contextualType) {
- return node.contextualType;
- }
- var parent = node.parent;
- switch (parent.kind) {
- case 242:
- case 156:
- case 159:
- case 158:
- case 191:
- return getContextualTypeForInitializerExpression(node);
- case 202:
- case 235:
- return getContextualTypeForReturnExpression(node);
- case 212:
- return getContextualTypeForYieldOperand(parent);
- case 206:
- return getContextualTypeForAwaitOperand(parent);
- case 196:
- if (parent.expression.kind === 96) {
- return stringType;
+ function isTypeSubsetOf(source, target) {
+ return source === target || target.flags & 1048576 && isTypeSubsetOfUnion(source, target);
+ }
+ function isTypeSubsetOfUnion(source, target) {
+ if (source.flags & 1048576) {
+ for (var _i = 0, _a = source.types; _i < _a.length; _i++) {
+ var t = _a[_i];
+ if (!containsType(target.types, t)) {
+ return false;
}
- case 197:
- return getContextualTypeForArgument(parent, node);
- case 199:
- case 217:
- return ts.isConstTypeReference(parent.type) ? undefined : getTypeFromTypeNode(parent.type);
- case 209:
- return getContextualTypeForBinaryOperand(node, contextFlags);
- case 281:
- case 282:
- return getContextualTypeForObjectLiteralElement(parent, contextFlags);
- case 283:
- return getApparentTypeOfContextualType(parent.parent, contextFlags);
- case 192: {
- var arrayLiteral = parent;
- var type = getApparentTypeOfContextualType(arrayLiteral, contextFlags);
- return getContextualTypeForElementExpression(type, ts.indexOfNode(arrayLiteral.elements, node));
- }
- case 210:
- return getContextualTypeForConditionalOperand(node, contextFlags);
- case 221:
- ts.Debug.assert(parent.parent.kind === 211);
- return getContextualTypeForSubstitutionExpression(parent.parent, node);
- case 200: {
- var tag = ts.isInJSFile(parent) ? ts.getJSDocTypeTag(parent) : undefined;
- return tag ? getTypeFromTypeNode(tag.typeExpression.type) : getContextualType(parent, contextFlags);
}
- case 276:
- return getContextualTypeForJsxExpression(parent);
- case 273:
- case 275:
- return getContextualTypeForJsxAttribute(parent);
- case 268:
- case 267:
- return getContextualJsxElementAttributesType(parent, contextFlags);
+ return true;
}
- return undefined;
+ if (source.flags & 1024 && getBaseTypeOfEnumLiteralType(source) === target) {
+ return true;
+ }
+ return containsType(target.types, source);
}
- function getInferenceContext(node) {
- var ancestor = ts.findAncestor(node, function (n) { return !!n.inferenceContext; });
- return ancestor && ancestor.inferenceContext;
+ function forEachType(type, f) {
+ return type.flags & 1048576 ? ts.forEach(type.types, f) : f(type);
}
- function getContextualJsxElementAttributesType(node, contextFlags) {
- if (ts.isJsxOpeningElement(node) && node.parent.contextualType && contextFlags !== 4) {
- return node.parent.contextualType;
+ function everyType(type, f) {
+ return type.flags & 1048576 ? ts.every(type.types, f) : f(type);
+ }
+ function filterType(type, f) {
+ if (type.flags & 1048576) {
+ var types = type.types;
+ var filtered = ts.filter(types, f);
+ return filtered === types ? type : getUnionTypeFromSortedList(filtered, type.objectFlags);
}
- return getContextualTypeForArgumentAtIndex(node, 0);
+ return type.flags & 131072 || f(type) ? type : neverType;
}
- function getEffectiveFirstArgumentForJsxSignature(signature, node) {
- return getJsxReferenceKind(node) !== 0
- ? getJsxPropsTypeFromCallSignature(signature, node)
- : getJsxPropsTypeFromClassType(signature, node);
+ function countTypes(type) {
+ return type.flags & 1048576 ? type.types.length : 1;
}
- function getJsxPropsTypeFromCallSignature(sig, context) {
- var propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType);
- propsType = getJsxManagedAttributesFromLocatedAttributes(context, getJsxNamespaceAt(context), propsType);
- var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
- if (intrinsicAttribs !== errorType) {
- propsType = intersectTypes(intrinsicAttribs, propsType);
+ function mapType(type, mapper, noReductions) {
+ if (type.flags & 131072) {
+ return type;
}
- return propsType;
- }
- function getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation) {
- if (sig.unionSignatures) {
- var results = [];
- for (var _i = 0, _a = sig.unionSignatures; _i < _a.length; _i++) {
- var signature = _a[_i];
- var instance = getReturnTypeOfSignature(signature);
- if (isTypeAny(instance)) {
- return instance;
+ if (!(type.flags & 1048576)) {
+ return mapper(type);
+ }
+ var mappedTypes;
+ for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+ var t = _a[_i];
+ var mapped = mapper(t);
+ if (mapped) {
+ if (!mappedTypes) {
+ mappedTypes = [mapped];
}
- var propType = getTypeOfPropertyOfType(instance, forcedLookupLocation);
- if (!propType) {
- return;
+ else {
+ mappedTypes.push(mapped);
}
- results.push(propType);
}
- return getIntersectionType(results);
}
- var instanceType = getReturnTypeOfSignature(sig);
- return isTypeAny(instanceType) ? instanceType : getTypeOfPropertyOfType(instanceType, forcedLookupLocation);
+ return mappedTypes && getUnionType(mappedTypes, noReductions ? 0 : 1);
}
- function getStaticTypeOfReferencedJsxConstructor(context) {
- if (isJsxIntrinsicIdentifier(context.tagName)) {
- var result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(context);
- var fakeSignature = createSignatureForJSXIntrinsic(context, result);
- return getOrCreateTypeFromSignature(fakeSignature);
- }
- var tagType = checkExpressionCached(context.tagName);
- if (tagType.flags & 128) {
- var result = getIntrinsicAttributesTypeFromStringLiteralType(tagType, context);
- if (!result) {
- return errorType;
- }
- var fakeSignature = createSignatureForJSXIntrinsic(context, result);
- return getOrCreateTypeFromSignature(fakeSignature);
- }
- return tagType;
+ function extractTypesOfKind(type, kind) {
+ return filterType(type, function (t) { return (t.flags & kind) !== 0; });
}
- function getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType) {
- var managedSym = getJsxLibraryManagedAttributes(ns);
- if (managedSym) {
- var declaredManagedType = getDeclaredTypeOfSymbol(managedSym);
- var ctorType = getStaticTypeOfReferencedJsxConstructor(context);
- if (ts.length(declaredManagedType.typeParameters) >= 2) {
- var args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.typeParameters, 2, ts.isInJSFile(context));
- return createTypeReference(declaredManagedType, args);
- }
- else if (ts.length(declaredManagedType.aliasTypeArguments) >= 2) {
- var args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.aliasTypeArguments, 2, ts.isInJSFile(context));
- return getTypeAliasInstantiation(declaredManagedType.aliasSymbol, args);
- }
+ function replacePrimitivesWithLiterals(typeWithPrimitives, typeWithLiterals) {
+ if (isTypeSubsetOf(stringType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 128) ||
+ isTypeSubsetOf(numberType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 256) ||
+ isTypeSubsetOf(bigintType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 2048)) {
+ return mapType(typeWithPrimitives, function (t) {
+ return t.flags & 4 ? extractTypesOfKind(typeWithLiterals, 4 | 128) :
+ t.flags & 8 ? extractTypesOfKind(typeWithLiterals, 8 | 256) :
+ t.flags & 64 ? extractTypesOfKind(typeWithLiterals, 64 | 2048) : t;
+ });
}
- return attributesType;
+ return typeWithPrimitives;
}
- function getJsxPropsTypeFromClassType(sig, context) {
- var ns = getJsxNamespaceAt(context);
- var forcedLookupLocation = getJsxElementPropertiesName(ns);
- var attributesType = forcedLookupLocation === undefined
- ? getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType)
- : forcedLookupLocation === ""
- ? getReturnTypeOfSignature(sig)
- : getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation);
- if (!attributesType) {
- if (!!forcedLookupLocation && !!ts.length(context.attributes.properties)) {
- error(context, ts.Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, ts.unescapeLeadingUnderscores(forcedLookupLocation));
- }
- return unknownType;
- }
- attributesType = getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType);
- if (isTypeAny(attributesType)) {
- return attributesType;
- }
- else {
- var apparentAttributesType = attributesType;
- var intrinsicClassAttribs = getJsxType(JsxNames.IntrinsicClassAttributes, context);
- if (intrinsicClassAttribs !== errorType) {
- var typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol);
- var hostClassType = getReturnTypeOfSignature(sig);
- apparentAttributesType = intersectTypes(typeParams
- ? createTypeReference(intrinsicClassAttribs, fillMissingTypeArguments([hostClassType], typeParams, getMinTypeArgumentCount(typeParams), ts.isInJSFile(context)))
- : intrinsicClassAttribs, apparentAttributesType);
- }
- var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
- if (intrinsicAttribs !== errorType) {
- apparentAttributesType = intersectTypes(intrinsicAttribs, apparentAttributesType);
- }
- return apparentAttributesType;
- }
+ function isIncomplete(flowType) {
+ return flowType.flags === 0;
}
- function getContextualCallSignature(type, node) {
- var signatures = getSignaturesOfType(type, 0);
- if (signatures.length === 1) {
- var signature = signatures[0];
- if (!isAritySmaller(signature, node)) {
- return signature;
- }
- }
+ function getTypeFromFlowType(flowType) {
+ return flowType.flags === 0 ? flowType.type : flowType;
+ }
+ function createFlowType(type, incomplete) {
+ return incomplete ? { flags: 0, type: type.flags & 131072 ? silentNeverType : type } : type;
+ }
+ function createEvolvingArrayType(elementType) {
+ var result = createObjectType(256);
+ result.elementType = elementType;
+ return result;
+ }
+ function getEvolvingArrayType(elementType) {
+ return evolvingArrayTypes[elementType.id] || (evolvingArrayTypes[elementType.id] = createEvolvingArrayType(elementType));
+ }
+ function addEvolvingArrayElementType(evolvingArrayType, node) {
+ var elementType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(getContextFreeTypeOfExpression(node)));
+ return isTypeSubsetOf(elementType, evolvingArrayType.elementType) ? evolvingArrayType : getEvolvingArrayType(getUnionType([evolvingArrayType.elementType, elementType]));
+ }
+ function createFinalArrayType(elementType) {
+ return elementType.flags & 131072 ?
+ autoArrayType :
+ createArrayType(elementType.flags & 1048576 ?
+ getUnionType(elementType.types, 2) :
+ elementType);
}
- function isAritySmaller(signature, target) {
- var targetParameterCount = 0;
- for (; targetParameterCount < target.parameters.length; targetParameterCount++) {
- var param = target.parameters[targetParameterCount];
- if (param.initializer || param.questionToken || param.dotDotDotToken || isJSDocOptionalParameter(param)) {
- break;
- }
- }
- if (target.parameters.length && ts.parameterIsThisKeyword(target.parameters[0])) {
- targetParameterCount--;
- }
- return !hasEffectiveRestParameter(signature) && getParameterCount(signature) < targetParameterCount;
+ function getFinalArrayType(evolvingArrayType) {
+ return evolvingArrayType.finalArrayType || (evolvingArrayType.finalArrayType = createFinalArrayType(evolvingArrayType.elementType));
}
- function isFunctionExpressionOrArrowFunction(node) {
- return node.kind === 201 || node.kind === 202;
+ function finalizeEvolvingArrayType(type) {
+ return ts.getObjectFlags(type) & 256 ? getFinalArrayType(type) : type;
}
- function getContextualSignatureForFunctionLikeDeclaration(node) {
- return isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node)
- ? getContextualSignature(node)
- : undefined;
+ function getElementTypeOfEvolvingArrayType(type) {
+ return ts.getObjectFlags(type) & 256 ? type.elementType : neverType;
}
- function getContextualSignature(node) {
- ts.Debug.assert(node.kind !== 161 || ts.isObjectLiteralMethod(node));
- var typeTagSignature = getSignatureOfTypeTag(node);
- if (typeTagSignature) {
- return typeTagSignature;
- }
- var type = getApparentTypeOfContextualType(node, 1);
- if (!type) {
- return undefined;
- }
- if (!(type.flags & 1048576)) {
- return getContextualCallSignature(type, node);
- }
- var signatureList;
- var types = type.types;
+ function isEvolvingArrayTypeList(types) {
+ var hasEvolvingArrayType = false;
for (var _i = 0, types_17 = types; _i < types_17.length; _i++) {
- var current = types_17[_i];
- var signature = getContextualCallSignature(current, node);
- if (signature) {
- if (!signatureList) {
- signatureList = [signature];
- }
- else if (!compareSignaturesIdentical(signatureList[0], signature, false, true, true, compareTypesIdentical)) {
- return undefined;
- }
- else {
- signatureList.push(signature);
+ var t = types_17[_i];
+ if (!(t.flags & 131072)) {
+ if (!(ts.getObjectFlags(t) & 256)) {
+ return false;
}
+ hasEvolvingArrayType = true;
}
}
- if (signatureList) {
- return signatureList.length === 1 ? signatureList[0] : createUnionSignature(signatureList[0], signatureList);
- }
+ return hasEvolvingArrayType;
}
- function checkSpreadExpression(node, checkMode) {
- if (languageVersion < 2) {
- checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 : 2048);
- }
- var arrayOrIterableType = checkExpression(node.expression, checkMode);
- return checkIteratedTypeOrElementType(33, arrayOrIterableType, undefinedType, node.expression);
+ function getUnionOrEvolvingArrayType(types, subtypeReduction) {
+ return isEvolvingArrayTypeList(types) ?
+ getEvolvingArrayType(getUnionType(ts.map(types, getElementTypeOfEvolvingArrayType))) :
+ getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction);
}
- function hasDefaultValue(node) {
- return (node.kind === 191 && !!node.initializer) ||
- (node.kind === 209 && node.operatorToken.kind === 62);
+ function isEvolvingArrayOperationTarget(node) {
+ var root = getReferenceRoot(node);
+ var parent = root.parent;
+ var isLengthPushOrUnshift = ts.isPropertyAccessExpression(parent) && (parent.name.escapedText === "length" ||
+ parent.parent.kind === 203
+ && ts.isIdentifier(parent.name)
+ && ts.isPushOrUnshiftIdentifier(parent.name));
+ var isElementAssignment = parent.kind === 202 &&
+ parent.expression === root &&
+ parent.parent.kind === 216 &&
+ parent.parent.operatorToken.kind === 62 &&
+ parent.parent.left === parent &&
+ !ts.isAssignmentTarget(parent.parent) &&
+ isTypeAssignableToKind(getTypeOfExpression(parent.argumentExpression), 296);
+ return isLengthPushOrUnshift || isElementAssignment;
}
- function checkArrayLiteral(node, checkMode, forceTuple) {
- var elements = node.elements;
- var elementCount = elements.length;
- var elementTypes = [];
- var hasEndingSpreadElement = false;
- var hasNonEndingSpreadElement = false;
- var contextualType = getApparentTypeOfContextualType(node);
- var inDestructuringPattern = ts.isAssignmentTarget(node);
- var inConstContext = isConstContext(node);
- for (var i = 0; i < elementCount; i++) {
- var e = elements[i];
- var spread = e.kind === 213 && e.expression;
- var spreadType = spread && checkExpression(spread, checkMode, forceTuple);
- if (spreadType && isTupleType(spreadType)) {
- elementTypes.push.apply(elementTypes, getTypeArguments(spreadType));
- if (spreadType.target.hasRestElement) {
- if (i === elementCount - 1)
- hasEndingSpreadElement = true;
- else
- hasNonEndingSpreadElement = true;
+ function isDeclarationWithExplicitTypeAnnotation(declaration) {
+ return (declaration.kind === 249 || declaration.kind === 160 ||
+ declaration.kind === 163 || declaration.kind === 162) &&
+ !!ts.getEffectiveTypeAnnotationNode(declaration);
+ }
+ function getExplicitTypeOfSymbol(symbol, diagnostic) {
+ if (symbol.flags & (16 | 8192 | 32 | 512)) {
+ return getTypeOfSymbol(symbol);
+ }
+ if (symbol.flags & (3 | 4)) {
+ if (ts.getCheckFlags(symbol) & 262144) {
+ var origin = symbol.syntheticOrigin;
+ if (origin && getExplicitTypeOfSymbol(origin)) {
+ return getTypeOfSymbol(symbol);
}
}
- else {
- if (inDestructuringPattern && spreadType) {
- var restElementType = getIndexTypeOfType(spreadType, 1) ||
- getIteratedTypeOrElementType(65, spreadType, undefinedType, undefined, false);
- if (restElementType) {
- elementTypes.push(restElementType);
- }
+ var declaration = symbol.valueDeclaration;
+ if (declaration) {
+ if (isDeclarationWithExplicitTypeAnnotation(declaration)) {
+ return getTypeOfSymbol(symbol);
}
- else {
- var elementContextualType = getContextualTypeForElementExpression(contextualType, elementTypes.length);
- var type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple);
- elementTypes.push(type);
+ if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 239) {
+ var statement = declaration.parent.parent;
+ var expressionType = getTypeOfDottedName(statement.expression, undefined);
+ if (expressionType) {
+ var use = statement.awaitModifier ? 15 : 13;
+ return checkIteratedTypeOrElementType(use, expressionType, undefinedType, undefined);
+ }
}
- if (spread) {
- if (i === elementCount - 1)
- hasEndingSpreadElement = true;
- else
- hasNonEndingSpreadElement = true;
+ if (diagnostic) {
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(declaration, ts.Diagnostics._0_needs_an_explicit_type_annotation, symbolToString(symbol)));
}
}
}
- if (!hasNonEndingSpreadElement) {
- var minLength = elementTypes.length - (hasEndingSpreadElement ? 1 : 0);
- var tupleResult = void 0;
- if (inDestructuringPattern && minLength > 0) {
- var type = cloneTypeReference(createTupleType(elementTypes, minLength, hasEndingSpreadElement));
- type.pattern = node;
- return type;
- }
- else if (tupleResult = getArrayLiteralTupleTypeIfApplicable(elementTypes, contextualType, hasEndingSpreadElement, elementTypes.length, inConstContext)) {
- return createArrayLiteralType(tupleResult);
- }
- else if (forceTuple) {
- return createArrayLiteralType(createTupleType(elementTypes, minLength, hasEndingSpreadElement));
+ }
+ function getTypeOfDottedName(node, diagnostic) {
+ if (!(node.flags & 16777216)) {
+ switch (node.kind) {
+ case 78:
+ var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
+ return getExplicitTypeOfSymbol(symbol.flags & 2097152 ? resolveAlias(symbol) : symbol, diagnostic);
+ case 107:
+ return getExplicitThisType(node);
+ case 105:
+ return checkSuperExpression(node);
+ case 201:
+ var type = getTypeOfDottedName(node.expression, diagnostic);
+ var prop = type && getPropertyOfType(type, node.name.escapedText);
+ return prop && getExplicitTypeOfSymbol(prop, diagnostic);
+ case 207:
+ return getTypeOfDottedName(node.expression, diagnostic);
}
}
- return createArrayLiteralType(createArrayType(elementTypes.length ?
- getUnionType(elementTypes, 2) :
- strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext));
}
- function createArrayLiteralType(type) {
- if (!(ts.getObjectFlags(type) & 4)) {
- return type;
- }
- var literalType = type.literalType;
- if (!literalType) {
- literalType = type.literalType = cloneTypeReference(type);
- literalType.objectFlags |= 65536 | 1048576;
+ function getEffectsSignature(node) {
+ var links = getNodeLinks(node);
+ var signature = links.effectsSignature;
+ if (signature === undefined) {
+ var funcType = void 0;
+ if (node.parent.kind === 233) {
+ funcType = getTypeOfDottedName(node.expression, undefined);
+ }
+ else if (node.expression.kind !== 105) {
+ if (ts.isOptionalChain(node)) {
+ funcType = checkNonNullType(getOptionalExpressionType(checkExpression(node.expression), node.expression), node.expression);
+ }
+ else {
+ funcType = checkNonNullExpression(node.expression);
+ }
+ }
+ var signatures = getSignaturesOfType(funcType && getApparentType(funcType) || unknownType, 0);
+ var candidate = signatures.length === 1 && !signatures[0].typeParameters ? signatures[0] :
+ ts.some(signatures, hasTypePredicateOrNeverReturnType) ? getResolvedSignature(node) :
+ undefined;
+ signature = links.effectsSignature = candidate && hasTypePredicateOrNeverReturnType(candidate) ? candidate : unknownSignature;
}
- return literalType;
+ return signature === unknownSignature ? undefined : signature;
}
- function getArrayLiteralTupleTypeIfApplicable(elementTypes, contextualType, hasRestElement, elementCount, readonly) {
- if (elementCount === void 0) { elementCount = elementTypes.length; }
- if (readonly === void 0) { readonly = false; }
- if (readonly || (contextualType && forEachType(contextualType, isTupleLikeType))) {
- return createTupleType(elementTypes, elementCount - (hasRestElement ? 1 : 0), hasRestElement, readonly);
- }
+ function hasTypePredicateOrNeverReturnType(signature) {
+ return !!(getTypePredicateOfSignature(signature) ||
+ signature.declaration && (getReturnTypeFromAnnotation(signature.declaration) || unknownType).flags & 131072);
}
- function isNumericName(name) {
- switch (name.kind) {
- case 154:
- return isNumericComputedName(name);
- case 75:
- return isNumericLiteralName(name.escapedText);
- case 8:
- case 10:
- return isNumericLiteralName(name.text);
- default:
- return false;
+ function getTypePredicateArgument(predicate, callExpression) {
+ if (predicate.kind === 1 || predicate.kind === 3) {
+ return callExpression.arguments[predicate.parameterIndex];
}
+ var invokedExpression = ts.skipParentheses(callExpression.expression);
+ return ts.isAccessExpression(invokedExpression) ? ts.skipParentheses(invokedExpression.expression) : undefined;
}
- function isNumericComputedName(name) {
- return isTypeAssignableToKind(checkComputedPropertyName(name), 296);
+ function reportFlowControlError(node) {
+ var block = ts.findAncestor(node, ts.isFunctionOrModuleBlock);
+ var sourceFile = ts.getSourceFileOfNode(node);
+ var span = ts.getSpanOfTokenAtPosition(sourceFile, block.statements.pos);
+ diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis));
}
- function isInfinityOrNaNString(name) {
- return name === "Infinity" || name === "-Infinity" || name === "NaN";
+ function isReachableFlowNode(flow) {
+ var result = isReachableFlowNodeWorker(flow, false);
+ lastFlowNode = flow;
+ lastFlowNodeReachable = result;
+ return result;
}
- function isNumericLiteralName(name) {
- return (+name).toString() === name;
+ function isFalseExpression(expr) {
+ var node = ts.skipParentheses(expr);
+ return node.kind === 94 || node.kind === 216 && (node.operatorToken.kind === 55 && (isFalseExpression(node.left) || isFalseExpression(node.right)) ||
+ node.operatorToken.kind === 56 && isFalseExpression(node.left) && isFalseExpression(node.right));
}
- function checkComputedPropertyName(node) {
- var links = getNodeLinks(node.expression);
- if (!links.resolvedType) {
- links.resolvedType = checkExpression(node.expression);
- if (links.resolvedType.flags & 98304 ||
- !isTypeAssignableToKind(links.resolvedType, 132 | 296 | 12288) &&
- !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) {
- error(node, ts.Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any);
- }
- else {
- checkThatExpressionIsProperSymbolReference(node.expression, links.resolvedType, true);
+ function isReachableFlowNodeWorker(flow, noCacheCheck) {
+ while (true) {
+ if (flow === lastFlowNode) {
+ return lastFlowNodeReachable;
}
- }
- return links.resolvedType;
- }
- function getObjectLiteralIndexInfo(node, offset, properties, kind) {
- var propTypes = [];
- for (var i = 0; i < properties.length; i++) {
- if (kind === 0 || isNumericName(node.properties[i + offset].name)) {
- propTypes.push(getTypeOfSymbol(properties[i]));
+ var flags = flow.flags;
+ if (flags & 4096) {
+ if (!noCacheCheck) {
+ var id = getFlowNodeId(flow);
+ var reachable = flowNodeReachable[id];
+ return reachable !== undefined ? reachable : (flowNodeReachable[id] = isReachableFlowNodeWorker(flow, true));
+ }
+ noCacheCheck = false;
}
- }
- var unionType = propTypes.length ? getUnionType(propTypes, 2) : undefinedType;
- return createIndexInfo(unionType, isConstContext(node));
- }
- function getImmediateAliasedSymbol(symbol) {
- ts.Debug.assert((symbol.flags & 2097152) !== 0, "Should only get Alias here.");
- var links = getSymbolLinks(symbol);
- if (!links.immediateTarget) {
- var node = getDeclarationOfAliasSymbol(symbol);
- if (!node)
- return ts.Debug.fail();
- links.immediateTarget = getTargetOfAliasDeclaration(node, true);
- }
- return links.immediateTarget;
- }
- function checkObjectLiteral(node, checkMode) {
- var inDestructuringPattern = ts.isAssignmentTarget(node);
- checkGrammarObjectLiteralExpression(node, inDestructuringPattern);
- var allPropertiesTable = strictNullChecks ? ts.createSymbolTable() : undefined;
- var propertiesTable = ts.createSymbolTable();
- var propertiesArray = [];
- var spread = emptyObjectType;
- var contextualType = getApparentTypeOfContextualType(node);
- var contextualTypeHasPattern = contextualType && contextualType.pattern &&
- (contextualType.pattern.kind === 189 || contextualType.pattern.kind === 193);
- var inConstContext = isConstContext(node);
- var checkFlags = inConstContext ? 8 : 0;
- var isInJavascript = ts.isInJSFile(node) && !ts.isInJsonFile(node);
- var enumTag = ts.getJSDocEnumTag(node);
- var isJSObjectLiteral = !contextualType && isInJavascript && !enumTag;
- var objectFlags = freshObjectLiteralFlag;
- var patternWithComputedProperties = false;
- var hasComputedStringProperty = false;
- var hasComputedNumberProperty = false;
- for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
- var elem = _a[_i];
- if (elem.name && ts.isComputedPropertyName(elem.name) && !ts.isWellKnownSymbolSyntactically(elem.name)) {
- checkComputedPropertyName(elem.name);
+ if (flags & (16 | 96 | 256)) {
+ flow = flow.antecedent;
}
- }
- var offset = 0;
- for (var i = 0; i < node.properties.length; i++) {
- var memberDecl = node.properties[i];
- var member = getSymbolOfNode(memberDecl);
- var computedNameType = memberDecl.name && memberDecl.name.kind === 154 && !ts.isWellKnownSymbolSyntactically(memberDecl.name.expression) ?
- checkComputedPropertyName(memberDecl.name) : undefined;
- if (memberDecl.kind === 281 ||
- memberDecl.kind === 282 ||
- ts.isObjectLiteralMethod(memberDecl)) {
- var type = memberDecl.kind === 281 ? checkPropertyAssignment(memberDecl, checkMode) :
- memberDecl.kind === 282 ? checkExpressionForMutableLocation(memberDecl.name, checkMode) :
- checkObjectLiteralMethod(memberDecl, checkMode);
- if (isInJavascript) {
- var jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl);
- if (jsDocType) {
- checkTypeAssignableTo(type, jsDocType, memberDecl);
- type = jsDocType;
- }
- else if (enumTag && enumTag.typeExpression) {
- checkTypeAssignableTo(type, getTypeFromTypeNode(enumTag.typeExpression), memberDecl);
- }
- }
- objectFlags |= ts.getObjectFlags(type) & 3670016;
- var nameType = computedNameType && isTypeUsableAsPropertyName(computedNameType) ? computedNameType : undefined;
- var prop = nameType ?
- createSymbol(4 | member.flags, getPropertyNameFromType(nameType), checkFlags | 4096) :
- createSymbol(4 | member.flags, member.escapedName, checkFlags);
- if (nameType) {
- prop.nameType = nameType;
- }
- if (inDestructuringPattern) {
- var isOptional = (memberDecl.kind === 281 && hasDefaultValue(memberDecl.initializer)) ||
- (memberDecl.kind === 282 && memberDecl.objectAssignmentInitializer);
- if (isOptional) {
- prop.flags |= 16777216;
- }
- }
- else if (contextualTypeHasPattern && !(ts.getObjectFlags(contextualType) & 512)) {
- var impliedProp = getPropertyOfType(contextualType, member.escapedName);
- if (impliedProp) {
- prop.flags |= impliedProp.flags & 16777216;
+ else if (flags & 512) {
+ var signature = getEffectsSignature(flow.node);
+ if (signature) {
+ var predicate = getTypePredicateOfSignature(signature);
+ if (predicate && predicate.kind === 3 && !predicate.type) {
+ var predicateArgument = flow.node.arguments[predicate.parameterIndex];
+ if (predicateArgument && isFalseExpression(predicateArgument)) {
+ return false;
+ }
}
- else if (!compilerOptions.suppressExcessPropertyErrors && !getIndexInfoOfType(contextualType, 0)) {
- error(memberDecl.name, ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(member), typeToString(contextualType));
+ if (getReturnTypeOfSignature(signature).flags & 131072) {
+ return false;
}
}
- prop.declarations = member.declarations;
- prop.parent = member.parent;
- if (member.valueDeclaration) {
- prop.valueDeclaration = member.valueDeclaration;
- }
- prop.type = type;
- prop.target = member;
- member = prop;
- allPropertiesTable === null || allPropertiesTable === void 0 ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
+ flow = flow.antecedent;
}
- else if (memberDecl.kind === 283) {
- if (languageVersion < 2) {
- checkExternalEmitHelpers(memberDecl, 2);
- }
- if (propertiesArray.length > 0) {
- spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext);
- propertiesArray = [];
- propertiesTable = ts.createSymbolTable();
- hasComputedStringProperty = false;
- hasComputedNumberProperty = false;
- }
- var type = getReducedType(checkExpression(memberDecl.expression));
- if (!isValidSpreadType(type)) {
- error(memberDecl, ts.Diagnostics.Spread_types_may_only_be_created_from_object_types);
- return errorType;
- }
- if (allPropertiesTable) {
- checkSpreadPropOverrides(type, allPropertiesTable, memberDecl);
- }
- spread = getSpreadType(spread, type, node.symbol, objectFlags, inConstContext);
- offset = i + 1;
- continue;
+ else if (flags & 4) {
+ return ts.some(flow.antecedents, function (f) { return isReachableFlowNodeWorker(f, false); });
}
- else {
- ts.Debug.assert(memberDecl.kind === 163 || memberDecl.kind === 164);
- checkNodeDeferred(memberDecl);
+ else if (flags & 8) {
+ flow = flow.antecedents[0];
}
- if (computedNameType && !(computedNameType.flags & 8576)) {
- if (isTypeAssignableTo(computedNameType, stringNumberSymbolType)) {
- if (isTypeAssignableTo(computedNameType, numberType)) {
- hasComputedNumberProperty = true;
- }
- else {
- hasComputedStringProperty = true;
- }
- if (inDestructuringPattern) {
- patternWithComputedProperties = true;
- }
+ else if (flags & 128) {
+ if (flow.clauseStart === flow.clauseEnd && isExhaustiveSwitchStatement(flow.switchStatement)) {
+ return false;
}
+ flow = flow.antecedent;
+ }
+ else if (flags & 1024) {
+ lastFlowNode = undefined;
+ var target = flow.target;
+ var saveAntecedents = target.antecedents;
+ target.antecedents = flow.antecedents;
+ var result = isReachableFlowNodeWorker(flow.antecedent, false);
+ target.antecedents = saveAntecedents;
+ return result;
}
else {
- propertiesTable.set(member.escapedName, member);
+ return !(flags & 1);
}
- propertiesArray.push(member);
}
- if (contextualTypeHasPattern && node.parent.kind !== 283) {
- for (var _b = 0, _c = getPropertiesOfType(contextualType); _b < _c.length; _b++) {
- var prop = _c[_b];
- if (!propertiesTable.get(prop.escapedName) && !getPropertyOfType(spread, prop.escapedName)) {
- if (!(prop.flags & 16777216)) {
- error(prop.valueDeclaration || prop.bindingElement, ts.Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value);
- }
- propertiesTable.set(prop.escapedName, prop);
- propertiesArray.push(prop);
+ }
+ function isPostSuperFlowNode(flow, noCacheCheck) {
+ while (true) {
+ var flags = flow.flags;
+ if (flags & 4096) {
+ if (!noCacheCheck) {
+ var id = getFlowNodeId(flow);
+ var postSuper = flowNodePostSuper[id];
+ return postSuper !== undefined ? postSuper : (flowNodePostSuper[id] = isPostSuperFlowNode(flow, true));
}
+ noCacheCheck = false;
}
- }
- if (spread !== emptyObjectType) {
- if (propertiesArray.length > 0) {
- spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext);
- propertiesArray = [];
- propertiesTable = ts.createSymbolTable();
- hasComputedStringProperty = false;
- hasComputedNumberProperty = false;
+ if (flags & (16 | 96 | 256 | 128)) {
+ flow = flow.antecedent;
}
- return mapType(spread, function (t) { return t === emptyObjectType ? createObjectLiteralType() : t; });
- }
- return createObjectLiteralType();
- function createObjectLiteralType() {
- var stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, 0) : undefined;
- var numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, 1) : undefined;
- var result = createAnonymousType(node.symbol, propertiesTable, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo);
- result.objectFlags |= objectFlags | 128 | 1048576;
- if (isJSObjectLiteral) {
- result.objectFlags |= 16384;
+ else if (flags & 512) {
+ if (flow.node.expression.kind === 105) {
+ return true;
+ }
+ flow = flow.antecedent;
}
- if (patternWithComputedProperties) {
- result.objectFlags |= 512;
+ else if (flags & 4) {
+ return ts.every(flow.antecedents, function (f) { return isPostSuperFlowNode(f, false); });
}
- if (inDestructuringPattern) {
- result.pattern = node;
+ else if (flags & 8) {
+ flow = flow.antecedents[0];
}
- return result;
- }
- }
- function isValidSpreadType(type) {
- if (type.flags & 63176704) {
- var constraint = getBaseConstraintOfType(type);
- if (constraint !== undefined) {
- return isValidSpreadType(constraint);
+ else if (flags & 1024) {
+ var target = flow.target;
+ var saveAntecedents = target.antecedents;
+ target.antecedents = flow.antecedents;
+ var result = isPostSuperFlowNode(flow.antecedent, false);
+ target.antecedents = saveAntecedents;
+ return result;
+ }
+ else {
+ return !!(flags & 1);
}
}
- return !!(type.flags & (1 | 67108864 | 524288 | 58982400) ||
- getFalsyFlags(type) & 117632 && isValidSpreadType(removeDefinitelyFalsyTypes(type)) ||
- type.flags & 3145728 && ts.every(type.types, isValidSpreadType));
- }
- function checkJsxSelfClosingElementDeferred(node) {
- checkJsxOpeningLikeElementOrOpeningFragment(node);
- resolveUntypedCall(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);
+ function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer, couldBeUninitialized) {
+ if (initialType === void 0) { initialType = declaredType; }
+ var key;
+ var isKeySet = false;
+ var flowDepth = 0;
+ if (flowAnalysisDisabled) {
+ return errorType;
}
- else {
- checkExpression(node.closingElement.tagName);
+ if (!reference.flowNode || !couldBeUninitialized && !(declaredType.flags & 536624127)) {
+ return declaredType;
}
- checkJsxChildren(node);
- }
- function checkJsxElement(node, _checkMode) {
- checkNodeDeferred(node);
- return getJsxElementTypeAt(node) || anyType;
- }
- function checkJsxFragment(node) {
- checkJsxOpeningLikeElementOrOpeningFragment(node.openingFragment);
- if (compilerOptions.jsx === 2 && (compilerOptions.jsxFactory || ts.getSourceFileOfNode(node).pragmas.has("jsx"))) {
- error(node, compilerOptions.jsxFactory
- ? ts.Diagnostics.JSX_fragment_is_not_supported_when_using_jsxFactory
- : ts.Diagnostics.JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma);
+ flowInvocationCount++;
+ var sharedFlowStart = sharedFlowCount;
+ var evolvedType = getTypeFromFlowType(getTypeAtFlowNode(reference.flowNode));
+ sharedFlowCount = sharedFlowStart;
+ var resultType = ts.getObjectFlags(evolvedType) & 256 && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
+ if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === 225 && getTypeWithFacts(resultType, 2097152).flags & 131072) {
+ return declaredType;
}
- checkJsxChildren(node);
- return getJsxElementTypeAt(node) || anyType;
- }
- function isUnhyphenatedJsxName(name) {
- return !ts.stringContains(name, "-");
- }
- function isJsxIntrinsicIdentifier(tagName) {
- return tagName.kind === 75 && ts.isIntrinsicJsxName(tagName.escapedText);
- }
- function checkJsxAttribute(node, checkMode) {
- return node.initializer
- ? checkExpressionForMutableLocation(node.initializer, checkMode)
- : trueType;
- }
- function createJsxAttributesTypeFromAttributesProperty(openingLikeElement, checkMode) {
- var attributes = openingLikeElement.attributes;
- var allAttributesTable = strictNullChecks ? ts.createSymbolTable() : undefined;
- var attributesTable = ts.createSymbolTable();
- var spread = emptyJsxObjectType;
- var hasSpreadAnyType = false;
- var typeToIntersect;
- var explicitlySpecifyChildrenAttribute = false;
- var objectFlags = 4096;
- var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement));
- for (var _i = 0, _a = attributes.properties; _i < _a.length; _i++) {
- var attributeDecl = _a[_i];
- var member = attributeDecl.symbol;
- if (ts.isJsxAttribute(attributeDecl)) {
- var exprType = checkJsxAttribute(attributeDecl, checkMode);
- objectFlags |= ts.getObjectFlags(exprType) & 3670016;
- var attributeSymbol = createSymbol(4 | 33554432 | member.flags, member.escapedName);
- attributeSymbol.declarations = member.declarations;
- attributeSymbol.parent = member.parent;
- if (member.valueDeclaration) {
- attributeSymbol.valueDeclaration = member.valueDeclaration;
+ return resultType;
+ function getOrSetCacheKey() {
+ if (isKeySet) {
+ return key;
+ }
+ isKeySet = true;
+ return key = getFlowCacheKey(reference, declaredType, initialType, flowContainer);
+ }
+ function getTypeAtFlowNode(flow) {
+ if (flowDepth === 2000) {
+ ts.tracing.instant("check", "getTypeAtFlowNode_DepthLimit", { flowId: flow.id });
+ flowAnalysisDisabled = true;
+ reportFlowControlError(reference);
+ return errorType;
+ }
+ flowDepth++;
+ while (true) {
+ var flags = flow.flags;
+ if (flags & 4096) {
+ for (var i = sharedFlowStart; i < sharedFlowCount; i++) {
+ if (sharedFlowNodes[i] === flow) {
+ flowDepth--;
+ return sharedFlowTypes[i];
+ }
+ }
}
- attributeSymbol.type = exprType;
- attributeSymbol.target = member;
- attributesTable.set(attributeSymbol.escapedName, attributeSymbol);
- allAttributesTable === null || allAttributesTable === void 0 ? void 0 : allAttributesTable.set(attributeSymbol.escapedName, attributeSymbol);
- if (attributeDecl.name.escapedText === jsxChildrenPropertyName) {
- explicitlySpecifyChildrenAttribute = true;
+ var type = void 0;
+ if (flags & 16) {
+ type = getTypeAtFlowAssignment(flow);
+ if (!type) {
+ flow = flow.antecedent;
+ continue;
+ }
}
- }
- else {
- ts.Debug.assert(attributeDecl.kind === 275);
- if (attributesTable.size > 0) {
- spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, false);
- attributesTable = ts.createSymbolTable();
+ else if (flags & 512) {
+ type = getTypeAtFlowCall(flow);
+ if (!type) {
+ flow = flow.antecedent;
+ continue;
+ }
}
- var exprType = getReducedType(checkExpressionCached(attributeDecl.expression, checkMode));
- if (isTypeAny(exprType)) {
- hasSpreadAnyType = true;
+ else if (flags & 96) {
+ type = getTypeAtFlowCondition(flow);
}
- if (isValidSpreadType(exprType)) {
- spread = getSpreadType(spread, exprType, attributes.symbol, objectFlags, false);
- if (allAttributesTable) {
- checkSpreadPropOverrides(exprType, allAttributesTable, attributeDecl);
+ else if (flags & 128) {
+ type = getTypeAtSwitchClause(flow);
+ }
+ else if (flags & 12) {
+ if (flow.antecedents.length === 1) {
+ flow = flow.antecedents[0];
+ continue;
+ }
+ type = flags & 4 ?
+ getTypeAtFlowBranchLabel(flow) :
+ getTypeAtFlowLoopLabel(flow);
+ }
+ else if (flags & 256) {
+ type = getTypeAtFlowArrayMutation(flow);
+ if (!type) {
+ flow = flow.antecedent;
+ continue;
+ }
+ }
+ else if (flags & 1024) {
+ var target = flow.target;
+ var saveAntecedents = target.antecedents;
+ target.antecedents = flow.antecedents;
+ type = getTypeAtFlowNode(flow.antecedent);
+ target.antecedents = saveAntecedents;
+ }
+ else if (flags & 2) {
+ var container = flow.node;
+ if (container && container !== flowContainer &&
+ reference.kind !== 201 &&
+ reference.kind !== 202 &&
+ reference.kind !== 107) {
+ flow = container.flowNode;
+ continue;
}
+ type = initialType;
}
else {
- typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;
+ type = convertAutoToAny(declaredType);
}
+ if (flags & 4096) {
+ sharedFlowNodes[sharedFlowCount] = flow;
+ sharedFlowTypes[sharedFlowCount] = type;
+ sharedFlowCount++;
+ }
+ flowDepth--;
+ return type;
}
}
- if (!hasSpreadAnyType) {
- if (attributesTable.size > 0) {
- spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, false);
- }
+ function getInitialOrAssignedType(flow) {
+ var node = flow.node;
+ return getConstraintForLocation(node.kind === 249 || node.kind === 198 ?
+ getInitialType(node) :
+ getAssignedType(node), reference);
}
- var parent = openingLikeElement.parent.kind === 266 ? openingLikeElement.parent : undefined;
- if (parent && parent.openingElement === openingLikeElement && parent.children.length > 0) {
- var childrenTypes = checkJsxChildren(parent, checkMode);
- if (!hasSpreadAnyType && jsxChildrenPropertyName && jsxChildrenPropertyName !== "") {
- if (explicitlySpecifyChildrenAttribute) {
- error(attributes, ts.Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName));
+ function getTypeAtFlowAssignment(flow) {
+ var node = flow.node;
+ if (isMatchingReference(reference, node)) {
+ if (!isReachableFlowNode(flow)) {
+ return unreachableNeverType;
}
- var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes);
- var childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName);
- var childrenPropSymbol = createSymbol(4 | 33554432, jsxChildrenPropertyName);
- childrenPropSymbol.type = childrenTypes.length === 1 ?
- childrenTypes[0] :
- (getArrayLiteralTupleTypeIfApplicable(childrenTypes, childrenContextualType, false) || createArrayType(getUnionType(childrenTypes)));
- childrenPropSymbol.valueDeclaration = ts.createPropertySignature(undefined, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName), undefined, undefined, undefined);
- childrenPropSymbol.valueDeclaration.parent = attributes;
- childrenPropSymbol.valueDeclaration.symbol = childrenPropSymbol;
- var childPropMap = ts.createSymbolTable();
- childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol);
- spread = getSpreadType(spread, createAnonymousType(attributes.symbol, childPropMap, ts.emptyArray, ts.emptyArray, undefined, undefined), attributes.symbol, objectFlags, false);
+ if (ts.getAssignmentTargetKind(node) === 2) {
+ var flowType = getTypeAtFlowNode(flow.antecedent);
+ return createFlowType(getBaseTypeOfLiteralType(getTypeFromFlowType(flowType)), isIncomplete(flowType));
+ }
+ if (declaredType === autoType || declaredType === autoArrayType) {
+ if (isEmptyArrayAssignment(node)) {
+ return getEvolvingArrayType(neverType);
+ }
+ var assignedType = getWidenedLiteralType(getInitialOrAssignedType(flow));
+ return isTypeAssignableTo(assignedType, declaredType) ? assignedType : anyArrayType;
+ }
+ if (declaredType.flags & 1048576) {
+ return getAssignmentReducedType(declaredType, getInitialOrAssignedType(flow));
+ }
+ return declaredType;
}
- }
- if (hasSpreadAnyType) {
- return anyType;
- }
- if (typeToIntersect && spread !== emptyJsxObjectType) {
- return getIntersectionType([typeToIntersect, spread]);
- }
- return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesType() : spread);
- function createJsxAttributesType() {
- objectFlags |= freshObjectLiteralFlag;
- var result = createAnonymousType(attributes.symbol, attributesTable, ts.emptyArray, ts.emptyArray, undefined, undefined);
- result.objectFlags |= objectFlags | 128 | 1048576;
- return result;
- }
- }
- function checkJsxChildren(node, checkMode) {
- var childrenTypes = [];
- for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
- var child = _a[_i];
- if (child.kind === 11) {
- if (!child.containsOnlyTriviaWhiteSpaces) {
- childrenTypes.push(stringType);
+ if (containsMatchingReference(reference, node)) {
+ if (!isReachableFlowNode(flow)) {
+ return unreachableNeverType;
+ }
+ if (ts.isVariableDeclaration(node) && (ts.isInJSFile(node) || ts.isVarConst(node))) {
+ var init = ts.getDeclaredExpandoInitializer(node);
+ if (init && (init.kind === 208 || init.kind === 209)) {
+ return getTypeAtFlowNode(flow.antecedent);
+ }
}
+ return declaredType;
}
- else {
- childrenTypes.push(checkExpressionForMutableLocation(child, checkMode));
+ if (ts.isVariableDeclaration(node) && node.parent.parent.kind === 238 && isMatchingReference(reference, node.parent.parent.expression)) {
+ return getNonNullableTypeIfNeeded(getTypeFromFlowType(getTypeAtFlowNode(flow.antecedent)));
}
+ return undefined;
}
- return childrenTypes;
- }
- function checkSpreadPropOverrides(type, props, spread) {
- for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) {
- var right = _a[_i];
- var left = props.get(right.escapedName);
- var rightType = getTypeOfSymbol(right);
- if (left && !maybeTypeOfKind(rightType, 98304) && !(maybeTypeOfKind(rightType, 3) && right.flags & 16777216)) {
- var diagnostic = error(left.valueDeclaration, ts.Diagnostics._0_is_specified_more_than_once_so_this_usage_will_be_overwritten, ts.unescapeLeadingUnderscores(left.escapedName));
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(spread, ts.Diagnostics.This_spread_always_overwrites_this_property));
+ function narrowTypeByAssertion(type, expr) {
+ var node = ts.skipParentheses(expr);
+ if (node.kind === 94) {
+ return unreachableNeverType;
}
- }
- }
- function checkJsxAttributes(node, checkMode) {
- return createJsxAttributesTypeFromAttributesProperty(node.parent, checkMode);
- }
- function getJsxType(name, location) {
- var namespace = getJsxNamespaceAt(location);
- var exports = namespace && getExportsOfSymbol(namespace);
- var typeSymbol = exports && getSymbol(exports, name, 788968);
- return typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType;
- }
- function getIntrinsicTagSymbol(node) {
- var links = getNodeLinks(node);
- if (!links.resolvedSymbol) {
- var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, node);
- if (intrinsicElementsType !== errorType) {
- if (!ts.isIdentifier(node.tagName))
- return ts.Debug.fail();
- var intrinsicProp = getPropertyOfType(intrinsicElementsType, node.tagName.escapedText);
- if (intrinsicProp) {
- links.jsxFlags |= 1;
- return links.resolvedSymbol = intrinsicProp;
+ if (node.kind === 216) {
+ if (node.operatorToken.kind === 55) {
+ return narrowTypeByAssertion(narrowTypeByAssertion(type, node.left), node.right);
}
- var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, 0);
- if (indexSignatureType) {
- links.jsxFlags |= 2;
- return links.resolvedSymbol = intrinsicElementsType.symbol;
+ if (node.operatorToken.kind === 56) {
+ return getUnionType([narrowTypeByAssertion(type, node.left), narrowTypeByAssertion(type, node.right)]);
}
- error(node, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.idText(node.tagName), "JSX." + JsxNames.IntrinsicElements);
- return links.resolvedSymbol = unknownSymbol;
}
- else {
- if (noImplicitAny) {
- error(node, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, ts.unescapeLeadingUnderscores(JsxNames.IntrinsicElements));
+ return narrowType(type, node, true);
+ }
+ function getTypeAtFlowCall(flow) {
+ var signature = getEffectsSignature(flow.node);
+ if (signature) {
+ var predicate = getTypePredicateOfSignature(signature);
+ if (predicate && (predicate.kind === 2 || predicate.kind === 3)) {
+ var flowType = getTypeAtFlowNode(flow.antecedent);
+ var type = finalizeEvolvingArrayType(getTypeFromFlowType(flowType));
+ var narrowedType = predicate.type ? narrowTypeByTypePredicate(type, predicate, flow.node, true) :
+ predicate.kind === 3 && 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) {
+ return unreachableNeverType;
}
- return links.resolvedSymbol = unknownSymbol;
}
+ return undefined;
}
- return links.resolvedSymbol;
- }
- function getJsxNamespaceAt(location) {
- var links = location && getNodeLinks(location);
- if (links && links.jsxNamespace) {
- return links.jsxNamespace;
- }
- if (!links || links.jsxNamespace !== false) {
- var namespaceName = getJsxNamespace(location);
- var resolvedNamespace = resolveName(location, namespaceName, 1920, undefined, namespaceName, false);
- if (resolvedNamespace) {
- var candidate = resolveSymbol(getSymbol(getExportsOfSymbol(resolveSymbol(resolvedNamespace)), JsxNames.JSX, 1920));
- if (candidate) {
- if (links) {
- links.jsxNamespace = candidate;
+ function getTypeAtFlowArrayMutation(flow) {
+ if (declaredType === autoType || declaredType === autoArrayType) {
+ var node = flow.node;
+ var expr = node.kind === 203 ?
+ node.expression.expression :
+ node.left.expression;
+ if (isMatchingReference(reference, getReferenceCandidate(expr))) {
+ var flowType = getTypeAtFlowNode(flow.antecedent);
+ var type = getTypeFromFlowType(flowType);
+ if (ts.getObjectFlags(type) & 256) {
+ var evolvedType_1 = type;
+ if (node.kind === 203) {
+ for (var _i = 0, _a = node.arguments; _i < _a.length; _i++) {
+ var arg = _a[_i];
+ evolvedType_1 = addEvolvingArrayElementType(evolvedType_1, arg);
+ }
+ }
+ else {
+ var indexType = getContextFreeTypeOfExpression(node.left.argumentExpression);
+ if (isTypeAssignableToKind(indexType, 296)) {
+ evolvedType_1 = addEvolvingArrayElementType(evolvedType_1, node.right);
+ }
+ }
+ return evolvedType_1 === type ? flowType : createFlowType(evolvedType_1, isIncomplete(flowType));
}
- return candidate;
- }
- if (links) {
- links.jsxNamespace = false;
+ return flowType;
}
}
+ return undefined;
}
- return getGlobalSymbol(JsxNames.JSX, 1920, undefined);
- }
- function getNameFromJsxElementAttributesContainer(nameOfAttribPropContainer, jsxNamespace) {
- var jsxElementAttribPropInterfaceSym = jsxNamespace && getSymbol(jsxNamespace.exports, nameOfAttribPropContainer, 788968);
- var jsxElementAttribPropInterfaceType = jsxElementAttribPropInterfaceSym && getDeclaredTypeOfSymbol(jsxElementAttribPropInterfaceSym);
- var propertiesOfJsxElementAttribPropInterface = jsxElementAttribPropInterfaceType && getPropertiesOfType(jsxElementAttribPropInterfaceType);
- if (propertiesOfJsxElementAttribPropInterface) {
- if (propertiesOfJsxElementAttribPropInterface.length === 0) {
- return "";
- }
- else if (propertiesOfJsxElementAttribPropInterface.length === 1) {
- return propertiesOfJsxElementAttribPropInterface[0].escapedName;
+ function getTypeAtFlowCondition(flow) {
+ var flowType = getTypeAtFlowNode(flow.antecedent);
+ var type = getTypeFromFlowType(flowType);
+ if (type.flags & 131072) {
+ return flowType;
}
- else if (propertiesOfJsxElementAttribPropInterface.length > 1) {
- error(jsxElementAttribPropInterfaceSym.declarations[0], ts.Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, ts.unescapeLeadingUnderscores(nameOfAttribPropContainer));
+ var assumeTrue = (flow.flags & 32) !== 0;
+ var nonEvolvingType = finalizeEvolvingArrayType(type);
+ var narrowedType = narrowType(nonEvolvingType, flow.node, assumeTrue);
+ if (narrowedType === nonEvolvingType) {
+ return flowType;
}
+ return createFlowType(narrowedType, isIncomplete(flowType));
}
- return undefined;
- }
- function getJsxLibraryManagedAttributes(jsxNamespace) {
- return jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968);
- }
- function getJsxElementPropertiesName(jsxNamespace) {
- return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace);
- }
- function getJsxElementChildrenPropertyName(jsxNamespace) {
- return getNameFromJsxElementAttributesContainer(JsxNames.ElementChildrenAttributeNameContainer, jsxNamespace);
- }
- function getUninstantiatedJsxSignaturesOfType(elementType, caller) {
- if (elementType.flags & 4) {
- return [anySignature];
- }
- else if (elementType.flags & 128) {
- var intrinsicType = getIntrinsicAttributesTypeFromStringLiteralType(elementType, caller);
- if (!intrinsicType) {
- error(caller, ts.Diagnostics.Property_0_does_not_exist_on_type_1, elementType.value, "JSX." + JsxNames.IntrinsicElements);
- return ts.emptyArray;
- }
- else {
- var fakeSignature = createSignatureForJSXIntrinsic(caller, intrinsicType);
- return [fakeSignature];
+ function getTypeAtSwitchClause(flow) {
+ var expr = flow.switchStatement.expression;
+ var flowType = getTypeAtFlowNode(flow.antecedent);
+ var type = getTypeFromFlowType(flowType);
+ if (isMatchingReference(reference, expr)) {
+ type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
}
- }
- var apparentElemType = getApparentType(elementType);
- var signatures = getSignaturesOfType(apparentElemType, 1);
- if (signatures.length === 0) {
- signatures = getSignaturesOfType(apparentElemType, 0);
- }
- if (signatures.length === 0 && apparentElemType.flags & 1048576) {
- signatures = getUnionSignatures(ts.map(apparentElemType.types, function (t) { return getUninstantiatedJsxSignaturesOfType(t, caller); }));
- }
- return signatures;
- }
- function getIntrinsicAttributesTypeFromStringLiteralType(type, location) {
- var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, location);
- if (intrinsicElementsType !== errorType) {
- var stringLiteralTypeName = type.value;
- var intrinsicProp = getPropertyOfType(intrinsicElementsType, ts.escapeLeadingUnderscores(stringLiteralTypeName));
- if (intrinsicProp) {
- return getTypeOfSymbol(intrinsicProp);
+ else if (expr.kind === 211 && isMatchingReference(reference, expr.expression)) {
+ type = narrowBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
}
- var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, 0);
- if (indexSignatureType) {
- return indexSignatureType;
+ else {
+ if (strictNullChecks) {
+ if (optionalChainContainsReference(expr, reference)) {
+ type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, function (t) { return !(t.flags & (32768 | 131072)); });
+ }
+ else if (expr.kind === 211 && optionalChainContainsReference(expr.expression, reference)) {
+ type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, function (t) { return !(t.flags & 131072 || t.flags & 128 && t.value === "undefined"); });
+ }
+ }
+ if (isMatchingReferenceDiscriminant(expr, type)) {
+ type = narrowTypeByDiscriminant(type, expr, function (t) { return narrowTypeBySwitchOnDiscriminant(t, flow.switchStatement, flow.clauseStart, flow.clauseEnd); });
+ }
}
- return undefined;
+ return createFlowType(type, isIncomplete(flowType));
}
- return anyType;
- }
- function checkJsxReturnAssignableToAppropriateBound(refKind, elemInstanceType, openingLikeElement) {
- if (refKind === 1) {
- var sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement);
- if (sfcReturnConstraint) {
- checkTypeRelatedTo(elemInstanceType, sfcReturnConstraint, assignableRelation, openingLikeElement.tagName, ts.Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
+ function getTypeAtFlowBranchLabel(flow) {
+ var antecedentTypes = [];
+ var subtypeReduction = false;
+ var seenIncomplete = false;
+ var bypassFlow;
+ for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) {
+ var antecedent = _a[_i];
+ if (!bypassFlow && antecedent.flags & 128 && antecedent.clauseStart === antecedent.clauseEnd) {
+ bypassFlow = antecedent;
+ continue;
+ }
+ var flowType = getTypeAtFlowNode(antecedent);
+ var type = getTypeFromFlowType(flowType);
+ if (type === declaredType && declaredType === initialType) {
+ return type;
+ }
+ ts.pushIfUnique(antecedentTypes, type);
+ if (!isTypeSubsetOf(type, declaredType)) {
+ subtypeReduction = true;
+ }
+ if (isIncomplete(flowType)) {
+ seenIncomplete = true;
+ }
}
- }
- else if (refKind === 0) {
- var classConstraint = getJsxElementClassTypeAt(openingLikeElement);
- if (classConstraint) {
- checkTypeRelatedTo(elemInstanceType, classConstraint, assignableRelation, openingLikeElement.tagName, ts.Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
+ if (bypassFlow) {
+ var flowType = getTypeAtFlowNode(bypassFlow);
+ var type = getTypeFromFlowType(flowType);
+ if (!ts.contains(antecedentTypes, type) && !isExhaustiveSwitchStatement(bypassFlow.switchStatement)) {
+ if (type === declaredType && declaredType === initialType) {
+ return type;
+ }
+ antecedentTypes.push(type);
+ if (!isTypeSubsetOf(type, declaredType)) {
+ subtypeReduction = true;
+ }
+ if (isIncomplete(flowType)) {
+ seenIncomplete = true;
+ }
+ }
}
+ return createFlowType(getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 : 1), seenIncomplete);
}
- else {
- var sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement);
- var classConstraint = getJsxElementClassTypeAt(openingLikeElement);
- if (!sfcReturnConstraint || !classConstraint) {
- return;
+ function getTypeAtFlowLoopLabel(flow) {
+ var id = getFlowNodeId(flow);
+ var cache = flowLoopCaches[id] || (flowLoopCaches[id] = new ts.Map());
+ var key = getOrSetCacheKey();
+ if (!key) {
+ return declaredType;
}
- var combined = getUnionType([sfcReturnConstraint, classConstraint]);
- checkTypeRelatedTo(elemInstanceType, combined, assignableRelation, openingLikeElement.tagName, ts.Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
- }
- function generateInitialErrorChain() {
- var componentName = ts.getTextOfNode(openingLikeElement.tagName);
- return ts.chainDiagnosticMessages(undefined, ts.Diagnostics._0_cannot_be_used_as_a_JSX_component, componentName);
- }
- }
- function getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node) {
- ts.Debug.assert(isJsxIntrinsicIdentifier(node.tagName));
- var links = getNodeLinks(node);
- if (!links.resolvedJsxElementAttributesType) {
- var symbol = getIntrinsicTagSymbol(node);
- if (links.jsxFlags & 1) {
- return links.resolvedJsxElementAttributesType = getTypeOfSymbol(symbol);
+ var cached = cache.get(key);
+ if (cached) {
+ return cached;
}
- else if (links.jsxFlags & 2) {
- return links.resolvedJsxElementAttributesType =
- getIndexTypeOfType(getDeclaredTypeOfSymbol(symbol), 0);
+ for (var i = flowLoopStart; i < flowLoopCount; i++) {
+ if (flowLoopNodes[i] === flow && flowLoopKeys[i] === key && flowLoopTypes[i].length) {
+ return createFlowType(getUnionOrEvolvingArrayType(flowLoopTypes[i], 1), true);
+ }
}
- else {
- return links.resolvedJsxElementAttributesType = errorType;
+ var antecedentTypes = [];
+ var subtypeReduction = false;
+ var firstAntecedentType;
+ for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) {
+ var antecedent = _a[_i];
+ var flowType = void 0;
+ if (!firstAntecedentType) {
+ flowType = firstAntecedentType = getTypeAtFlowNode(antecedent);
+ }
+ else {
+ flowLoopNodes[flowLoopCount] = flow;
+ flowLoopKeys[flowLoopCount] = key;
+ flowLoopTypes[flowLoopCount] = antecedentTypes;
+ flowLoopCount++;
+ var saveFlowTypeCache = flowTypeCache;
+ flowTypeCache = undefined;
+ flowType = getTypeAtFlowNode(antecedent);
+ flowTypeCache = saveFlowTypeCache;
+ flowLoopCount--;
+ var cached_1 = cache.get(key);
+ if (cached_1) {
+ return cached_1;
+ }
+ }
+ var type = getTypeFromFlowType(flowType);
+ ts.pushIfUnique(antecedentTypes, type);
+ if (!isTypeSubsetOf(type, declaredType)) {
+ subtypeReduction = true;
+ }
+ if (type === declaredType) {
+ break;
+ }
}
- }
- return links.resolvedJsxElementAttributesType;
- }
- function getJsxElementClassTypeAt(location) {
- var type = getJsxType(JsxNames.ElementClass, location);
- if (type === errorType)
- return undefined;
- return type;
- }
- function getJsxElementTypeAt(location) {
- return getJsxType(JsxNames.Element, location);
- }
- function getJsxStatelessElementTypeAt(location) {
- var jsxElementType = getJsxElementTypeAt(location);
- if (jsxElementType) {
- return getUnionType([jsxElementType, nullType]);
- }
- }
- function getJsxIntrinsicTagNamesAt(location) {
- var intrinsics = getJsxType(JsxNames.IntrinsicElements, location);
- return intrinsics ? getPropertiesOfType(intrinsics) : ts.emptyArray;
- }
- function checkJsxPreconditions(errorNode) {
- if ((compilerOptions.jsx || 0) === 0) {
- error(errorNode, ts.Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided);
- }
- if (getJsxElementTypeAt(errorNode) === undefined) {
- if (noImplicitAny) {
- error(errorNode, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist);
+ var result = getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 : 1);
+ if (isIncomplete(firstAntecedentType)) {
+ return createFlowType(result, true);
}
+ cache.set(key, result);
+ return result;
}
- }
- function checkJsxOpeningLikeElementOrOpeningFragment(node) {
- var isNodeOpeningLikeElement = ts.isJsxOpeningLikeElement(node);
- if (isNodeOpeningLikeElement) {
- checkGrammarJsxElement(node);
+ function isMatchingReferenceDiscriminant(expr, computedType) {
+ var type = declaredType.flags & 1048576 ? declaredType : computedType;
+ if (!(type.flags & 1048576) || !ts.isAccessExpression(expr)) {
+ return false;
+ }
+ var name = getAccessedPropertyName(expr);
+ if (name === undefined) {
+ return false;
+ }
+ return isMatchingReference(reference, expr.expression) && isDiscriminantProperty(type, name);
}
- checkJsxPreconditions(node);
- var reactRefErr = diagnostics && compilerOptions.jsx === 2 ? ts.Diagnostics.Cannot_find_name_0 : undefined;
- var reactNamespace = getJsxNamespace(node);
- var reactLocation = isNodeOpeningLikeElement ? node.tagName : node;
- var reactSym = resolveName(reactLocation, reactNamespace, 111551, reactRefErr, reactNamespace, true);
- if (reactSym) {
- reactSym.isReferenced = 67108863;
- if (reactSym.flags & 2097152 && !getTypeOnlyAliasDeclaration(reactSym)) {
- markAliasSymbolAsReferenced(reactSym);
+ function narrowTypeByDiscriminant(type, access, narrowType) {
+ var propName = getAccessedPropertyName(access);
+ if (propName === undefined) {
+ return type;
+ }
+ var propType = getTypeOfPropertyOfType(type, propName);
+ if (!propType) {
+ return type;
}
+ var narrowedPropType = narrowType(propType);
+ return filterType(type, function (t) {
+ var discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
+ return !(discriminantType.flags & 131072) && isTypeComparableTo(discriminantType, narrowedPropType);
+ });
}
- if (isNodeOpeningLikeElement) {
- var jsxOpeningLikeNode = node;
- var sig = getResolvedSignature(jsxOpeningLikeNode);
- checkJsxReturnAssignableToAppropriateBound(getJsxReferenceKind(jsxOpeningLikeNode), getReturnTypeOfSignature(sig), jsxOpeningLikeNode);
+ function narrowTypeByTruthiness(type, expr, assumeTrue) {
+ if (isMatchingReference(reference, expr)) {
+ return getTypeWithFacts(type, assumeTrue ? 4194304 : 8388608);
+ }
+ if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) {
+ type = getTypeWithFacts(type, 2097152);
+ }
+ if (isMatchingReferenceDiscriminant(expr, type)) {
+ return narrowTypeByDiscriminant(type, expr, function (t) { return getTypeWithFacts(t, assumeTrue ? 4194304 : 8388608); });
+ }
+ return type;
}
- }
- function isKnownProperty(targetType, name, isComparingJsxAttributes) {
- if (targetType.flags & 524288) {
- var resolved = resolveStructuredTypeMembers(targetType);
- if (resolved.stringIndexInfo ||
- resolved.numberIndexInfo && isNumericLiteralName(name) ||
- getPropertyOfObjectType(targetType, name) ||
- isComparingJsxAttributes && !isUnhyphenatedJsxName(name)) {
+ function isTypePresencePossible(type, propName, assumeTrue) {
+ if (getIndexInfoOfType(type, 0)) {
return true;
}
- }
- else if (targetType.flags & 3145728 && isExcessPropertyCheckTarget(targetType)) {
- for (var _i = 0, _a = targetType.types; _i < _a.length; _i++) {
- var t = _a[_i];
- if (isKnownProperty(t, name, isComparingJsxAttributes)) {
- return true;
- }
+ var prop = getPropertyOfType(type, propName);
+ if (prop) {
+ return prop.flags & 16777216 ? true : assumeTrue;
}
+ return !assumeTrue;
}
- return false;
- }
- function isExcessPropertyCheckTarget(type) {
- return !!(type.flags & 524288 && !(ts.getObjectFlags(type) & 512) ||
- type.flags & 67108864 ||
- type.flags & 1048576 && ts.some(type.types, isExcessPropertyCheckTarget) ||
- type.flags & 2097152 && ts.every(type.types, isExcessPropertyCheckTarget));
- }
- function checkJsxExpression(node, checkMode) {
- checkGrammarJsxExpression(node);
- if (node.expression) {
- var type = checkExpression(node.expression, checkMode);
- if (node.dotDotDotToken && type !== anyType && !isArrayType(type)) {
- error(node, ts.Diagnostics.JSX_spread_child_must_be_an_array_type);
+ function narrowByInKeyword(type, literal, assumeTrue) {
+ if (type.flags & (1048576 | 524288)
+ || isThisTypeParameter(type)
+ || type.flags & 2097152 && ts.every(type.types, function (t) { return t.symbol !== globalThisSymbol; })) {
+ var propName_1 = ts.escapeLeadingUnderscores(literal.text);
+ return filterType(type, function (t) { return isTypePresencePossible(t, propName_1, assumeTrue); });
}
return type;
}
- else {
- return errorType;
- }
- }
- function getDeclarationNodeFlagsFromSymbol(s) {
- return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : 0;
- }
- function isPrototypeProperty(symbol) {
- if (symbol.flags & 8192 || ts.getCheckFlags(symbol) & 4) {
- return true;
+ function narrowTypeByBinaryExpression(type, expr, assumeTrue) {
+ switch (expr.operatorToken.kind) {
+ case 62:
+ case 74:
+ case 75:
+ case 76:
+ return narrowTypeByTruthiness(narrowType(type, expr.right, assumeTrue), expr.left, assumeTrue);
+ case 34:
+ case 35:
+ case 36:
+ case 37:
+ var operator_1 = expr.operatorToken.kind;
+ var left_1 = getReferenceCandidate(expr.left);
+ var right_1 = getReferenceCandidate(expr.right);
+ if (left_1.kind === 211 && ts.isStringLiteralLike(right_1)) {
+ return narrowTypeByTypeof(type, left_1, operator_1, right_1, assumeTrue);
+ }
+ if (right_1.kind === 211 && ts.isStringLiteralLike(left_1)) {
+ return narrowTypeByTypeof(type, right_1, operator_1, left_1, assumeTrue);
+ }
+ if (isMatchingReference(reference, left_1)) {
+ return narrowTypeByEquality(type, operator_1, right_1, assumeTrue);
+ }
+ if (isMatchingReference(reference, right_1)) {
+ return narrowTypeByEquality(type, operator_1, left_1, assumeTrue);
+ }
+ if (strictNullChecks) {
+ if (optionalChainContainsReference(left_1, reference)) {
+ type = narrowTypeByOptionalChainContainment(type, operator_1, right_1, assumeTrue);
+ }
+ else if (optionalChainContainsReference(right_1, reference)) {
+ type = narrowTypeByOptionalChainContainment(type, operator_1, left_1, assumeTrue);
+ }
+ }
+ if (isMatchingReferenceDiscriminant(left_1, type)) {
+ return narrowTypeByDiscriminant(type, left_1, function (t) { return narrowTypeByEquality(t, operator_1, right_1, assumeTrue); });
+ }
+ if (isMatchingReferenceDiscriminant(right_1, type)) {
+ return narrowTypeByDiscriminant(type, right_1, function (t) { return narrowTypeByEquality(t, operator_1, left_1, assumeTrue); });
+ }
+ if (isMatchingConstructorReference(left_1)) {
+ return narrowTypeByConstructor(type, operator_1, right_1, assumeTrue);
+ }
+ if (isMatchingConstructorReference(right_1)) {
+ return narrowTypeByConstructor(type, operator_1, left_1, assumeTrue);
+ }
+ break;
+ case 101:
+ return narrowTypeByInstanceof(type, expr, assumeTrue);
+ case 100:
+ var target = getReferenceCandidate(expr.right);
+ if (ts.isStringLiteralLike(expr.left) && isMatchingReference(reference, target)) {
+ return narrowByInKeyword(type, expr.left, assumeTrue);
+ }
+ break;
+ case 27:
+ return narrowType(type, expr.right, assumeTrue);
+ }
+ return type;
}
- if (ts.isInJSFile(symbol.valueDeclaration)) {
- var parent = symbol.valueDeclaration.parent;
- return parent && ts.isBinaryExpression(parent) &&
- ts.getAssignmentDeclarationKind(parent) === 3;
+ function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) {
+ var equalsOperator = operator === 34 || operator === 36;
+ var nullableFlags = operator === 34 || operator === 35 ? 98304 : 32768;
+ var valueType = getTypeOfExpression(value);
+ var removeNullable = equalsOperator !== assumeTrue && everyType(valueType, function (t) { return !!(t.flags & nullableFlags); }) ||
+ equalsOperator === assumeTrue && everyType(valueType, function (t) { return !(t.flags & (3 | nullableFlags)); });
+ return removeNullable ? getTypeWithFacts(type, 2097152) : type;
}
- }
- function checkPropertyAccessibility(node, isSuper, type, prop) {
- var flags = ts.getDeclarationModifierFlagsFromSymbol(prop);
- var errorNode = node.kind === 153 ? node.right : node.kind === 188 ? node : node.name;
- if (isSuper) {
- if (languageVersion < 2) {
- if (symbolHasNonMethodDeclaration(prop)) {
- error(errorNode, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
- return false;
+ function narrowTypeByEquality(type, operator, value, assumeTrue) {
+ if (type.flags & 1) {
+ return type;
+ }
+ if (operator === 35 || operator === 37) {
+ assumeTrue = !assumeTrue;
+ }
+ var valueType = getTypeOfExpression(value);
+ if ((type.flags & 2) && assumeTrue && (operator === 36 || operator === 37)) {
+ if (valueType.flags & (131068 | 67108864)) {
+ return valueType;
+ }
+ if (valueType.flags & 524288) {
+ return nonPrimitiveType;
}
+ return type;
}
- if (flags & 128) {
- error(errorNode, ts.Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(getDeclaringClass(prop)));
- return false;
+ if (valueType.flags & 98304) {
+ if (!strictNullChecks) {
+ return type;
+ }
+ var doubleEquals = operator === 34 || operator === 35;
+ var facts = doubleEquals ?
+ assumeTrue ? 262144 : 2097152 :
+ valueType.flags & 65536 ?
+ assumeTrue ? 131072 : 1048576 :
+ assumeTrue ? 65536 : 524288;
+ return getTypeWithFacts(type, facts);
}
- }
- if ((flags & 128) && ts.isThisProperty(node) && symbolHasNonMethodDeclaration(prop)) {
- var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
- if (declaringClassDeclaration && isNodeUsedDuringClassInitialization(node)) {
- error(errorNode, ts.Diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor, symbolToString(prop), ts.getTextOfIdentifierOrLiteral(declaringClassDeclaration.name));
- return false;
+ if (assumeTrue) {
+ var filterFn = operator === 34 ?
+ (function (t) { return areTypesComparable(t, valueType) || isCoercibleUnderDoubleEquals(t, valueType); }) :
+ function (t) { return areTypesComparable(t, valueType); };
+ return replacePrimitivesWithLiterals(filterType(type, filterFn), valueType);
}
- }
- if (ts.isPropertyAccessExpression(node) && ts.isPrivateIdentifier(node.name)) {
- if (!ts.getContainingClass(node)) {
- error(errorNode, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
- return false;
+ if (isUnitType(valueType)) {
+ var regularType_1 = getRegularTypeOfLiteralType(valueType);
+ return filterType(type, function (t) { return isUnitType(t) ? !areTypesComparable(t, valueType) : getRegularTypeOfLiteralType(t) !== regularType_1; });
}
- return true;
- }
- if (!(flags & 24)) {
- return true;
+ return type;
}
- if (flags & 8) {
- var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
- if (!isNodeWithinClass(node, declaringClassDeclaration)) {
- error(errorNode, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(getDeclaringClass(prop)));
- return false;
+ function narrowTypeByTypeof(type, typeOfExpr, operator, literal, assumeTrue) {
+ if (operator === 35 || operator === 37) {
+ assumeTrue = !assumeTrue;
}
- return true;
- }
- if (isSuper) {
- return true;
- }
- var enclosingClass = forEachEnclosingClass(node, function (enclosingDeclaration) {
- var enclosingClass = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingDeclaration));
- return isClassDerivedFromDeclaringClasses(enclosingClass, prop) ? enclosingClass : undefined;
- });
- if (!enclosingClass) {
- var thisParameter = void 0;
- if (flags & 32 || !(thisParameter = getThisParameterFromNodeContext(node)) || !thisParameter.type) {
- error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(getDeclaringClass(prop) || type));
- return false;
+ var target = getReferenceCandidate(typeOfExpr.expression);
+ if (!isMatchingReference(reference, target)) {
+ if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
+ return getTypeWithFacts(type, 2097152);
+ }
+ return type;
}
- var thisType = getTypeFromTypeNode(thisParameter.type);
- enclosingClass = ((thisType.flags & 262144) ? getConstraintOfTypeParameter(thisType) : thisType).target;
- }
- if (flags & 32) {
- return true;
- }
- if (type.flags & 262144) {
- type = type.isThisType ? getConstraintOfTypeParameter(type) : getBaseConstraintOfType(type);
- }
- if (!type || !hasBaseType(type, enclosingClass)) {
- error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1, symbolToString(prop), typeToString(enclosingClass));
- return false;
+ if (type.flags & 1 && literal.text === "function") {
+ return type;
+ }
+ if (assumeTrue && type.flags & 2 && literal.text === "object") {
+ if (typeOfExpr.parent.parent.kind === 216) {
+ var expr = typeOfExpr.parent.parent;
+ if (expr.operatorToken.kind === 55 && expr.right === typeOfExpr.parent && containsTruthyCheck(reference, expr.left)) {
+ return nonPrimitiveType;
+ }
+ }
+ return getUnionType([nonPrimitiveType, nullType]);
+ }
+ var facts = assumeTrue ?
+ typeofEQFacts.get(literal.text) || 128 :
+ typeofNEFacts.get(literal.text) || 32768;
+ var impliedType = getImpliedTypeFromTypeofGuard(type, literal.text);
+ return getTypeWithFacts(assumeTrue && impliedType ? mapType(type, narrowUnionMemberByTypeof(impliedType)) : type, facts);
}
- return true;
- }
- function getThisParameterFromNodeContext(node) {
- var thisContainer = ts.getThisContainer(node, false);
- return thisContainer && ts.isFunctionLike(thisContainer) ? ts.getThisParameter(thisContainer) : undefined;
- }
- function symbolHasNonMethodDeclaration(symbol) {
- return !!forEachProperty(symbol, function (prop) { return !(prop.flags & 8192); });
- }
- function checkNonNullExpression(node) {
- return checkNonNullType(checkExpression(node), node);
- }
- function isNullableType(type) {
- return !!((strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304);
- }
- function getNonNullableTypeIfNeeded(type) {
- return isNullableType(type) ? getNonNullableType(type) : type;
- }
- function reportObjectPossiblyNullOrUndefinedError(node, flags) {
- error(node, flags & 32768 ? flags & 65536 ?
- ts.Diagnostics.Object_is_possibly_null_or_undefined :
- ts.Diagnostics.Object_is_possibly_undefined :
- ts.Diagnostics.Object_is_possibly_null);
- }
- function reportCannotInvokePossiblyNullOrUndefinedError(node, flags) {
- error(node, flags & 32768 ? flags & 65536 ?
- ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined :
- ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined :
- ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null);
- }
- function checkNonNullTypeWithReporter(type, node, reportError) {
- if (strictNullChecks && type.flags & 2) {
- error(node, ts.Diagnostics.Object_is_of_type_unknown);
- return errorType;
+ function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
+ var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
+ return everyClauseChecks ? getTypeWithFacts(type, 2097152) : type;
}
- var kind = (strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304;
- if (kind) {
- reportError(node, kind);
- var t = getNonNullableType(type);
- return t.flags & (98304 | 131072) ? errorType : t;
+ function narrowTypeBySwitchOnDiscriminant(type, switchStatement, clauseStart, clauseEnd) {
+ var switchTypes = getSwitchClauseTypes(switchStatement);
+ if (!switchTypes.length) {
+ return type;
+ }
+ var clauseTypes = switchTypes.slice(clauseStart, clauseEnd);
+ var hasDefaultClause = clauseStart === clauseEnd || ts.contains(clauseTypes, neverType);
+ if ((type.flags & 2) && !hasDefaultClause) {
+ var groundClauseTypes = void 0;
+ for (var i = 0; i < clauseTypes.length; i += 1) {
+ var t = clauseTypes[i];
+ if (t.flags & (131068 | 67108864)) {
+ if (groundClauseTypes !== undefined) {
+ groundClauseTypes.push(t);
+ }
+ }
+ else if (t.flags & 524288) {
+ if (groundClauseTypes === undefined) {
+ groundClauseTypes = clauseTypes.slice(0, i);
+ }
+ groundClauseTypes.push(nonPrimitiveType);
+ }
+ else {
+ return type;
+ }
+ }
+ return getUnionType(groundClauseTypes === undefined ? clauseTypes : groundClauseTypes);
+ }
+ var discriminantType = getUnionType(clauseTypes);
+ var caseType = discriminantType.flags & 131072 ? neverType :
+ replacePrimitivesWithLiterals(filterType(type, function (t) { return areTypesComparable(discriminantType, t); }), discriminantType);
+ if (!hasDefaultClause) {
+ return caseType;
+ }
+ var defaultType = filterType(type, function (t) { return !(isUnitType(t) && ts.contains(switchTypes, getRegularTypeOfLiteralType(t))); });
+ return caseType.flags & 131072 ? defaultType : getUnionType([caseType, defaultType]);
}
- return type;
- }
- function checkNonNullType(type, node) {
- return checkNonNullTypeWithReporter(type, node, reportObjectPossiblyNullOrUndefinedError);
- }
- function checkNonNullNonVoidType(type, node) {
- var nonNullType = checkNonNullType(type, node);
- if (nonNullType !== errorType && nonNullType.flags & 16384) {
- error(node, ts.Diagnostics.Object_is_possibly_undefined);
+ function getImpliedTypeFromTypeofGuard(type, text) {
+ switch (text) {
+ case "function":
+ return type.flags & 1 ? type : globalFunctionType;
+ case "object":
+ return type.flags & 2 ? getUnionType([nonPrimitiveType, nullType]) : type;
+ default:
+ return typeofTypesByName.get(text);
+ }
}
- return nonNullType;
- }
- function checkPropertyAccessExpression(node) {
- return node.flags & 32 ? checkPropertyAccessChain(node) :
- checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name);
- }
- function checkPropertyAccessChain(node) {
- var leftType = checkExpression(node.expression);
- var nonOptionalType = getOptionalExpressionType(leftType, node.expression);
- return propagateOptionalTypeMarker(checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullType(nonOptionalType, node.expression), node.name), node, nonOptionalType !== leftType);
- }
- function checkQualifiedName(node) {
- return checkPropertyAccessExpressionOrQualifiedName(node, node.left, checkNonNullExpression(node.left), node.right);
- }
- function isMethodAccessForCall(node) {
- while (node.parent.kind === 200) {
- node = node.parent;
+ function narrowUnionMemberByTypeof(candidate) {
+ return function (type) {
+ if (isTypeSubtypeOf(type, candidate)) {
+ return type;
+ }
+ if (isTypeSubtypeOf(candidate, type)) {
+ return candidate;
+ }
+ if (type.flags & 465829888) {
+ var constraint = getBaseConstraintOfType(type) || anyType;
+ if (isTypeSubtypeOf(candidate, constraint)) {
+ return getIntersectionType([type, candidate]);
+ }
+ }
+ return type;
+ };
}
- return ts.isCallOrNewExpression(node.parent) && node.parent.expression === node;
- }
- function lookupSymbolForPrivateIdentifierDeclaration(propName, location) {
- for (var containingClass = ts.getContainingClass(location); !!containingClass; containingClass = ts.getContainingClass(containingClass)) {
- var symbol = containingClass.symbol;
- var name = ts.getSymbolNameForPrivateIdentifier(symbol, propName);
- var prop = (symbol.members && symbol.members.get(name)) || (symbol.exports && symbol.exports.get(name));
- if (prop) {
- return prop;
+ function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
+ var switchWitnesses = getSwitchClauseTypeOfWitnesses(switchStatement, true);
+ if (!switchWitnesses.length) {
+ return type;
+ }
+ var defaultCaseLocation = ts.findIndex(switchWitnesses, function (elem) { return elem === undefined; });
+ var hasDefaultClause = clauseStart === clauseEnd || (defaultCaseLocation >= clauseStart && defaultCaseLocation < clauseEnd);
+ var clauseWitnesses;
+ var switchFacts;
+ if (defaultCaseLocation > -1) {
+ var witnesses = switchWitnesses.filter(function (witness) { return witness !== undefined; });
+ var fixedClauseStart = defaultCaseLocation < clauseStart ? clauseStart - 1 : clauseStart;
+ var fixedClauseEnd = defaultCaseLocation < clauseEnd ? clauseEnd - 1 : clauseEnd;
+ clauseWitnesses = witnesses.slice(fixedClauseStart, fixedClauseEnd);
+ switchFacts = getFactsFromTypeofSwitch(fixedClauseStart, fixedClauseEnd, witnesses, hasDefaultClause);
}
+ else {
+ clauseWitnesses = switchWitnesses.slice(clauseStart, clauseEnd);
+ switchFacts = getFactsFromTypeofSwitch(clauseStart, clauseEnd, switchWitnesses, hasDefaultClause);
+ }
+ if (hasDefaultClause) {
+ return filterType(type, function (t) { return (getTypeFacts(t) & switchFacts) === switchFacts; });
+ }
+ var impliedType = getTypeWithFacts(getUnionType(clauseWitnesses.map(function (text) { return getImpliedTypeFromTypeofGuard(type, text) || type; })), switchFacts);
+ return getTypeWithFacts(mapType(type, narrowUnionMemberByTypeof(impliedType)), switchFacts);
}
- }
- function getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) {
- return getPropertyOfType(leftType, lexicallyScopedIdentifier.escapedName);
- }
- function checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedIdentifier) {
- var propertyOnType;
- var properties = getPropertiesOfType(leftType);
- if (properties) {
- ts.forEach(properties, function (symbol) {
- var decl = symbol.valueDeclaration;
- if (decl && ts.isNamedDeclaration(decl) && ts.isPrivateIdentifier(decl.name) && decl.name.escapedText === right.escapedText) {
- propertyOnType = symbol;
- return true;
- }
- });
+ function isMatchingConstructorReference(expr) {
+ return (ts.isPropertyAccessExpression(expr) && ts.idText(expr.name) === "constructor" ||
+ ts.isElementAccessExpression(expr) && ts.isStringLiteralLike(expr.argumentExpression) && expr.argumentExpression.text === "constructor") &&
+ isMatchingReference(reference, expr.expression);
}
- var diagName = diagnosticName(right);
- if (propertyOnType) {
- var typeValueDecl = propertyOnType.valueDeclaration;
- var typeClass_1 = ts.getContainingClass(typeValueDecl);
- ts.Debug.assert(!!typeClass_1);
- if (lexicallyScopedIdentifier) {
- var lexicalValueDecl = lexicallyScopedIdentifier.valueDeclaration;
- var lexicalClass = ts.getContainingClass(lexicalValueDecl);
- ts.Debug.assert(!!lexicalClass);
- if (ts.findAncestor(lexicalClass, function (n) { return typeClass_1 === n; })) {
- var diagnostic = error(right, ts.Diagnostics.The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling, diagName, typeToString(leftType));
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(lexicalValueDecl, ts.Diagnostics.The_shadowing_declaration_of_0_is_defined_here, diagName), ts.createDiagnosticForNode(typeValueDecl, ts.Diagnostics.The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here, diagName));
- return true;
+ function narrowTypeByConstructor(type, operator, identifier, assumeTrue) {
+ if (assumeTrue ? (operator !== 34 && operator !== 36) : (operator !== 35 && operator !== 37)) {
+ return type;
+ }
+ var identifierType = getTypeOfExpression(identifier);
+ if (!isFunctionType(identifierType) && !isConstructorType(identifierType)) {
+ return type;
+ }
+ var prototypeProperty = getPropertyOfType(identifierType, "prototype");
+ if (!prototypeProperty) {
+ return type;
+ }
+ var prototypeType = getTypeOfSymbol(prototypeProperty);
+ var candidate = !isTypeAny(prototypeType) ? prototypeType : undefined;
+ if (!candidate || candidate === globalObjectType || candidate === globalFunctionType) {
+ return type;
+ }
+ if (isTypeAny(type)) {
+ return candidate;
+ }
+ return filterType(type, function (t) { return isConstructedBy(t, candidate); });
+ function isConstructedBy(source, target) {
+ if (source.flags & 524288 && ts.getObjectFlags(source) & 1 ||
+ target.flags & 524288 && ts.getObjectFlags(target) & 1) {
+ return source.symbol === target.symbol;
}
+ return isTypeSubtypeOf(source, target);
}
- error(right, ts.Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier, diagName, diagnosticName(typeClass_1.name || anon));
- return true;
- }
- return false;
- }
- function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right) {
- var parentSymbol = getNodeLinks(left).resolvedSymbol;
- var assignmentKind = ts.getAssignmentTargetKind(node);
- var apparentType = getApparentType(assignmentKind !== 0 || isMethodAccessForCall(node) ? getWidenedType(leftType) : leftType);
- if (ts.isPrivateIdentifier(right)) {
- checkExternalEmitHelpers(node, 262144);
}
- var isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType;
- var prop;
- if (ts.isPrivateIdentifier(right)) {
- var lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(right.escapedText, right);
- if (isAnyLike) {
- if (lexicallyScopedSymbol) {
- return apparentType;
+ function narrowTypeByInstanceof(type, expr, assumeTrue) {
+ var left = getReferenceCandidate(expr.left);
+ if (!isMatchingReference(reference, left)) {
+ if (assumeTrue && strictNullChecks && optionalChainContainsReference(left, reference)) {
+ return getTypeWithFacts(type, 2097152);
}
- if (!ts.getContainingClass(right)) {
- grammarErrorOnNode(right, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
- return anyType;
+ return type;
+ }
+ var rightType = getTypeOfExpression(expr.right);
+ if (!isTypeDerivedFrom(rightType, globalFunctionType)) {
+ return type;
+ }
+ var targetType;
+ var prototypeProperty = getPropertyOfType(rightType, "prototype");
+ if (prototypeProperty) {
+ var prototypePropertyType = getTypeOfSymbol(prototypeProperty);
+ if (!isTypeAny(prototypePropertyType)) {
+ targetType = prototypePropertyType;
}
}
- prop = lexicallyScopedSymbol ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedSymbol) : undefined;
- if (!prop && checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedSymbol)) {
- return errorType;
+ if (isTypeAny(type) && (targetType === globalObjectType || targetType === globalFunctionType)) {
+ return type;
+ }
+ if (!targetType) {
+ var constructSignatures = getSignaturesOfType(rightType, 1);
+ targetType = constructSignatures.length ?
+ getUnionType(ts.map(constructSignatures, function (signature) { return getReturnTypeOfSignature(getErasedSignature(signature)); })) :
+ emptyObjectType;
+ }
+ if (!assumeTrue && rightType.flags & 1048576) {
+ var nonConstructorTypeInUnion = ts.find(rightType.types, function (t) { return !isConstructorType(t); });
+ if (!nonConstructorTypeInUnion)
+ return type;
}
+ return getNarrowedType(type, targetType, assumeTrue, isTypeDerivedFrom);
}
- else {
- if (isAnyLike) {
- if (ts.isIdentifier(left) && parentSymbol) {
- markAliasReferenced(parentSymbol, node);
+ function getNarrowedType(type, candidate, assumeTrue, isRelated) {
+ if (!assumeTrue) {
+ return filterType(type, function (t) { return !isRelated(t, candidate); });
+ }
+ if (type.flags & 1048576) {
+ var assignableType = filterType(type, function (t) { return isRelated(t, candidate); });
+ if (!(assignableType.flags & 131072)) {
+ return assignableType;
}
- return apparentType;
}
- prop = getPropertyOfType(apparentType, right.escapedText);
- }
- if (ts.isIdentifier(left) && parentSymbol && !(prop && isConstEnumOrConstEnumOnlyModule(prop))) {
- markAliasReferenced(parentSymbol, node);
+ return isTypeSubtypeOf(candidate, type) ? candidate : isTypeSubtypeOf(type, candidate) ? type : getIntersectionType([type, candidate]);
}
- var propType;
- if (!prop) {
- var indexInfo = !ts.isPrivateIdentifier(right) && (assignmentKind === 0 || !isGenericObjectType(leftType) || isThisTypeParameter(leftType)) ? getIndexInfoOfType(apparentType, 0) : undefined;
- if (!(indexInfo && indexInfo.type)) {
- if (isJSLiteralType(leftType)) {
- return anyType;
+ function narrowTypeByCallExpression(type, callExpression, assumeTrue) {
+ if (hasMatchingArgument(callExpression, reference)) {
+ var signature = assumeTrue || !ts.isCallChain(callExpression) ? getEffectsSignature(callExpression) : undefined;
+ var predicate = signature && getTypePredicateOfSignature(signature);
+ if (predicate && (predicate.kind === 0 || predicate.kind === 1)) {
+ return narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue);
}
- if (leftType.symbol === globalThisSymbol) {
- if (globalThisSymbol.exports.has(right.escapedText) && (globalThisSymbol.exports.get(right.escapedText).flags & 418)) {
- error(right, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(right.escapedText), typeToString(leftType));
+ }
+ return type;
+ }
+ function narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue) {
+ if (predicate.type && !(isTypeAny(type) && (predicate.type === globalObjectType || predicate.type === globalFunctionType))) {
+ var predicateArgument = getTypePredicateArgument(predicate, callExpression);
+ if (predicateArgument) {
+ if (isMatchingReference(reference, predicateArgument)) {
+ return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);
}
- else if (noImplicitAny) {
- error(right, ts.Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature, typeToString(leftType));
+ if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) &&
+ !(getTypeFacts(predicate.type) & 65536)) {
+ type = getTypeWithFacts(type, 2097152);
+ }
+ if (isMatchingReferenceDiscriminant(predicateArgument, type)) {
+ return narrowTypeByDiscriminant(type, predicateArgument, function (t) { return getNarrowedType(t, predicate.type, assumeTrue, isTypeSubtypeOf); });
}
- return anyType;
- }
- if (right.escapedText && !checkAndReportErrorForExtendingInterface(node)) {
- reportNonexistentProperty(right, isThisTypeParameter(leftType) ? apparentType : leftType);
}
- return errorType;
}
- if (indexInfo.isReadonly && (ts.isAssignmentTarget(node) || ts.isDeleteTarget(node))) {
- error(node, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType));
+ return type;
+ }
+ function narrowType(type, expr, assumeTrue) {
+ if (ts.isExpressionOfOptionalChainRoot(expr) ||
+ ts.isBinaryExpression(expr.parent) && expr.parent.operatorToken.kind === 60 && expr.parent.left === expr) {
+ return narrowTypeByOptionality(type, expr, assumeTrue);
+ }
+ switch (expr.kind) {
+ case 78:
+ case 107:
+ case 105:
+ case 201:
+ case 202:
+ return narrowTypeByTruthiness(type, expr, assumeTrue);
+ case 203:
+ return narrowTypeByCallExpression(type, expr, assumeTrue);
+ case 207:
+ case 225:
+ return narrowType(type, expr.expression, assumeTrue);
+ case 216:
+ return narrowTypeByBinaryExpression(type, expr, assumeTrue);
+ case 214:
+ if (expr.operator === 53) {
+ return narrowType(type, expr.operand, !assumeTrue);
+ }
+ break;
}
- propType = indexInfo.type;
+ return type;
}
- else {
- checkPropertyNotUsedBeforeDeclaration(prop, node, right);
- markPropertyAsReferenced(prop, node, left.kind === 104);
- getNodeLinks(node).resolvedSymbol = prop;
- checkPropertyAccessibility(node, left.kind === 102, apparentType, prop);
- if (isAssignmentToReadonlyEntity(node, prop, assignmentKind)) {
- error(right, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, ts.idText(right));
- return errorType;
+ function narrowTypeByOptionality(type, expr, assumePresent) {
+ if (isMatchingReference(reference, expr)) {
+ return getTypeWithFacts(type, assumePresent ? 2097152 : 262144);
+ }
+ if (isMatchingReferenceDiscriminant(expr, type)) {
+ return narrowTypeByDiscriminant(type, expr, function (t) { return getTypeWithFacts(t, assumePresent ? 2097152 : 262144); });
}
- propType = getConstraintForLocation(getTypeOfSymbol(prop), node);
+ return type;
}
- return getFlowTypeOfAccessExpression(node, prop, propType, right);
}
- function getFlowTypeOfAccessExpression(node, prop, propType, errorNode) {
- var assignmentKind = ts.getAssignmentTargetKind(node);
- if (!ts.isAccessExpression(node) ||
- assignmentKind === 1 ||
- prop && !(prop.flags & (3 | 4 | 98304)) && !(prop.flags & 8192 && propType.flags & 1048576)) {
- return propType;
- }
- var assumeUninitialized = false;
- if (strictNullChecks && strictPropertyInitialization && node.expression.kind === 104) {
- var declaration = prop && prop.valueDeclaration;
- if (declaration && isInstancePropertyWithoutInitializer(declaration)) {
- var flowContainer = getControlFlowContainer(node);
- if (flowContainer.kind === 162 && flowContainer.parent === declaration.parent && !(declaration.flags & 8388608)) {
- assumeUninitialized = true;
+ function getTypeOfSymbolAtLocation(symbol, location) {
+ symbol = symbol.exportSymbol || symbol;
+ if (location.kind === 78) {
+ if (ts.isRightSideOfQualifiedNameOrPropertyAccess(location)) {
+ location = location.parent;
+ }
+ if (ts.isExpressionNode(location) && !ts.isAssignmentTarget(location)) {
+ var type = getTypeOfExpression(location);
+ if (getExportSymbolOfValueSymbolIfExported(getNodeLinks(location).resolvedSymbol) === symbol) {
+ return type;
}
}
}
- else if (strictNullChecks && prop && prop.valueDeclaration &&
- ts.isPropertyAccessExpression(prop.valueDeclaration) &&
- ts.getAssignmentDeclarationPropertyAccessKind(prop.valueDeclaration) &&
- getControlFlowContainer(node) === getControlFlowContainer(prop.valueDeclaration)) {
- assumeUninitialized = true;
- }
- var flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType);
- if (assumeUninitialized && !(getFalsyFlags(propType) & 32768) && getFalsyFlags(flowType) & 32768) {
- error(errorNode, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(prop));
- return propType;
- }
- return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
- }
- function checkPropertyNotUsedBeforeDeclaration(prop, node, right) {
- var valueDeclaration = prop.valueDeclaration;
- if (!valueDeclaration || ts.getSourceFileOfNode(node).isDeclarationFile) {
- return;
- }
- var diagnosticMessage;
- var declarationName = ts.idText(right);
- if (isInPropertyInitializer(node)
- && !(ts.isAccessExpression(node) && ts.isAccessExpression(node.expression))
- && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)
- && !isPropertyDeclaredInAncestorClass(prop)) {
- diagnosticMessage = error(right, ts.Diagnostics.Property_0_is_used_before_its_initialization, declarationName);
- }
- else if (valueDeclaration.kind === 245 &&
- node.parent.kind !== 169 &&
- !(valueDeclaration.flags & 8388608) &&
- !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)) {
- diagnosticMessage = error(right, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName);
- }
- if (diagnosticMessage) {
- ts.addRelatedInfo(diagnosticMessage, ts.createDiagnosticForNode(valueDeclaration, ts.Diagnostics._0_is_declared_here, declarationName));
- }
+ return getTypeOfSymbol(symbol);
}
- function isInPropertyInitializer(node) {
- return !!ts.findAncestor(node, function (node) {
- switch (node.kind) {
- case 159:
- return true;
- case 281:
- case 161:
- case 163:
- case 164:
- case 283:
- case 154:
- case 221:
- case 276:
- case 273:
- case 274:
- case 275:
- case 268:
- case 216:
- case 279:
- return false;
- default:
- return ts.isExpressionNode(node) ? false : "quit";
- }
+ function getControlFlowContainer(node) {
+ return ts.findAncestor(node.parent, function (node) {
+ return ts.isFunctionLike(node) && !ts.getImmediatelyInvokedFunctionExpression(node) ||
+ node.kind === 257 ||
+ node.kind === 297 ||
+ node.kind === 163;
});
}
- function isPropertyDeclaredInAncestorClass(prop) {
- if (!(prop.parent.flags & 32)) {
- return false;
- }
- var classType = getTypeOfSymbol(prop.parent);
- while (true) {
- classType = classType.symbol && getSuperClass(classType);
- if (!classType) {
- return false;
- }
- var superProperty = getPropertyOfType(classType, prop.escapedName);
- if (superProperty && superProperty.valueDeclaration) {
- return true;
+ function isParameterAssigned(symbol) {
+ var func = ts.getRootDeclaration(symbol.valueDeclaration).parent;
+ var links = getNodeLinks(func);
+ if (!(links.flags & 8388608)) {
+ links.flags |= 8388608;
+ if (!hasParentWithAssignmentsMarked(func)) {
+ markParameterAssignments(func);
}
}
+ return symbol.isAssigned || false;
}
- function getSuperClass(classType) {
- var x = getBaseTypes(classType);
- if (x.length === 0) {
- return undefined;
- }
- return getIntersectionType(x);
+ function hasParentWithAssignmentsMarked(node) {
+ return !!ts.findAncestor(node.parent, function (node) { return ts.isFunctionLike(node) && !!(getNodeLinks(node).flags & 8388608); });
}
- function reportNonexistentProperty(propNode, containingType) {
- var errorInfo;
- var relatedInfo;
- if (!ts.isPrivateIdentifier(propNode) && containingType.flags & 1048576 && !(containingType.flags & 131068)) {
- for (var _i = 0, _a = containingType.types; _i < _a.length; _i++) {
- var subtype = _a[_i];
- if (!getPropertyOfType(subtype, propNode.escapedText) && !getIndexInfoOfType(subtype, 0)) {
- errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(subtype));
- break;
+ function markParameterAssignments(node) {
+ if (node.kind === 78) {
+ if (ts.isAssignmentTarget(node)) {
+ var symbol = getResolvedSymbol(node);
+ if (symbol.valueDeclaration && ts.getRootDeclaration(symbol.valueDeclaration).kind === 160) {
+ symbol.isAssigned = true;
}
}
}
- if (typeHasStaticProperty(propNode.escapedText, containingType)) {
- errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_is_a_static_member_of_type_1, ts.declarationNameToString(propNode), typeToString(containingType));
- }
else {
- var promisedType = getPromisedTypeOfPromise(containingType);
- if (promisedType && getPropertyOfType(promisedType, propNode.escapedText)) {
- errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(containingType));
- relatedInfo = ts.createDiagnosticForNode(propNode, ts.Diagnostics.Did_you_forget_to_use_await);
- }
- else {
- var suggestion = getSuggestedSymbolForNonexistentProperty(propNode, containingType);
- if (suggestion !== undefined) {
- var suggestedName = ts.symbolName(suggestion);
- errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, ts.declarationNameToString(propNode), typeToString(containingType), suggestedName);
- relatedInfo = suggestion.valueDeclaration && ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestedName);
- }
- else {
- errorInfo = ts.chainDiagnosticMessages(elaborateNeverIntersection(errorInfo, containingType), ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(containingType));
- }
- }
- }
- var resultDiagnostic = ts.createDiagnosticForNodeFromMessageChain(propNode, errorInfo);
- if (relatedInfo) {
- ts.addRelatedInfo(resultDiagnostic, relatedInfo);
+ ts.forEachChild(node, markParameterAssignments);
}
- diagnostics.add(resultDiagnostic);
- }
- function typeHasStaticProperty(propName, containingType) {
- var prop = containingType.symbol && getPropertyOfType(getTypeOfSymbol(containingType.symbol), propName);
- return prop !== undefined && prop.valueDeclaration && ts.hasModifier(prop.valueDeclaration, 32);
}
- function getSuggestedSymbolForNonexistentProperty(name, containingType) {
- return getSpellingSuggestionForName(ts.isString(name) ? name : ts.idText(name), getPropertiesOfType(containingType), 111551);
+ function isConstVariable(symbol) {
+ return symbol.flags & 3 && (getDeclarationNodeFlagsFromSymbol(symbol) & 2) !== 0 && getTypeOfSymbol(symbol) !== autoArrayType;
}
- function getSuggestionForNonexistentProperty(name, containingType) {
- var suggestion = getSuggestedSymbolForNonexistentProperty(name, containingType);
- return suggestion && ts.symbolName(suggestion);
+ function removeOptionalityFromDeclaredType(declaredType, declaration) {
+ if (pushTypeResolution(declaration.symbol, 2)) {
+ var annotationIncludesUndefined = strictNullChecks &&
+ declaration.kind === 160 &&
+ declaration.initializer &&
+ getFalsyFlags(declaredType) & 32768 &&
+ !(getFalsyFlags(checkExpression(declaration.initializer)) & 32768);
+ popTypeResolution();
+ return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288) : declaredType;
+ }
+ else {
+ reportCircularityError(declaration.symbol);
+ return declaredType;
+ }
}
- function getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning) {
- ts.Debug.assert(outerName !== undefined, "outername should always be defined");
- var result = resolveNameHelper(location, outerName, meaning, undefined, outerName, false, false, function (symbols, name, meaning) {
- ts.Debug.assertEqual(outerName, name, "name should equal outerName");
- var symbol = getSymbol(symbols, name, meaning);
- return symbol || getSpellingSuggestionForName(ts.unescapeLeadingUnderscores(name), ts.arrayFrom(symbols.values()), meaning);
- });
- return result;
+ function isConstraintPosition(node) {
+ var parent = node.parent;
+ return parent.kind === 201 ||
+ parent.kind === 203 && parent.expression === node ||
+ parent.kind === 202 && parent.expression === node ||
+ parent.kind === 198 && parent.name === node && !!parent.initializer;
}
- function getSuggestionForNonexistentSymbol(location, outerName, meaning) {
- var symbolResult = getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning);
- return symbolResult && ts.symbolName(symbolResult);
+ function typeHasNullableConstraint(type) {
+ return type.flags & 58982400 && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 98304);
}
- function getSuggestedSymbolForNonexistentModule(name, targetModule) {
- return targetModule.exports && getSpellingSuggestionForName(ts.idText(name), getExportsOfModuleAsArray(targetModule), 2623475);
+ function getConstraintForLocation(type, node) {
+ if (type && isConstraintPosition(node) && forEachType(type, typeHasNullableConstraint)) {
+ return mapType(getWidenedType(type), getBaseConstraintOrType);
+ }
+ return type;
}
- function getSuggestionForNonexistentExport(name, targetModule) {
- var suggestion = getSuggestedSymbolForNonexistentModule(name, targetModule);
- return suggestion && ts.symbolName(suggestion);
+ function isExportOrExportExpression(location) {
+ return !!ts.findAncestor(location, function (e) { return e.parent && ts.isExportAssignment(e.parent) && e.parent.expression === e && ts.isEntityNameExpression(e); });
}
- function getSuggestionForNonexistentIndexSignature(objectType, expr, keyedType) {
- function hasProp(name) {
- var prop = getPropertyOfObjectType(objectType, name);
- if (prop) {
- var s = getSingleCallSignature(getTypeOfSymbol(prop));
- return !!s && getMinArgumentCount(s) >= 1 && isTypeAssignableTo(keyedType, getTypeAtPosition(s, 0));
+ function markAliasReferenced(symbol, location) {
+ if (isNonLocalAlias(symbol, 111551) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol)) {
+ if (compilerOptions.preserveConstEnums && isExportOrExportExpression(location) || !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) {
+ markAliasSymbolAsReferenced(symbol);
+ }
+ else {
+ markConstEnumAliasAsReferenced(symbol);
}
- return false;
}
- ;
- var suggestedMethod = ts.isAssignmentTarget(expr) ? "set" : "get";
- if (!hasProp(suggestedMethod)) {
- return undefined;
+ }
+ function checkIdentifier(node) {
+ var symbol = getResolvedSymbol(node);
+ if (symbol === unknownSymbol) {
+ return errorType;
}
- var suggestion = ts.tryGetPropertyAccessOrIdentifierToString(expr.expression);
- if (suggestion === undefined) {
- suggestion = suggestedMethod;
+ if (symbol === argumentsSymbol) {
+ var container = ts.getContainingFunction(node);
+ if (languageVersion < 2) {
+ if (container.kind === 209) {
+ error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
+ }
+ else if (ts.hasSyntacticModifier(container, 256)) {
+ error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method);
+ }
+ }
+ getNodeLinks(container).flags |= 8192;
+ return getTypeOfSymbol(symbol);
}
- else {
- suggestion += "." + suggestedMethod;
+ if (!(node.parent && ts.isPropertyAccessExpression(node.parent) && node.parent.expression === node)) {
+ markAliasReferenced(symbol, node);
}
- return suggestion;
- }
- function getSpellingSuggestionForName(name, symbols, meaning) {
- return ts.getSpellingSuggestion(name, symbols, getCandidateName);
- function getCandidateName(candidate) {
- var candidateName = ts.symbolName(candidate);
- if (ts.startsWith(candidateName, "\"")) {
- return undefined;
- }
- if (candidate.flags & meaning) {
- return candidateName;
+ var localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
+ var sourceSymbol = localOrExportSymbol.flags & 2097152 ? resolveAlias(localOrExportSymbol) : localOrExportSymbol;
+ if (getDeclarationNodeFlagsFromSymbol(sourceSymbol) & 134217728 && isUncalledFunctionReference(node.parent, sourceSymbol)) {
+ errorOrSuggestion(false, node, ts.Diagnostics._0_is_deprecated, node.escapedText);
+ }
+ var declaration = localOrExportSymbol.valueDeclaration;
+ if (localOrExportSymbol.flags & 32) {
+ if (declaration.kind === 252
+ && ts.nodeIsDecorated(declaration)) {
+ var container = ts.getContainingClass(node);
+ while (container !== undefined) {
+ if (container === declaration && container.name !== node) {
+ getNodeLinks(declaration).flags |= 16777216;
+ getNodeLinks(node).flags |= 33554432;
+ break;
+ }
+ container = ts.getContainingClass(container);
+ }
}
- if (candidate.flags & 2097152) {
- var alias = tryResolveAlias(candidate);
- if (alias && alias.flags & meaning) {
- return candidateName;
+ else if (declaration.kind === 221) {
+ var container = ts.getThisContainer(node, false);
+ while (container.kind !== 297) {
+ if (container.parent === declaration) {
+ if (container.kind === 163 && ts.hasSyntacticModifier(container, 32)) {
+ getNodeLinks(declaration).flags |= 16777216;
+ getNodeLinks(node).flags |= 33554432;
+ }
+ break;
+ }
+ container = ts.getThisContainer(container, false);
}
}
- return undefined;
- }
- }
- function markPropertyAsReferenced(prop, nodeForCheckWriteOnly, isThisAccess) {
- var valueDeclaration = prop && (prop.flags & 106500) && prop.valueDeclaration;
- if (!valueDeclaration) {
- return;
- }
- var hasPrivateModifier = ts.hasModifier(valueDeclaration, 8);
- var hasPrivateIdentifier = ts.isNamedDeclaration(prop.valueDeclaration) && ts.isPrivateIdentifier(prop.valueDeclaration.name);
- if (!hasPrivateModifier && !hasPrivateIdentifier) {
- return;
}
- if (nodeForCheckWriteOnly && ts.isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536)) {
- return;
+ checkNestedBlockScopedBinding(node, symbol);
+ var type = getConstraintForLocation(getTypeOfSymbol(localOrExportSymbol), node);
+ var assignmentKind = ts.getAssignmentTargetKind(node);
+ if (assignmentKind) {
+ if (!(localOrExportSymbol.flags & 3) &&
+ !(ts.isInJSFile(node) && localOrExportSymbol.flags & 512)) {
+ error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_not_a_variable, symbolToString(symbol));
+ return errorType;
+ }
+ if (isReadonlySymbol(localOrExportSymbol)) {
+ if (localOrExportSymbol.flags & 3) {
+ error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_constant, symbolToString(symbol));
+ }
+ else {
+ error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(symbol));
+ }
+ return errorType;
+ }
}
- if (isThisAccess) {
- var containingMethod = ts.findAncestor(nodeForCheckWriteOnly, ts.isFunctionLikeDeclaration);
- if (containingMethod && containingMethod.symbol === prop) {
- return;
+ var isAlias = localOrExportSymbol.flags & 2097152;
+ if (localOrExportSymbol.flags & 3) {
+ if (assignmentKind === 1) {
+ return type;
}
}
- (ts.getCheckFlags(prop) & 1 ? getSymbolLinks(prop).target : prop).isReferenced = 67108863;
- }
- function isValidPropertyAccess(node, propertyName) {
- switch (node.kind) {
- case 194:
- return isValidPropertyAccessWithType(node, node.expression.kind === 102, propertyName, getWidenedType(checkExpression(node.expression)));
- case 153:
- return isValidPropertyAccessWithType(node, false, propertyName, getWidenedType(checkExpression(node.left)));
- case 188:
- return isValidPropertyAccessWithType(node, false, propertyName, getTypeFromTypeNode(node));
+ else if (isAlias) {
+ declaration = ts.find(symbol.declarations, isSomeImportDeclaration);
}
- }
- function isValidPropertyAccessForCompletions(node, type, property) {
- return isValidPropertyAccessWithType(node, node.kind === 194 && node.expression.kind === 102, property.escapedName, type);
- }
- function isValidPropertyAccessWithType(node, isSuper, propertyName, type) {
- if (type === errorType || isTypeAny(type)) {
- return true;
+ else {
+ return type;
}
- var prop = getPropertyOfType(type, propertyName);
- if (prop) {
- if (ts.isPropertyAccessExpression(node) && prop.valueDeclaration && ts.isPrivateIdentifierPropertyDeclaration(prop.valueDeclaration)) {
- var declClass_1 = ts.getContainingClass(prop.valueDeclaration);
- return !ts.isOptionalChain(node) && !!ts.findAncestor(node, function (parent) { return parent === declClass_1; });
- }
- return checkPropertyAccessibility(node, isSuper, type, prop);
+ if (!declaration) {
+ return type;
}
- return ts.isInJSFile(node) && (type.flags & 1048576) !== 0 && type.types.some(function (elementType) { return isValidPropertyAccessWithType(node, isSuper, propertyName, elementType); });
- }
- function getForInVariableSymbol(node) {
- var initializer = node.initializer;
- if (initializer.kind === 243) {
- var variable = initializer.declarations[0];
- if (variable && !ts.isBindingPattern(variable.name)) {
- return getSymbolOfNode(variable);
+ var isParameter = ts.getRootDeclaration(declaration).kind === 160;
+ var declarationContainer = getControlFlowContainer(declaration);
+ var flowContainer = getControlFlowContainer(node);
+ var isOuterVariable = flowContainer !== declarationContainer;
+ var isSpreadDestructuringAssignmentTarget = node.parent && node.parent.parent && ts.isSpreadAssignment(node.parent) && isDestructuringAssignmentTarget(node.parent.parent);
+ var isModuleExports = symbol.flags & 134217728;
+ while (flowContainer !== declarationContainer && (flowContainer.kind === 208 ||
+ flowContainer.kind === 209 || ts.isObjectLiteralOrClassExpressionMethod(flowContainer)) &&
+ (isConstVariable(localOrExportSymbol) || isParameter && !isParameterAssigned(localOrExportSymbol))) {
+ flowContainer = getControlFlowContainer(flowContainer);
+ }
+ var assumeInitialized = isParameter || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || ts.isBindingElement(declaration) ||
+ type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 | 16384)) !== 0 ||
+ isInTypeQuery(node) || node.parent.kind === 270) ||
+ node.parent.kind === 225 ||
+ declaration.kind === 249 && declaration.exclamationToken ||
+ declaration.flags & 8388608;
+ var initialType = assumeInitialized ? (isParameter ? removeOptionalityFromDeclaredType(type, declaration) : type) :
+ type === autoType || type === autoArrayType ? undefinedType :
+ getOptionalType(type);
+ var flowType = getFlowTypeOfReference(node, type, initialType, flowContainer, !assumeInitialized);
+ if (!isEvolvingArrayOperationTarget(node) && (type === autoType || type === autoArrayType)) {
+ if (flowType === autoType || flowType === autoArrayType) {
+ if (noImplicitAny) {
+ error(ts.getNameOfDeclaration(declaration), ts.Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined, symbolToString(symbol), typeToString(flowType));
+ error(node, ts.Diagnostics.Variable_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType));
+ }
+ return convertAutoToAny(flowType);
}
}
- else if (initializer.kind === 75) {
- return getResolvedSymbol(initializer);
+ else if (!assumeInitialized && !(getFalsyFlags(type) & 32768) && getFalsyFlags(flowType) & 32768) {
+ error(node, ts.Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
+ return type;
}
- return undefined;
+ return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
}
- function hasNumericPropertyNames(type) {
- return getIndexTypeOfType(type, 1) && !getIndexTypeOfType(type, 0);
+ function isInsideFunction(node, threshold) {
+ return !!ts.findAncestor(node, function (n) { return n === threshold ? "quit" : ts.isFunctionLike(n); });
}
- function isForInVariableForNumericPropertyNames(expr) {
- var e = ts.skipParentheses(expr);
- if (e.kind === 75) {
- var symbol = getResolvedSymbol(e);
- if (symbol.flags & 3) {
- var child = expr;
- var node = expr.parent;
- while (node) {
- if (node.kind === 231 &&
- child === node.statement &&
- getForInVariableSymbol(node) === symbol &&
- hasNumericPropertyNames(getTypeOfExpression(node.expression))) {
- return true;
+ function getPartOfForStatementContainingNode(node, container) {
+ return ts.findAncestor(node, function (n) { return n === container ? "quit" : n === container.initializer || n === container.condition || n === container.incrementor || n === container.statement; });
+ }
+ function checkNestedBlockScopedBinding(node, symbol) {
+ if (languageVersion >= 2 ||
+ (symbol.flags & (2 | 32)) === 0 ||
+ ts.isSourceFile(symbol.valueDeclaration) ||
+ symbol.valueDeclaration.parent.kind === 287) {
+ return;
+ }
+ var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration);
+ var usedInFunction = isInsideFunction(node.parent, container);
+ var current = container;
+ var containedInIterationStatement = false;
+ while (current && !ts.nodeStartsNewLexicalEnvironment(current)) {
+ if (ts.isIterationStatement(current, false)) {
+ containedInIterationStatement = true;
+ break;
+ }
+ current = current.parent;
+ }
+ if (containedInIterationStatement) {
+ if (usedInFunction) {
+ var capturesBlockScopeBindingInLoopBody = true;
+ if (ts.isForStatement(container)) {
+ var varDeclList = ts.getAncestor(symbol.valueDeclaration, 250);
+ if (varDeclList && varDeclList.parent === container) {
+ var part = getPartOfForStatementContainingNode(node.parent, container);
+ if (part) {
+ var links = getNodeLinks(part);
+ links.flags |= 131072;
+ var capturedBindings = links.capturedBlockScopeBindings || (links.capturedBlockScopeBindings = []);
+ ts.pushIfUnique(capturedBindings, symbol);
+ if (part === container.initializer) {
+ capturesBlockScopeBindingInLoopBody = false;
+ }
+ }
}
- child = node;
- node = node.parent;
+ }
+ if (capturesBlockScopeBindingInLoopBody) {
+ getNodeLinks(current).flags |= 65536;
}
}
+ if (ts.isForStatement(container)) {
+ var varDeclList = ts.getAncestor(symbol.valueDeclaration, 250);
+ if (varDeclList && varDeclList.parent === container && isAssignedInBodyOfForStatement(node, container)) {
+ getNodeLinks(symbol.valueDeclaration).flags |= 4194304;
+ }
+ }
+ getNodeLinks(symbol.valueDeclaration).flags |= 524288;
}
- return false;
- }
- function checkIndexedAccess(node) {
- return node.flags & 32 ? checkElementAccessChain(node) :
- checkElementAccessExpression(node, checkNonNullExpression(node.expression));
- }
- function checkElementAccessChain(node) {
- var exprType = checkExpression(node.expression);
- var nonOptionalType = getOptionalExpressionType(exprType, node.expression);
- return propagateOptionalTypeMarker(checkElementAccessExpression(node, checkNonNullType(nonOptionalType, node.expression)), node, nonOptionalType !== exprType);
- }
- function checkElementAccessExpression(node, exprType) {
- var objectType = ts.getAssignmentTargetKind(node) !== 0 || isMethodAccessForCall(node) ? getWidenedType(exprType) : exprType;
- var indexExpression = node.argumentExpression;
- var indexType = checkExpression(indexExpression);
- if (objectType === errorType || objectType === silentNeverType) {
- return objectType;
- }
- if (isConstEnumObjectType(objectType) && !ts.isStringLiteralLike(indexExpression)) {
- error(indexExpression, ts.Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
- return errorType;
+ if (usedInFunction) {
+ getNodeLinks(symbol.valueDeclaration).flags |= 262144;
}
- var effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
- var accessFlags = ts.isAssignmentTarget(node) ?
- 2 | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 1 : 0) :
- 0;
- var indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, node, accessFlags) || errorType;
- return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, indexedAccessType.symbol, indexedAccessType, indexExpression), node);
}
- function checkThatExpressionIsProperSymbolReference(expression, expressionType, reportError) {
- if (expressionType === errorType) {
- return false;
+ function isBindingCapturedByNode(node, decl) {
+ var links = getNodeLinks(node);
+ return !!links && ts.contains(links.capturedBlockScopeBindings, getSymbolOfNode(decl));
+ }
+ function isAssignedInBodyOfForStatement(node, container) {
+ var current = node;
+ while (current.parent.kind === 207) {
+ current = current.parent;
}
- if (!ts.isWellKnownSymbolSyntactically(expression)) {
- return false;
+ var isAssigned = false;
+ if (ts.isAssignmentTarget(current)) {
+ isAssigned = true;
}
- if ((expressionType.flags & 12288) === 0) {
- if (reportError) {
- error(expression, ts.Diagnostics.A_computed_property_name_of_the_form_0_must_be_of_type_symbol, ts.getTextOfNode(expression));
- }
- return false;
+ else if ((current.parent.kind === 214 || current.parent.kind === 215)) {
+ var expr = current.parent;
+ isAssigned = expr.operator === 45 || expr.operator === 46;
}
- var leftHandSide = expression.expression;
- var leftHandSideSymbol = getResolvedSymbol(leftHandSide);
- if (!leftHandSideSymbol) {
+ if (!isAssigned) {
return false;
}
- var globalESSymbol = getGlobalESSymbolConstructorSymbol(true);
- if (!globalESSymbol) {
- return false;
+ return !!ts.findAncestor(current, function (n) { return n === container ? "quit" : n === container.statement; });
+ }
+ function captureLexicalThis(node, container) {
+ getNodeLinks(node).flags |= 2;
+ if (container.kind === 163 || container.kind === 166) {
+ var classNode = container.parent;
+ getNodeLinks(classNode).flags |= 4;
}
- if (leftHandSideSymbol !== globalESSymbol) {
- if (reportError) {
- error(leftHandSide, ts.Diagnostics.Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object);
- }
- return false;
+ else {
+ getNodeLinks(container).flags |= 4;
}
- return true;
}
- function callLikeExpressionMayHaveTypeArguments(node) {
- return ts.isCallOrNewExpression(node) || ts.isTaggedTemplateExpression(node) || ts.isJsxOpeningLikeElement(node);
+ function findFirstSuperCall(node) {
+ return ts.isSuperCall(node) ? node :
+ ts.isFunctionLike(node) ? undefined :
+ ts.forEachChild(node, findFirstSuperCall);
}
- function resolveUntypedCall(node) {
- if (callLikeExpressionMayHaveTypeArguments(node)) {
- ts.forEach(node.typeArguments, checkSourceElement);
- }
- if (node.kind === 198) {
- checkExpression(node.template);
+ function classDeclarationExtendsNull(classDecl) {
+ var classSymbol = getSymbolOfNode(classDecl);
+ var classInstanceType = getDeclaredTypeOfSymbol(classSymbol);
+ var baseConstructorType = getBaseConstructorTypeOfClass(classInstanceType);
+ return baseConstructorType === nullWideningType;
+ }
+ function checkThisBeforeSuper(node, container, diagnosticMessage) {
+ var containingClassDecl = container.parent;
+ var baseTypeNode = ts.getClassExtendsHeritageElement(containingClassDecl);
+ if (baseTypeNode && !classDeclarationExtendsNull(containingClassDecl)) {
+ if (node.flowNode && !isPostSuperFlowNode(node.flowNode, false)) {
+ error(node, diagnosticMessage);
+ }
}
- else if (ts.isJsxOpeningLikeElement(node)) {
- checkExpression(node.attributes);
+ }
+ function checkThisExpression(node) {
+ var container = ts.getThisContainer(node, true);
+ var capturedByArrowFunction = false;
+ if (container.kind === 166) {
+ checkThisBeforeSuper(node, container, ts.Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class);
}
- else if (node.kind !== 157) {
- ts.forEach(node.arguments, function (argument) {
- checkExpression(argument);
- });
+ if (container.kind === 209) {
+ container = ts.getThisContainer(container, false);
+ capturedByArrowFunction = true;
}
- return anySignature;
- }
- function resolveErrorCall(node) {
- resolveUntypedCall(node);
- return unknownSignature;
- }
- function reorderCandidates(signatures, result, callChainFlags) {
- var lastParent;
- var lastSymbol;
- var cutoffIndex = 0;
- var index;
- var specializedIndex = -1;
- var spliceIndex;
- ts.Debug.assert(!result.length);
- for (var _i = 0, signatures_7 = signatures; _i < signatures_7.length; _i++) {
- var signature = signatures_7[_i];
- var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
- var parent = signature.declaration && signature.declaration.parent;
- if (!lastSymbol || symbol === lastSymbol) {
- if (lastParent && parent === lastParent) {
- index = index + 1;
+ switch (container.kind) {
+ case 256:
+ error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body);
+ break;
+ case 255:
+ error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location);
+ break;
+ case 166:
+ if (isInConstructorArgumentInitializer(node, container)) {
+ error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments);
}
- else {
- lastParent = parent;
- index = cutoffIndex;
+ break;
+ case 163:
+ case 162:
+ if (ts.hasSyntacticModifier(container, 32) && !(compilerOptions.target === 99 && compilerOptions.useDefineForClassFields)) {
+ error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer);
}
+ break;
+ case 158:
+ error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name);
+ break;
+ }
+ if (capturedByArrowFunction && languageVersion < 2) {
+ captureLexicalThis(node, container);
+ }
+ var type = tryGetThisTypeAt(node, true, container);
+ if (noImplicitThis) {
+ var globalThisType_1 = getTypeOfSymbol(globalThisSymbol);
+ if (type === globalThisType_1 && capturedByArrowFunction) {
+ error(node, ts.Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this);
}
- else {
- index = cutoffIndex = result.length;
- lastParent = parent;
- }
- lastSymbol = symbol;
- if (signatureHasLiteralTypes(signature)) {
- specializedIndex++;
- spliceIndex = specializedIndex;
- cutoffIndex++;
- }
- else {
- spliceIndex = index;
+ else if (!type) {
+ var diag = error(node, ts.Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);
+ if (!ts.isSourceFile(container)) {
+ var outsideThis = tryGetThisTypeAt(container);
+ if (outsideThis && outsideThis !== globalThisType_1) {
+ ts.addRelatedInfo(diag, ts.createDiagnosticForNode(container, ts.Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container));
+ }
+ }
}
- result.splice(spliceIndex, 0, callChainFlags ? getOptionalCallSignature(signature, callChainFlags) : signature);
}
+ return type || anyType;
}
- function isSpreadArgument(arg) {
- return !!arg && (arg.kind === 213 || arg.kind === 220 && arg.isSpread);
- }
- function getSpreadArgumentIndex(args) {
- return ts.findIndex(args, isSpreadArgument);
- }
- function acceptsVoid(t) {
- return !!(t.flags & 16384);
- }
- function hasCorrectArity(node, args, signature, signatureHelpTrailingComma) {
- if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; }
- var argCount;
- var callIsIncomplete = false;
- var effectiveParameterCount = getParameterCount(signature);
- var effectiveMinimumArguments = getMinArgumentCount(signature);
- if (node.kind === 198) {
- argCount = args.length;
- if (node.template.kind === 211) {
- var lastSpan = ts.last(node.template.templateSpans);
- callIsIncomplete = ts.nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated;
+ function tryGetThisTypeAt(node, includeGlobalThis, container) {
+ if (includeGlobalThis === void 0) { includeGlobalThis = true; }
+ if (container === void 0) { container = ts.getThisContainer(node, false); }
+ var isInJS = ts.isInJSFile(node);
+ if (ts.isFunctionLike(container) &&
+ (!isInParameterInitializerBeforeContainingFunction(node) || ts.getThisParameter(container))) {
+ var thisType = getThisTypeOfDeclaration(container) || isInJS && getTypeForThisExpressionFromJSDoc(container);
+ if (!thisType) {
+ var className = getClassNameFromPrototypeMethod(container);
+ if (isInJS && className) {
+ var classSymbol = checkExpression(className).symbol;
+ if (classSymbol && classSymbol.members && (classSymbol.flags & 16)) {
+ thisType = getDeclaredTypeOfSymbol(classSymbol).thisType;
+ }
+ }
+ else if (isJSConstructor(container)) {
+ thisType = getDeclaredTypeOfSymbol(getMergedSymbol(container.symbol)).thisType;
+ }
+ thisType || (thisType = getContextualThisParameterType(container));
}
- else {
- var templateLiteral = node.template;
- ts.Debug.assert(templateLiteral.kind === 14);
- callIsIncomplete = !!templateLiteral.isUnterminated;
+ if (thisType) {
+ return getFlowTypeOfReference(node, thisType);
}
}
- else if (node.kind === 157) {
- argCount = getDecoratorArgumentCount(node, signature);
- }
- else if (ts.isJsxOpeningLikeElement(node)) {
- callIsIncomplete = node.attributes.end === node.end;
- if (callIsIncomplete) {
- return true;
- }
- argCount = effectiveMinimumArguments === 0 ? args.length : 1;
- effectiveParameterCount = args.length === 0 ? effectiveParameterCount : 1;
- effectiveMinimumArguments = Math.min(effectiveMinimumArguments, 1);
+ if (ts.isClassLike(container.parent)) {
+ var symbol = getSymbolOfNode(container.parent);
+ var type = ts.hasSyntacticModifier(container, 32) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
+ return getFlowTypeOfReference(node, type);
}
- else {
- if (!node.arguments) {
- ts.Debug.assert(node.kind === 197);
- return getMinArgumentCount(signature) === 0;
+ if (ts.isSourceFile(container)) {
+ if (container.commonJsModuleIndicator) {
+ var fileSymbol = getSymbolOfNode(container);
+ return fileSymbol && getTypeOfSymbol(fileSymbol);
}
- argCount = signatureHelpTrailingComma ? args.length + 1 : args.length;
- callIsIncomplete = node.arguments.end === node.end;
- var spreadArgIndex = getSpreadArgumentIndex(args);
- if (spreadArgIndex >= 0) {
- return spreadArgIndex >= getMinArgumentCount(signature) && (hasEffectiveRestParameter(signature) || spreadArgIndex < getParameterCount(signature));
+ else if (container.externalModuleIndicator) {
+ return undefinedType;
}
- }
- if (!hasEffectiveRestParameter(signature) && argCount > effectiveParameterCount) {
- return false;
- }
- if (callIsIncomplete || argCount >= effectiveMinimumArguments) {
- return true;
- }
- for (var i = argCount; i < effectiveMinimumArguments; i++) {
- var type = getTypeAtPosition(signature, i);
- if (filterType(type, acceptsVoid).flags & 131072) {
- return false;
+ else if (includeGlobalThis) {
+ return getTypeOfSymbol(globalThisSymbol);
}
}
- return true;
- }
- function hasCorrectTypeArgumentArity(signature, typeArguments) {
- var numTypeParameters = ts.length(signature.typeParameters);
- var minTypeArgumentCount = getMinTypeArgumentCount(signature.typeParameters);
- return !ts.some(typeArguments) ||
- (typeArguments.length >= minTypeArgumentCount && typeArguments.length <= numTypeParameters);
- }
- function getSingleCallSignature(type) {
- return getSingleSignature(type, 0, false);
- }
- function getSingleCallOrConstructSignature(type) {
- return getSingleSignature(type, 0, false) ||
- getSingleSignature(type, 1, false);
}
- function getSingleSignature(type, kind, allowMembers) {
- if (type.flags & 524288) {
- var resolved = resolveStructuredTypeMembers(type);
- if (allowMembers || resolved.properties.length === 0 && !resolved.stringIndexInfo && !resolved.numberIndexInfo) {
- if (kind === 0 && resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0) {
- return resolved.callSignatures[0];
- }
- if (kind === 1 && resolved.constructSignatures.length === 1 && resolved.callSignatures.length === 0) {
- return resolved.constructSignatures[0];
- }
+ function getExplicitThisType(node) {
+ var container = ts.getThisContainer(node, false);
+ if (ts.isFunctionLike(container)) {
+ var signature = getSignatureFromDeclaration(container);
+ if (signature.thisParameter) {
+ return getExplicitTypeOfSymbol(signature.thisParameter);
}
}
- return undefined;
- }
- function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
- var context = createInferenceContext(signature.typeParameters, signature, 0, compareTypes);
- var restType = getEffectiveRestType(contextualSignature);
- var mapper = inferenceContext && (restType && restType.flags & 262144 ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
- var sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
- applyToParameterTypes(sourceSignature, signature, function (source, target) {
- inferTypes(context.inferences, source, target);
- });
- if (!inferenceContext) {
- applyToReturnTypes(contextualSignature, signature, function (source, target) {
- inferTypes(context.inferences, source, target, 32);
- });
+ if (ts.isClassLike(container.parent)) {
+ var symbol = getSymbolOfNode(container.parent);
+ return ts.hasSyntacticModifier(container, 32) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
}
- return getSignatureInstantiation(signature, getInferredTypes(context), ts.isInJSFile(contextualSignature.declaration));
- }
- function inferJsxTypeArguments(node, signature, checkMode, context) {
- var paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
- var checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode);
- inferTypes(context.inferences, checkAttrType, paramType);
- return getInferredTypes(context);
}
- function inferTypeArguments(node, signature, args, checkMode, context) {
- if (ts.isJsxOpeningLikeElement(node)) {
- return inferJsxTypeArguments(node, signature, checkMode, context);
+ function getClassNameFromPrototypeMethod(container) {
+ if (container.kind === 208 &&
+ ts.isBinaryExpression(container.parent) &&
+ ts.getAssignmentDeclarationKind(container.parent) === 3) {
+ return container.parent
+ .left
+ .expression
+ .expression;
}
- if (node.kind !== 157) {
- var contextualType = getContextualType(node);
- if (contextualType) {
- var outerContext = getInferenceContext(node);
- var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1));
- var instantiatedType = instantiateType(contextualType, outerMapper);
- var contextualSignature = getSingleCallSignature(instantiatedType);
- var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
- getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
- instantiatedType;
- var inferenceTargetType = getReturnTypeOfSignature(signature);
- inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 32);
- var returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
- var returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
- inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
- context.returnMapper = ts.some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : undefined;
- }
+ else if (container.kind === 165 &&
+ container.parent.kind === 200 &&
+ ts.isBinaryExpression(container.parent.parent) &&
+ ts.getAssignmentDeclarationKind(container.parent.parent) === 6) {
+ return container.parent.parent.left.expression;
}
- var thisType = getThisTypeOfSignature(signature);
- if (thisType) {
- var thisArgumentNode = getThisArgumentOfCall(node);
- var thisArgumentType = thisArgumentNode ? checkExpression(thisArgumentNode) : voidType;
- inferTypes(context.inferences, thisArgumentType, thisType);
+ else if (container.kind === 208 &&
+ container.parent.kind === 288 &&
+ container.parent.parent.kind === 200 &&
+ ts.isBinaryExpression(container.parent.parent.parent) &&
+ ts.getAssignmentDeclarationKind(container.parent.parent.parent) === 6) {
+ return container.parent.parent.parent.left.expression;
}
- var restType = getNonArrayRestType(signature);
- var argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length;
- for (var i = 0; i < argCount; i++) {
- var arg = args[i];
- if (arg.kind !== 215) {
- var paramType = getTypeAtPosition(signature, i);
- var argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
- inferTypes(context.inferences, argType, paramType);
+ else if (container.kind === 208 &&
+ ts.isPropertyAssignment(container.parent) &&
+ ts.isIdentifier(container.parent.name) &&
+ (container.parent.name.escapedText === "value" || container.parent.name.escapedText === "get" || container.parent.name.escapedText === "set") &&
+ ts.isObjectLiteralExpression(container.parent.parent) &&
+ ts.isCallExpression(container.parent.parent.parent) &&
+ container.parent.parent.parent.arguments[2] === container.parent.parent &&
+ ts.getAssignmentDeclarationKind(container.parent.parent.parent) === 9) {
+ return container.parent.parent.parent.arguments[0].expression;
+ }
+ else if (ts.isMethodDeclaration(container) &&
+ ts.isIdentifier(container.name) &&
+ (container.name.escapedText === "value" || container.name.escapedText === "get" || container.name.escapedText === "set") &&
+ ts.isObjectLiteralExpression(container.parent) &&
+ ts.isCallExpression(container.parent.parent) &&
+ container.parent.parent.arguments[2] === container.parent &&
+ ts.getAssignmentDeclarationKind(container.parent.parent) === 9) {
+ return container.parent.parent.arguments[0].expression;
+ }
+ }
+ function getTypeForThisExpressionFromJSDoc(node) {
+ var jsdocType = ts.getJSDocType(node);
+ if (jsdocType && jsdocType.kind === 308) {
+ var jsDocFunctionType = jsdocType;
+ if (jsDocFunctionType.parameters.length > 0 &&
+ jsDocFunctionType.parameters[0].name &&
+ jsDocFunctionType.parameters[0].name.escapedText === "this") {
+ return getTypeFromTypeNode(jsDocFunctionType.parameters[0].type);
}
}
- if (restType) {
- var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context);
- inferTypes(context.inferences, spreadType, restType);
+ var thisTag = ts.getJSDocThisTag(node);
+ if (thisTag && thisTag.typeExpression) {
+ return getTypeFromTypeNode(thisTag.typeExpression);
}
- return getInferredTypes(context);
}
- function getArrayifiedType(type) {
- return type.flags & 1048576 ? mapType(type, getArrayifiedType) :
- type.flags & (1 | 63176704) || isMutableArrayOrTuple(type) ? type :
- isTupleType(type) ? createTupleType(getTypeArguments(type), type.target.minLength, type.target.hasRestElement, false, type.target.associatedNames) :
- createArrayType(getIndexedAccessType(type, numberType));
+ function isInConstructorArgumentInitializer(node, constructorDecl) {
+ return !!ts.findAncestor(node, function (n) { return ts.isFunctionLikeDeclaration(n) ? "quit" : n.kind === 160 && n.parent === constructorDecl; });
}
- function getSpreadArgumentType(args, index, argCount, restType, context) {
- if (index >= argCount - 1) {
- var arg = args[argCount - 1];
- if (isSpreadArgument(arg)) {
- return arg.kind === 220 ?
- createArrayType(arg.type) :
- getArrayifiedType(checkExpressionWithContextualType(arg.expression, restType, context, 0));
+ function checkSuperExpression(node) {
+ var isCallExpression = node.parent.kind === 203 && node.parent.expression === node;
+ var immediateContainer = ts.getSuperContainer(node, true);
+ var container = immediateContainer;
+ var needToCaptureLexicalThis = false;
+ if (!isCallExpression) {
+ while (container && container.kind === 209) {
+ container = ts.getSuperContainer(container, true);
+ needToCaptureLexicalThis = languageVersion < 2;
}
}
- var types = [];
- var spreadIndex = -1;
- for (var i = index; i < argCount; i++) {
- var contextualType = getIndexedAccessType(restType, getLiteralType(i - index));
- var argType = checkExpressionWithContextualType(args[i], contextualType, context, 0);
- if (spreadIndex < 0 && isSpreadArgument(args[i])) {
- spreadIndex = i - index;
+ var canUseSuperExpression = isLegalUsageOfSuperExpression(container);
+ var nodeCheckFlag = 0;
+ if (!canUseSuperExpression) {
+ var current = ts.findAncestor(node, function (n) { return n === container ? "quit" : n.kind === 158; });
+ if (current && current.kind === 158) {
+ error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);
}
- var hasPrimitiveContextualType = maybeTypeOfKind(contextualType, 131068 | 4194304);
- types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
- }
- return spreadIndex < 0 ?
- createTupleType(types) :
- createTupleType(ts.append(types.slice(0, spreadIndex), getUnionType(types.slice(spreadIndex))), spreadIndex, true);
- }
- function checkTypeArguments(signature, typeArgumentNodes, reportErrors, headMessage) {
- var isJavascript = ts.isInJSFile(signature.declaration);
- var typeParameters = signature.typeParameters;
- var typeArgumentTypes = fillMissingTypeArguments(ts.map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript);
- var mapper;
- for (var i = 0; i < typeArgumentNodes.length; i++) {
- ts.Debug.assert(typeParameters[i] !== undefined, "Should not call checkTypeArguments with too many type arguments");
- var constraint = getConstraintOfTypeParameter(typeParameters[i]);
- if (constraint) {
- var errorInfo = reportErrors && headMessage ? (function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); }) : undefined;
- var typeArgumentHeadMessage = headMessage || ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1;
- if (!mapper) {
- mapper = createTypeMapper(typeParameters, typeArgumentTypes);
- }
- var typeArgument = typeArgumentTypes[i];
- if (!checkTypeAssignableTo(typeArgument, getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), reportErrors ? typeArgumentNodes[i] : undefined, typeArgumentHeadMessage, errorInfo)) {
- return undefined;
- }
+ else if (isCallExpression) {
+ error(node, ts.Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors);
+ }
+ else if (!container || !container.parent || !(ts.isClassLike(container.parent) || container.parent.kind === 200)) {
+ error(node, ts.Diagnostics.super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions);
+ }
+ else {
+ error(node, ts.Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class);
}
+ return errorType;
}
- return typeArgumentTypes;
- }
- function getJsxReferenceKind(node) {
- if (isJsxIntrinsicIdentifier(node.tagName)) {
- return 2;
+ if (!isCallExpression && immediateContainer.kind === 166) {
+ checkThisBeforeSuper(node, container, ts.Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class);
}
- var tagType = getApparentType(checkExpression(node.tagName));
- if (ts.length(getSignaturesOfType(tagType, 1))) {
- return 0;
+ if (ts.hasSyntacticModifier(container, 32) || isCallExpression) {
+ nodeCheckFlag = 512;
}
- if (ts.length(getSignaturesOfType(tagType, 0))) {
- return 1;
+ else {
+ nodeCheckFlag = 256;
}
- return 2;
- }
- function checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors, containingMessageChain, errorOutputContainer) {
- var paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
- var attributesType = checkExpressionWithContextualType(node.attributes, paramType, undefined, checkMode);
- return checkTagNameDoesNotExpectTooManyArguments() && checkTypeRelatedToAndOptionallyElaborate(attributesType, paramType, relation, reportErrors ? node.tagName : undefined, node.attributes, undefined, containingMessageChain, errorOutputContainer);
- function checkTagNameDoesNotExpectTooManyArguments() {
- var _a;
- var tagType = ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node) && !isJsxIntrinsicIdentifier(node.tagName) ? checkExpression(node.tagName) : undefined;
- if (!tagType) {
- return true;
- }
- var tagCallSignatures = getSignaturesOfType(tagType, 0);
- if (!ts.length(tagCallSignatures)) {
- return true;
- }
- var factory = getJsxFactoryEntity(node);
- if (!factory) {
- return true;
- }
- var factorySymbol = resolveEntityName(factory, 111551, true, false, node);
- if (!factorySymbol) {
- return true;
+ getNodeLinks(node).flags |= nodeCheckFlag;
+ if (container.kind === 165 && ts.hasSyntacticModifier(container, 256)) {
+ if (ts.isSuperProperty(node.parent) && ts.isAssignmentTarget(node.parent)) {
+ getNodeLinks(container).flags |= 4096;
}
- var factoryType = getTypeOfSymbol(factorySymbol);
- var callSignatures = getSignaturesOfType(factoryType, 0);
- if (!ts.length(callSignatures)) {
- return true;
+ else {
+ getNodeLinks(container).flags |= 2048;
}
- var hasFirstParamSignatures = false;
- var maxParamCount = 0;
- for (var _i = 0, callSignatures_1 = callSignatures; _i < callSignatures_1.length; _i++) {
- var sig = callSignatures_1[_i];
- var firstparam = getTypeAtPosition(sig, 0);
- var signaturesOfParam = getSignaturesOfType(firstparam, 0);
- if (!ts.length(signaturesOfParam))
- continue;
- for (var _b = 0, signaturesOfParam_1 = signaturesOfParam; _b < signaturesOfParam_1.length; _b++) {
- var paramSig = signaturesOfParam_1[_b];
- hasFirstParamSignatures = true;
- if (hasEffectiveRestParameter(paramSig)) {
- return true;
- }
- var paramCount = getParameterCount(paramSig);
- if (paramCount > maxParamCount) {
- maxParamCount = paramCount;
- }
- }
+ }
+ if (needToCaptureLexicalThis) {
+ captureLexicalThis(node.parent, container);
+ }
+ if (container.parent.kind === 200) {
+ if (languageVersion < 2) {
+ error(node, ts.Diagnostics.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher);
+ return errorType;
}
- if (!hasFirstParamSignatures) {
- return true;
+ else {
+ return anyType;
}
- var absoluteMinArgCount = Infinity;
- for (var _c = 0, tagCallSignatures_1 = tagCallSignatures; _c < tagCallSignatures_1.length; _c++) {
- var tagSig = tagCallSignatures_1[_c];
- var tagRequiredArgCount = getMinArgumentCount(tagSig);
- if (tagRequiredArgCount < absoluteMinArgCount) {
- absoluteMinArgCount = tagRequiredArgCount;
- }
+ }
+ var classLikeDeclaration = container.parent;
+ if (!ts.getClassExtendsHeritageElement(classLikeDeclaration)) {
+ error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class);
+ return errorType;
+ }
+ var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classLikeDeclaration));
+ var baseClassType = classType && getBaseTypes(classType)[0];
+ if (!baseClassType) {
+ return errorType;
+ }
+ if (container.kind === 166 && isInConstructorArgumentInitializer(node, container)) {
+ error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments);
+ return errorType;
+ }
+ return nodeCheckFlag === 512
+ ? getBaseConstructorTypeOfClass(classType)
+ : getTypeWithThisArgument(baseClassType, classType.thisType);
+ function isLegalUsageOfSuperExpression(container) {
+ if (!container) {
+ return false;
}
- if (absoluteMinArgCount <= maxParamCount) {
- return true;
+ if (isCallExpression) {
+ return container.kind === 166;
}
- if (reportErrors) {
- var diag = ts.createDiagnosticForNode(node.tagName, ts.Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, ts.entityNameToString(node.tagName), absoluteMinArgCount, ts.entityNameToString(factory), maxParamCount);
- var tagNameDeclaration = (_a = getSymbolAtLocation(node.tagName)) === null || _a === void 0 ? void 0 : _a.valueDeclaration;
- if (tagNameDeclaration) {
- ts.addRelatedInfo(diag, ts.createDiagnosticForNode(tagNameDeclaration, ts.Diagnostics._0_is_declared_here, ts.entityNameToString(node.tagName)));
- }
- if (errorOutputContainer && errorOutputContainer.skipLogging) {
- (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
- }
- if (!errorOutputContainer.skipLogging) {
- diagnostics.add(diag);
+ else {
+ if (ts.isClassLike(container.parent) || container.parent.kind === 200) {
+ if (ts.hasSyntacticModifier(container, 32)) {
+ return container.kind === 165 ||
+ container.kind === 164 ||
+ container.kind === 167 ||
+ container.kind === 168;
+ }
+ else {
+ return container.kind === 165 ||
+ container.kind === 164 ||
+ container.kind === 167 ||
+ container.kind === 168 ||
+ container.kind === 163 ||
+ container.kind === 162 ||
+ container.kind === 166;
+ }
}
}
return false;
}
}
- function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors, containingMessageChain) {
- var errorOutputContainer = { errors: undefined, skipLogging: true };
- if (ts.isJsxOpeningLikeElement(node)) {
- if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors, containingMessageChain, errorOutputContainer)) {
- ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "jsx should have errors when reporting errors");
- return errorOutputContainer.errors || ts.emptyArray;
- }
+ function getContainingObjectLiteral(func) {
+ return (func.kind === 165 ||
+ func.kind === 167 ||
+ func.kind === 168) && func.parent.kind === 200 ? func.parent :
+ func.kind === 208 && func.parent.kind === 288 ? func.parent.parent :
+ undefined;
+ }
+ function getThisTypeArgument(type) {
+ return ts.getObjectFlags(type) & 4 && type.target === globalThisType ? getTypeArguments(type)[0] : undefined;
+ }
+ function getThisTypeFromContextualType(type) {
+ return mapType(type, function (t) {
+ return t.flags & 2097152 ? ts.forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t);
+ });
+ }
+ function getContextualThisParameterType(func) {
+ if (func.kind === 209) {
return undefined;
}
- var thisType = getThisTypeOfSignature(signature);
- if (thisType && thisType !== voidType && node.kind !== 197) {
- var thisArgumentNode = getThisArgumentOfCall(node);
- var thisArgumentType = void 0;
- if (thisArgumentNode) {
- thisArgumentType = checkExpression(thisArgumentNode);
- if (ts.isOptionalChainRoot(thisArgumentNode.parent)) {
- thisArgumentType = getNonNullableType(thisArgumentType);
- }
- else if (ts.isOptionalChain(thisArgumentNode.parent)) {
- thisArgumentType = removeOptionalTypeMarker(thisArgumentType);
+ if (isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
+ var contextualSignature = getContextualSignature(func);
+ if (contextualSignature) {
+ var thisParameter = contextualSignature.thisParameter;
+ if (thisParameter) {
+ return getTypeOfSymbol(thisParameter);
}
}
- else {
- thisArgumentType = voidType;
- }
- var errorNode = reportErrors ? (thisArgumentNode || node) : undefined;
- var headMessage_1 = ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1;
- if (!checkTypeRelatedTo(thisArgumentType, thisType, relation, errorNode, headMessage_1, containingMessageChain, errorOutputContainer)) {
- ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "this parameter should have errors when reporting errors");
- return errorOutputContainer.errors || ts.emptyArray;
- }
}
- var headMessage = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1;
- var restType = getNonArrayRestType(signature);
- var argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length;
- for (var i = 0; i < argCount; i++) {
- var arg = args[i];
- if (arg.kind !== 215) {
- var paramType = getTypeAtPosition(signature, i);
- var argType = checkExpressionWithContextualType(arg, paramType, undefined, checkMode);
- var checkArgType = checkMode & 4 ? getRegularTypeOfObjectLiteral(argType) : argType;
- if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors ? arg : undefined, arg, headMessage, containingMessageChain, errorOutputContainer)) {
- ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
- maybeAddMissingAwaitInfo(arg, checkArgType, paramType);
- return errorOutputContainer.errors || ts.emptyArray;
+ var inJs = ts.isInJSFile(func);
+ if (noImplicitThis || inJs) {
+ var containingLiteral = getContainingObjectLiteral(func);
+ if (containingLiteral) {
+ var contextualType = getApparentTypeOfContextualType(containingLiteral);
+ var literal = containingLiteral;
+ var type = contextualType;
+ while (type) {
+ var thisType = getThisTypeFromContextualType(type);
+ if (thisType) {
+ return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
+ }
+ if (literal.parent.kind !== 288) {
+ break;
+ }
+ literal = literal.parent.parent;
+ type = getApparentTypeOfContextualType(literal);
}
+ return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral));
}
- }
- if (restType) {
- var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, undefined);
- var errorNode = reportErrors ? argCount < args.length ? args[argCount] : node : undefined;
- if (!checkTypeRelatedTo(spreadType, restType, relation, errorNode, headMessage, undefined, errorOutputContainer)) {
- ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "rest parameter should have errors when reporting errors");
- maybeAddMissingAwaitInfo(errorNode, spreadType, restType);
- return errorOutputContainer.errors || ts.emptyArray;
- }
- }
- return undefined;
- function maybeAddMissingAwaitInfo(errorNode, source, target) {
- if (errorNode && reportErrors && errorOutputContainer.errors && errorOutputContainer.errors.length) {
- if (getAwaitedTypeOfPromise(target)) {
- return;
- }
- var awaitedTypeOfSource = getAwaitedTypeOfPromise(source);
- if (awaitedTypeOfSource && isTypeRelatedTo(awaitedTypeOfSource, target, relation)) {
- ts.addRelatedInfo(errorOutputContainer.errors[0], ts.createDiagnosticForNode(errorNode, ts.Diagnostics.Did_you_forget_to_use_await));
+ var parent = ts.walkUpParenthesizedExpressions(func.parent);
+ if (parent.kind === 216 && parent.operatorToken.kind === 62) {
+ var target = parent.left;
+ if (ts.isAccessExpression(target)) {
+ var expression = target.expression;
+ if (inJs && ts.isIdentifier(expression)) {
+ var sourceFile = ts.getSourceFileOfNode(parent);
+ if (sourceFile.commonJsModuleIndicator && getResolvedSymbol(expression) === sourceFile.symbol) {
+ return undefined;
+ }
+ }
+ return getWidenedType(checkExpressionCached(expression));
}
}
}
+ return undefined;
}
- function getThisArgumentOfCall(node) {
- if (node.kind === 196) {
- var callee = ts.skipOuterExpressions(node.expression);
- if (ts.isAccessExpression(callee)) {
- return callee.expression;
- }
+ function getContextuallyTypedParameterType(parameter) {
+ var func = parameter.parent;
+ if (!isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
+ return undefined;
}
- }
- function createSyntheticExpression(parent, type, isSpread) {
- var result = ts.createNode(220, parent.pos, parent.end);
- result.parent = parent;
- result.type = type;
- result.isSpread = isSpread || false;
- return result;
- }
- function getEffectiveCallArguments(node) {
- if (node.kind === 198) {
- var template = node.template;
- var args_3 = [createSyntheticExpression(template, getGlobalTemplateStringsArrayType())];
- if (template.kind === 211) {
- ts.forEach(template.templateSpans, function (span) {
- args_3.push(span.expression);
- });
+ var iife = ts.getImmediatelyInvokedFunctionExpression(func);
+ if (iife && iife.arguments) {
+ var args = getEffectiveCallArguments(iife);
+ var indexOfParameter = func.parameters.indexOf(parameter);
+ if (parameter.dotDotDotToken) {
+ return getSpreadArgumentType(args, indexOfParameter, args.length, anyType, undefined, 0);
}
- return args_3;
- }
- if (node.kind === 157) {
- return getEffectiveDecoratorArguments(node);
- }
- if (ts.isJsxOpeningLikeElement(node)) {
- return node.attributes.properties.length > 0 || (ts.isJsxOpeningElement(node) && node.parent.children.length > 0) ? [node.attributes] : ts.emptyArray;
+ var links = getNodeLinks(iife);
+ var cached = links.resolvedSignature;
+ links.resolvedSignature = anySignature;
+ var type = indexOfParameter < args.length ?
+ getWidenedLiteralType(checkExpression(args[indexOfParameter])) :
+ parameter.initializer ? undefined : undefinedWideningType;
+ links.resolvedSignature = cached;
+ return type;
}
- var args = node.arguments || ts.emptyArray;
- var length = args.length;
- if (length && isSpreadArgument(args[length - 1]) && getSpreadArgumentIndex(args) === length - 1) {
- var spreadArgument_1 = args[length - 1];
- var type = flowLoopCount ? checkExpression(spreadArgument_1.expression) : checkExpressionCached(spreadArgument_1.expression);
- if (isTupleType(type)) {
- var typeArguments = getTypeArguments(type);
- var restIndex_2 = type.target.hasRestElement ? typeArguments.length - 1 : -1;
- var syntheticArgs = ts.map(typeArguments, function (t, i) { return createSyntheticExpression(spreadArgument_1, t, i === restIndex_2); });
- return ts.concatenate(args.slice(0, length - 1), syntheticArgs);
- }
+ var contextualSignature = getContextualSignature(func);
+ if (contextualSignature) {
+ var index = func.parameters.indexOf(parameter) - (ts.getThisParameter(func) ? 1 : 0);
+ return parameter.dotDotDotToken && ts.lastOrUndefined(func.parameters) === parameter ?
+ getRestTypeAtPosition(contextualSignature, index) :
+ tryGetTypeAtPosition(contextualSignature, index);
}
- return args;
}
- function getEffectiveDecoratorArguments(node) {
- var parent = node.parent;
- var expr = node.expression;
- switch (parent.kind) {
- case 245:
- case 214:
- return [
- createSyntheticExpression(expr, getTypeOfSymbol(getSymbolOfNode(parent)))
- ];
- case 156:
- var func = parent.parent;
- return [
- createSyntheticExpression(expr, parent.parent.kind === 162 ? getTypeOfSymbol(getSymbolOfNode(func)) : errorType),
- createSyntheticExpression(expr, anyType),
- createSyntheticExpression(expr, numberType)
- ];
- case 159:
- case 161:
- case 163:
- case 164:
- var hasPropDesc = parent.kind !== 159 && languageVersion !== 0;
- return [
- createSyntheticExpression(expr, getParentTypeOfClassElement(parent)),
- createSyntheticExpression(expr, getClassElementPropertyKeyType(parent)),
- createSyntheticExpression(expr, hasPropDesc ? createTypedPropertyDescriptorType(getTypeOfNode(parent)) : anyType)
- ];
+ function getContextualTypeForVariableLikeDeclaration(declaration) {
+ var typeNode = ts.getEffectiveTypeAnnotationNode(declaration);
+ if (typeNode) {
+ return getTypeFromTypeNode(typeNode);
}
- return ts.Debug.fail();
- }
- function getDecoratorArgumentCount(node, signature) {
- switch (node.parent.kind) {
- case 245:
- case 214:
- return 1;
- case 159:
- return 2;
- case 161:
+ switch (declaration.kind) {
+ case 160:
+ return getContextuallyTypedParameterType(declaration);
+ case 198:
+ return getContextualTypeForBindingElement(declaration);
case 163:
- case 164:
- return languageVersion === 0 || signature.parameters.length <= 2 ? 2 : 3;
- case 156:
- return 3;
- default:
- return ts.Debug.fail();
+ if (ts.hasSyntacticModifier(declaration, 32)) {
+ return getContextualTypeForStaticPropertyDeclaration(declaration);
+ }
}
}
- function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) {
- var start;
- var length;
- var sourceFile = ts.getSourceFileOfNode(node);
- if (ts.isPropertyAccessExpression(node.expression)) {
- var nameSpan = ts.getErrorSpanForNode(sourceFile, node.expression.name);
- start = nameSpan.start;
- length = doNotIncludeArguments ? nameSpan.length : node.end - start;
+ function getContextualTypeForBindingElement(declaration) {
+ var parent = declaration.parent.parent;
+ var name = declaration.propertyName || declaration.name;
+ var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
+ parent.kind !== 198 && parent.initializer && checkDeclarationInitializer(parent);
+ if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name))
+ return undefined;
+ if (parent.name.kind === 197) {
+ var index = ts.indexOfNode(declaration.parent.elements, declaration);
+ if (index < 0)
+ return undefined;
+ return getContextualTypeForElementExpression(parentType, index);
}
- else {
- var expressionSpan = ts.getErrorSpanForNode(sourceFile, node.expression);
- start = expressionSpan.start;
- length = doNotIncludeArguments ? expressionSpan.length : node.end - start;
+ var nameType = getLiteralTypeFromPropertyName(name);
+ if (isTypeUsableAsPropertyName(nameType)) {
+ var text = getPropertyNameFromType(nameType);
+ return getTypeOfPropertyOfType(parentType, text);
}
- return { start: start, length: length, sourceFile: sourceFile };
}
- function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) {
- if (ts.isCallExpression(node)) {
- var _a = getDiagnosticSpanForCallNode(node), sourceFile = _a.sourceFile, start = _a.start, length_5 = _a.length;
- return ts.createFileDiagnostic(sourceFile, start, length_5, message, arg0, arg1, arg2, arg3);
- }
- else {
- return ts.createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3);
- }
+ function getContextualTypeForStaticPropertyDeclaration(declaration) {
+ var parentType = ts.isExpression(declaration.parent) && getContextualType(declaration.parent);
+ if (!parentType)
+ return undefined;
+ return getTypeOfPropertyOfContextualType(parentType, getSymbolOfNode(declaration).escapedName);
}
- function getArgumentArityError(node, signatures, args) {
- var min = Number.POSITIVE_INFINITY;
- var max = Number.NEGATIVE_INFINITY;
- var belowArgCount = Number.NEGATIVE_INFINITY;
- var aboveArgCount = Number.POSITIVE_INFINITY;
- var argCount = args.length;
- var closestSignature;
- for (var _i = 0, signatures_8 = signatures; _i < signatures_8.length; _i++) {
- var sig = signatures_8[_i];
- var minCount = getMinArgumentCount(sig);
- var maxCount = getParameterCount(sig);
- if (minCount < argCount && minCount > belowArgCount)
- belowArgCount = minCount;
- if (argCount < maxCount && maxCount < aboveArgCount)
- aboveArgCount = maxCount;
- if (minCount < min) {
- min = minCount;
- closestSignature = sig;
+ function getContextualTypeForInitializerExpression(node, contextFlags) {
+ var declaration = node.parent;
+ if (ts.hasInitializer(declaration) && node === declaration.initializer) {
+ var result = getContextualTypeForVariableLikeDeclaration(declaration);
+ if (result) {
+ return result;
}
- max = Math.max(max, maxCount);
- }
- var hasRestParameter = ts.some(signatures, hasEffectiveRestParameter);
- var paramRange = hasRestParameter ? min :
- min < max ? min + "-" + max :
- min;
- var hasSpreadArgument = getSpreadArgumentIndex(args) > -1;
- if (argCount <= max && hasSpreadArgument) {
- argCount--;
- }
- var spanArray;
- var related;
- var error = hasRestParameter || hasSpreadArgument ? hasRestParameter && hasSpreadArgument ? ts.Diagnostics.Expected_at_least_0_arguments_but_got_1_or_more :
- hasRestParameter ? ts.Diagnostics.Expected_at_least_0_arguments_but_got_1 :
- ts.Diagnostics.Expected_0_arguments_but_got_1_or_more : ts.Diagnostics.Expected_0_arguments_but_got_1;
- if (closestSignature && getMinArgumentCount(closestSignature) > argCount && closestSignature.declaration) {
- var paramDecl = closestSignature.declaration.parameters[closestSignature.thisParameter ? argCount + 1 : argCount];
- if (paramDecl) {
- related = ts.createDiagnosticForNode(paramDecl, ts.isBindingPattern(paramDecl.name) ? ts.Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided : ts.Diagnostics.An_argument_for_0_was_not_provided, !paramDecl.name ? argCount : !ts.isBindingPattern(paramDecl.name) ? ts.idText(ts.getFirstIdentifier(paramDecl.name)) : undefined);
+ if (!(contextFlags & 8) && ts.isBindingPattern(declaration.name)) {
+ return getTypeFromBindingPattern(declaration.name, true, false);
}
}
- if (min < argCount && argCount < max) {
- return getDiagnosticForCallNode(node, ts.Diagnostics.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments, argCount, belowArgCount, aboveArgCount);
- }
- if (!hasSpreadArgument && argCount < min) {
- var diagnostic_1 = getDiagnosticForCallNode(node, error, paramRange, argCount);
- return related ? ts.addRelatedInfo(diagnostic_1, related) : diagnostic_1;
- }
- if (hasRestParameter || hasSpreadArgument) {
- spanArray = ts.createNodeArray(args);
- if (hasSpreadArgument && argCount) {
- var nextArg = ts.elementAt(args, getSpreadArgumentIndex(args) + 1) || undefined;
- spanArray = ts.createNodeArray(args.slice(max > argCount && nextArg ? args.indexOf(nextArg) : Math.min(max, args.length - 1)));
+ return undefined;
+ }
+ function getContextualTypeForReturnExpression(node) {
+ var func = ts.getContainingFunction(node);
+ if (func) {
+ var contextualReturnType = getContextualReturnType(func);
+ if (contextualReturnType) {
+ var functionFlags = ts.getFunctionFlags(func);
+ if (functionFlags & 1) {
+ var use = functionFlags & 2 ? 2 : 1;
+ var iterationTypes = getIterationTypesOfIterable(contextualReturnType, use, undefined);
+ if (!iterationTypes) {
+ return undefined;
+ }
+ contextualReturnType = iterationTypes.returnType;
+ }
+ if (functionFlags & 2) {
+ var contextualAwaitedType = mapType(contextualReturnType, getAwaitedType);
+ return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
+ }
+ return contextualReturnType;
}
}
- else {
- spanArray = ts.createNodeArray(args.slice(max));
- }
- spanArray.pos = ts.first(spanArray).pos;
- spanArray.end = ts.last(spanArray).end;
- if (spanArray.end === spanArray.pos) {
- spanArray.end++;
+ return undefined;
+ }
+ function getContextualTypeForAwaitOperand(node, contextFlags) {
+ var contextualType = getContextualType(node, contextFlags);
+ if (contextualType) {
+ var contextualAwaitedType = getAwaitedType(contextualType);
+ return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
}
- var diagnostic = ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), spanArray, error, paramRange, argCount);
- return related ? ts.addRelatedInfo(diagnostic, related) : diagnostic;
+ return undefined;
}
- function getTypeArgumentArityError(node, signatures, typeArguments) {
- var argCount = typeArguments.length;
- if (signatures.length === 1) {
- var sig = signatures[0];
- var min_1 = getMinTypeArgumentCount(sig.typeParameters);
- var max = ts.length(sig.typeParameters);
- return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, min_1 < max ? min_1 + "-" + max : min_1, argCount);
+ function getContextualTypeForYieldOperand(node) {
+ var func = ts.getContainingFunction(node);
+ if (func) {
+ var functionFlags = ts.getFunctionFlags(func);
+ var contextualReturnType = getContextualReturnType(func);
+ if (contextualReturnType) {
+ return node.asteriskToken
+ ? contextualReturnType
+ : getIterationTypeOfGeneratorFunctionReturnType(0, contextualReturnType, (functionFlags & 2) !== 0);
+ }
}
- var belowArgCount = -Infinity;
- var aboveArgCount = Infinity;
- for (var _i = 0, signatures_9 = signatures; _i < signatures_9.length; _i++) {
- var sig = signatures_9[_i];
- var min_2 = getMinTypeArgumentCount(sig.typeParameters);
- var max = ts.length(sig.typeParameters);
- if (min_2 > argCount) {
- aboveArgCount = Math.min(aboveArgCount, min_2);
+ return undefined;
+ }
+ function isInParameterInitializerBeforeContainingFunction(node) {
+ var inBindingInitializer = false;
+ while (node.parent && !ts.isFunctionLike(node.parent)) {
+ if (ts.isParameter(node.parent) && (inBindingInitializer || node.parent.initializer === node)) {
+ return true;
}
- else if (max < argCount) {
- belowArgCount = Math.max(belowArgCount, max);
+ if (ts.isBindingElement(node.parent) && node.parent.initializer === node) {
+ inBindingInitializer = true;
}
+ node = node.parent;
}
- if (belowArgCount !== -Infinity && aboveArgCount !== Infinity) {
- return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, argCount, belowArgCount, aboveArgCount);
+ return false;
+ }
+ function getContextualIterationType(kind, functionDecl) {
+ var isAsync = !!(ts.getFunctionFlags(functionDecl) & 2);
+ var contextualReturnType = getContextualReturnType(functionDecl);
+ if (contextualReturnType) {
+ return getIterationTypeOfGeneratorFunctionReturnType(kind, contextualReturnType, isAsync)
+ || undefined;
}
- return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, belowArgCount === -Infinity ? aboveArgCount : belowArgCount, argCount);
+ return undefined;
}
- function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, fallbackError) {
- var isTaggedTemplate = node.kind === 198;
- var isDecorator = node.kind === 157;
- var isJsxOpeningOrSelfClosingElement = ts.isJsxOpeningLikeElement(node);
- var reportErrors = !candidatesOutArray;
- var typeArguments;
- if (!isDecorator) {
- typeArguments = node.typeArguments;
- if (isTaggedTemplate || isJsxOpeningOrSelfClosingElement || node.expression.kind !== 102) {
- ts.forEach(typeArguments, checkSourceElement);
- }
+ function getContextualReturnType(functionDecl) {
+ var returnType = getReturnTypeFromAnnotation(functionDecl);
+ if (returnType) {
+ return returnType;
}
- var candidates = candidatesOutArray || [];
- reorderCandidates(signatures, candidates, callChainFlags);
- if (!candidates.length) {
- if (reportErrors) {
- diagnostics.add(getDiagnosticForCallNode(node, ts.Diagnostics.Call_target_does_not_contain_any_signatures));
- }
- return resolveErrorCall(node);
+ var signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl);
+ if (signature && !isResolvingReturnTypeOfSignature(signature)) {
+ return getReturnTypeOfSignature(signature);
}
- var args = getEffectiveCallArguments(node);
- var isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
- var argCheckMode = !isDecorator && !isSingleNonGenericCandidate && ts.some(args, isContextSensitive) ? 4 : 0;
- var candidatesForArgumentError;
- var candidateForArgumentArityError;
- var candidateForTypeArgumentError;
- var result;
- var signatureHelpTrailingComma = !!(checkMode & 16) && node.kind === 196 && node.arguments.hasTrailingComma;
- if (candidates.length > 1) {
- result = chooseOverload(candidates, subtypeRelation, signatureHelpTrailingComma);
+ return undefined;
+ }
+ function getContextualTypeForArgument(callTarget, arg) {
+ var args = getEffectiveCallArguments(callTarget);
+ var argIndex = args.indexOf(arg);
+ return argIndex === -1 ? undefined : getContextualTypeForArgumentAtIndex(callTarget, argIndex);
+ }
+ function getContextualTypeForArgumentAtIndex(callTarget, argIndex) {
+ var signature = getNodeLinks(callTarget).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(callTarget);
+ if (ts.isJsxOpeningLikeElement(callTarget) && argIndex === 0) {
+ return getEffectiveFirstArgumentForJsxSignature(signature, callTarget);
}
- if (!result) {
- result = chooseOverload(candidates, assignableRelation, signatureHelpTrailingComma);
+ return getTypeAtPosition(signature, argIndex);
+ }
+ function getContextualTypeForSubstitutionExpression(template, substitutionExpression) {
+ if (template.parent.kind === 205) {
+ return getContextualTypeForArgument(template.parent, substitutionExpression);
}
- if (result) {
- return result;
+ return undefined;
+ }
+ function getContextualTypeForBinaryOperand(node, contextFlags) {
+ var binaryExpression = node.parent;
+ var left = binaryExpression.left, operatorToken = binaryExpression.operatorToken, right = binaryExpression.right;
+ switch (operatorToken.kind) {
+ case 62:
+ case 75:
+ case 74:
+ case 76:
+ return node === right ? getContextualTypeForAssignmentDeclaration(binaryExpression) : undefined;
+ case 56:
+ case 60:
+ var type = getContextualType(binaryExpression, contextFlags);
+ return node === right && (type && type.pattern || !type && !ts.isDefaultedExpandoInitializer(binaryExpression)) ?
+ getTypeOfExpression(left) : type;
+ case 55:
+ case 27:
+ return node === right ? getContextualType(binaryExpression, contextFlags) : undefined;
+ default:
+ return undefined;
}
- if (reportErrors) {
- if (candidatesForArgumentError) {
- if (candidatesForArgumentError.length === 1 || candidatesForArgumentError.length > 3) {
- var last_2 = candidatesForArgumentError[candidatesForArgumentError.length - 1];
- var chain_1;
- if (candidatesForArgumentError.length > 3) {
- chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.The_last_overload_gave_the_following_error);
- chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.No_overload_matches_this_call);
- }
- var diags = getSignatureApplicabilityError(node, args, last_2, assignableRelation, 0, true, function () { return chain_1; });
- if (diags) {
- for (var _i = 0, diags_1 = diags; _i < diags_1.length; _i++) {
- var d = diags_1[_i];
- if (last_2.declaration && candidatesForArgumentError.length > 3) {
- ts.addRelatedInfo(d, ts.createDiagnosticForNode(last_2.declaration, ts.Diagnostics.The_last_overload_is_declared_here));
- }
- diagnostics.add(d);
- }
+ }
+ function getContextualTypeForAssignmentDeclaration(binaryExpression) {
+ var kind = ts.getAssignmentDeclarationKind(binaryExpression);
+ switch (kind) {
+ case 0:
+ return getTypeOfExpression(binaryExpression.left);
+ case 5:
+ case 1:
+ case 6:
+ case 3:
+ if (isPossiblyAliasedThisProperty(binaryExpression, kind)) {
+ return getContextualTypeForThisPropertyAssignment(binaryExpression, kind);
+ }
+ else if (!binaryExpression.left.symbol) {
+ return getTypeOfExpression(binaryExpression.left);
+ }
+ else {
+ var decl = binaryExpression.left.symbol.valueDeclaration;
+ if (!decl) {
+ return undefined;
}
- else {
- ts.Debug.fail("No error for last overload signature");
+ var lhs = ts.cast(binaryExpression.left, ts.isAccessExpression);
+ var overallAnnotation = ts.getEffectiveTypeAnnotationNode(decl);
+ if (overallAnnotation) {
+ return getTypeFromTypeNode(overallAnnotation);
}
- }
- else {
- var allDiagnostics = [];
- var max = 0;
- var min_3 = Number.MAX_VALUE;
- var minIndex = 0;
- var i_1 = 0;
- var _loop_17 = function (c) {
- var chain_2 = function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); };
- var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0, true, chain_2);
- if (diags_2) {
- if (diags_2.length <= min_3) {
- min_3 = diags_2.length;
- minIndex = i_1;
+ else if (ts.isIdentifier(lhs.expression)) {
+ var id = lhs.expression;
+ var parentSymbol = resolveName(id, id.escapedText, 111551, undefined, id.escapedText, true);
+ if (parentSymbol) {
+ var annotated = parentSymbol.valueDeclaration && ts.getEffectiveTypeAnnotationNode(parentSymbol.valueDeclaration);
+ if (annotated) {
+ var nameStr = ts.getElementOrPropertyAccessName(lhs);
+ if (nameStr !== undefined) {
+ return getTypeOfPropertyOfContextualType(getTypeFromTypeNode(annotated), nameStr);
+ }
}
- max = Math.max(max, diags_2.length);
- allDiagnostics.push(diags_2);
- }
- else {
- ts.Debug.fail("No error for 3 or fewer overload signatures");
+ return undefined;
}
- i_1++;
- };
- for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
- var c = candidatesForArgumentError_1[_a];
- _loop_17(c);
- }
- var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
- ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
- var chain = ts.chainDiagnosticMessages(ts.map(diags_3, function (d) { return typeof d.messageText === "string" ? d : d.messageText; }), ts.Diagnostics.No_overload_matches_this_call);
- var related = ts.flatMap(diags_3, function (d) { return d.relatedInformation; });
- if (ts.every(diags_3, function (d) { return d.start === diags_3[0].start && d.length === diags_3[0].length && d.file === diags_3[0].file; })) {
- var _b = diags_3[0], file = _b.file, start = _b.start, length_6 = _b.length;
- diagnostics.add({ file: file, start: start, length: length_6, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related });
- }
- else {
- diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, chain, related));
}
+ return ts.isInJSFile(decl) ? undefined : getTypeOfExpression(binaryExpression.left);
}
- }
- else if (candidateForArgumentArityError) {
- diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args));
- }
- else if (candidateForTypeArgumentError) {
- checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, true, fallbackError);
- }
- else {
- var signaturesWithCorrectTypeArgumentArity = ts.filter(signatures, function (s) { return hasCorrectTypeArgumentArity(s, typeArguments); });
- if (signaturesWithCorrectTypeArgumentArity.length === 0) {
- diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments));
- }
- else if (!isDecorator) {
- diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args));
- }
- else if (fallbackError) {
- diagnostics.add(getDiagnosticForCallNode(node, fallbackError));
+ case 2:
+ case 4:
+ return getContextualTypeForThisPropertyAssignment(binaryExpression, kind);
+ case 7:
+ case 8:
+ case 9:
+ return ts.Debug.fail("Does not apply");
+ default:
+ return ts.Debug.assertNever(kind);
+ }
+ }
+ function isPossiblyAliasedThisProperty(declaration, kind) {
+ if (kind === void 0) { kind = ts.getAssignmentDeclarationKind(declaration); }
+ if (kind === 4) {
+ return true;
+ }
+ if (!ts.isInJSFile(declaration) || kind !== 5 || !ts.isIdentifier(declaration.left.expression)) {
+ return false;
+ }
+ var name = declaration.left.expression.escapedText;
+ var symbol = resolveName(declaration.left, name, 111551, undefined, undefined, true, true);
+ return ts.isThisInitializedDeclaration(symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration);
+ }
+ function getContextualTypeForThisPropertyAssignment(binaryExpression, kind) {
+ if (!binaryExpression.symbol)
+ return getTypeOfExpression(binaryExpression.left);
+ if (binaryExpression.symbol.valueDeclaration) {
+ var annotated = ts.getEffectiveTypeAnnotationNode(binaryExpression.symbol.valueDeclaration);
+ if (annotated) {
+ var type = getTypeFromTypeNode(annotated);
+ if (type) {
+ return type;
}
}
}
- return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray);
- function chooseOverload(candidates, relation, signatureHelpTrailingComma) {
- if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; }
- candidatesForArgumentError = undefined;
- candidateForArgumentArityError = undefined;
- candidateForTypeArgumentError = undefined;
- if (isSingleNonGenericCandidate) {
- var candidate = candidates[0];
- if (ts.some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) {
- return undefined;
- }
- if (getSignatureApplicabilityError(node, args, candidate, relation, 0, false, undefined)) {
- candidatesForArgumentError = [candidate];
- return undefined;
+ if (kind === 2)
+ return undefined;
+ var thisAccess = ts.cast(binaryExpression.left, ts.isAccessExpression);
+ if (!ts.isObjectLiteralMethod(ts.getThisContainer(thisAccess.expression, false))) {
+ return undefined;
+ }
+ var thisType = checkThisExpression(thisAccess.expression);
+ var nameStr = ts.getElementOrPropertyAccessName(thisAccess);
+ return nameStr !== undefined && getTypeOfPropertyOfContextualType(thisType, nameStr) || undefined;
+ }
+ function isCircularMappedProperty(symbol) {
+ return !!(ts.getCheckFlags(symbol) & 262144 && !symbol.type && findResolutionCycleStartIndex(symbol, 0) >= 0);
+ }
+ function getTypeOfPropertyOfContextualType(type, name) {
+ return mapType(type, function (t) {
+ if (isGenericMappedType(t)) {
+ var constraint = getConstraintTypeFromMappedType(t);
+ var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
+ var propertyNameType = getLiteralType(ts.unescapeLeadingUnderscores(name));
+ if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
+ return substituteIndexedMappedType(t, propertyNameType);
}
- return candidate;
}
- for (var candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
- var candidate = candidates[candidateIndex];
- if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) {
- continue;
- }
- var checkCandidate = void 0;
- var inferenceContext = void 0;
- if (candidate.typeParameters) {
- var typeArgumentTypes = void 0;
- if (ts.some(typeArguments)) {
- typeArgumentTypes = checkTypeArguments(candidate, typeArguments, false);
- if (!typeArgumentTypes) {
- candidateForTypeArgumentError = candidate;
- continue;
- }
- }
- else {
- inferenceContext = createInferenceContext(candidate.typeParameters, candidate, ts.isInJSFile(node) ? 2 : 0);
- typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8, inferenceContext);
- argCheckMode |= inferenceContext.flags & 4 ? 8 : 0;
- }
- checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
- if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) {
- candidateForArgumentArityError = checkCandidate;
- continue;
- }
- }
- else {
- checkCandidate = candidate;
- }
- if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, undefined)) {
- (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
- continue;
+ else if (t.flags & 3670016) {
+ var prop = getPropertyOfType(t, name);
+ if (prop) {
+ return isCircularMappedProperty(prop) ? undefined : getTypeOfSymbol(prop);
}
- if (argCheckMode) {
- argCheckMode = 0;
- if (inferenceContext) {
- var typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
- checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
- if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) {
- candidateForArgumentArityError = checkCandidate;
- continue;
- }
- }
- if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, undefined)) {
- (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
- continue;
+ if (isTupleType(t)) {
+ var restType = getRestTypeOfTupleType(t);
+ if (restType && isNumericLiteralName(name) && +name >= 0) {
+ return restType;
}
}
- candidates[candidateIndex] = checkCandidate;
- return checkCandidate;
+ return isNumericLiteralName(name) && getIndexTypeOfContextualType(t, 1) ||
+ getIndexTypeOfContextualType(t, 0);
}
return undefined;
- }
+ }, true);
}
- function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray) {
- ts.Debug.assert(candidates.length > 0);
- checkNodeDeferred(node);
- return hasCandidatesOutArray || candidates.length === 1 || candidates.some(function (c) { return !!c.typeParameters; })
- ? pickLongestCandidateSignature(node, candidates, args)
- : createUnionOfSignaturesForOverloadFailure(candidates);
+ function getIndexTypeOfContextualType(type, kind) {
+ return mapType(type, function (t) { return getIndexTypeOfStructuredType(t, kind); }, true);
}
- function createUnionOfSignaturesForOverloadFailure(candidates) {
- var thisParameters = ts.mapDefined(candidates, function (c) { return c.thisParameter; });
- var thisParameter;
- if (thisParameters.length) {
- thisParameter = createCombinedSymbolFromTypes(thisParameters, thisParameters.map(getTypeOfParameter));
- }
- var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
- var parameters = [];
- var _loop_18 = function (i) {
- var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ?
- i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) :
- i < s.parameters.length ? s.parameters[i] : undefined; });
- ts.Debug.assert(symbols.length !== 0);
- parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
- };
- for (var i = 0; i < maxNonRestParam; i++) {
- _loop_18(i);
- }
- var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
- var flags = 0;
- if (restParameterSymbols.length !== 0) {
- var type = createArrayType(getUnionType(ts.mapDefined(candidates, tryGetRestTypeOfSignature), 2));
- parameters.push(createCombinedSymbolForOverloadFailure(restParameterSymbols, type));
- flags |= 1;
- }
- if (candidates.some(signatureHasLiteralTypes)) {
- flags |= 2;
+ function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
+ ts.Debug.assert(ts.isObjectLiteralMethod(node));
+ if (node.flags & 16777216) {
+ return undefined;
}
- return createSignature(candidates[0].declaration, undefined, thisParameter, parameters, getIntersectionType(candidates.map(getReturnTypeOfSignature)), undefined, minArgumentCount, flags);
+ return getContextualTypeForObjectLiteralElement(node, contextFlags);
}
- function getNumNonRestParameters(signature) {
- var numParams = signature.parameters.length;
- return signatureHasRestParameter(signature) ? numParams - 1 : numParams;
+ function getContextualTypeForObjectLiteralElement(element, contextFlags) {
+ var objectLiteral = element.parent;
+ var type = getApparentTypeOfContextualType(objectLiteral, contextFlags);
+ if (type) {
+ if (!hasNonBindableDynamicName(element)) {
+ var symbolName_3 = getSymbolOfNode(element).escapedName;
+ var propertyType = getTypeOfPropertyOfContextualType(type, symbolName_3);
+ if (propertyType) {
+ return propertyType;
+ }
+ }
+ return isNumericName(element.name) && getIndexTypeOfContextualType(type, 1) ||
+ getIndexTypeOfContextualType(type, 0);
+ }
+ return undefined;
}
- function createCombinedSymbolFromTypes(sources, types) {
- return createCombinedSymbolForOverloadFailure(sources, getUnionType(types, 2));
+ function getContextualTypeForElementExpression(arrayContextualType, index) {
+ return arrayContextualType && (getTypeOfPropertyOfContextualType(arrayContextualType, "" + index)
+ || mapType(arrayContextualType, function (t) { return getIteratedTypeOrElementType(1, t, undefinedType, undefined, false); }, true));
}
- function createCombinedSymbolForOverloadFailure(sources, type) {
- return createSymbolWithType(ts.first(sources), type);
+ function getContextualTypeForConditionalOperand(node, contextFlags) {
+ var conditional = node.parent;
+ return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined;
}
- function pickLongestCandidateSignature(node, candidates, args) {
- var bestIndex = getLongestCandidateIndex(candidates, apparentArgumentCount === undefined ? args.length : apparentArgumentCount);
- var candidate = candidates[bestIndex];
- var typeParameters = candidate.typeParameters;
- if (!typeParameters) {
- return candidate;
+ function getContextualTypeForChildJsxExpression(node, child) {
+ var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName);
+ var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
+ if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
+ return undefined;
}
- var typeArgumentNodes = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : undefined;
- var instantiated = typeArgumentNodes
- ? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, ts.isInJSFile(node)))
- : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args);
- candidates[bestIndex] = instantiated;
- return instantiated;
+ var realChildren = ts.getSemanticJsxChildren(node.children);
+ var childIndex = realChildren.indexOf(child);
+ var childFieldType = getTypeOfPropertyOfContextualType(attributesType, jsxChildrenPropertyName);
+ return childFieldType && (realChildren.length === 1 ? childFieldType : mapType(childFieldType, function (t) {
+ if (isArrayLikeType(t)) {
+ return getIndexedAccessType(t, getLiteralType(childIndex));
+ }
+ else {
+ return t;
+ }
+ }, true));
}
- function getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, isJs) {
- var typeArguments = typeArgumentNodes.map(getTypeOfNode);
- while (typeArguments.length > typeParameters.length) {
- typeArguments.pop();
+ function getContextualTypeForJsxExpression(node) {
+ var exprParent = node.parent;
+ return ts.isJsxAttributeLike(exprParent)
+ ? getContextualType(node)
+ : ts.isJsxElement(exprParent)
+ ? getContextualTypeForChildJsxExpression(exprParent, node)
+ : undefined;
+ }
+ function getContextualTypeForJsxAttribute(attribute) {
+ if (ts.isJsxAttribute(attribute)) {
+ var attributesType = getApparentTypeOfContextualType(attribute.parent);
+ if (!attributesType || isTypeAny(attributesType)) {
+ return undefined;
+ }
+ return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
}
- while (typeArguments.length < typeParameters.length) {
- typeArguments.push(getConstraintOfTypeParameter(typeParameters[typeArguments.length]) || getDefaultTypeArgumentType(isJs));
+ else {
+ return getContextualType(attribute.parent);
}
- return typeArguments;
}
- function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args) {
- var inferenceContext = createInferenceContext(typeParameters, candidate, ts.isInJSFile(node) ? 2 : 0);
- var typeArgumentTypes = inferTypeArguments(node, candidate, args, 4 | 8, inferenceContext);
- return createSignatureInstantiation(candidate, typeArgumentTypes);
+ function isPossiblyDiscriminantValue(node) {
+ switch (node.kind) {
+ case 10:
+ case 8:
+ case 9:
+ case 14:
+ case 109:
+ case 94:
+ case 103:
+ case 78:
+ case 150:
+ return true;
+ case 201:
+ case 207:
+ return isPossiblyDiscriminantValue(node.expression);
+ case 283:
+ return !node.expression || isPossiblyDiscriminantValue(node.expression);
+ }
+ return false;
}
- function getLongestCandidateIndex(candidates, argsCount) {
- var maxParamsIndex = -1;
- var maxParams = -1;
- for (var i = 0; i < candidates.length; i++) {
- var candidate = candidates[i];
- var paramCount = getParameterCount(candidate);
- if (hasEffectiveRestParameter(candidate) || paramCount >= argsCount) {
- return i;
- }
- if (paramCount > maxParams) {
- maxParams = paramCount;
- maxParamsIndex = i;
+ function discriminateContextualTypeByObjectMembers(node, contextualType) {
+ return discriminateTypeByDiscriminableItems(contextualType, ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 288 && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return checkExpression(prop.initializer); }, prop.symbol.escapedName]; }), isTypeAssignableTo, contextualType);
+ }
+ function discriminateContextualTypeByJSXAttributes(node, contextualType) {
+ return discriminateTypeByDiscriminableItems(contextualType, ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 280 && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return checkExpression(prop.initializer); }), prop.symbol.escapedName]; }), isTypeAssignableTo, contextualType);
+ }
+ function getApparentTypeOfContextualType(node, contextFlags) {
+ var contextualType = ts.isObjectLiteralMethod(node) ?
+ getContextualTypeForObjectLiteralMethod(node, contextFlags) :
+ getContextualType(node, contextFlags);
+ var instantiatedType = instantiateContextualType(contextualType, node, contextFlags);
+ if (instantiatedType && !(contextFlags && contextFlags & 2 && instantiatedType.flags & 8650752)) {
+ var apparentType = mapType(instantiatedType, getApparentType, true);
+ if (apparentType.flags & 1048576) {
+ if (ts.isObjectLiteralExpression(node)) {
+ return discriminateContextualTypeByObjectMembers(node, apparentType);
+ }
+ else if (ts.isJsxAttributes(node)) {
+ return discriminateContextualTypeByJSXAttributes(node, apparentType);
+ }
}
+ return apparentType;
}
- return maxParamsIndex;
}
- function resolveCallExpression(node, candidatesOutArray, checkMode) {
- if (node.expression.kind === 102) {
- var superType = checkSuperExpression(node.expression);
- if (isTypeAny(superType)) {
- for (var _i = 0, _a = node.arguments; _i < _a.length; _i++) {
- var arg = _a[_i];
- checkExpression(arg);
+ function instantiateContextualType(contextualType, node, contextFlags) {
+ if (contextualType && maybeTypeOfKind(contextualType, 465829888)) {
+ var inferenceContext = getInferenceContext(node);
+ if (inferenceContext && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
+ if (contextFlags && contextFlags & 1) {
+ return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
}
- return anySignature;
- }
- if (superType !== errorType) {
- var baseTypeNode = ts.getEffectiveBaseTypeNode(ts.getContainingClass(node));
- if (baseTypeNode) {
- var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode);
- return resolveCall(node, baseConstructors, candidatesOutArray, checkMode, 0);
+ if (inferenceContext.returnMapper) {
+ return instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
}
}
- return resolveUntypedCall(node);
}
- var callChainFlags;
- var funcType = checkExpression(node.expression);
- if (ts.isCallChain(node)) {
- var nonOptionalType = getOptionalExpressionType(funcType, node.expression);
- callChainFlags = nonOptionalType === funcType ? 0 :
- ts.isOutermostOptionalChain(node) ? 8 :
- 4;
- funcType = nonOptionalType;
+ return contextualType;
+ }
+ function instantiateInstantiableTypes(type, mapper) {
+ if (type.flags & 465829888) {
+ return instantiateType(type, mapper);
}
- else {
- callChainFlags = 0;
+ if (type.flags & 1048576) {
+ return getUnionType(ts.map(type.types, function (t) { return instantiateInstantiableTypes(t, mapper); }), 0);
}
- funcType = checkNonNullTypeWithReporter(funcType, node.expression, reportCannotInvokePossiblyNullOrUndefinedError);
- if (funcType === silentNeverType) {
- return silentNeverSignature;
+ if (type.flags & 2097152) {
+ return getIntersectionType(ts.map(type.types, function (t) { return instantiateInstantiableTypes(t, mapper); }));
}
- var apparentType = getApparentType(funcType);
- if (apparentType === errorType) {
- return resolveErrorCall(node);
+ return type;
+ }
+ function getContextualType(node, contextFlags) {
+ if (node.flags & 16777216) {
+ return undefined;
}
- var callSignatures = getSignaturesOfType(apparentType, 0);
- var numConstructSignatures = getSignaturesOfType(apparentType, 1).length;
- if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
- if (funcType !== errorType && node.typeArguments) {
- error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
- }
- return resolveUntypedCall(node);
+ if (node.contextualType) {
+ return node.contextualType;
}
- if (!callSignatures.length) {
- if (numConstructSignatures) {
- error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
- }
- else {
- var relatedInformation = void 0;
- if (node.arguments.length === 1) {
- var text = ts.getSourceFileOfNode(node).text;
- if (ts.isLineBreak(text.charCodeAt(ts.skipTrivia(text, node.expression.end, true) - 1))) {
- relatedInformation = ts.createDiagnosticForNode(node.expression, ts.Diagnostics.Are_you_missing_a_semicolon);
- }
+ var parent = node.parent;
+ switch (parent.kind) {
+ case 249:
+ case 160:
+ case 163:
+ case 162:
+ case 198:
+ return getContextualTypeForInitializerExpression(node, contextFlags);
+ case 209:
+ case 242:
+ return getContextualTypeForReturnExpression(node);
+ case 219:
+ return getContextualTypeForYieldOperand(parent);
+ case 213:
+ return getContextualTypeForAwaitOperand(parent, contextFlags);
+ case 203:
+ if (parent.expression.kind === 99) {
+ return stringType;
}
- invocationError(node.expression, apparentType, 0, relatedInformation);
+ case 204:
+ return getContextualTypeForArgument(parent, node);
+ case 206:
+ case 224:
+ return ts.isConstTypeReference(parent.type) ? tryFindWhenConstTypeReference(parent) : getTypeFromTypeNode(parent.type);
+ case 216:
+ return getContextualTypeForBinaryOperand(node, contextFlags);
+ case 288:
+ case 289:
+ return getContextualTypeForObjectLiteralElement(parent, contextFlags);
+ case 290:
+ return getApparentTypeOfContextualType(parent.parent, contextFlags);
+ case 199: {
+ var arrayLiteral = parent;
+ var type = getApparentTypeOfContextualType(arrayLiteral, contextFlags);
+ return getContextualTypeForElementExpression(type, ts.indexOfNode(arrayLiteral.elements, node));
}
- return resolveErrorCall(node);
+ case 217:
+ return getContextualTypeForConditionalOperand(node, contextFlags);
+ case 228:
+ ts.Debug.assert(parent.parent.kind === 218);
+ return getContextualTypeForSubstitutionExpression(parent.parent, node);
+ case 207: {
+ var tag = ts.isInJSFile(parent) ? ts.getJSDocTypeTag(parent) : undefined;
+ return tag ? getTypeFromTypeNode(tag.typeExpression.type) : getContextualType(parent, contextFlags);
+ }
+ case 283:
+ return getContextualTypeForJsxExpression(parent);
+ case 280:
+ case 282:
+ return getContextualTypeForJsxAttribute(parent);
+ case 275:
+ case 274:
+ return getContextualJsxElementAttributesType(parent, contextFlags);
}
- if (checkMode & 8 && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
- skippedGenericFunction(node, checkMode);
- return resolvingSignature;
+ return undefined;
+ function tryFindWhenConstTypeReference(node) {
+ if (ts.isCallLikeExpression(node.parent)) {
+ return getContextualTypeForArgument(node.parent, node);
+ }
+ return undefined;
}
- if (callSignatures.some(function (sig) { return ts.isInJSFile(sig.declaration) && !!ts.getJSDocClassTag(sig.declaration); })) {
- error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
- return resolveErrorCall(node);
+ }
+ function getInferenceContext(node) {
+ var ancestor = ts.findAncestor(node, function (n) { return !!n.inferenceContext; });
+ return ancestor && ancestor.inferenceContext;
+ }
+ function getContextualJsxElementAttributesType(node, contextFlags) {
+ if (ts.isJsxOpeningElement(node) && node.parent.contextualType && contextFlags !== 4) {
+ return node.parent.contextualType;
}
- return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags);
+ return getContextualTypeForArgumentAtIndex(node, 0);
}
- function isGenericFunctionReturningFunction(signature) {
- return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature)));
+ function getEffectiveFirstArgumentForJsxSignature(signature, node) {
+ return getJsxReferenceKind(node) !== 0
+ ? getJsxPropsTypeFromCallSignature(signature, node)
+ : getJsxPropsTypeFromClassType(signature, node);
}
- function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) {
- return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144) ||
- !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & (1048576 | 131072)) && isTypeAssignableTo(funcType, globalFunctionType);
+ function getJsxPropsTypeFromCallSignature(sig, context) {
+ var propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType);
+ propsType = getJsxManagedAttributesFromLocatedAttributes(context, getJsxNamespaceAt(context), propsType);
+ var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
+ if (intrinsicAttribs !== errorType) {
+ propsType = intersectTypes(intrinsicAttribs, propsType);
+ }
+ return propsType;
}
- function resolveNewExpression(node, candidatesOutArray, checkMode) {
- if (node.arguments && languageVersion < 1) {
- var spreadIndex = getSpreadArgumentIndex(node.arguments);
- if (spreadIndex >= 0) {
- error(node.arguments[spreadIndex], ts.Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher);
+ function getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation) {
+ if (sig.unionSignatures) {
+ var results = [];
+ for (var _i = 0, _a = sig.unionSignatures; _i < _a.length; _i++) {
+ var signature = _a[_i];
+ var instance = getReturnTypeOfSignature(signature);
+ if (isTypeAny(instance)) {
+ return instance;
+ }
+ var propType = getTypeOfPropertyOfType(instance, forcedLookupLocation);
+ if (!propType) {
+ return;
+ }
+ results.push(propType);
+ }
+ return getIntersectionType(results);
+ }
+ var instanceType = getReturnTypeOfSignature(sig);
+ return isTypeAny(instanceType) ? instanceType : getTypeOfPropertyOfType(instanceType, forcedLookupLocation);
+ }
+ function getStaticTypeOfReferencedJsxConstructor(context) {
+ if (isJsxIntrinsicIdentifier(context.tagName)) {
+ var result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(context);
+ var fakeSignature = createSignatureForJSXIntrinsic(context, result);
+ return getOrCreateTypeFromSignature(fakeSignature);
+ }
+ var tagType = checkExpressionCached(context.tagName);
+ if (tagType.flags & 128) {
+ var result = getIntrinsicAttributesTypeFromStringLiteralType(tagType, context);
+ if (!result) {
+ return errorType;
}
+ var fakeSignature = createSignatureForJSXIntrinsic(context, result);
+ return getOrCreateTypeFromSignature(fakeSignature);
}
- var expressionType = checkNonNullExpression(node.expression);
- if (expressionType === silentNeverType) {
- return silentNeverSignature;
- }
- expressionType = getApparentType(expressionType);
- if (expressionType === errorType) {
- return resolveErrorCall(node);
+ return tagType;
+ }
+ function getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType) {
+ var managedSym = getJsxLibraryManagedAttributes(ns);
+ if (managedSym) {
+ var declaredManagedType = getDeclaredTypeOfSymbol(managedSym);
+ var ctorType = getStaticTypeOfReferencedJsxConstructor(context);
+ if (ts.length(declaredManagedType.typeParameters) >= 2) {
+ var args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.typeParameters, 2, ts.isInJSFile(context));
+ return createTypeReference(declaredManagedType, args);
+ }
+ else if (ts.length(declaredManagedType.aliasTypeArguments) >= 2) {
+ var args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.aliasTypeArguments, 2, ts.isInJSFile(context));
+ return getTypeAliasInstantiation(declaredManagedType.aliasSymbol, args);
+ }
}
- if (isTypeAny(expressionType)) {
- if (node.typeArguments) {
- error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
+ return attributesType;
+ }
+ function getJsxPropsTypeFromClassType(sig, context) {
+ var ns = getJsxNamespaceAt(context);
+ var forcedLookupLocation = getJsxElementPropertiesName(ns);
+ var attributesType = forcedLookupLocation === undefined
+ ? getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType)
+ : forcedLookupLocation === ""
+ ? getReturnTypeOfSignature(sig)
+ : getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation);
+ if (!attributesType) {
+ if (!!forcedLookupLocation && !!ts.length(context.attributes.properties)) {
+ error(context, ts.Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, ts.unescapeLeadingUnderscores(forcedLookupLocation));
}
- return resolveUntypedCall(node);
+ return unknownType;
}
- var constructSignatures = getSignaturesOfType(expressionType, 1);
- if (constructSignatures.length) {
- if (!isConstructorAccessible(node, constructSignatures[0])) {
- return resolveErrorCall(node);
+ attributesType = getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType);
+ if (isTypeAny(attributesType)) {
+ return attributesType;
+ }
+ else {
+ var apparentAttributesType = attributesType;
+ var intrinsicClassAttribs = getJsxType(JsxNames.IntrinsicClassAttributes, context);
+ if (intrinsicClassAttribs !== errorType) {
+ var typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol);
+ var hostClassType = getReturnTypeOfSignature(sig);
+ apparentAttributesType = intersectTypes(typeParams
+ ? createTypeReference(intrinsicClassAttribs, fillMissingTypeArguments([hostClassType], typeParams, getMinTypeArgumentCount(typeParams), ts.isInJSFile(context)))
+ : intrinsicClassAttribs, apparentAttributesType);
}
- var valueDecl = expressionType.symbol && ts.getClassLikeDeclarationOfSymbol(expressionType.symbol);
- if (valueDecl && ts.hasModifier(valueDecl, 128)) {
- error(node, ts.Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
- return resolveErrorCall(node);
+ var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
+ if (intrinsicAttribs !== errorType) {
+ apparentAttributesType = intersectTypes(intrinsicAttribs, apparentAttributesType);
}
- return resolveCall(node, constructSignatures, candidatesOutArray, checkMode, 0);
+ return apparentAttributesType;
}
- var callSignatures = getSignaturesOfType(expressionType, 0);
- if (callSignatures.length) {
- var signature = resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0);
- if (!noImplicitAny) {
- if (signature.declaration && !isJSConstructor(signature.declaration) && getReturnTypeOfSignature(signature) !== voidType) {
- error(node, ts.Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword);
- }
- if (getThisTypeOfSignature(signature) === voidType) {
- error(node, ts.Diagnostics.A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void);
- }
+ }
+ function getContextualCallSignature(type, node) {
+ var signatures = getSignaturesOfType(type, 0);
+ if (signatures.length === 1) {
+ var signature = signatures[0];
+ if (!isAritySmaller(signature, node)) {
+ return signature;
}
- return signature;
}
- invocationError(node.expression, expressionType, 1);
- return resolveErrorCall(node);
}
- function typeHasProtectedAccessibleBase(target, type) {
- var baseTypes = getBaseTypes(type);
- if (!ts.length(baseTypes)) {
- return false;
- }
- var firstBase = baseTypes[0];
- if (firstBase.flags & 2097152) {
- var types = firstBase.types;
- var mixinFlags = findMixins(types);
- var i = 0;
- for (var _i = 0, _a = firstBase.types; _i < _a.length; _i++) {
- var intersectionMember = _a[_i];
- if (!mixinFlags[i]) {
- if (ts.getObjectFlags(intersectionMember) & (1 | 2)) {
- if (intersectionMember.symbol === target) {
- return true;
- }
- if (typeHasProtectedAccessibleBase(target, intersectionMember)) {
- return true;
- }
- }
- }
- i++;
+ function isAritySmaller(signature, target) {
+ var targetParameterCount = 0;
+ for (; targetParameterCount < target.parameters.length; targetParameterCount++) {
+ var param = target.parameters[targetParameterCount];
+ if (param.initializer || param.questionToken || param.dotDotDotToken || isJSDocOptionalParameter(param)) {
+ break;
}
- return false;
}
- if (firstBase.symbol === target) {
- return true;
+ if (target.parameters.length && ts.parameterIsThisKeyword(target.parameters[0])) {
+ targetParameterCount--;
}
- return typeHasProtectedAccessibleBase(target, firstBase);
+ return !hasEffectiveRestParameter(signature) && getParameterCount(signature) < targetParameterCount;
}
- function isConstructorAccessible(node, signature) {
- if (!signature || !signature.declaration) {
- return true;
+ function isFunctionExpressionOrArrowFunction(node) {
+ return node.kind === 208 || node.kind === 209;
+ }
+ function getContextualSignatureForFunctionLikeDeclaration(node) {
+ return isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node)
+ ? getContextualSignature(node)
+ : undefined;
+ }
+ function getContextualSignature(node) {
+ ts.Debug.assert(node.kind !== 165 || ts.isObjectLiteralMethod(node));
+ var typeTagSignature = getSignatureOfTypeTag(node);
+ if (typeTagSignature) {
+ return typeTagSignature;
}
- var declaration = signature.declaration;
- var modifiers = ts.getSelectedModifierFlags(declaration, 24);
- if (!modifiers || declaration.kind !== 162) {
- return true;
+ var type = getApparentTypeOfContextualType(node, 1);
+ if (!type) {
+ return undefined;
}
- var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(declaration.parent.symbol);
- var declaringClass = getDeclaredTypeOfSymbol(declaration.parent.symbol);
- if (!isNodeWithinClass(node, declaringClassDeclaration)) {
- var containingClass = ts.getContainingClass(node);
- if (containingClass && modifiers & 16) {
- var containingType = getTypeOfNode(containingClass);
- if (typeHasProtectedAccessibleBase(declaration.parent.symbol, containingType)) {
- return true;
+ if (!(type.flags & 1048576)) {
+ return getContextualCallSignature(type, node);
+ }
+ var signatureList;
+ var types = type.types;
+ for (var _i = 0, types_18 = types; _i < types_18.length; _i++) {
+ var current = types_18[_i];
+ var signature = getContextualCallSignature(current, node);
+ if (signature) {
+ if (!signatureList) {
+ signatureList = [signature];
+ }
+ else if (!compareSignaturesIdentical(signatureList[0], signature, false, true, true, compareTypesIdentical)) {
+ return undefined;
+ }
+ else {
+ signatureList.push(signature);
}
}
- if (modifiers & 8) {
- error(node, ts.Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
- }
- if (modifiers & 16) {
- error(node, ts.Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
- }
- return false;
}
- return true;
+ if (signatureList) {
+ return signatureList.length === 1 ? signatureList[0] : createUnionSignature(signatureList[0], signatureList);
+ }
}
- function invocationErrorDetails(apparentType, kind) {
- var errorInfo;
- var isCall = kind === 0;
- var awaitedType = getAwaitedType(apparentType);
- var maybeMissingAwait = awaitedType && getSignaturesOfType(awaitedType, kind).length > 0;
- if (apparentType.flags & 1048576) {
- var types = apparentType.types;
- var hasSignatures = false;
- for (var _i = 0, types_18 = types; _i < types_18.length; _i++) {
- var constituent = types_18[_i];
- var signatures = getSignaturesOfType(constituent, kind);
- if (signatures.length !== 0) {
- hasSignatures = true;
- if (errorInfo) {
- break;
- }
+ function checkSpreadExpression(node, checkMode) {
+ if (languageVersion < 2) {
+ checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 : 2048);
+ }
+ var arrayOrIterableType = checkExpression(node.expression, checkMode);
+ return checkIteratedTypeOrElementType(33, arrayOrIterableType, undefinedType, node.expression);
+ }
+ function checkSyntheticExpression(node) {
+ return node.isSpread ? getIndexedAccessType(node.type, numberType) : node.type;
+ }
+ function hasDefaultValue(node) {
+ return (node.kind === 198 && !!node.initializer) ||
+ (node.kind === 216 && node.operatorToken.kind === 62);
+ }
+ function checkArrayLiteral(node, checkMode, forceTuple) {
+ var elements = node.elements;
+ var elementCount = elements.length;
+ var elementTypes = [];
+ var elementFlags = [];
+ var contextualType = getApparentTypeOfContextualType(node);
+ var inDestructuringPattern = ts.isAssignmentTarget(node);
+ var inConstContext = isConstContext(node);
+ for (var i = 0; i < elementCount; i++) {
+ var e = elements[i];
+ if (e.kind === 220) {
+ if (languageVersion < 2) {
+ checkExternalEmitHelpers(e, compilerOptions.downlevelIteration ? 1536 : 2048);
+ }
+ var spreadType = checkExpression(e.expression, checkMode, forceTuple);
+ if (isArrayLikeType(spreadType)) {
+ elementTypes.push(spreadType);
+ elementFlags.push(8);
+ }
+ else if (inDestructuringPattern) {
+ var restElementType = getIndexTypeOfType(spreadType, 1) ||
+ getIteratedTypeOrElementType(65, spreadType, undefinedType, undefined, false) ||
+ unknownType;
+ elementTypes.push(restElementType);
+ elementFlags.push(4);
}
else {
- if (!errorInfo) {
- errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ?
- ts.Diagnostics.Type_0_has_no_call_signatures :
- ts.Diagnostics.Type_0_has_no_construct_signatures, typeToString(constituent));
- errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ?
- ts.Diagnostics.Not_all_constituents_of_type_0_are_callable :
- ts.Diagnostics.Not_all_constituents_of_type_0_are_constructable, typeToString(apparentType));
- }
- if (hasSignatures) {
- break;
- }
+ elementTypes.push(checkIteratedTypeOrElementType(33, spreadType, undefinedType, e.expression));
+ elementFlags.push(4);
}
}
- if (!hasSignatures) {
- errorInfo = ts.chainDiagnosticMessages(undefined, isCall ?
- ts.Diagnostics.No_constituent_of_type_0_is_callable :
- ts.Diagnostics.No_constituent_of_type_0_is_constructable, typeToString(apparentType));
- }
- if (!errorInfo) {
- errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ?
- ts.Diagnostics.Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other :
- ts.Diagnostics.Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other, typeToString(apparentType));
+ else {
+ var elementContextualType = getContextualTypeForElementExpression(contextualType, elementTypes.length);
+ var type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple);
+ elementTypes.push(type);
+ elementFlags.push(1);
}
}
- else {
- errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ?
- ts.Diagnostics.Type_0_has_no_call_signatures :
- ts.Diagnostics.Type_0_has_no_construct_signatures, typeToString(apparentType));
- }
- return {
- messageChain: ts.chainDiagnosticMessages(errorInfo, isCall ? ts.Diagnostics.This_expression_is_not_callable : ts.Diagnostics.This_expression_is_not_constructable),
- relatedMessage: maybeMissingAwait ? ts.Diagnostics.Did_you_forget_to_use_await : undefined,
- };
- }
- function invocationError(errorTarget, apparentType, kind, relatedInformation) {
- var _a = invocationErrorDetails(apparentType, kind), messageChain = _a.messageChain, relatedInfo = _a.relatedMessage;
- var diagnostic = ts.createDiagnosticForNodeFromMessageChain(errorTarget, messageChain);
- if (relatedInfo) {
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(errorTarget, relatedInfo));
+ if (inDestructuringPattern) {
+ return createTupleType(elementTypes, elementFlags);
}
- if (ts.isCallExpression(errorTarget.parent)) {
- var _b = getDiagnosticSpanForCallNode(errorTarget.parent, true), start = _b.start, length_7 = _b.length;
- diagnostic.start = start;
- diagnostic.length = length_7;
+ if (forceTuple || inConstContext || contextualType && forEachType(contextualType, isTupleLikeType)) {
+ return createArrayLiteralType(createTupleType(elementTypes, elementFlags, inConstContext));
}
- diagnostics.add(diagnostic);
- invocationErrorRecovery(apparentType, kind, relatedInformation ? ts.addRelatedInfo(diagnostic, relatedInformation) : diagnostic);
+ return createArrayLiteralType(createArrayType(elementTypes.length ?
+ getUnionType(ts.sameMap(elementTypes, function (t, i) { return elementFlags[i] & 8 ? getIndexedAccessTypeOrUndefined(t, numberType) || anyType : t; }), 2) :
+ strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext));
}
- function invocationErrorRecovery(apparentType, kind, diagnostic) {
- if (!apparentType.symbol) {
- return;
+ function createArrayLiteralType(type) {
+ if (!(ts.getObjectFlags(type) & 4)) {
+ return type;
}
- var importNode = getSymbolLinks(apparentType.symbol).originatingImport;
- if (importNode && !ts.isImportCall(importNode)) {
- var sigs = getSignaturesOfType(getTypeOfSymbol(getSymbolLinks(apparentType.symbol).target), kind);
- if (!sigs || !sigs.length)
- return;
- ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(importNode, ts.Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead));
+ var literalType = type.literalType;
+ if (!literalType) {
+ literalType = type.literalType = cloneTypeReference(type);
+ literalType.objectFlags |= 65536 | 1048576;
}
+ return literalType;
}
- function resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode) {
- var tagType = checkExpression(node.tag);
- var apparentType = getApparentType(tagType);
- if (apparentType === errorType) {
- return resolveErrorCall(node);
+ function isNumericName(name) {
+ switch (name.kind) {
+ case 158:
+ return isNumericComputedName(name);
+ case 78:
+ return isNumericLiteralName(name.escapedText);
+ case 8:
+ case 10:
+ return isNumericLiteralName(name.text);
+ default:
+ return false;
}
- var callSignatures = getSignaturesOfType(apparentType, 0);
- var numConstructSignatures = getSignaturesOfType(apparentType, 1).length;
- if (isUntypedFunctionCall(tagType, apparentType, callSignatures.length, numConstructSignatures)) {
- return resolveUntypedCall(node);
+ }
+ function isNumericComputedName(name) {
+ return isTypeAssignableToKind(checkComputedPropertyName(name), 296);
+ }
+ function isInfinityOrNaNString(name) {
+ return name === "Infinity" || name === "-Infinity" || name === "NaN";
+ }
+ function isNumericLiteralName(name) {
+ return (+name).toString() === name;
+ }
+ function checkComputedPropertyName(node) {
+ var links = getNodeLinks(node.expression);
+ if (!links.resolvedType) {
+ links.resolvedType = checkExpression(node.expression);
+ if (links.resolvedType.flags & 98304 ||
+ !isTypeAssignableToKind(links.resolvedType, 402653316 | 296 | 12288) &&
+ !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) {
+ error(node, ts.Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any);
+ }
+ else {
+ checkThatExpressionIsProperSymbolReference(node.expression, links.resolvedType, true);
+ }
}
- if (!callSignatures.length) {
- invocationError(node.tag, apparentType, 0);
- return resolveErrorCall(node);
+ return links.resolvedType;
+ }
+ function isSymbolWithNumericName(symbol) {
+ var _a;
+ var firstDecl = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0];
+ return isNumericLiteralName(symbol.escapedName) || (firstDecl && ts.isNamedDeclaration(firstDecl) && isNumericName(firstDecl.name));
+ }
+ function getObjectLiteralIndexInfo(node, offset, properties, kind) {
+ var propTypes = [];
+ for (var i = offset; i < properties.length; i++) {
+ if (kind === 0 || isSymbolWithNumericName(properties[i])) {
+ propTypes.push(getTypeOfSymbol(properties[i]));
+ }
}
- return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0);
+ var unionType = propTypes.length ? getUnionType(propTypes, 2) : undefinedType;
+ return createIndexInfo(unionType, isConstContext(node));
}
- function getDiagnosticHeadMessageForDecoratorResolution(node) {
- switch (node.parent.kind) {
- case 245:
- case 214:
- return ts.Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression;
- case 156:
- return ts.Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression;
- case 159:
- return ts.Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression;
- case 161:
- case 163:
- case 164:
- return ts.Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression;
- default:
+ function getImmediateAliasedSymbol(symbol) {
+ ts.Debug.assert((symbol.flags & 2097152) !== 0, "Should only get Alias here.");
+ var links = getSymbolLinks(symbol);
+ if (!links.immediateTarget) {
+ var node = getDeclarationOfAliasSymbol(symbol);
+ if (!node)
return ts.Debug.fail();
+ links.immediateTarget = getTargetOfAliasDeclaration(node, true);
}
+ return links.immediateTarget;
}
- function resolveDecorator(node, candidatesOutArray, checkMode) {
- var funcType = checkExpression(node.expression);
- var apparentType = getApparentType(funcType);
- if (apparentType === errorType) {
- return resolveErrorCall(node);
+ function checkObjectLiteral(node, checkMode) {
+ var inDestructuringPattern = ts.isAssignmentTarget(node);
+ checkGrammarObjectLiteralExpression(node, inDestructuringPattern);
+ var allPropertiesTable = strictNullChecks ? ts.createSymbolTable() : undefined;
+ var propertiesTable = ts.createSymbolTable();
+ var propertiesArray = [];
+ var spread = emptyObjectType;
+ var contextualType = getApparentTypeOfContextualType(node);
+ var contextualTypeHasPattern = contextualType && contextualType.pattern &&
+ (contextualType.pattern.kind === 196 || contextualType.pattern.kind === 200);
+ var inConstContext = isConstContext(node);
+ var checkFlags = inConstContext ? 8 : 0;
+ var isInJavascript = ts.isInJSFile(node) && !ts.isInJsonFile(node);
+ var enumTag = ts.getJSDocEnumTag(node);
+ var isJSObjectLiteral = !contextualType && isInJavascript && !enumTag;
+ var objectFlags = freshObjectLiteralFlag;
+ var patternWithComputedProperties = false;
+ var hasComputedStringProperty = false;
+ var hasComputedNumberProperty = false;
+ for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
+ var elem = _a[_i];
+ if (elem.name && ts.isComputedPropertyName(elem.name) && !ts.isWellKnownSymbolSyntactically(elem.name)) {
+ checkComputedPropertyName(elem.name);
+ }
}
- var callSignatures = getSignaturesOfType(apparentType, 0);
- var numConstructSignatures = getSignaturesOfType(apparentType, 1).length;
- if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
- return resolveUntypedCall(node);
+ var offset = 0;
+ for (var _b = 0, _c = node.properties; _b < _c.length; _b++) {
+ var memberDecl = _c[_b];
+ var member = getSymbolOfNode(memberDecl);
+ var computedNameType = memberDecl.name && memberDecl.name.kind === 158 && !ts.isWellKnownSymbolSyntactically(memberDecl.name.expression) ?
+ checkComputedPropertyName(memberDecl.name) : undefined;
+ if (memberDecl.kind === 288 ||
+ memberDecl.kind === 289 ||
+ ts.isObjectLiteralMethod(memberDecl)) {
+ var type = memberDecl.kind === 288 ? checkPropertyAssignment(memberDecl, checkMode) :
+ memberDecl.kind === 289 ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, checkMode) :
+ checkObjectLiteralMethod(memberDecl, checkMode);
+ if (isInJavascript) {
+ var jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl);
+ if (jsDocType) {
+ checkTypeAssignableTo(type, jsDocType, memberDecl);
+ type = jsDocType;
+ }
+ else if (enumTag && enumTag.typeExpression) {
+ checkTypeAssignableTo(type, getTypeFromTypeNode(enumTag.typeExpression), memberDecl);
+ }
+ }
+ objectFlags |= ts.getObjectFlags(type) & 3670016;
+ var nameType = computedNameType && isTypeUsableAsPropertyName(computedNameType) ? computedNameType : undefined;
+ var prop = nameType ?
+ createSymbol(4 | member.flags, getPropertyNameFromType(nameType), checkFlags | 4096) :
+ createSymbol(4 | member.flags, member.escapedName, checkFlags);
+ if (nameType) {
+ prop.nameType = nameType;
+ }
+ if (inDestructuringPattern) {
+ var isOptional = (memberDecl.kind === 288 && hasDefaultValue(memberDecl.initializer)) ||
+ (memberDecl.kind === 289 && memberDecl.objectAssignmentInitializer);
+ if (isOptional) {
+ prop.flags |= 16777216;
+ }
+ }
+ else if (contextualTypeHasPattern && !(ts.getObjectFlags(contextualType) & 512)) {
+ var impliedProp = getPropertyOfType(contextualType, member.escapedName);
+ if (impliedProp) {
+ prop.flags |= impliedProp.flags & 16777216;
+ }
+ else if (!compilerOptions.suppressExcessPropertyErrors && !getIndexInfoOfType(contextualType, 0)) {
+ error(memberDecl.name, ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(member), typeToString(contextualType));
+ }
+ }
+ prop.declarations = member.declarations;
+ prop.parent = member.parent;
+ if (member.valueDeclaration) {
+ prop.valueDeclaration = member.valueDeclaration;
+ }
+ prop.type = type;
+ prop.target = member;
+ member = prop;
+ allPropertiesTable === null || allPropertiesTable === void 0 ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
+ }
+ else if (memberDecl.kind === 290) {
+ if (languageVersion < 2) {
+ checkExternalEmitHelpers(memberDecl, 2);
+ }
+ if (propertiesArray.length > 0) {
+ spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext);
+ propertiesArray = [];
+ propertiesTable = ts.createSymbolTable();
+ hasComputedStringProperty = false;
+ hasComputedNumberProperty = false;
+ }
+ var type = getReducedType(checkExpression(memberDecl.expression));
+ if (!isValidSpreadType(type)) {
+ error(memberDecl, ts.Diagnostics.Spread_types_may_only_be_created_from_object_types);
+ return errorType;
+ }
+ if (allPropertiesTable) {
+ checkSpreadPropOverrides(type, allPropertiesTable, memberDecl);
+ }
+ spread = getSpreadType(spread, type, node.symbol, objectFlags, inConstContext);
+ offset = propertiesArray.length;
+ continue;
+ }
+ else {
+ ts.Debug.assert(memberDecl.kind === 167 || memberDecl.kind === 168);
+ checkNodeDeferred(memberDecl);
+ }
+ if (computedNameType && !(computedNameType.flags & 8576)) {
+ if (isTypeAssignableTo(computedNameType, stringNumberSymbolType)) {
+ if (isTypeAssignableTo(computedNameType, numberType)) {
+ hasComputedNumberProperty = true;
+ }
+ else {
+ hasComputedStringProperty = true;
+ }
+ if (inDestructuringPattern) {
+ patternWithComputedProperties = true;
+ }
+ }
+ }
+ else {
+ propertiesTable.set(member.escapedName, member);
+ }
+ propertiesArray.push(member);
}
- if (isPotentiallyUncalledDecorator(node, callSignatures)) {
- var nodeStr = ts.getTextOfNode(node.expression, false);
- error(node, ts.Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0, nodeStr);
- return resolveErrorCall(node);
+ if (contextualTypeHasPattern && node.parent.kind !== 290) {
+ for (var _d = 0, _e = getPropertiesOfType(contextualType); _d < _e.length; _d++) {
+ var prop = _e[_d];
+ if (!propertiesTable.get(prop.escapedName) && !getPropertyOfType(spread, prop.escapedName)) {
+ if (!(prop.flags & 16777216)) {
+ error(prop.valueDeclaration || prop.bindingElement, ts.Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value);
+ }
+ propertiesTable.set(prop.escapedName, prop);
+ propertiesArray.push(prop);
+ }
+ }
}
- var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
- if (!callSignatures.length) {
- var errorDetails = invocationErrorDetails(apparentType, 0);
- var messageChain = ts.chainDiagnosticMessages(errorDetails.messageChain, headMessage);
- var diag = ts.createDiagnosticForNodeFromMessageChain(node.expression, messageChain);
- if (errorDetails.relatedMessage) {
- ts.addRelatedInfo(diag, ts.createDiagnosticForNode(node.expression, errorDetails.relatedMessage));
+ if (spread !== emptyObjectType) {
+ if (propertiesArray.length > 0) {
+ spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext);
+ propertiesArray = [];
+ propertiesTable = ts.createSymbolTable();
+ hasComputedStringProperty = false;
+ hasComputedNumberProperty = false;
+ }
+ return mapType(spread, function (t) { return t === emptyObjectType ? createObjectLiteralType() : t; });
+ }
+ return createObjectLiteralType();
+ function createObjectLiteralType() {
+ var stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, 0) : undefined;
+ var numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, 1) : undefined;
+ var result = createAnonymousType(node.symbol, propertiesTable, ts.emptyArray, ts.emptyArray, stringIndexInfo, numberIndexInfo);
+ result.objectFlags |= objectFlags | 128 | 1048576;
+ if (isJSObjectLiteral) {
+ result.objectFlags |= 16384;
+ }
+ if (patternWithComputedProperties) {
+ result.objectFlags |= 512;
+ }
+ if (inDestructuringPattern) {
+ result.pattern = node;
+ }
+ return result;
+ }
+ }
+ function isValidSpreadType(type) {
+ if (type.flags & 465829888) {
+ var constraint = getBaseConstraintOfType(type);
+ if (constraint !== undefined) {
+ return isValidSpreadType(constraint);
}
- diagnostics.add(diag);
- invocationErrorRecovery(apparentType, 0, diag);
- return resolveErrorCall(node);
}
- return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0, headMessage);
+ return !!(type.flags & (1 | 67108864 | 524288 | 58982400) ||
+ getFalsyFlags(type) & 117632 && isValidSpreadType(removeDefinitelyFalsyTypes(type)) ||
+ type.flags & 3145728 && ts.every(type.types, isValidSpreadType));
}
- function createSignatureForJSXIntrinsic(node, result) {
- var namespace = getJsxNamespaceAt(node);
- var exports = namespace && getExportsOfSymbol(namespace);
- var typeSymbol = exports && getSymbol(exports, JsxNames.Element, 788968);
- var returnNode = typeSymbol && nodeBuilder.symbolToEntityName(typeSymbol, 788968, node);
- var declaration = ts.createFunctionTypeNode(undefined, [ts.createParameter(undefined, undefined, undefined, "props", undefined, nodeBuilder.typeToTypeNode(result, node))], returnNode ? ts.createTypeReferenceNode(returnNode, undefined) : ts.createKeywordTypeNode(125));
- var parameterSymbol = createSymbol(1, "props");
- parameterSymbol.type = result;
- return createSignature(declaration, undefined, undefined, [parameterSymbol], typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType, undefined, 1, 0);
+ function checkJsxSelfClosingElementDeferred(node) {
+ checkJsxOpeningLikeElementOrOpeningFragment(node);
}
- function resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode) {
- if (isJsxIntrinsicIdentifier(node.tagName)) {
- var result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node);
- var fakeSignature = createSignatureForJSXIntrinsic(node, result);
- checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType(node.attributes, getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), undefined, 0), result, node.tagName, node.attributes);
- return fakeSignature;
- }
- var exprTypes = checkExpression(node.tagName);
- var apparentType = getApparentType(exprTypes);
- if (apparentType === errorType) {
- return resolveErrorCall(node);
- }
- var signatures = getUninstantiatedJsxSignaturesOfType(exprTypes, node);
- if (isUntypedFunctionCall(exprTypes, apparentType, signatures.length, 0)) {
- return resolveUntypedCall(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);
}
- if (signatures.length === 0) {
- error(node.tagName, ts.Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, ts.getTextOfNode(node.tagName));
- return resolveErrorCall(node);
+ else {
+ checkExpression(node.closingElement.tagName);
}
- return resolveCall(node, signatures, candidatesOutArray, checkMode, 0);
+ checkJsxChildren(node);
}
- function isPotentiallyUncalledDecorator(decorator, signatures) {
- return signatures.length && ts.every(signatures, function (signature) {
- return signature.minArgumentCount === 0 &&
- !signatureHasRestParameter(signature) &&
- signature.parameters.length < getDecoratorArgumentCount(decorator, signature);
- });
+ function checkJsxElement(node, _checkMode) {
+ checkNodeDeferred(node);
+ return getJsxElementTypeAt(node) || anyType;
}
- function resolveSignature(node, candidatesOutArray, checkMode) {
- switch (node.kind) {
- case 196:
- return resolveCallExpression(node, candidatesOutArray, checkMode);
- case 197:
- return resolveNewExpression(node, candidatesOutArray, checkMode);
- case 198:
- return resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode);
- case 157:
- return resolveDecorator(node, candidatesOutArray, checkMode);
- case 268:
- case 267:
- return resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode);
+ function checkJsxFragment(node) {
+ checkJsxOpeningLikeElementOrOpeningFragment(node.openingFragment);
+ var nodeSourceFile = ts.getSourceFileOfNode(node);
+ if (ts.getJSXTransformEnabled(compilerOptions) && (compilerOptions.jsxFactory || nodeSourceFile.pragmas.has("jsx"))
+ && !compilerOptions.jsxFragmentFactory && !nodeSourceFile.pragmas.has("jsxfrag")) {
+ error(node, compilerOptions.jsxFactory
+ ? ts.Diagnostics.The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option
+ : ts.Diagnostics.An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments);
}
- throw ts.Debug.assertNever(node, "Branch in 'resolveSignature' should be unreachable.");
+ checkJsxChildren(node);
+ return getJsxElementTypeAt(node) || anyType;
}
- function getResolvedSignature(node, candidatesOutArray, checkMode) {
- var links = getNodeLinks(node);
- var cached = links.resolvedSignature;
- if (cached && cached !== resolvingSignature && !candidatesOutArray) {
- return cached;
- }
- links.resolvedSignature = resolvingSignature;
- var result = resolveSignature(node, candidatesOutArray, checkMode || 0);
- if (result !== resolvingSignature) {
- links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;
- }
- return result;
+ function isUnhyphenatedJsxName(name) {
+ return !ts.stringContains(name, "-");
}
- function isJSConstructor(node) {
- if (!node || !ts.isInJSFile(node)) {
- return false;
- }
- var func = ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) ? node :
- ts.isVariableDeclaration(node) && node.initializer && ts.isFunctionExpression(node.initializer) ? node.initializer :
- undefined;
- if (func) {
- if (ts.getJSDocClassTag(node))
- return true;
- var symbol = getSymbolOfNode(func);
- return !!symbol && ts.hasEntries(symbol.members);
- }
- return false;
+ function isJsxIntrinsicIdentifier(tagName) {
+ return tagName.kind === 78 && ts.isIntrinsicJsxName(tagName.escapedText);
}
- function mergeJSSymbols(target, source) {
- if (source) {
- var links = getSymbolLinks(source);
- if (!links.inferredClassSymbol || !links.inferredClassSymbol.has("" + getSymbolId(target))) {
- var inferred = ts.isTransientSymbol(target) ? target : cloneSymbol(target);
- inferred.exports = inferred.exports || ts.createSymbolTable();
- inferred.members = inferred.members || ts.createSymbolTable();
- inferred.flags |= source.flags & 32;
- if (ts.hasEntries(source.exports)) {
- mergeSymbolTable(inferred.exports, source.exports);
+ function checkJsxAttribute(node, checkMode) {
+ return node.initializer
+ ? checkExpressionForMutableLocation(node.initializer, checkMode)
+ : trueType;
+ }
+ function createJsxAttributesTypeFromAttributesProperty(openingLikeElement, checkMode) {
+ var attributes = openingLikeElement.attributes;
+ var allAttributesTable = strictNullChecks ? ts.createSymbolTable() : undefined;
+ var attributesTable = ts.createSymbolTable();
+ var spread = emptyJsxObjectType;
+ var hasSpreadAnyType = false;
+ var typeToIntersect;
+ var explicitlySpecifyChildrenAttribute = false;
+ var objectFlags = 4096;
+ var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement));
+ for (var _i = 0, _a = attributes.properties; _i < _a.length; _i++) {
+ var attributeDecl = _a[_i];
+ var member = attributeDecl.symbol;
+ if (ts.isJsxAttribute(attributeDecl)) {
+ var exprType = checkJsxAttribute(attributeDecl, checkMode);
+ objectFlags |= ts.getObjectFlags(exprType) & 3670016;
+ var attributeSymbol = createSymbol(4 | member.flags, member.escapedName);
+ attributeSymbol.declarations = member.declarations;
+ attributeSymbol.parent = member.parent;
+ if (member.valueDeclaration) {
+ attributeSymbol.valueDeclaration = member.valueDeclaration;
}
- if (ts.hasEntries(source.members)) {
- mergeSymbolTable(inferred.members, source.members);
+ attributeSymbol.type = exprType;
+ attributeSymbol.target = member;
+ attributesTable.set(attributeSymbol.escapedName, attributeSymbol);
+ allAttributesTable === null || allAttributesTable === void 0 ? void 0 : allAttributesTable.set(attributeSymbol.escapedName, attributeSymbol);
+ if (attributeDecl.name.escapedText === jsxChildrenPropertyName) {
+ explicitlySpecifyChildrenAttribute = true;
}
- (links.inferredClassSymbol || (links.inferredClassSymbol = ts.createMap())).set("" + getSymbolId(inferred), inferred);
- return inferred;
}
- return links.inferredClassSymbol.get("" + getSymbolId(target));
- }
- }
- function getAssignedClassSymbol(decl) {
- var assignmentSymbol = decl && decl.parent &&
- (ts.isFunctionDeclaration(decl) && getSymbolOfNode(decl) ||
- ts.isBinaryExpression(decl.parent) && getSymbolOfNode(decl.parent.left) ||
- ts.isVariableDeclaration(decl.parent) && getSymbolOfNode(decl.parent));
- var prototype = assignmentSymbol && assignmentSymbol.exports && assignmentSymbol.exports.get("prototype");
- var init = prototype && prototype.valueDeclaration && getAssignedJSPrototype(prototype.valueDeclaration);
- return init ? getSymbolOfNode(init) : undefined;
- }
- function getAssignedJSPrototype(node) {
- if (!node.parent) {
- return false;
- }
- var parent = node.parent;
- while (parent && parent.kind === 194) {
- parent = parent.parent;
- }
- if (parent && ts.isBinaryExpression(parent) && ts.isPrototypeAccess(parent.left) && parent.operatorToken.kind === 62) {
- var right = ts.getInitializerOfBinaryExpression(parent);
- return ts.isObjectLiteralExpression(right) && right;
- }
- }
- function checkCallExpression(node, checkMode) {
- if (!checkGrammarTypeArguments(node, node.typeArguments))
- checkGrammarArguments(node.arguments);
- var signature = getResolvedSignature(node, undefined, checkMode);
- if (signature === resolvingSignature) {
- return nonInferrableType;
- }
- if (node.expression.kind === 102) {
- return voidType;
- }
- if (node.kind === 197) {
- var declaration = signature.declaration;
- if (declaration &&
- declaration.kind !== 162 &&
- declaration.kind !== 166 &&
- declaration.kind !== 171 &&
- !ts.isJSDocConstructSignature(declaration) &&
- !isJSConstructor(declaration)) {
- if (noImplicitAny) {
- error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type);
+ else {
+ ts.Debug.assert(attributeDecl.kind === 282);
+ if (attributesTable.size > 0) {
+ spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, false);
+ attributesTable = ts.createSymbolTable();
+ }
+ var exprType = getReducedType(checkExpressionCached(attributeDecl.expression, checkMode));
+ if (isTypeAny(exprType)) {
+ hasSpreadAnyType = true;
+ }
+ if (isValidSpreadType(exprType)) {
+ spread = getSpreadType(spread, exprType, attributes.symbol, objectFlags, false);
+ if (allAttributesTable) {
+ checkSpreadPropOverrides(exprType, allAttributesTable, attributeDecl);
+ }
+ }
+ else {
+ typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;
}
- return anyType;
}
}
- if (ts.isInJSFile(node) && isCommonJsRequire(node)) {
- return resolveExternalModuleTypeByLiteral(node.arguments[0]);
- }
- var returnType = getReturnTypeOfSignature(signature);
- if (returnType.flags & 12288 && isSymbolOrSymbolForCall(node)) {
- return getESSymbolLikeTypeForNode(ts.walkUpParenthesizedExpressions(node.parent));
- }
- if (node.kind === 196 && node.parent.kind === 226 &&
- returnType.flags & 16384 && getTypePredicateOfSignature(signature)) {
- if (!ts.isDottedName(node.expression)) {
- error(node.expression, ts.Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name);
- }
- else if (!getEffectsSignature(node)) {
- var diagnostic = error(node.expression, ts.Diagnostics.Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation);
- getTypeOfDottedName(node.expression, diagnostic);
+ if (!hasSpreadAnyType) {
+ if (attributesTable.size > 0) {
+ spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, false);
}
}
- if (ts.isInJSFile(node)) {
- var decl = ts.getDeclarationOfExpando(node);
- if (decl) {
- var jsSymbol = getSymbolOfNode(decl);
- if (jsSymbol && ts.hasEntries(jsSymbol.exports)) {
- var jsAssignmentType = createAnonymousType(jsSymbol, jsSymbol.exports, ts.emptyArray, ts.emptyArray, undefined, undefined);
- jsAssignmentType.objectFlags |= 16384;
- return getIntersectionType([returnType, jsAssignmentType]);
+ var parent = openingLikeElement.parent.kind === 273 ? openingLikeElement.parent : undefined;
+ if (parent && parent.openingElement === openingLikeElement && parent.children.length > 0) {
+ var childrenTypes = checkJsxChildren(parent, checkMode);
+ if (!hasSpreadAnyType && jsxChildrenPropertyName && jsxChildrenPropertyName !== "") {
+ if (explicitlySpecifyChildrenAttribute) {
+ error(attributes, ts.Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName));
}
+ var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes);
+ var childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName);
+ var childrenPropSymbol = createSymbol(4, jsxChildrenPropertyName);
+ childrenPropSymbol.type = childrenTypes.length === 1 ? childrenTypes[0] :
+ childrenContextualType && forEachType(childrenContextualType, isTupleLikeType) ? createTupleType(childrenTypes) :
+ createArrayType(getUnionType(childrenTypes));
+ childrenPropSymbol.valueDeclaration = ts.factory.createPropertySignature(undefined, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName), undefined, undefined);
+ ts.setParent(childrenPropSymbol.valueDeclaration, attributes);
+ childrenPropSymbol.valueDeclaration.symbol = childrenPropSymbol;
+ var childPropMap = ts.createSymbolTable();
+ childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol);
+ spread = getSpreadType(spread, createAnonymousType(attributes.symbol, childPropMap, ts.emptyArray, ts.emptyArray, undefined, undefined), attributes.symbol, objectFlags, false);
}
}
- return returnType;
- }
- function isSymbolOrSymbolForCall(node) {
- if (!ts.isCallExpression(node))
- return false;
- var left = node.expression;
- if (ts.isPropertyAccessExpression(left) && left.name.escapedText === "for") {
- left = left.expression;
+ if (hasSpreadAnyType) {
+ return anyType;
}
- if (!ts.isIdentifier(left) || left.escapedText !== "Symbol") {
- return false;
+ if (typeToIntersect && spread !== emptyJsxObjectType) {
+ return getIntersectionType([typeToIntersect, spread]);
}
- var globalESSymbol = getGlobalESSymbolConstructorSymbol(false);
- if (!globalESSymbol) {
- return false;
+ return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesType() : spread);
+ function createJsxAttributesType() {
+ objectFlags |= freshObjectLiteralFlag;
+ var result = createAnonymousType(attributes.symbol, attributesTable, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ result.objectFlags |= objectFlags | 128 | 1048576;
+ return result;
}
- return globalESSymbol === resolveName(left, "Symbol", 111551, undefined, undefined, false);
}
- function checkImportCallExpression(node) {
- if (!checkGrammarArguments(node.arguments))
- checkGrammarImportCallExpression(node);
- if (node.arguments.length === 0) {
- return createPromiseReturnType(node, anyType);
- }
- var specifier = node.arguments[0];
- var specifierType = checkExpressionCached(specifier);
- for (var i = 1; i < node.arguments.length; ++i) {
- checkExpressionCached(node.arguments[i]);
- }
- if (specifierType.flags & 32768 || specifierType.flags & 65536 || !isTypeAssignableTo(specifierType, stringType)) {
- error(specifier, ts.Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0, typeToString(specifierType));
+ function checkJsxChildren(node, checkMode) {
+ var childrenTypes = [];
+ for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
+ var child = _a[_i];
+ if (child.kind === 11) {
+ if (!child.containsOnlyTriviaWhiteSpaces) {
+ childrenTypes.push(stringType);
+ }
+ }
+ else if (child.kind === 283 && !child.expression) {
+ continue;
+ }
+ else {
+ childrenTypes.push(checkExpressionForMutableLocation(child, checkMode));
+ }
}
- var moduleSymbol = resolveExternalModuleName(node, specifier);
- if (moduleSymbol) {
- var esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, true, false);
- if (esModuleSymbol) {
- return createPromiseReturnType(node, getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol));
+ return childrenTypes;
+ }
+ function checkSpreadPropOverrides(type, props, spread) {
+ for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) {
+ var right = _a[_i];
+ var left = props.get(right.escapedName);
+ var rightType = getTypeOfSymbol(right);
+ if (left && !maybeTypeOfKind(rightType, 98304) && !(maybeTypeOfKind(rightType, 3) && right.flags & 16777216)) {
+ var diagnostic = error(left.valueDeclaration, ts.Diagnostics._0_is_specified_more_than_once_so_this_usage_will_be_overwritten, ts.unescapeLeadingUnderscores(left.escapedName));
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(spread, ts.Diagnostics.This_spread_always_overwrites_this_property));
}
}
- return createPromiseReturnType(node, anyType);
}
- function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol) {
- if (allowSyntheticDefaultImports && type && type !== errorType) {
- var synthType = type;
- if (!synthType.syntheticType) {
- var file = ts.find(originalSymbol.declarations, ts.isSourceFile);
- var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, false);
- if (hasSyntheticDefault) {
- var memberTable = ts.createSymbolTable();
- var newSymbol = createSymbol(2097152, "default");
- newSymbol.nameType = getLiteralType("default");
- newSymbol.target = resolveSymbol(symbol);
- memberTable.set("default", newSymbol);
- var anonymousSymbol = createSymbol(2048, "__type");
- var defaultContainingObject = createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, undefined, undefined);
- anonymousSymbol.type = defaultContainingObject;
- synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, 0, false) : defaultContainingObject;
+ function checkJsxAttributes(node, checkMode) {
+ return createJsxAttributesTypeFromAttributesProperty(node.parent, checkMode);
+ }
+ function getJsxType(name, location) {
+ var namespace = getJsxNamespaceAt(location);
+ var exports = namespace && getExportsOfSymbol(namespace);
+ var typeSymbol = exports && getSymbol(exports, name, 788968);
+ return typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType;
+ }
+ function getIntrinsicTagSymbol(node) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedSymbol) {
+ var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, node);
+ if (intrinsicElementsType !== errorType) {
+ if (!ts.isIdentifier(node.tagName))
+ return ts.Debug.fail();
+ var intrinsicProp = getPropertyOfType(intrinsicElementsType, node.tagName.escapedText);
+ if (intrinsicProp) {
+ links.jsxFlags |= 1;
+ return links.resolvedSymbol = intrinsicProp;
}
- else {
- synthType.syntheticType = type;
+ var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, 0);
+ if (indexSignatureType) {
+ links.jsxFlags |= 2;
+ return links.resolvedSymbol = intrinsicElementsType.symbol;
}
+ error(node, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.idText(node.tagName), "JSX." + JsxNames.IntrinsicElements);
+ return links.resolvedSymbol = unknownSymbol;
+ }
+ else {
+ if (noImplicitAny) {
+ error(node, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, ts.unescapeLeadingUnderscores(JsxNames.IntrinsicElements));
+ }
+ return links.resolvedSymbol = unknownSymbol;
}
- return synthType.syntheticType;
}
- return type;
+ return links.resolvedSymbol;
}
- function isCommonJsRequire(node) {
- if (!ts.isRequireCall(node, true)) {
- return false;
+ function getJsxNamespaceContainerForImplicitImport(location) {
+ var file = location && ts.getSourceFileOfNode(location);
+ var links = file && getNodeLinks(file);
+ if (links && links.jsxImplicitImportContainer === false) {
+ return undefined;
}
- if (!ts.isIdentifier(node.expression))
- return ts.Debug.fail();
- var resolvedRequire = resolveName(node.expression, node.expression.escapedText, 111551, undefined, undefined, true);
- if (resolvedRequire === requireSymbol) {
- return true;
+ if (links && links.jsxImplicitImportContainer) {
+ return links.jsxImplicitImportContainer;
}
- if (resolvedRequire.flags & 2097152) {
- return false;
+ var runtimeImportSpecifier = ts.getJSXRuntimeImport(ts.getJSXImplicitImportBase(compilerOptions, file), compilerOptions);
+ if (!runtimeImportSpecifier) {
+ return undefined;
}
- var targetDeclarationKind = resolvedRequire.flags & 16
- ? 244
- : resolvedRequire.flags & 3
- ? 242
- : 0;
- if (targetDeclarationKind !== 0) {
- var decl = ts.getDeclarationOfKind(resolvedRequire, targetDeclarationKind);
- return !!decl && !!(decl.flags & 8388608);
+ var isClassic = ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Classic;
+ var errorMessage = isClassic
+ ? ts.Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option
+ : ts.Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
+ var mod = resolveExternalModule(location, runtimeImportSpecifier, errorMessage, location);
+ var result = mod && mod !== unknownSymbol ? getMergedSymbol(resolveSymbol(mod)) : undefined;
+ if (links) {
+ links.jsxImplicitImportContainer = result || false;
}
- return false;
+ return result;
}
- function checkTaggedTemplateExpression(node) {
- if (!checkGrammarTaggedTemplateChain(node))
- checkGrammarTypeArguments(node, node.typeArguments);
- if (languageVersion < 2) {
- checkExternalEmitHelpers(node, 131072);
+ function getJsxNamespaceAt(location) {
+ var links = location && getNodeLinks(location);
+ if (links && links.jsxNamespace) {
+ return links.jsxNamespace;
}
- return getReturnTypeOfSignature(getResolvedSignature(node));
- }
- function checkAssertion(node) {
- return checkAssertionWorker(node, node.type, node.expression);
- }
- function isValidConstAssertionArgument(node) {
- switch (node.kind) {
- case 10:
- case 14:
- case 8:
- case 9:
- case 106:
- case 91:
- case 192:
- case 193:
- return true;
- case 200:
- return isValidConstAssertionArgument(node.expression);
- case 207:
- var op = node.operator;
- var arg = node.operand;
- return op === 40 && (arg.kind === 8 || arg.kind === 9) ||
- op === 39 && arg.kind === 8;
- case 194:
- case 195:
- var expr = node.expression;
- if (ts.isIdentifier(expr)) {
- var symbol = getSymbolAtLocation(expr);
- if (symbol && symbol.flags & 2097152) {
- symbol = resolveAlias(symbol);
+ if (!links || links.jsxNamespace !== false) {
+ var resolvedNamespace = getJsxNamespaceContainerForImplicitImport(location);
+ if (!resolvedNamespace || resolvedNamespace === unknownSymbol) {
+ var namespaceName = getJsxNamespace(location);
+ resolvedNamespace = resolveName(location, namespaceName, 1920, undefined, namespaceName, false);
+ }
+ if (resolvedNamespace) {
+ var candidate = resolveSymbol(getSymbol(getExportsOfSymbol(resolveSymbol(resolvedNamespace)), JsxNames.JSX, 1920));
+ if (candidate && candidate !== unknownSymbol) {
+ if (links) {
+ links.jsxNamespace = candidate;
}
- return !!(symbol && (symbol.flags & 384) && getEnumKind(symbol) === 1);
+ return candidate;
}
+ }
+ if (links) {
+ links.jsxNamespace = false;
+ }
}
- return false;
+ var s = resolveSymbol(getGlobalSymbol(JsxNames.JSX, 1920, undefined));
+ if (s === unknownSymbol) {
+ return undefined;
+ }
+ return s;
}
- function checkAssertionWorker(errNode, type, expression, checkMode) {
- var exprType = checkExpression(expression, checkMode);
- if (ts.isConstTypeReference(type)) {
- if (!isValidConstAssertionArgument(expression)) {
- error(expression, ts.Diagnostics.A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals);
+ function getNameFromJsxElementAttributesContainer(nameOfAttribPropContainer, jsxNamespace) {
+ var jsxElementAttribPropInterfaceSym = jsxNamespace && getSymbol(jsxNamespace.exports, nameOfAttribPropContainer, 788968);
+ var jsxElementAttribPropInterfaceType = jsxElementAttribPropInterfaceSym && getDeclaredTypeOfSymbol(jsxElementAttribPropInterfaceSym);
+ var propertiesOfJsxElementAttribPropInterface = jsxElementAttribPropInterfaceType && getPropertiesOfType(jsxElementAttribPropInterfaceType);
+ if (propertiesOfJsxElementAttribPropInterface) {
+ if (propertiesOfJsxElementAttribPropInterface.length === 0) {
+ return "";
}
- return getRegularTypeOfLiteralType(exprType);
- }
- checkSourceElement(type);
- exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(exprType));
- var targetType = getTypeFromTypeNode(type);
- if (produceDiagnostics && targetType !== errorType) {
- var widenedType = getWidenedType(exprType);
- if (!isTypeComparableTo(targetType, widenedType)) {
- checkTypeComparableTo(exprType, targetType, errNode, ts.Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first);
+ else if (propertiesOfJsxElementAttribPropInterface.length === 1) {
+ return propertiesOfJsxElementAttribPropInterface[0].escapedName;
+ }
+ else if (propertiesOfJsxElementAttribPropInterface.length > 1) {
+ error(jsxElementAttribPropInterfaceSym.declarations[0], ts.Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, ts.unescapeLeadingUnderscores(nameOfAttribPropContainer));
}
}
- return targetType;
+ return undefined;
}
- function checkNonNullChain(node) {
- var leftType = checkExpression(node.expression);
- var nonOptionalType = getOptionalExpressionType(leftType, node.expression);
- return propagateOptionalTypeMarker(getNonNullableType(nonOptionalType), node, nonOptionalType !== leftType);
+ function getJsxLibraryManagedAttributes(jsxNamespace) {
+ return jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968);
}
- function checkNonNullAssertion(node) {
- return node.flags & 32 ? checkNonNullChain(node) :
- getNonNullableType(checkExpression(node.expression));
+ function getJsxElementPropertiesName(jsxNamespace) {
+ return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace);
}
- function checkMetaProperty(node) {
- checkGrammarMetaProperty(node);
- if (node.keywordToken === 99) {
- return checkNewTargetMetaProperty(node);
+ function getJsxElementChildrenPropertyName(jsxNamespace) {
+ return getNameFromJsxElementAttributesContainer(JsxNames.ElementChildrenAttributeNameContainer, jsxNamespace);
+ }
+ function getUninstantiatedJsxSignaturesOfType(elementType, caller) {
+ if (elementType.flags & 4) {
+ return [anySignature];
}
- if (node.keywordToken === 96) {
- return checkImportMetaProperty(node);
+ else if (elementType.flags & 128) {
+ var intrinsicType = getIntrinsicAttributesTypeFromStringLiteralType(elementType, caller);
+ if (!intrinsicType) {
+ error(caller, ts.Diagnostics.Property_0_does_not_exist_on_type_1, elementType.value, "JSX." + JsxNames.IntrinsicElements);
+ return ts.emptyArray;
+ }
+ else {
+ var fakeSignature = createSignatureForJSXIntrinsic(caller, intrinsicType);
+ return [fakeSignature];
+ }
}
- return ts.Debug.assertNever(node.keywordToken);
+ var apparentElemType = getApparentType(elementType);
+ var signatures = getSignaturesOfType(apparentElemType, 1);
+ if (signatures.length === 0) {
+ signatures = getSignaturesOfType(apparentElemType, 0);
+ }
+ if (signatures.length === 0 && apparentElemType.flags & 1048576) {
+ signatures = getUnionSignatures(ts.map(apparentElemType.types, function (t) { return getUninstantiatedJsxSignaturesOfType(t, caller); }));
+ }
+ return signatures;
}
- function checkNewTargetMetaProperty(node) {
- var container = ts.getNewTargetContainer(node);
- if (!container) {
- error(node, ts.Diagnostics.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, "new.target");
- return errorType;
+ function getIntrinsicAttributesTypeFromStringLiteralType(type, location) {
+ var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, location);
+ if (intrinsicElementsType !== errorType) {
+ var stringLiteralTypeName = type.value;
+ var intrinsicProp = getPropertyOfType(intrinsicElementsType, ts.escapeLeadingUnderscores(stringLiteralTypeName));
+ if (intrinsicProp) {
+ return getTypeOfSymbol(intrinsicProp);
+ }
+ var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, 0);
+ if (indexSignatureType) {
+ return indexSignatureType;
+ }
+ return undefined;
+ }
+ return anyType;
+ }
+ function checkJsxReturnAssignableToAppropriateBound(refKind, elemInstanceType, openingLikeElement) {
+ if (refKind === 1) {
+ var sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement);
+ if (sfcReturnConstraint) {
+ checkTypeRelatedTo(elemInstanceType, sfcReturnConstraint, assignableRelation, openingLikeElement.tagName, ts.Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
+ }
}
- else if (container.kind === 162) {
- var symbol = getSymbolOfNode(container.parent);
- return getTypeOfSymbol(symbol);
+ else if (refKind === 0) {
+ var classConstraint = getJsxElementClassTypeAt(openingLikeElement);
+ if (classConstraint) {
+ checkTypeRelatedTo(elemInstanceType, classConstraint, assignableRelation, openingLikeElement.tagName, ts.Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
+ }
}
else {
- var symbol = getSymbolOfNode(container);
- return getTypeOfSymbol(symbol);
+ var sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement);
+ var classConstraint = getJsxElementClassTypeAt(openingLikeElement);
+ if (!sfcReturnConstraint || !classConstraint) {
+ return;
+ }
+ var combined = getUnionType([sfcReturnConstraint, classConstraint]);
+ checkTypeRelatedTo(elemInstanceType, combined, assignableRelation, openingLikeElement.tagName, ts.Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
}
- }
- function checkImportMetaProperty(node) {
- if (moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System) {
- error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_esnext_or_system);
+ function generateInitialErrorChain() {
+ var componentName = ts.getTextOfNode(openingLikeElement.tagName);
+ return ts.chainDiagnosticMessages(undefined, ts.Diagnostics._0_cannot_be_used_as_a_JSX_component, componentName);
}
- var file = ts.getSourceFileOfNode(node);
- ts.Debug.assert(!!(file.flags & 2097152), "Containing file is missing import meta node flag.");
- ts.Debug.assert(!!file.externalModuleIndicator, "Containing file should be a module.");
- return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType;
}
- function getTypeOfParameter(symbol) {
- var type = getTypeOfSymbol(symbol);
- if (strictNullChecks) {
- var declaration = symbol.valueDeclaration;
- if (declaration && ts.hasInitializer(declaration)) {
- return getOptionalType(type);
+ function getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node) {
+ ts.Debug.assert(isJsxIntrinsicIdentifier(node.tagName));
+ var links = getNodeLinks(node);
+ if (!links.resolvedJsxElementAttributesType) {
+ var symbol = getIntrinsicTagSymbol(node);
+ if (links.jsxFlags & 1) {
+ return links.resolvedJsxElementAttributesType = getTypeOfSymbol(symbol);
+ }
+ else if (links.jsxFlags & 2) {
+ return links.resolvedJsxElementAttributesType =
+ getIndexTypeOfType(getDeclaredTypeOfSymbol(symbol), 0);
+ }
+ else {
+ return links.resolvedJsxElementAttributesType = errorType;
}
}
+ return links.resolvedJsxElementAttributesType;
+ }
+ function getJsxElementClassTypeAt(location) {
+ var type = getJsxType(JsxNames.ElementClass, location);
+ if (type === errorType)
+ return undefined;
return type;
}
- function getParameterNameAtPosition(signature, pos) {
- var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
- if (pos < paramCount) {
- return signature.parameters[pos].escapedName;
- }
- var restParameter = signature.parameters[paramCount] || unknownSymbol;
- var restType = getTypeOfSymbol(restParameter);
- if (isTupleType(restType)) {
- var associatedNames = restType.target.associatedNames;
- var index = pos - paramCount;
- return associatedNames && associatedNames[index] || restParameter.escapedName + "_" + index;
+ function getJsxElementTypeAt(location) {
+ return getJsxType(JsxNames.Element, location);
+ }
+ function getJsxStatelessElementTypeAt(location) {
+ var jsxElementType = getJsxElementTypeAt(location);
+ if (jsxElementType) {
+ return getUnionType([jsxElementType, nullType]);
}
- return restParameter.escapedName;
}
- function getTypeAtPosition(signature, pos) {
- return tryGetTypeAtPosition(signature, pos) || anyType;
+ function getJsxIntrinsicTagNamesAt(location) {
+ var intrinsics = getJsxType(JsxNames.IntrinsicElements, location);
+ return intrinsics ? getPropertiesOfType(intrinsics) : ts.emptyArray;
}
- function tryGetTypeAtPosition(signature, pos) {
- var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
- if (pos < paramCount) {
- return getTypeOfParameter(signature.parameters[pos]);
+ function checkJsxPreconditions(errorNode) {
+ if ((compilerOptions.jsx || 0) === 0) {
+ error(errorNode, ts.Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided);
}
- if (signatureHasRestParameter(signature)) {
- var restType = getTypeOfSymbol(signature.parameters[paramCount]);
- var index = pos - paramCount;
- if (!isTupleType(restType) || restType.target.hasRestElement || index < getTypeArguments(restType).length) {
- return getIndexedAccessType(restType, getLiteralType(index));
+ if (getJsxElementTypeAt(errorNode) === undefined) {
+ if (noImplicitAny) {
+ error(errorNode, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist);
}
}
- return undefined;
}
- function getRestTypeAtPosition(source, pos) {
- var paramCount = getParameterCount(source);
- var restType = getEffectiveRestType(source);
- var nonRestCount = paramCount - (restType ? 1 : 0);
- if (restType && pos === nonRestCount) {
- return restType;
+ function checkJsxOpeningLikeElementOrOpeningFragment(node) {
+ var isNodeOpeningLikeElement = ts.isJsxOpeningLikeElement(node);
+ if (isNodeOpeningLikeElement) {
+ checkGrammarJsxElement(node);
}
- var types = [];
- var names = [];
- for (var i = pos; i < nonRestCount; i++) {
- types.push(getTypeAtPosition(source, i));
- names.push(getParameterNameAtPosition(source, i));
+ checkJsxPreconditions(node);
+ if (!getJsxNamespaceContainerForImplicitImport(node)) {
+ var jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 ? ts.Diagnostics.Cannot_find_name_0 : undefined;
+ var jsxFactoryNamespace = getJsxNamespace(node);
+ var jsxFactoryLocation = isNodeOpeningLikeElement ? node.tagName : node;
+ var jsxFactorySym = void 0;
+ if (!(ts.isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) {
+ jsxFactorySym = resolveName(jsxFactoryLocation, jsxFactoryNamespace, 111551, jsxFactoryRefErr, jsxFactoryNamespace, true);
+ }
+ if (jsxFactorySym) {
+ jsxFactorySym.isReferenced = 67108863;
+ if (jsxFactorySym.flags & 2097152 && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
+ markAliasSymbolAsReferenced(jsxFactorySym);
+ }
+ }
}
- if (restType) {
- types.push(getIndexedAccessType(restType, numberType));
- names.push(getParameterNameAtPosition(source, nonRestCount));
+ if (isNodeOpeningLikeElement) {
+ var jsxOpeningLikeNode = node;
+ var sig = getResolvedSignature(jsxOpeningLikeNode);
+ checkDeprecatedSignature(sig, node);
+ checkJsxReturnAssignableToAppropriateBound(getJsxReferenceKind(jsxOpeningLikeNode), getReturnTypeOfSignature(sig), jsxOpeningLikeNode);
}
- var minArgumentCount = getMinArgumentCount(source);
- var minLength = minArgumentCount < pos ? 0 : minArgumentCount - pos;
- return createTupleType(types, minLength, !!restType, false, names);
}
- function getParameterCount(signature) {
- var length = signature.parameters.length;
- if (signatureHasRestParameter(signature)) {
- var restType = getTypeOfSymbol(signature.parameters[length - 1]);
- if (isTupleType(restType)) {
- return length + getTypeArguments(restType).length - 1;
+ function isKnownProperty(targetType, name, isComparingJsxAttributes) {
+ if (targetType.flags & 524288) {
+ var resolved = resolveStructuredTypeMembers(targetType);
+ if (resolved.stringIndexInfo ||
+ resolved.numberIndexInfo && isNumericLiteralName(name) ||
+ getPropertyOfObjectType(targetType, name) ||
+ isComparingJsxAttributes && !isUnhyphenatedJsxName(name)) {
+ return true;
}
}
- return length;
- }
- function getMinArgumentCount(signature, strongArityForUntypedJS) {
- if (signatureHasRestParameter(signature)) {
- var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
- if (isTupleType(restType)) {
- var minLength = restType.target.minLength;
- if (minLength > 0) {
- return signature.parameters.length - 1 + minLength;
+ else if (targetType.flags & 3145728 && isExcessPropertyCheckTarget(targetType)) {
+ for (var _i = 0, _a = targetType.types; _i < _a.length; _i++) {
+ var t = _a[_i];
+ if (isKnownProperty(t, name, isComparingJsxAttributes)) {
+ return true;
}
}
}
- if (!strongArityForUntypedJS && signature.flags & 16) {
- return 0;
- }
- return signature.minArgumentCount;
- }
- function hasEffectiveRestParameter(signature) {
- if (signatureHasRestParameter(signature)) {
- var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
- return !isTupleType(restType) || restType.target.hasRestElement;
- }
return false;
}
- function getEffectiveRestType(signature) {
- if (signatureHasRestParameter(signature)) {
- var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
- return isTupleType(restType) ? getRestArrayTypeOfTupleType(restType) : restType;
- }
- return undefined;
- }
- function getNonArrayRestType(signature) {
- var restType = getEffectiveRestType(signature);
- return restType && !isArrayType(restType) && !isTypeAny(restType) && (getReducedType(restType).flags & 131072) === 0 ? restType : undefined;
- }
- function getTypeOfFirstParameterOfSignature(signature) {
- return getTypeOfFirstParameterOfSignatureWithFallback(signature, neverType);
- }
- function getTypeOfFirstParameterOfSignatureWithFallback(signature, fallbackType) {
- return signature.parameters.length > 0 ? getTypeAtPosition(signature, 0) : fallbackType;
+ function isExcessPropertyCheckTarget(type) {
+ return !!(type.flags & 524288 && !(ts.getObjectFlags(type) & 512) ||
+ type.flags & 67108864 ||
+ type.flags & 1048576 && ts.some(type.types, isExcessPropertyCheckTarget) ||
+ type.flags & 2097152 && ts.every(type.types, isExcessPropertyCheckTarget));
}
- function inferFromAnnotatedParameters(signature, context, inferenceContext) {
- var len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
- for (var i = 0; i < len; i++) {
- var declaration = signature.parameters[i].valueDeclaration;
- if (declaration.type) {
- var typeNode = ts.getEffectiveTypeAnnotationNode(declaration);
- if (typeNode) {
- inferTypes(inferenceContext.inferences, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
- }
+ function checkJsxExpression(node, checkMode) {
+ checkGrammarJsxExpression(node);
+ if (node.expression) {
+ var type = checkExpression(node.expression, checkMode);
+ if (node.dotDotDotToken && type !== anyType && !isArrayType(type)) {
+ error(node, ts.Diagnostics.JSX_spread_child_must_be_an_array_type);
}
+ return type;
}
- var restType = getEffectiveRestType(context);
- if (restType && restType.flags & 262144) {
- var instantiatedContext = instantiateSignature(context, inferenceContext.nonFixingMapper);
- assignContextualParameterTypes(signature, instantiatedContext);
- var restPos = getParameterCount(context) - 1;
- inferTypes(inferenceContext.inferences, getRestTypeAtPosition(signature, restPos), restType);
+ else {
+ return errorType;
}
}
- function assignContextualParameterTypes(signature, context) {
- signature.typeParameters = context.typeParameters;
- if (context.thisParameter) {
- var parameter = signature.thisParameter;
- if (!parameter || parameter.valueDeclaration && !parameter.valueDeclaration.type) {
- if (!parameter) {
- signature.thisParameter = createSymbolWithType(context.thisParameter, undefined);
- }
- assignParameterType(signature.thisParameter, getTypeOfSymbol(context.thisParameter));
- }
- }
- var len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
- for (var i = 0; i < len; i++) {
- var parameter = signature.parameters[i];
- if (!ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) {
- var contextualParameterType = tryGetTypeAtPosition(context, i);
- assignParameterType(parameter, contextualParameterType);
- }
- }
- if (signatureHasRestParameter(signature)) {
- var parameter = ts.last(signature.parameters);
- if (ts.isTransientSymbol(parameter) || !ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) {
- var contextualParameterType = getRestTypeAtPosition(context, len);
- assignParameterType(parameter, contextualParameterType);
- }
- }
+ function getDeclarationNodeFlagsFromSymbol(s) {
+ return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : 0;
}
- function assignNonContextualParameterTypes(signature) {
- if (signature.thisParameter) {
- assignParameterType(signature.thisParameter);
+ function isPrototypeProperty(symbol) {
+ if (symbol.flags & 8192 || ts.getCheckFlags(symbol) & 4) {
+ return true;
}
- for (var _i = 0, _a = signature.parameters; _i < _a.length; _i++) {
- var parameter = _a[_i];
- assignParameterType(parameter);
+ if (ts.isInJSFile(symbol.valueDeclaration)) {
+ var parent = symbol.valueDeclaration.parent;
+ return parent && ts.isBinaryExpression(parent) &&
+ ts.getAssignmentDeclarationKind(parent) === 3;
}
}
- function assignParameterType(parameter, type) {
- var links = getSymbolLinks(parameter);
- if (!links.type) {
- var declaration = parameter.valueDeclaration;
- links.type = type || getWidenedTypeForVariableLikeDeclaration(declaration, true);
- if (declaration.name.kind !== 75) {
- if (links.type === unknownType) {
- links.type = getTypeFromBindingPattern(declaration.name);
+ function checkPropertyAccessibility(node, isSuper, type, prop) {
+ var flags = ts.getDeclarationModifierFlagsFromSymbol(prop);
+ var errorNode = node.kind === 157 ? node.right : node.kind === 195 ? node : node.name;
+ if (isSuper) {
+ if (languageVersion < 2) {
+ if (symbolHasNonMethodDeclaration(prop)) {
+ error(errorNode, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
+ return false;
}
- assignBindingElementTypes(declaration.name);
}
- }
- }
- function assignBindingElementTypes(pattern) {
- for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
- var element = _a[_i];
- if (!ts.isOmittedExpression(element)) {
- if (element.name.kind === 75) {
- getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element);
- }
- else {
- assignBindingElementTypes(element.name);
- }
+ if (flags & 128) {
+ error(errorNode, ts.Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(getDeclaringClass(prop)));
+ return false;
}
}
- }
- function createPromiseType(promisedType) {
- var globalPromiseType = getGlobalPromiseType(true);
- if (globalPromiseType !== emptyGenericType) {
- promisedType = getAwaitedType(promisedType) || unknownType;
- return createTypeReference(globalPromiseType, [promisedType]);
- }
- return unknownType;
- }
- function createPromiseLikeType(promisedType) {
- var globalPromiseLikeType = getGlobalPromiseLikeType(true);
- if (globalPromiseLikeType !== emptyGenericType) {
- promisedType = getAwaitedType(promisedType) || unknownType;
- return createTypeReference(globalPromiseLikeType, [promisedType]);
- }
- return unknownType;
- }
- function createPromiseReturnType(func, promisedType) {
- var promiseType = createPromiseType(promisedType);
- if (promiseType === unknownType) {
- error(func, ts.isImportCall(func) ?
- ts.Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option :
- ts.Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option);
- return errorType;
+ if ((flags & 128) && ts.isThisProperty(node) && symbolHasNonMethodDeclaration(prop)) {
+ var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
+ if (declaringClassDeclaration && isNodeUsedDuringClassInitialization(node)) {
+ error(errorNode, ts.Diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor, symbolToString(prop), ts.getTextOfIdentifierOrLiteral(declaringClassDeclaration.name));
+ return false;
+ }
}
- else if (!getGlobalPromiseConstructorSymbol(true)) {
- error(func, ts.isImportCall(func) ?
- ts.Diagnostics.A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option :
- ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
+ if (ts.isPropertyAccessExpression(node) && ts.isPrivateIdentifier(node.name)) {
+ if (!ts.getContainingClass(node)) {
+ error(errorNode, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+ return false;
+ }
+ return true;
}
- return promiseType;
- }
- function getReturnTypeFromBody(func, checkMode) {
- if (!func.body) {
- return errorType;
+ if (!(flags & 24)) {
+ return true;
}
- var functionFlags = ts.getFunctionFlags(func);
- var isAsync = (functionFlags & 2) !== 0;
- var isGenerator = (functionFlags & 1) !== 0;
- var returnType;
- var yieldType;
- var nextType;
- var fallbackReturnType = voidType;
- if (func.body.kind !== 223) {
- returnType = checkExpressionCached(func.body, checkMode && checkMode & ~8);
- if (isAsync) {
- returnType = checkAwaitedType(returnType, func, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+ if (flags & 8) {
+ var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
+ if (!isNodeWithinClass(node, declaringClassDeclaration)) {
+ error(errorNode, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(getDeclaringClass(prop)));
+ return false;
}
+ return true;
}
- else if (isGenerator) {
- var returnTypes = checkAndAggregateReturnExpressionTypes(func, checkMode);
- if (!returnTypes) {
- fallbackReturnType = neverType;
- }
- else if (returnTypes.length > 0) {
- returnType = getUnionType(returnTypes, 2);
- }
- var _a = checkAndAggregateYieldOperandTypes(func, checkMode), yieldTypes = _a.yieldTypes, nextTypes = _a.nextTypes;
- yieldType = ts.some(yieldTypes) ? getUnionType(yieldTypes, 2) : undefined;
- nextType = ts.some(nextTypes) ? getIntersectionType(nextTypes) : undefined;
+ if (isSuper) {
+ return true;
}
- else {
- var types = checkAndAggregateReturnExpressionTypes(func, checkMode);
- if (!types) {
- return functionFlags & 2
- ? createPromiseReturnType(func, neverType)
- : neverType;
- }
- if (types.length === 0) {
- return functionFlags & 2
- ? createPromiseReturnType(func, voidType)
- : voidType;
+ var enclosingClass = forEachEnclosingClass(node, function (enclosingDeclaration) {
+ var enclosingClass = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingDeclaration));
+ return isClassDerivedFromDeclaringClasses(enclosingClass, prop) ? enclosingClass : undefined;
+ });
+ if (!enclosingClass) {
+ var thisParameter = void 0;
+ if (flags & 32 || !(thisParameter = getThisParameterFromNodeContext(node)) || !thisParameter.type) {
+ error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(getDeclaringClass(prop) || type));
+ return false;
}
- returnType = getUnionType(types, 2);
+ var thisType = getTypeFromTypeNode(thisParameter.type);
+ enclosingClass = ((thisType.flags & 262144) ? getConstraintOfTypeParameter(thisType) : thisType).target;
}
- if (returnType || yieldType || nextType) {
- if (yieldType)
- reportErrorsFromWidening(func, yieldType, 3);
- if (returnType)
- reportErrorsFromWidening(func, returnType, 1);
- if (nextType)
- reportErrorsFromWidening(func, nextType, 2);
- if (returnType && isUnitType(returnType) ||
- yieldType && isUnitType(yieldType) ||
- nextType && isUnitType(nextType)) {
- var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
- var contextualType = !contextualSignature ? undefined :
- contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? undefined : returnType :
- instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func);
- if (isGenerator) {
- yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, 0, isAsync);
- returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, 1, isAsync);
- nextType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(nextType, contextualType, 2, isAsync);
- }
- else {
- returnType = getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(returnType, contextualType, isAsync);
- }
- }
- if (yieldType)
- yieldType = getWidenedType(yieldType);
- if (returnType)
- returnType = getWidenedType(returnType);
- if (nextType)
- nextType = getWidenedType(nextType);
+ if (flags & 32) {
+ return true;
}
- if (isGenerator) {
- return createGeneratorReturnType(yieldType || neverType, returnType || fallbackReturnType, nextType || getContextualIterationType(2, func) || unknownType, isAsync);
+ if (type.flags & 262144) {
+ type = type.isThisType ? getConstraintOfTypeParameter(type) : getBaseConstraintOfType(type);
}
- else {
- return isAsync
- ? createPromiseType(returnType || fallbackReturnType)
- : returnType || fallbackReturnType;
+ if (!type || !hasBaseType(type, enclosingClass)) {
+ error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1, symbolToString(prop), typeToString(enclosingClass));
+ return false;
}
+ return true;
}
- function createGeneratorReturnType(yieldType, returnType, nextType, isAsyncGenerator) {
- var resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
- var globalGeneratorType = resolver.getGlobalGeneratorType(false);
- yieldType = resolver.resolveIterationType(yieldType, undefined) || unknownType;
- returnType = resolver.resolveIterationType(returnType, undefined) || unknownType;
- nextType = resolver.resolveIterationType(nextType, undefined) || unknownType;
- if (globalGeneratorType === emptyGenericType) {
- var globalType = resolver.getGlobalIterableIteratorType(false);
- var iterationTypes = globalType !== emptyGenericType ? getIterationTypesOfGlobalIterableType(globalType, resolver) : undefined;
- var iterableIteratorReturnType = iterationTypes ? iterationTypes.returnType : anyType;
- var iterableIteratorNextType = iterationTypes ? iterationTypes.nextType : undefinedType;
- if (isTypeAssignableTo(returnType, iterableIteratorReturnType) &&
- isTypeAssignableTo(iterableIteratorNextType, nextType)) {
- if (globalType !== emptyGenericType) {
- return createTypeFromGenericGlobalType(globalType, [yieldType]);
- }
- resolver.getGlobalIterableIteratorType(true);
- return emptyObjectType;
- }
- resolver.getGlobalGeneratorType(true);
- return emptyObjectType;
- }
- return createTypeFromGenericGlobalType(globalGeneratorType, [yieldType, returnType, nextType]);
+ function getThisParameterFromNodeContext(node) {
+ var thisContainer = ts.getThisContainer(node, false);
+ return thisContainer && ts.isFunctionLike(thisContainer) ? ts.getThisParameter(thisContainer) : undefined;
}
- function checkAndAggregateYieldOperandTypes(func, checkMode) {
- var yieldTypes = [];
- var nextTypes = [];
- var isAsync = (ts.getFunctionFlags(func) & 2) !== 0;
- ts.forEachYieldExpression(func.body, function (yieldExpression) {
- var yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType;
- ts.pushIfUnique(yieldTypes, getYieldedTypeOfYieldExpression(yieldExpression, yieldExpressionType, anyType, isAsync));
- var nextType;
- if (yieldExpression.asteriskToken) {
- var iterationTypes = getIterationTypesOfIterable(yieldExpressionType, isAsync ? 19 : 17, yieldExpression.expression);
- nextType = iterationTypes && iterationTypes.nextType;
- }
- else {
- nextType = getContextualType(yieldExpression);
- }
- if (nextType)
- ts.pushIfUnique(nextTypes, nextType);
- });
- return { yieldTypes: yieldTypes, nextTypes: nextTypes };
+ function symbolHasNonMethodDeclaration(symbol) {
+ return !!forEachProperty(symbol, function (prop) { return !(prop.flags & 8192); });
}
- function getYieldedTypeOfYieldExpression(node, expressionType, sentType, isAsync) {
- var errorNode = node.expression || node;
- var yieldedType = node.asteriskToken ? checkIteratedTypeOrElementType(isAsync ? 19 : 17, expressionType, sentType, errorNode) : expressionType;
- return !isAsync ? yieldedType : getAwaitedType(yieldedType, errorNode, node.asteriskToken
- ? ts.Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
- : ts.Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+ function checkNonNullExpression(node) {
+ return checkNonNullType(checkExpression(node), node);
}
- function getFactsFromTypeofSwitch(start, end, witnesses, hasDefault) {
- var facts = 0;
- if (hasDefault) {
- for (var i = end; i < witnesses.length; i++) {
- facts |= typeofNEFacts.get(witnesses[i]) || 32768;
- }
- for (var i = start; i < end; i++) {
- facts &= ~(typeofNEFacts.get(witnesses[i]) || 0);
- }
- for (var i = 0; i < start; i++) {
- facts |= typeofNEFacts.get(witnesses[i]) || 32768;
- }
+ function isNullableType(type) {
+ return !!((strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304);
+ }
+ function getNonNullableTypeIfNeeded(type) {
+ return isNullableType(type) ? getNonNullableType(type) : type;
+ }
+ function reportObjectPossiblyNullOrUndefinedError(node, flags) {
+ error(node, flags & 32768 ? flags & 65536 ?
+ ts.Diagnostics.Object_is_possibly_null_or_undefined :
+ ts.Diagnostics.Object_is_possibly_undefined :
+ ts.Diagnostics.Object_is_possibly_null);
+ }
+ function reportCannotInvokePossiblyNullOrUndefinedError(node, flags) {
+ error(node, flags & 32768 ? flags & 65536 ?
+ ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined :
+ ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined :
+ ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null);
+ }
+ function checkNonNullTypeWithReporter(type, node, reportError) {
+ if (strictNullChecks && type.flags & 2) {
+ error(node, ts.Diagnostics.Object_is_of_type_unknown);
+ return errorType;
}
- else {
- for (var i = start; i < end; i++) {
- facts |= typeofEQFacts.get(witnesses[i]) || 128;
- }
- for (var i = 0; i < start; i++) {
- facts &= ~(typeofEQFacts.get(witnesses[i]) || 0);
- }
+ var kind = (strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304;
+ if (kind) {
+ reportError(node, kind);
+ var t = getNonNullableType(type);
+ return t.flags & (98304 | 131072) ? errorType : t;
}
- return facts;
+ return type;
+ }
+ function checkNonNullType(type, node) {
+ return checkNonNullTypeWithReporter(type, node, reportObjectPossiblyNullOrUndefinedError);
+ }
+ function checkNonNullNonVoidType(type, node) {
+ var nonNullType = checkNonNullType(type, node);
+ if (nonNullType !== errorType && nonNullType.flags & 16384) {
+ error(node, ts.Diagnostics.Object_is_possibly_undefined);
+ }
+ return nonNullType;
+ }
+ function checkPropertyAccessExpression(node) {
+ return node.flags & 32 ? checkPropertyAccessChain(node) :
+ checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name);
}
- function isExhaustiveSwitchStatement(node) {
- var links = getNodeLinks(node);
- return links.isExhaustive !== undefined ? links.isExhaustive : (links.isExhaustive = computeExhaustiveSwitchStatement(node));
+ function checkPropertyAccessChain(node) {
+ var leftType = checkExpression(node.expression);
+ var nonOptionalType = getOptionalExpressionType(leftType, node.expression);
+ return propagateOptionalTypeMarker(checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullType(nonOptionalType, node.expression), node.name), node, nonOptionalType !== leftType);
}
- function computeExhaustiveSwitchStatement(node) {
- if (node.expression.kind === 204) {
- var operandType = getTypeOfExpression(node.expression.expression);
- var witnesses = getSwitchClauseTypeOfWitnesses(node, false);
- var notEqualFacts_1 = getFactsFromTypeofSwitch(0, 0, witnesses, true);
- var type_3 = getBaseConstraintOfType(operandType) || operandType;
- return !!(filterType(type_3, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072);
- }
- var type = getTypeOfExpression(node.expression);
- if (!isLiteralType(type)) {
- return false;
+ function checkQualifiedName(node) {
+ return checkPropertyAccessExpressionOrQualifiedName(node, node.left, checkNonNullExpression(node.left), node.right);
+ }
+ function isMethodAccessForCall(node) {
+ while (node.parent.kind === 207) {
+ node = node.parent;
}
- var switchTypes = getSwitchClauseTypes(node);
- if (!switchTypes.length || ts.some(switchTypes, isNeitherUnitTypeNorNever)) {
- return false;
+ return ts.isCallOrNewExpression(node.parent) && node.parent.expression === node;
+ }
+ function lookupSymbolForPrivateIdentifierDeclaration(propName, location) {
+ for (var containingClass = ts.getContainingClass(location); !!containingClass; containingClass = ts.getContainingClass(containingClass)) {
+ var symbol = containingClass.symbol;
+ var name = ts.getSymbolNameForPrivateIdentifier(symbol, propName);
+ var prop = (symbol.members && symbol.members.get(name)) || (symbol.exports && symbol.exports.get(name));
+ if (prop) {
+ return prop;
+ }
}
- return eachTypeContainedIn(mapType(type, getRegularTypeOfLiteralType), switchTypes);
}
- function functionHasImplicitReturn(func) {
- return func.endFlowNode && isReachableFlowNode(func.endFlowNode);
+ function getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) {
+ return getPropertyOfType(leftType, lexicallyScopedIdentifier.escapedName);
}
- function checkAndAggregateReturnExpressionTypes(func, checkMode) {
- var functionFlags = ts.getFunctionFlags(func);
- var aggregatedTypes = [];
- var hasReturnWithNoExpression = functionHasImplicitReturn(func);
- var hasReturnOfTypeNever = false;
- ts.forEachReturnStatement(func.body, function (returnStatement) {
- var expr = returnStatement.expression;
- if (expr) {
- var type = checkExpressionCached(expr, checkMode && checkMode & ~8);
- if (functionFlags & 2) {
- type = checkAwaitedType(type, func, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+ function checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedIdentifier) {
+ var propertyOnType;
+ var properties = getPropertiesOfType(leftType);
+ if (properties) {
+ ts.forEach(properties, function (symbol) {
+ var decl = symbol.valueDeclaration;
+ if (decl && ts.isNamedDeclaration(decl) && ts.isPrivateIdentifier(decl.name) && decl.name.escapedText === right.escapedText) {
+ propertyOnType = symbol;
+ return true;
}
- if (type.flags & 131072) {
- hasReturnOfTypeNever = true;
+ });
+ }
+ var diagName = diagnosticName(right);
+ if (propertyOnType) {
+ var typeValueDecl = propertyOnType.valueDeclaration;
+ var typeClass_1 = ts.getContainingClass(typeValueDecl);
+ ts.Debug.assert(!!typeClass_1);
+ if (lexicallyScopedIdentifier) {
+ var lexicalValueDecl = lexicallyScopedIdentifier.valueDeclaration;
+ var lexicalClass = ts.getContainingClass(lexicalValueDecl);
+ ts.Debug.assert(!!lexicalClass);
+ if (ts.findAncestor(lexicalClass, function (n) { return typeClass_1 === n; })) {
+ var diagnostic = error(right, ts.Diagnostics.The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling, diagName, typeToString(leftType));
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(lexicalValueDecl, ts.Diagnostics.The_shadowing_declaration_of_0_is_defined_here, diagName), ts.createDiagnosticForNode(typeValueDecl, ts.Diagnostics.The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here, diagName));
+ return true;
}
- ts.pushIfUnique(aggregatedTypes, type);
- }
- else {
- hasReturnWithNoExpression = true;
}
- });
- if (aggregatedTypes.length === 0 && !hasReturnWithNoExpression && (hasReturnOfTypeNever || mayReturnNever(func))) {
- return undefined;
- }
- if (strictNullChecks && aggregatedTypes.length && hasReturnWithNoExpression &&
- !(isJSConstructor(func) && aggregatedTypes.some(function (t) { return t.symbol === func.symbol; }))) {
- ts.pushIfUnique(aggregatedTypes, undefinedType);
+ error(right, ts.Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier, diagName, diagnosticName(typeClass_1.name || anon));
+ return true;
}
- return aggregatedTypes;
+ return false;
}
- function mayReturnNever(func) {
- switch (func.kind) {
- case 201:
- case 202:
- return true;
- case 161:
- return func.parent.kind === 193;
- default:
- return false;
- }
+ function isThisPropertyAccessInConstructor(node, prop) {
+ return (isConstructorDeclaredProperty(prop) || ts.isThisProperty(node) && isAutoTypedProperty(prop))
+ && ts.getThisContainer(node, true) === getDeclaringConstructor(prop);
}
- function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
- if (!produceDiagnostics) {
- return;
- }
- var functionFlags = ts.getFunctionFlags(func);
- var type = returnType && unwrapReturnType(returnType, functionFlags);
- if (type && maybeTypeOfKind(type, 1 | 16384)) {
- return;
- }
- if (func.kind === 160 || ts.nodeIsMissing(func.body) || func.body.kind !== 223 || !functionHasImplicitReturn(func)) {
- return;
- }
- var hasExplicitReturn = func.flags & 512;
- if (type && type.flags & 131072) {
- error(ts.getEffectiveReturnTypeNode(func), ts.Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
- }
- else if (type && !hasExplicitReturn) {
- error(ts.getEffectiveReturnTypeNode(func), ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
- }
- else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {
- error(ts.getEffectiveReturnTypeNode(func) || func, ts.Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
+ function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right) {
+ var parentSymbol = getNodeLinks(left).resolvedSymbol;
+ var assignmentKind = ts.getAssignmentTargetKind(node);
+ var apparentType = getApparentType(assignmentKind !== 0 || isMethodAccessForCall(node) ? getWidenedType(leftType) : leftType);
+ if (ts.isPrivateIdentifier(right)) {
+ checkExternalEmitHelpers(node, 1048576);
}
- else if (compilerOptions.noImplicitReturns) {
- if (!type) {
- if (!hasExplicitReturn) {
- return;
+ var isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType;
+ var prop;
+ if (ts.isPrivateIdentifier(right)) {
+ var lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(right.escapedText, right);
+ if (isAnyLike) {
+ if (lexicallyScopedSymbol) {
+ return apparentType;
}
- var inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
- if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) {
- return;
+ if (!ts.getContainingClass(right)) {
+ grammarErrorOnNode(right, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+ return anyType;
}
}
- error(ts.getEffectiveReturnTypeNode(func) || func, ts.Diagnostics.Not_all_code_paths_return_a_value);
+ prop = lexicallyScopedSymbol ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedSymbol) : undefined;
+ if (!prop && checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedSymbol)) {
+ return errorType;
+ }
}
- }
- function checkFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
- ts.Debug.assert(node.kind !== 161 || ts.isObjectLiteralMethod(node));
- checkNodeDeferred(node);
- if (checkMode && checkMode & 4 && isContextSensitive(node)) {
- if (!ts.getEffectiveReturnTypeNode(node) && !hasContextSensitiveParameters(node)) {
- var contextualSignature = getContextualSignature(node);
- if (contextualSignature && couldContainTypeVariables(getReturnTypeOfSignature(contextualSignature))) {
- var links = getNodeLinks(node);
- if (links.contextFreeType) {
- return links.contextFreeType;
- }
- var returnType = getReturnTypeFromBody(node, checkMode);
- var returnOnlySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, returnType, undefined, 0, 0);
- var returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], ts.emptyArray, undefined, undefined);
- returnOnlyType.objectFlags |= 2097152;
- return links.contextFreeType = returnOnlyType;
+ else {
+ if (isAnyLike) {
+ if (ts.isIdentifier(left) && parentSymbol) {
+ markAliasReferenced(parentSymbol, node);
}
+ return apparentType;
}
- return anyFunctionType;
+ prop = getPropertyOfType(apparentType, right.escapedText);
}
- var hasGrammarError = checkGrammarFunctionLikeDeclaration(node);
- if (!hasGrammarError && node.kind === 201) {
- checkGrammarForGenerator(node);
+ if (ts.isIdentifier(left) && parentSymbol && !(prop && isConstEnumOrConstEnumOnlyModule(prop))) {
+ markAliasReferenced(parentSymbol, node);
}
- contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode);
- return getTypeOfSymbol(getSymbolOfNode(node));
- }
- function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
- var links = getNodeLinks(node);
- if (!(links.flags & 1024)) {
- var contextualSignature = getContextualSignature(node);
- if (!(links.flags & 1024)) {
- links.flags |= 1024;
- var signature = ts.firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfNode(node)), 0));
- if (!signature) {
- return;
+ var propType;
+ if (!prop) {
+ var indexInfo = !ts.isPrivateIdentifier(right) && (assignmentKind === 0 || !isGenericObjectType(leftType) || isThisTypeParameter(leftType)) ? getIndexInfoOfType(apparentType, 0) : undefined;
+ if (!(indexInfo && indexInfo.type)) {
+ if (isJSLiteralType(leftType)) {
+ return anyType;
}
- if (isContextSensitive(node)) {
- if (contextualSignature) {
- var inferenceContext = getInferenceContext(node);
- if (checkMode && checkMode & 2) {
- inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext);
- }
- var instantiatedContextualSignature = inferenceContext ?
- instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature;
- assignContextualParameterTypes(signature, instantiatedContextualSignature);
+ if (leftType.symbol === globalThisSymbol) {
+ if (globalThisSymbol.exports.has(right.escapedText) && (globalThisSymbol.exports.get(right.escapedText).flags & 418)) {
+ error(right, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(right.escapedText), typeToString(leftType));
}
- else {
- assignNonContextualParameterTypes(signature);
+ else if (noImplicitAny) {
+ error(right, ts.Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature, typeToString(leftType));
}
+ return anyType;
}
- if (contextualSignature && !getReturnTypeFromAnnotation(node) && !signature.resolvedReturnType) {
- var returnType = getReturnTypeFromBody(node, checkMode);
- if (!signature.resolvedReturnType) {
- signature.resolvedReturnType = returnType;
- }
+ if (right.escapedText && !checkAndReportErrorForExtendingInterface(node)) {
+ reportNonexistentProperty(right, isThisTypeParameter(leftType) ? apparentType : leftType);
}
- checkSignatureDeclaration(node);
- }
- }
- }
- function checkFunctionExpressionOrObjectLiteralMethodDeferred(node) {
- ts.Debug.assert(node.kind !== 161 || ts.isObjectLiteralMethod(node));
- var functionFlags = ts.getFunctionFlags(node);
- var returnType = getReturnTypeFromAnnotation(node);
- checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
- if (node.body) {
- if (!ts.getEffectiveReturnTypeNode(node)) {
- getReturnTypeOfSignature(getSignatureFromDeclaration(node));
- }
- if (node.body.kind === 223) {
- checkSourceElement(node.body);
+ return errorType;
}
- else {
- var exprType = checkExpression(node.body);
- var returnOrPromisedType = returnType && unwrapReturnType(returnType, functionFlags);
- if (returnOrPromisedType) {
- if ((functionFlags & 3) === 2) {
- var awaitedType = checkAwaitedType(exprType, node.body, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
- checkTypeAssignableToAndOptionallyElaborate(awaitedType, returnOrPromisedType, node.body, node.body);
- }
- else {
- checkTypeAssignableToAndOptionallyElaborate(exprType, returnOrPromisedType, node.body, node.body);
- }
- }
+ if (indexInfo.isReadonly && (ts.isAssignmentTarget(node) || ts.isDeleteTarget(node))) {
+ error(node, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType));
}
+ propType = (compilerOptions.noUncheckedIndexedAccess && !ts.isAssignmentTarget(node)) ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
}
- }
- function checkArithmeticOperandType(operand, type, diagnostic, isAwaitValid) {
- if (isAwaitValid === void 0) { isAwaitValid = false; }
- if (!isTypeAssignableTo(type, numberOrBigIntType)) {
- var awaitedType = isAwaitValid && getAwaitedTypeOfPromise(type);
- errorAndMaybeSuggestAwait(operand, !!awaitedType && isTypeAssignableTo(awaitedType, numberOrBigIntType), diagnostic);
- return false;
- }
- return true;
- }
- function isReadonlyAssignmentDeclaration(d) {
- if (!ts.isCallExpression(d)) {
- return false;
- }
- if (!ts.isBindableObjectDefinePropertyCall(d)) {
- return false;
- }
- var objectLitType = checkExpressionCached(d.arguments[2]);
- var valueType = getTypeOfPropertyOfType(objectLitType, "value");
- if (valueType) {
- var writableProp = getPropertyOfType(objectLitType, "writable");
- var writableType = writableProp && getTypeOfSymbol(writableProp);
- if (!writableType || writableType === falseType || writableType === regularFalseType) {
- return true;
+ else {
+ if (getDeclarationNodeFlagsFromSymbol(prop) & 134217728 && isUncalledFunctionReference(node, prop)) {
+ errorOrSuggestion(false, right, ts.Diagnostics._0_is_deprecated, right.escapedText);
}
- if (writableProp && writableProp.valueDeclaration && ts.isPropertyAssignment(writableProp.valueDeclaration)) {
- var initializer = writableProp.valueDeclaration.initializer;
- var rawOriginalType = checkExpression(initializer);
- if (rawOriginalType === falseType || rawOriginalType === regularFalseType) {
- return true;
- }
+ checkPropertyNotUsedBeforeDeclaration(prop, node, right);
+ markPropertyAsReferenced(prop, node, left.kind === 107);
+ getNodeLinks(node).resolvedSymbol = prop;
+ checkPropertyAccessibility(node, left.kind === 105, apparentType, prop);
+ if (isAssignmentToReadonlyEntity(node, prop, assignmentKind)) {
+ error(right, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, ts.idText(right));
+ return errorType;
}
- return false;
+ propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : getConstraintForLocation(getTypeOfSymbol(prop), node);
}
- var setProp = getPropertyOfType(objectLitType, "set");
- return !setProp;
- }
- function isReadonlySymbol(symbol) {
- return !!(ts.getCheckFlags(symbol) & 8 ||
- symbol.flags & 4 && ts.getDeclarationModifierFlagsFromSymbol(symbol) & 64 ||
- symbol.flags & 3 && getDeclarationNodeFlagsFromSymbol(symbol) & 2 ||
- symbol.flags & 98304 && !(symbol.flags & 65536) ||
- symbol.flags & 8 ||
- ts.some(symbol.declarations, isReadonlyAssignmentDeclaration));
+ return getFlowTypeOfAccessExpression(node, prop, propType, right);
}
- function isAssignmentToReadonlyEntity(expr, symbol, assignmentKind) {
- var _a, _b;
- if (assignmentKind === 0) {
- return false;
+ function getFlowTypeOfAccessExpression(node, prop, propType, errorNode) {
+ var assignmentKind = ts.getAssignmentTargetKind(node);
+ if (!ts.isAccessExpression(node) ||
+ assignmentKind === 1 ||
+ prop && !(prop.flags & (3 | 4 | 98304)) && !(prop.flags & 8192 && propType.flags & 1048576)) {
+ return propType;
}
- if (isReadonlySymbol(symbol)) {
- if (symbol.flags & 4 &&
- ts.isAccessExpression(expr) &&
- expr.expression.kind === 104) {
- var ctor = ts.getContainingFunction(expr);
- if (!(ctor && ctor.kind === 162)) {
- return true;
- }
- if (symbol.valueDeclaration) {
- var isAssignmentDeclaration_1 = ts.isBinaryExpression(symbol.valueDeclaration);
- var isLocalPropertyDeclaration = ctor.parent === symbol.valueDeclaration.parent;
- var isLocalParameterProperty = ctor === symbol.valueDeclaration.parent;
- var isLocalThisPropertyAssignment = isAssignmentDeclaration_1 && ((_a = symbol.parent) === null || _a === void 0 ? void 0 : _a.valueDeclaration) === ctor.parent;
- var isLocalThisPropertyAssignmentConstructorFunction = isAssignmentDeclaration_1 && ((_b = symbol.parent) === null || _b === void 0 ? void 0 : _b.valueDeclaration) === ctor;
- var isWriteableSymbol = isLocalPropertyDeclaration
- || isLocalParameterProperty
- || isLocalThisPropertyAssignment
- || isLocalThisPropertyAssignmentConstructorFunction;
- return !isWriteableSymbol;
- }
- }
- return true;
+ if (propType === autoType) {
+ return getFlowTypeOfProperty(node, prop);
}
- if (ts.isAccessExpression(expr)) {
- var node = ts.skipParentheses(expr.expression);
- if (node.kind === 75) {
- var symbol_2 = getNodeLinks(node).resolvedSymbol;
- if (symbol_2.flags & 2097152) {
- var declaration = getDeclarationOfAliasSymbol(symbol_2);
- return !!declaration && declaration.kind === 256;
+ var assumeUninitialized = false;
+ if (strictNullChecks && strictPropertyInitialization && node.expression.kind === 107) {
+ var declaration = prop && prop.valueDeclaration;
+ if (declaration && isInstancePropertyWithoutInitializer(declaration)) {
+ var flowContainer = getControlFlowContainer(node);
+ if (flowContainer.kind === 166 && flowContainer.parent === declaration.parent && !(declaration.flags & 8388608)) {
+ assumeUninitialized = true;
}
}
}
- return false;
- }
- function checkReferenceExpression(expr, invalidReferenceMessage, invalidOptionalChainMessage) {
- var node = ts.skipOuterExpressions(expr, 6 | 1);
- if (node.kind !== 75 && !ts.isAccessExpression(node)) {
- error(expr, invalidReferenceMessage);
- return false;
+ else if (strictNullChecks && prop && prop.valueDeclaration &&
+ ts.isPropertyAccessExpression(prop.valueDeclaration) &&
+ ts.getAssignmentDeclarationPropertyAccessKind(prop.valueDeclaration) &&
+ getControlFlowContainer(node) === getControlFlowContainer(prop.valueDeclaration)) {
+ assumeUninitialized = true;
}
- if (node.flags & 32) {
- error(expr, invalidOptionalChainMessage);
- return false;
+ var flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType);
+ if (assumeUninitialized && !(getFalsyFlags(propType) & 32768) && getFalsyFlags(flowType) & 32768) {
+ error(errorNode, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(prop));
+ return propType;
}
- return true;
+ return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
}
- function checkDeleteExpression(node) {
- checkExpression(node.expression);
- var expr = ts.skipParentheses(node.expression);
- if (!ts.isAccessExpression(expr)) {
- error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference);
- return booleanType;
+ function checkPropertyNotUsedBeforeDeclaration(prop, node, right) {
+ var valueDeclaration = prop.valueDeclaration;
+ if (!valueDeclaration || ts.getSourceFileOfNode(node).isDeclarationFile) {
+ return;
}
- if (expr.kind === 194 && ts.isPrivateIdentifier(expr.name)) {
- error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier);
+ var diagnosticMessage;
+ var declarationName = ts.idText(right);
+ if (isInPropertyInitializer(node)
+ && !(ts.isAccessExpression(node) && ts.isAccessExpression(node.expression))
+ && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)
+ && !isPropertyDeclaredInAncestorClass(prop)) {
+ diagnosticMessage = error(right, ts.Diagnostics.Property_0_is_used_before_its_initialization, declarationName);
}
- var links = getNodeLinks(expr);
- var symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol);
- if (symbol && isReadonlySymbol(symbol)) {
- error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property);
+ else if (valueDeclaration.kind === 252 &&
+ node.parent.kind !== 173 &&
+ !(valueDeclaration.flags & 8388608) &&
+ !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)) {
+ diagnosticMessage = error(right, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName);
+ }
+ if (diagnosticMessage) {
+ ts.addRelatedInfo(diagnosticMessage, ts.createDiagnosticForNode(valueDeclaration, ts.Diagnostics._0_is_declared_here, declarationName));
}
- return booleanType;
- }
- function checkTypeOfExpression(node) {
- checkExpression(node.expression);
- return typeofType;
- }
- function checkVoidExpression(node) {
- checkExpression(node.expression);
- return undefinedWideningType;
}
- function isTopLevelAwait(node) {
- var container = ts.getThisContainer(node, true);
- return ts.isSourceFile(container);
+ function isInPropertyInitializer(node) {
+ return !!ts.findAncestor(node, function (node) {
+ switch (node.kind) {
+ case 163:
+ return true;
+ case 288:
+ case 165:
+ case 167:
+ case 168:
+ case 290:
+ case 158:
+ case 228:
+ case 283:
+ case 280:
+ case 281:
+ case 282:
+ case 275:
+ case 223:
+ case 286:
+ return false;
+ default:
+ return ts.isExpressionNode(node) ? false : "quit";
+ }
+ });
}
- function checkAwaitExpression(node) {
- if (produceDiagnostics) {
- if (!(node.flags & 32768)) {
- if (isTopLevelAwait(node)) {
- var sourceFile = ts.getSourceFileOfNode(node);
- if (!hasParseDiagnostics(sourceFile)) {
- var span = void 0;
- if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
- if (!span)
- span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
- var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module);
- diagnostics.add(diagnostic);
- }
- if ((moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System) || languageVersion < 4) {
- span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
- var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher);
- diagnostics.add(diagnostic);
- }
- }
- }
- else {
- var sourceFile = ts.getSourceFileOfNode(node);
- if (!hasParseDiagnostics(sourceFile)) {
- var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
- var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);
- var func = ts.getContainingFunction(node);
- if (func && func.kind !== 162 && (ts.getFunctionFlags(func) & 2) === 0) {
- var relatedInfo = ts.createDiagnosticForNode(func, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async);
- ts.addRelatedInfo(diagnostic, relatedInfo);
- }
- diagnostics.add(diagnostic);
- }
- }
+ function isPropertyDeclaredInAncestorClass(prop) {
+ if (!(prop.parent.flags & 32)) {
+ return false;
+ }
+ var classType = getTypeOfSymbol(prop.parent);
+ while (true) {
+ classType = classType.symbol && getSuperClass(classType);
+ if (!classType) {
+ return false;
}
- if (isInParameterInitializerBeforeContainingFunction(node)) {
- error(node, ts.Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer);
+ var superProperty = getPropertyOfType(classType, prop.escapedName);
+ if (superProperty && superProperty.valueDeclaration) {
+ return true;
}
}
- var operandType = checkExpression(node.expression);
- var awaitedType = checkAwaitedType(operandType, node, ts.Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
- if (awaitedType === operandType && awaitedType !== errorType && !(operandType.flags & 3)) {
- addErrorOrSuggestion(false, ts.createDiagnosticForNode(node, ts.Diagnostics.await_has_no_effect_on_the_type_of_this_expression));
- }
- return awaitedType;
}
- function checkPrefixUnaryExpression(node) {
- var operandType = checkExpression(node.operand);
- if (operandType === silentNeverType) {
- return silentNeverType;
+ function getSuperClass(classType) {
+ var x = getBaseTypes(classType);
+ if (x.length === 0) {
+ return undefined;
}
- switch (node.operand.kind) {
- case 8:
- switch (node.operator) {
- case 40:
- return getFreshTypeOfLiteralType(getLiteralType(-node.operand.text));
- case 39:
- return getFreshTypeOfLiteralType(getLiteralType(+node.operand.text));
- }
- break;
- case 9:
- if (node.operator === 40) {
- return getFreshTypeOfLiteralType(getLiteralType({
- negative: true,
- base10Value: ts.parsePseudoBigInt(node.operand.text)
- }));
+ return getIntersectionType(x);
+ }
+ function reportNonexistentProperty(propNode, containingType) {
+ var errorInfo;
+ var relatedInfo;
+ if (!ts.isPrivateIdentifier(propNode) && containingType.flags & 1048576 && !(containingType.flags & 131068)) {
+ for (var _i = 0, _a = containingType.types; _i < _a.length; _i++) {
+ var subtype = _a[_i];
+ if (!getPropertyOfType(subtype, propNode.escapedText) && !getIndexInfoOfType(subtype, 0)) {
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(subtype));
+ break;
}
+ }
}
- switch (node.operator) {
- case 39:
- case 40:
- case 54:
- checkNonNullType(operandType, node.operand);
- if (maybeTypeOfKind(operandType, 12288)) {
- error(node.operand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(node.operator));
+ if (typeHasStaticProperty(propNode.escapedText, containingType)) {
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_is_a_static_member_of_type_1, ts.declarationNameToString(propNode), typeToString(containingType));
+ }
+ else {
+ var promisedType = getPromisedTypeOfPromise(containingType);
+ if (promisedType && getPropertyOfType(promisedType, propNode.escapedText)) {
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(containingType));
+ relatedInfo = ts.createDiagnosticForNode(propNode, ts.Diagnostics.Did_you_forget_to_use_await);
+ }
+ else {
+ var missingProperty = ts.declarationNameToString(propNode);
+ var container = typeToString(containingType);
+ var libSuggestion = getSuggestedLibForNonExistentProperty(missingProperty, containingType);
+ if (libSuggestion !== undefined) {
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later, missingProperty, container, libSuggestion);
}
- if (node.operator === 39) {
- if (maybeTypeOfKind(operandType, 2112)) {
- error(node.operand, ts.Diagnostics.Operator_0_cannot_be_applied_to_type_1, ts.tokenToString(node.operator), typeToString(getBaseTypeOfLiteralType(operandType)));
+ else {
+ var suggestion = getSuggestedSymbolForNonexistentProperty(propNode, containingType);
+ if (suggestion !== undefined) {
+ var suggestedName = ts.symbolName(suggestion);
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, missingProperty, container, suggestedName);
+ relatedInfo = suggestion.valueDeclaration && ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestedName);
+ }
+ else {
+ errorInfo = ts.chainDiagnosticMessages(elaborateNeverIntersection(errorInfo, containingType), ts.Diagnostics.Property_0_does_not_exist_on_type_1, missingProperty, container);
}
- return numberType;
- }
- return getUnaryResultType(operandType);
- case 53:
- checkTruthinessExpression(node.operand);
- var facts = getTypeFacts(operandType) & (4194304 | 8388608);
- return facts === 4194304 ? falseType :
- facts === 8388608 ? trueType :
- booleanType;
- case 45:
- case 46:
- var ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type);
- if (ok) {
- checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access);
}
- return getUnaryResultType(operandType);
- }
- return errorType;
- }
- function checkPostfixUnaryExpression(node) {
- var operandType = checkExpression(node.operand);
- if (operandType === silentNeverType) {
- return silentNeverType;
+ }
}
- var ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type);
- if (ok) {
- checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access);
+ var resultDiagnostic = ts.createDiagnosticForNodeFromMessageChain(propNode, errorInfo);
+ if (relatedInfo) {
+ ts.addRelatedInfo(resultDiagnostic, relatedInfo);
}
- return getUnaryResultType(operandType);
+ diagnostics.add(resultDiagnostic);
}
- function getUnaryResultType(operandType) {
- if (maybeTypeOfKind(operandType, 2112)) {
- return isTypeAssignableToKind(operandType, 3) || maybeTypeOfKind(operandType, 296)
- ? numberOrBigIntType
- : bigintType;
- }
- return numberType;
+ function typeHasStaticProperty(propName, containingType) {
+ var prop = containingType.symbol && getPropertyOfType(getTypeOfSymbol(containingType.symbol), propName);
+ return prop !== undefined && prop.valueDeclaration && ts.hasSyntacticModifier(prop.valueDeclaration, 32);
}
- function maybeTypeOfKind(type, kind) {
- if (type.flags & kind) {
- return true;
- }
- if (type.flags & 3145728) {
- var types = type.types;
- for (var _i = 0, types_19 = types; _i < types_19.length; _i++) {
- var t = types_19[_i];
- if (maybeTypeOfKind(t, kind)) {
- return true;
- }
+ function getSuggestedLibForNonExistentName(name) {
+ var missingName = diagnosticName(name);
+ var allFeatures = ts.getScriptTargetFeatures();
+ var libTargets = ts.getOwnKeys(allFeatures);
+ for (var _i = 0, libTargets_1 = libTargets; _i < libTargets_1.length; _i++) {
+ var libTarget = libTargets_1[_i];
+ var containingTypes = ts.getOwnKeys(allFeatures[libTarget]);
+ if (containingTypes !== undefined && ts.contains(containingTypes, missingName)) {
+ return libTarget;
}
}
- return false;
}
- function isTypeAssignableToKind(source, kind, strict) {
- if (source.flags & kind) {
- return true;
+ function getSuggestedLibForNonExistentProperty(missingProperty, containingType) {
+ var container = getApparentType(containingType).symbol;
+ if (!container) {
+ return undefined;
}
- if (strict && source.flags & (3 | 16384 | 32768 | 65536)) {
- return false;
+ var allFeatures = ts.getScriptTargetFeatures();
+ var libTargets = ts.getOwnKeys(allFeatures);
+ for (var _i = 0, libTargets_2 = libTargets; _i < libTargets_2.length; _i++) {
+ var libTarget = libTargets_2[_i];
+ var featuresOfLib = allFeatures[libTarget];
+ var featuresOfContainingType = featuresOfLib[ts.symbolName(container)];
+ if (featuresOfContainingType !== undefined && ts.contains(featuresOfContainingType, missingProperty)) {
+ return libTarget;
+ }
}
- return !!(kind & 296) && isTypeAssignableTo(source, numberType) ||
- !!(kind & 2112) && isTypeAssignableTo(source, bigintType) ||
- !!(kind & 132) && isTypeAssignableTo(source, stringType) ||
- !!(kind & 528) && isTypeAssignableTo(source, booleanType) ||
- !!(kind & 16384) && isTypeAssignableTo(source, voidType) ||
- !!(kind & 131072) && isTypeAssignableTo(source, neverType) ||
- !!(kind & 65536) && isTypeAssignableTo(source, nullType) ||
- !!(kind & 32768) && isTypeAssignableTo(source, undefinedType) ||
- !!(kind & 4096) && isTypeAssignableTo(source, esSymbolType) ||
- !!(kind & 67108864) && isTypeAssignableTo(source, nonPrimitiveType);
}
- function allTypesAssignableToKind(source, kind, strict) {
- return source.flags & 1048576 ?
- ts.every(source.types, function (subType) { return allTypesAssignableToKind(subType, kind, strict); }) :
- isTypeAssignableToKind(source, kind, strict);
+ function getSuggestedSymbolForNonexistentProperty(name, containingType) {
+ return getSpellingSuggestionForName(ts.isString(name) ? name : ts.idText(name), getPropertiesOfType(containingType), 111551);
}
- function isConstEnumObjectType(type) {
- return !!(ts.getObjectFlags(type) & 16) && !!type.symbol && isConstEnumSymbol(type.symbol);
+ function getSuggestedSymbolForNonexistentJSXAttribute(name, containingType) {
+ var strName = ts.isString(name) ? name : ts.idText(name);
+ var properties = getPropertiesOfType(containingType);
+ var jsxSpecific = strName === "for" ? ts.find(properties, function (x) { return ts.symbolName(x) === "htmlFor"; })
+ : strName === "class" ? ts.find(properties, function (x) { return ts.symbolName(x) === "className"; })
+ : undefined;
+ return jsxSpecific !== null && jsxSpecific !== void 0 ? jsxSpecific : getSpellingSuggestionForName(strName, properties, 111551);
}
- function isConstEnumSymbol(symbol) {
- return (symbol.flags & 128) !== 0;
+ function getSuggestionForNonexistentProperty(name, containingType) {
+ var suggestion = getSuggestedSymbolForNonexistentProperty(name, containingType);
+ return suggestion && ts.symbolName(suggestion);
}
- function checkInstanceOfExpression(left, right, leftType, rightType) {
- if (leftType === silentNeverType || rightType === silentNeverType) {
- return silentNeverType;
- }
- if (!isTypeAny(leftType) &&
- allTypesAssignableToKind(leftType, 131068)) {
- error(left, ts.Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
- }
- if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
- error(right, ts.Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
- }
- return booleanType;
+ function getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning) {
+ ts.Debug.assert(outerName !== undefined, "outername should always be defined");
+ var result = resolveNameHelper(location, outerName, meaning, undefined, outerName, false, false, function (symbols, name, meaning) {
+ ts.Debug.assertEqual(outerName, name, "name should equal outerName");
+ var symbol = getSymbol(symbols, name, meaning);
+ return symbol || getSpellingSuggestionForName(ts.unescapeLeadingUnderscores(name), ts.arrayFrom(symbols.values()), meaning);
+ });
+ return result;
}
- function checkInExpression(left, right, leftType, rightType) {
- if (leftType === silentNeverType || rightType === silentNeverType) {
- return silentNeverType;
- }
- leftType = checkNonNullType(leftType, left);
- rightType = checkNonNullType(rightType, right);
- if (!(isTypeComparableTo(leftType, stringType) || isTypeAssignableToKind(leftType, 296 | 12288))) {
- error(left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
+ function getSuggestionForNonexistentSymbol(location, outerName, meaning) {
+ var symbolResult = getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning);
+ return symbolResult && ts.symbolName(symbolResult);
+ }
+ function getSuggestedSymbolForNonexistentModule(name, targetModule) {
+ return targetModule.exports && getSpellingSuggestionForName(ts.idText(name), getExportsOfModuleAsArray(targetModule), 2623475);
+ }
+ function getSuggestionForNonexistentExport(name, targetModule) {
+ var suggestion = getSuggestedSymbolForNonexistentModule(name, targetModule);
+ return suggestion && ts.symbolName(suggestion);
+ }
+ function getSuggestionForNonexistentIndexSignature(objectType, expr, keyedType) {
+ function hasProp(name) {
+ var prop = getPropertyOfObjectType(objectType, name);
+ if (prop) {
+ var s = getSingleCallSignature(getTypeOfSymbol(prop));
+ return !!s && getMinArgumentCount(s) >= 1 && isTypeAssignableTo(keyedType, getTypeAtPosition(s, 0));
+ }
+ return false;
}
- if (!allTypesAssignableToKind(rightType, 67108864 | 58982400)) {
- error(right, ts.Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
+ ;
+ var suggestedMethod = ts.isAssignmentTarget(expr) ? "set" : "get";
+ if (!hasProp(suggestedMethod)) {
+ return undefined;
}
- return booleanType;
- }
- function checkObjectLiteralAssignment(node, sourceType, rightIsThis) {
- var properties = node.properties;
- if (strictNullChecks && properties.length === 0) {
- return checkNonNullType(sourceType, node);
+ var suggestion = ts.tryGetPropertyAccessOrIdentifierToString(expr.expression);
+ if (suggestion === undefined) {
+ suggestion = suggestedMethod;
}
- for (var i = 0; i < properties.length; i++) {
- checkObjectLiteralDestructuringPropertyAssignment(node, sourceType, i, properties, rightIsThis);
+ else {
+ suggestion += "." + suggestedMethod;
}
- return sourceType;
+ return suggestion;
}
- function checkObjectLiteralDestructuringPropertyAssignment(node, objectLiteralType, propertyIndex, allProperties, rightIsThis) {
- if (rightIsThis === void 0) { rightIsThis = false; }
- var properties = node.properties;
- var property = properties[propertyIndex];
- if (property.kind === 281 || property.kind === 282) {
- var name = property.name;
- var exprType = getLiteralTypeFromPropertyName(name);
- if (isTypeUsableAsPropertyName(exprType)) {
- var text = getPropertyNameFromType(exprType);
- var prop = getPropertyOfType(objectLiteralType, text);
- if (prop) {
- markPropertyAsReferenced(prop, property, rightIsThis);
- checkPropertyAccessibility(property, false, objectLiteralType, prop);
- }
+ function getSpellingSuggestionForName(name, symbols, meaning) {
+ return ts.getSpellingSuggestion(name, symbols, getCandidateName);
+ function getCandidateName(candidate) {
+ var candidateName = ts.symbolName(candidate);
+ if (ts.startsWith(candidateName, "\"")) {
+ return undefined;
}
- var elementType = getIndexedAccessType(objectLiteralType, exprType, name);
- var type = getFlowTypeOfDestructuring(property, elementType);
- return checkDestructuringAssignment(property.kind === 282 ? property : property.initializer, type);
- }
- else if (property.kind === 283) {
- if (propertyIndex < properties.length - 1) {
- error(property, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
+ if (candidate.flags & meaning) {
+ return candidateName;
}
- else {
- if (languageVersion < 99) {
- checkExternalEmitHelpers(property, 4);
- }
- var nonRestNames = [];
- if (allProperties) {
- for (var _i = 0, allProperties_1 = allProperties; _i < allProperties_1.length; _i++) {
- var otherProperty = allProperties_1[_i];
- if (!ts.isSpreadAssignment(otherProperty)) {
- nonRestNames.push(otherProperty.name);
- }
- }
+ if (candidate.flags & 2097152) {
+ var alias = tryResolveAlias(candidate);
+ if (alias && alias.flags & meaning) {
+ return candidateName;
}
- var type = getRestType(objectLiteralType, nonRestNames, objectLiteralType.symbol);
- checkGrammarForDisallowedTrailingComma(allProperties, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
- return checkDestructuringAssignment(property.expression, type);
}
- }
- else {
- error(property, ts.Diagnostics.Property_assignment_expected);
+ return undefined;
}
}
- function checkArrayLiteralAssignment(node, sourceType, checkMode) {
- var elements = node.elements;
- if (languageVersion < 2 && compilerOptions.downlevelIteration) {
- checkExternalEmitHelpers(node, 512);
+ function markPropertyAsReferenced(prop, nodeForCheckWriteOnly, isThisAccess) {
+ var valueDeclaration = prop && (prop.flags & 106500) && prop.valueDeclaration;
+ if (!valueDeclaration) {
+ return;
}
- var elementType = checkIteratedTypeOrElementType(65, sourceType, undefinedType, node) || errorType;
- for (var i = 0; i < elements.length; i++) {
- checkArrayLiteralDestructuringElementAssignment(node, sourceType, i, elementType, checkMode);
+ var hasPrivateModifier = ts.hasEffectiveModifier(valueDeclaration, 8);
+ var hasPrivateIdentifier = ts.isNamedDeclaration(prop.valueDeclaration) && ts.isPrivateIdentifier(prop.valueDeclaration.name);
+ if (!hasPrivateModifier && !hasPrivateIdentifier) {
+ return;
}
- return sourceType;
- }
- function checkArrayLiteralDestructuringElementAssignment(node, sourceType, elementIndex, elementType, checkMode) {
- var elements = node.elements;
- var element = elements[elementIndex];
- if (element.kind !== 215) {
- if (element.kind !== 213) {
- var indexType = getLiteralType(elementIndex);
- if (isArrayLikeType(sourceType)) {
- var accessFlags = hasDefaultValue(element) ? 8 : 0;
- var elementType_2 = getIndexedAccessTypeOrUndefined(sourceType, indexType, createSyntheticExpression(element, indexType), accessFlags) || errorType;
- var assignedType = hasDefaultValue(element) ? getTypeWithFacts(elementType_2, 524288) : elementType_2;
- var type = getFlowTypeOfDestructuring(element, assignedType);
- return checkDestructuringAssignment(element, type, checkMode);
- }
- return checkDestructuringAssignment(element, elementType, checkMode);
+ if (nodeForCheckWriteOnly && ts.isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536)) {
+ return;
+ }
+ if (isThisAccess) {
+ var containingMethod = ts.findAncestor(nodeForCheckWriteOnly, ts.isFunctionLikeDeclaration);
+ if (containingMethod && containingMethod.symbol === prop) {
+ return;
}
- if (elementIndex < elements.length - 1) {
- error(element, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
+ }
+ (ts.getCheckFlags(prop) & 1 ? getSymbolLinks(prop).target : prop).isReferenced = 67108863;
+ }
+ function isValidPropertyAccess(node, propertyName) {
+ switch (node.kind) {
+ case 201:
+ return isValidPropertyAccessWithType(node, node.expression.kind === 105, propertyName, getWidenedType(checkExpression(node.expression)));
+ case 157:
+ return isValidPropertyAccessWithType(node, false, propertyName, getWidenedType(checkExpression(node.left)));
+ case 195:
+ return isValidPropertyAccessWithType(node, false, propertyName, getTypeFromTypeNode(node));
+ }
+ }
+ function isValidPropertyAccessForCompletions(node, type, property) {
+ return isValidPropertyAccessWithType(node, node.kind === 201 && node.expression.kind === 105, property.escapedName, type);
+ }
+ function isValidPropertyAccessWithType(node, isSuper, propertyName, type) {
+ if (type === errorType || isTypeAny(type)) {
+ return true;
+ }
+ var prop = getPropertyOfType(type, propertyName);
+ if (prop) {
+ if (ts.isPropertyAccessExpression(node) && prop.valueDeclaration && ts.isPrivateIdentifierPropertyDeclaration(prop.valueDeclaration)) {
+ var declClass_1 = ts.getContainingClass(prop.valueDeclaration);
+ return !ts.isOptionalChain(node) && !!ts.findAncestor(node, function (parent) { return parent === declClass_1; });
}
- else {
- var restExpression = element.expression;
- if (restExpression.kind === 209 && restExpression.operatorToken.kind === 62) {
- error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer);
- }
- else {
- checkGrammarForDisallowedTrailingComma(node.elements, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
- var type = everyType(sourceType, isTupleType) ?
- mapType(sourceType, function (t) { return sliceTupleType(t, elementIndex); }) :
- createArrayType(elementType);
- return checkDestructuringAssignment(restExpression, type, checkMode);
- }
+ return checkPropertyAccessibility(node, isSuper, type, prop);
+ }
+ return ts.isInJSFile(node) && (type.flags & 1048576) !== 0 && type.types.some(function (elementType) { return isValidPropertyAccessWithType(node, isSuper, propertyName, elementType); });
+ }
+ function getForInVariableSymbol(node) {
+ var initializer = node.initializer;
+ if (initializer.kind === 250) {
+ var variable = initializer.declarations[0];
+ if (variable && !ts.isBindingPattern(variable.name)) {
+ return getSymbolOfNode(variable);
}
}
+ else if (initializer.kind === 78) {
+ return getResolvedSymbol(initializer);
+ }
return undefined;
}
- function checkDestructuringAssignment(exprOrAssignment, sourceType, checkMode, rightIsThis) {
- var target;
- if (exprOrAssignment.kind === 282) {
- var prop = exprOrAssignment;
- if (prop.objectAssignmentInitializer) {
- if (strictNullChecks &&
- !(getFalsyFlags(checkExpression(prop.objectAssignmentInitializer)) & 32768)) {
- sourceType = getTypeWithFacts(sourceType, 524288);
+ function hasNumericPropertyNames(type) {
+ return getIndexTypeOfType(type, 1) && !getIndexTypeOfType(type, 0);
+ }
+ function isForInVariableForNumericPropertyNames(expr) {
+ var e = ts.skipParentheses(expr);
+ if (e.kind === 78) {
+ var symbol = getResolvedSymbol(e);
+ if (symbol.flags & 3) {
+ var child = expr;
+ var node = expr.parent;
+ while (node) {
+ if (node.kind === 238 &&
+ child === node.statement &&
+ getForInVariableSymbol(node) === symbol &&
+ hasNumericPropertyNames(getTypeOfExpression(node.expression))) {
+ return true;
+ }
+ child = node;
+ node = node.parent;
}
- checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode);
}
- target = exprOrAssignment.name;
}
- else {
- target = exprOrAssignment;
+ return false;
+ }
+ function checkIndexedAccess(node) {
+ return node.flags & 32 ? checkElementAccessChain(node) :
+ checkElementAccessExpression(node, checkNonNullExpression(node.expression));
+ }
+ function checkElementAccessChain(node) {
+ var exprType = checkExpression(node.expression);
+ var nonOptionalType = getOptionalExpressionType(exprType, node.expression);
+ return propagateOptionalTypeMarker(checkElementAccessExpression(node, checkNonNullType(nonOptionalType, node.expression)), node, nonOptionalType !== exprType);
+ }
+ function checkElementAccessExpression(node, exprType) {
+ var objectType = ts.getAssignmentTargetKind(node) !== 0 || isMethodAccessForCall(node) ? getWidenedType(exprType) : exprType;
+ var indexExpression = node.argumentExpression;
+ var indexType = checkExpression(indexExpression);
+ if (objectType === errorType || objectType === silentNeverType) {
+ return objectType;
}
- if (target.kind === 209 && target.operatorToken.kind === 62) {
- checkBinaryExpression(target, checkMode);
- target = target.left;
+ if (isConstEnumObjectType(objectType) && !ts.isStringLiteralLike(indexExpression)) {
+ error(indexExpression, ts.Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
+ return errorType;
}
- if (target.kind === 193) {
- return checkObjectLiteralAssignment(target, sourceType, rightIsThis);
+ var effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
+ var accessFlags = ts.isAssignmentTarget(node) ?
+ 2 | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 1 : 0) :
+ 0;
+ var indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, undefined, node, accessFlags | 16) || errorType;
+ return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, indexedAccessType.symbol, indexedAccessType, indexExpression), node);
+ }
+ function checkThatExpressionIsProperSymbolReference(expression, expressionType, reportError) {
+ if (expressionType === errorType) {
+ return false;
}
- if (target.kind === 192) {
- return checkArrayLiteralAssignment(target, sourceType, checkMode);
+ if (!ts.isWellKnownSymbolSyntactically(expression)) {
+ return false;
}
- return checkReferenceAssignment(target, sourceType, checkMode);
+ if ((expressionType.flags & 12288) === 0) {
+ if (reportError) {
+ error(expression, ts.Diagnostics.A_computed_property_name_of_the_form_0_must_be_of_type_symbol, ts.getTextOfNode(expression));
+ }
+ return false;
+ }
+ var leftHandSide = expression.expression;
+ var leftHandSideSymbol = getResolvedSymbol(leftHandSide);
+ if (!leftHandSideSymbol) {
+ return false;
+ }
+ var globalESSymbol = getGlobalESSymbolConstructorSymbol(true);
+ if (!globalESSymbol) {
+ return false;
+ }
+ if (leftHandSideSymbol !== globalESSymbol) {
+ if (reportError) {
+ error(leftHandSide, ts.Diagnostics.Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object);
+ }
+ return false;
+ }
+ return true;
}
- function checkReferenceAssignment(target, sourceType, checkMode) {
- var targetType = checkExpression(target, checkMode);
- var error = target.parent.kind === 283 ?
- ts.Diagnostics.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access :
- ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access;
- var optionalError = target.parent.kind === 283 ?
- ts.Diagnostics.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access :
- ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access;
- if (checkReferenceExpression(target, error, optionalError)) {
- checkTypeAssignableToAndOptionallyElaborate(sourceType, targetType, target, target);
+ function callLikeExpressionMayHaveTypeArguments(node) {
+ return ts.isCallOrNewExpression(node) || ts.isTaggedTemplateExpression(node) || ts.isJsxOpeningLikeElement(node);
+ }
+ function resolveUntypedCall(node) {
+ if (callLikeExpressionMayHaveTypeArguments(node)) {
+ ts.forEach(node.typeArguments, checkSourceElement);
}
- if (ts.isPrivateIdentifierPropertyAccessExpression(target)) {
- checkExternalEmitHelpers(target.parent, 524288);
+ if (node.kind === 205) {
+ checkExpression(node.template);
}
- return sourceType;
+ else if (ts.isJsxOpeningLikeElement(node)) {
+ checkExpression(node.attributes);
+ }
+ else if (node.kind !== 161) {
+ ts.forEach(node.arguments, function (argument) {
+ checkExpression(argument);
+ });
+ }
+ return anySignature;
}
- function isSideEffectFree(node) {
- node = ts.skipParentheses(node);
- switch (node.kind) {
- case 75:
- case 10:
- case 13:
- case 198:
- case 211:
- case 14:
- case 8:
- case 9:
- case 106:
- case 91:
- case 100:
- case 146:
- case 201:
- case 214:
- case 202:
- case 192:
- case 193:
- case 204:
- case 218:
- case 267:
- case 266:
- return true;
- case 210:
- return isSideEffectFree(node.whenTrue) &&
- isSideEffectFree(node.whenFalse);
- case 209:
- if (ts.isAssignmentOperator(node.operatorToken.kind)) {
- return false;
+ function resolveErrorCall(node) {
+ resolveUntypedCall(node);
+ return unknownSignature;
+ }
+ function reorderCandidates(signatures, result, callChainFlags) {
+ var lastParent;
+ var lastSymbol;
+ var cutoffIndex = 0;
+ var index;
+ var specializedIndex = -1;
+ var spliceIndex;
+ ts.Debug.assert(!result.length);
+ for (var _i = 0, signatures_7 = signatures; _i < signatures_7.length; _i++) {
+ var signature = signatures_7[_i];
+ var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
+ var parent = signature.declaration && signature.declaration.parent;
+ if (!lastSymbol || symbol === lastSymbol) {
+ if (lastParent && parent === lastParent) {
+ index = index + 1;
}
- return isSideEffectFree(node.left) &&
- isSideEffectFree(node.right);
- case 207:
- case 208:
- switch (node.operator) {
- case 53:
- case 39:
- case 40:
- case 54:
- return true;
+ 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 === 220 || arg.kind === 227 && arg.isSpread);
+ }
+ function getSpreadArgumentIndex(args) {
+ return ts.findIndex(args, isSpreadArgument);
+ }
+ function acceptsVoid(t) {
+ return !!(t.flags & 16384);
+ }
+ function acceptsVoidUndefinedUnknownOrAny(t) {
+ return !!(t.flags & (16384 | 32768 | 2 | 1));
+ }
+ function hasCorrectArity(node, args, signature, signatureHelpTrailingComma) {
+ if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; }
+ var argCount;
+ var callIsIncomplete = false;
+ var effectiveParameterCount = getParameterCount(signature);
+ var effectiveMinimumArguments = getMinArgumentCount(signature);
+ if (node.kind === 205) {
+ argCount = args.length;
+ if (node.template.kind === 218) {
+ var lastSpan = ts.last(node.template.templateSpans);
+ callIsIncomplete = ts.nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated;
+ }
+ else {
+ var templateLiteral = node.template;
+ ts.Debug.assert(templateLiteral.kind === 14);
+ callIsIncomplete = !!templateLiteral.isUnterminated;
+ }
+ }
+ else if (node.kind === 161) {
+ argCount = getDecoratorArgumentCount(node, signature);
+ }
+ else if (ts.isJsxOpeningLikeElement(node)) {
+ callIsIncomplete = node.attributes.end === node.end;
+ if (callIsIncomplete) {
+ return true;
+ }
+ argCount = effectiveMinimumArguments === 0 ? args.length : 1;
+ effectiveParameterCount = args.length === 0 ? effectiveParameterCount : 1;
+ effectiveMinimumArguments = Math.min(effectiveMinimumArguments, 1);
+ }
+ else if (!node.arguments) {
+ ts.Debug.assert(node.kind === 204);
+ return getMinArgumentCount(signature) === 0;
+ }
+ else {
+ argCount = signatureHelpTrailingComma ? args.length + 1 : args.length;
+ callIsIncomplete = node.arguments.end === node.end;
+ var 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 (var i = argCount; i < effectiveMinimumArguments; i++) {
+ var type = getTypeAtPosition(signature, i);
+ if (filterType(type, ts.isInJSFile(node) && !strictNullChecks ? acceptsVoidUndefinedUnknownOrAny : acceptsVoid).flags & 131072) {
return false;
- case 205:
- case 199:
- case 217:
- default:
- return false;
+ }
}
+ return true;
}
- function isTypeEqualityComparableTo(source, target) {
- return (target.flags & 98304) !== 0 || isTypeComparableTo(source, target);
+ function hasCorrectTypeArgumentArity(signature, typeArguments) {
+ var numTypeParameters = ts.length(signature.typeParameters);
+ var minTypeArgumentCount = getMinTypeArgumentCount(signature.typeParameters);
+ return !ts.some(typeArguments) ||
+ (typeArguments.length >= minTypeArgumentCount && typeArguments.length <= numTypeParameters);
}
- function checkBinaryExpression(node, checkMode) {
- var workStacks = {
- expr: [node],
- state: [0],
- leftType: [undefined]
- };
- var stackIndex = 0;
- var lastResult;
- while (stackIndex >= 0) {
- node = workStacks.expr[stackIndex];
- switch (workStacks.state[stackIndex]) {
- case 0: {
- if (ts.isInJSFile(node) && ts.getAssignedExpandoInitializer(node)) {
- finishInvocation(checkExpression(node.right, checkMode));
- break;
- }
- checkGrammarNullishCoalesceWithLogicalExpression(node);
- var operator = node.operatorToken.kind;
- if (operator === 62 && (node.left.kind === 193 || node.left.kind === 192)) {
- finishInvocation(checkDestructuringAssignment(node.left, checkExpression(node.right, checkMode), checkMode, node.right.kind === 104));
- break;
- }
- advanceState(1);
- maybeCheckExpression(node.left);
- break;
- }
- case 1: {
- var leftType = lastResult;
- workStacks.leftType[stackIndex] = leftType;
- var operator = node.operatorToken.kind;
- if (operator === 55 || operator === 56 || operator === 60) {
- checkTruthinessOfType(leftType, node.left);
- }
- advanceState(2);
- maybeCheckExpression(node.right);
- break;
+ function getSingleCallSignature(type) {
+ return getSingleSignature(type, 0, false);
+ }
+ function getSingleCallOrConstructSignature(type) {
+ return getSingleSignature(type, 0, false) ||
+ getSingleSignature(type, 1, false);
+ }
+ function getSingleSignature(type, kind, allowMembers) {
+ if (type.flags & 524288) {
+ var resolved = resolveStructuredTypeMembers(type);
+ if (allowMembers || resolved.properties.length === 0 && !resolved.stringIndexInfo && !resolved.numberIndexInfo) {
+ if (kind === 0 && resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0) {
+ return resolved.callSignatures[0];
}
- case 2: {
- var leftType = workStacks.leftType[stackIndex];
- var rightType = lastResult;
- finishInvocation(checkBinaryLikeExpressionWorker(node.left, node.operatorToken, node.right, leftType, rightType, node));
- break;
+ if (kind === 1 && resolved.constructSignatures.length === 1 && resolved.callSignatures.length === 0) {
+ return resolved.constructSignatures[0];
}
- default: return ts.Debug.fail("Invalid state " + workStacks.state[stackIndex] + " for checkBinaryExpression");
}
}
- return lastResult;
- function finishInvocation(result) {
- lastResult = result;
- stackIndex--;
+ return undefined;
+ }
+ function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
+ var context = createInferenceContext(signature.typeParameters, signature, 0, compareTypes);
+ var restType = getEffectiveRestType(contextualSignature);
+ var mapper = inferenceContext && (restType && restType.flags & 262144 ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
+ var sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
+ applyToParameterTypes(sourceSignature, signature, function (source, target) {
+ inferTypes(context.inferences, source, target);
+ });
+ if (!inferenceContext) {
+ applyToReturnTypes(contextualSignature, signature, function (source, target) {
+ inferTypes(context.inferences, source, target, 64);
+ });
}
- function advanceState(nextState) {
- workStacks.state[stackIndex] = nextState;
+ return getSignatureInstantiation(signature, getInferredTypes(context), ts.isInJSFile(contextualSignature.declaration));
+ }
+ function inferJsxTypeArguments(node, signature, checkMode, context) {
+ var paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
+ var checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode);
+ inferTypes(context.inferences, checkAttrType, paramType);
+ return getInferredTypes(context);
+ }
+ function inferTypeArguments(node, signature, args, checkMode, context) {
+ if (ts.isJsxOpeningLikeElement(node)) {
+ return inferJsxTypeArguments(node, signature, checkMode, context);
}
- function maybeCheckExpression(node) {
- if (ts.isBinaryExpression(node)) {
- stackIndex++;
- workStacks.expr[stackIndex] = node;
- workStacks.state[stackIndex] = 0;
- workStacks.leftType[stackIndex] = undefined;
- }
- else {
- lastResult = checkExpression(node, checkMode);
+ if (node.kind !== 161) {
+ var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 : 0);
+ if (contextualType) {
+ var outerContext = getInferenceContext(node);
+ var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1));
+ var instantiatedType = instantiateType(contextualType, outerMapper);
+ var contextualSignature = getSingleCallSignature(instantiatedType);
+ var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
+ getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
+ instantiatedType;
+ var inferenceTargetType = getReturnTypeOfSignature(signature);
+ inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 64);
+ var returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
+ var returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
+ inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
+ context.returnMapper = ts.some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : undefined;
}
}
- }
- function checkGrammarNullishCoalesceWithLogicalExpression(node) {
- var left = node.left, operatorToken = node.operatorToken, right = node.right;
- if (operatorToken.kind === 60) {
- if (ts.isBinaryExpression(left) && (left.operatorToken.kind === 56 || left.operatorToken.kind === 55)) {
- grammarErrorOnNode(left, ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, ts.tokenToString(left.operatorToken.kind), ts.tokenToString(operatorToken.kind));
- }
- if (ts.isBinaryExpression(right) && (right.operatorToken.kind === 56 || right.operatorToken.kind === 55)) {
- grammarErrorOnNode(right, ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, ts.tokenToString(right.operatorToken.kind), ts.tokenToString(operatorToken.kind));
+ var restType = getNonArrayRestType(signature);
+ var argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length;
+ if (restType && restType.flags & 262144) {
+ var info = ts.find(context.inferences, function (info) { return info.typeParameter === restType; });
+ if (info) {
+ info.impliedArity = ts.findIndex(args, isSpreadArgument, argCount) < 0 ? args.length - argCount : undefined;
}
}
- }
- function checkBinaryLikeExpression(left, operatorToken, right, checkMode, errorNode) {
- var operator = operatorToken.kind;
- if (operator === 62 && (left.kind === 193 || left.kind === 192)) {
- return checkDestructuringAssignment(left, checkExpression(right, checkMode), checkMode, right.kind === 104);
+ var thisType = getThisTypeOfSignature(signature);
+ if (thisType) {
+ var thisArgumentNode = getThisArgumentOfCall(node);
+ var thisArgumentType = thisArgumentNode ? checkExpression(thisArgumentNode) : voidType;
+ inferTypes(context.inferences, thisArgumentType, thisType);
}
- var leftType;
- if (operator === 55 || operator === 56 || operator === 60) {
- leftType = checkTruthinessExpression(left, checkMode);
+ for (var i = 0; i < argCount; i++) {
+ var arg = args[i];
+ if (arg.kind !== 222) {
+ var paramType = getTypeAtPosition(signature, i);
+ var argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
+ inferTypes(context.inferences, argType, paramType);
+ }
}
- else {
- leftType = checkExpression(left, checkMode);
+ if (restType) {
+ var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context, checkMode);
+ inferTypes(context.inferences, spreadType, restType);
}
- var rightType = checkExpression(right, checkMode);
- return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode);
+ return getInferredTypes(context);
}
- function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode) {
- var operator = operatorToken.kind;
- switch (operator) {
- case 41:
- case 42:
- case 65:
- case 66:
- case 43:
- case 67:
- case 44:
- case 68:
- case 40:
- case 64:
- case 47:
- case 69:
- case 48:
- case 70:
- case 49:
- case 71:
- case 51:
- case 73:
- case 52:
- case 74:
- case 50:
- case 72:
- if (leftType === silentNeverType || rightType === silentNeverType) {
- return silentNeverType;
- }
- leftType = checkNonNullType(leftType, left);
- rightType = checkNonNullType(rightType, right);
- var suggestedOperator = void 0;
- if ((leftType.flags & 528) &&
- (rightType.flags & 528) &&
- (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== undefined) {
- error(errorNode || operatorToken, ts.Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, ts.tokenToString(operatorToken.kind), ts.tokenToString(suggestedOperator));
- return numberType;
+ function getMutableArrayOrTupleType(type) {
+ return type.flags & 1048576 ? mapType(type, getMutableArrayOrTupleType) :
+ type.flags & 1 || isMutableArrayOrTuple(getBaseConstraintOfType(type) || type) ? type :
+ isTupleType(type) ? createTupleType(getTypeArguments(type), type.target.elementFlags, false, type.target.labeledElementDeclarations) :
+ createTupleType([type], [8]);
+ }
+ function getSpreadArgumentType(args, index, argCount, restType, context, checkMode) {
+ if (index >= argCount - 1) {
+ var arg = args[argCount - 1];
+ if (isSpreadArgument(arg)) {
+ return getMutableArrayOrTupleType(arg.kind === 227 ? arg.type :
+ checkExpressionWithContextualType(arg.expression, restType, context, checkMode));
+ }
+ }
+ var types = [];
+ var flags = [];
+ var names = [];
+ for (var i = index; i < argCount; i++) {
+ var arg = args[i];
+ if (isSpreadArgument(arg)) {
+ var spreadType = arg.kind === 227 ? arg.type : checkExpression(arg.expression);
+ if (isArrayLikeType(spreadType)) {
+ types.push(spreadType);
+ flags.push(8);
}
else {
- var leftOk = checkArithmeticOperandType(left, leftType, ts.Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true);
- var rightOk = checkArithmeticOperandType(right, rightType, ts.Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true);
- var resultType_1;
- if ((isTypeAssignableToKind(leftType, 3) && isTypeAssignableToKind(rightType, 3)) ||
- !(maybeTypeOfKind(leftType, 2112) || maybeTypeOfKind(rightType, 2112))) {
- resultType_1 = numberType;
- }
- else if (bothAreBigIntLike(leftType, rightType)) {
- switch (operator) {
- case 49:
- case 71:
- reportOperatorError();
- }
- resultType_1 = bigintType;
- }
- else {
- reportOperatorError(bothAreBigIntLike);
- resultType_1 = errorType;
- }
- if (leftOk && rightOk) {
- checkAssignmentOperator(resultType_1);
- }
- return resultType_1;
- }
- case 39:
- case 63:
- if (leftType === silentNeverType || rightType === silentNeverType) {
- return silentNeverType;
- }
- if (!isTypeAssignableToKind(leftType, 132) && !isTypeAssignableToKind(rightType, 132)) {
- leftType = checkNonNullType(leftType, left);
- rightType = checkNonNullType(rightType, right);
- }
- var resultType = void 0;
- if (isTypeAssignableToKind(leftType, 296, true) && isTypeAssignableToKind(rightType, 296, true)) {
- resultType = numberType;
- }
- else if (isTypeAssignableToKind(leftType, 2112, true) && isTypeAssignableToKind(rightType, 2112, true)) {
- resultType = bigintType;
- }
- else if (isTypeAssignableToKind(leftType, 132, true) || isTypeAssignableToKind(rightType, 132, true)) {
- resultType = stringType;
- }
- else if (isTypeAny(leftType) || isTypeAny(rightType)) {
- resultType = leftType === errorType || rightType === errorType ? errorType : anyType;
- }
- if (resultType && !checkForDisallowedESSymbolOperand(operator)) {
- return resultType;
- }
- if (!resultType) {
- var closeEnoughKind_1 = 296 | 2112 | 132 | 3;
- reportOperatorError(function (left, right) {
- return isTypeAssignableToKind(left, closeEnoughKind_1) &&
- isTypeAssignableToKind(right, closeEnoughKind_1);
- });
- return anyType;
- }
- if (operator === 63) {
- checkAssignmentOperator(resultType);
- }
- return resultType;
- case 29:
- case 31:
- case 32:
- case 33:
- if (checkForDisallowedESSymbolOperand(operator)) {
- leftType = getBaseTypeOfLiteralType(checkNonNullType(leftType, left));
- rightType = getBaseTypeOfLiteralType(checkNonNullType(rightType, right));
- reportOperatorErrorUnless(function (left, right) {
- return isTypeComparableTo(left, right) || isTypeComparableTo(right, left) || (isTypeAssignableTo(left, numberOrBigIntType) && isTypeAssignableTo(right, numberOrBigIntType));
- });
- }
- return booleanType;
- case 34:
- case 35:
- case 36:
- case 37:
- reportOperatorErrorUnless(function (left, right) { return isTypeEqualityComparableTo(left, right) || isTypeEqualityComparableTo(right, left); });
- return booleanType;
- case 98:
- return checkInstanceOfExpression(left, right, leftType, rightType);
- case 97:
- return checkInExpression(left, right, leftType, rightType);
- case 55:
- return getTypeFacts(leftType) & 4194304 ?
- getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) :
- leftType;
- case 56:
- return getTypeFacts(leftType) & 8388608 ?
- getUnionType([removeDefinitelyFalsyTypes(leftType), rightType], 2) :
- leftType;
- case 60:
- return getTypeFacts(leftType) & 262144 ?
- getUnionType([getNonNullableType(leftType), rightType], 2) :
- leftType;
- case 62:
- var declKind = ts.isBinaryExpression(left.parent) ? ts.getAssignmentDeclarationKind(left.parent) : 0;
- checkAssignmentDeclaration(declKind, rightType);
- if (isAssignmentDeclaration(declKind)) {
- if (!(rightType.flags & 524288) ||
- declKind !== 2 &&
- declKind !== 6 &&
- !isEmptyObjectType(rightType) &&
- !isFunctionObjectType(rightType) &&
- !(ts.getObjectFlags(rightType) & 1)) {
- checkAssignmentOperator(rightType);
- }
- return leftType;
+ types.push(checkIteratedTypeOrElementType(33, spreadType, undefinedType, arg.kind === 220 ? arg.expression : arg));
+ flags.push(4);
}
- else {
- checkAssignmentOperator(rightType);
- return getRegularTypeOfObjectLiteral(rightType);
+ }
+ else {
+ var contextualType = getIndexedAccessType(restType, getLiteralType(i - index));
+ var argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode);
+ var hasPrimitiveContextualType = maybeTypeOfKind(contextualType, 131068 | 4194304 | 134217728 | 268435456);
+ types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
+ flags.push(1);
+ }
+ if (arg.kind === 227 && arg.tupleNameSource) {
+ names.push(arg.tupleNameSource);
+ }
+ }
+ return createTupleType(types, flags, false, ts.length(names) === ts.length(types) ? names : undefined);
+ }
+ function checkTypeArguments(signature, typeArgumentNodes, reportErrors, headMessage) {
+ var isJavascript = ts.isInJSFile(signature.declaration);
+ var typeParameters = signature.typeParameters;
+ var typeArgumentTypes = fillMissingTypeArguments(ts.map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript);
+ var mapper;
+ for (var i = 0; i < typeArgumentNodes.length; i++) {
+ ts.Debug.assert(typeParameters[i] !== undefined, "Should not call checkTypeArguments with too many type arguments");
+ var constraint = getConstraintOfTypeParameter(typeParameters[i]);
+ if (constraint) {
+ var errorInfo = reportErrors && headMessage ? (function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); }) : undefined;
+ var typeArgumentHeadMessage = headMessage || ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1;
+ if (!mapper) {
+ mapper = createTypeMapper(typeParameters, typeArgumentTypes);
}
- case 27:
- if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isEvalNode(right)) {
- error(left, ts.Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects);
+ var typeArgument = typeArgumentTypes[i];
+ if (!checkTypeAssignableTo(typeArgument, getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), reportErrors ? typeArgumentNodes[i] : undefined, typeArgumentHeadMessage, errorInfo)) {
+ return undefined;
}
- return rightType;
- default:
- return ts.Debug.fail();
+ }
}
- function bothAreBigIntLike(left, right) {
- return isTypeAssignableToKind(left, 2112) && isTypeAssignableToKind(right, 2112);
+ return typeArgumentTypes;
+ }
+ function getJsxReferenceKind(node) {
+ if (isJsxIntrinsicIdentifier(node.tagName)) {
+ return 2;
}
- function checkAssignmentDeclaration(kind, rightType) {
- if (kind === 2) {
- for (var _i = 0, _a = getPropertiesOfObjectType(rightType); _i < _a.length; _i++) {
- var prop = _a[_i];
- var propType = getTypeOfSymbol(prop);
- if (propType.symbol && propType.symbol.flags & 32) {
- var name = prop.escapedName;
- var symbol = resolveName(prop.valueDeclaration, name, 788968, undefined, name, false);
- if (symbol && symbol.declarations.some(ts.isJSDocTypedefTag)) {
- addDuplicateDeclarationErrorsForSymbols(symbol, ts.Diagnostics.Duplicate_identifier_0, ts.unescapeLeadingUnderscores(name), prop);
- addDuplicateDeclarationErrorsForSymbols(prop, ts.Diagnostics.Duplicate_identifier_0, ts.unescapeLeadingUnderscores(name), symbol);
- }
+ var tagType = getApparentType(checkExpression(node.tagName));
+ if (ts.length(getSignaturesOfType(tagType, 1))) {
+ return 0;
+ }
+ if (ts.length(getSignaturesOfType(tagType, 0))) {
+ return 1;
+ }
+ return 2;
+ }
+ function checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors, containingMessageChain, errorOutputContainer) {
+ var paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
+ var attributesType = checkExpressionWithContextualType(node.attributes, paramType, undefined, checkMode);
+ return checkTagNameDoesNotExpectTooManyArguments() && checkTypeRelatedToAndOptionallyElaborate(attributesType, paramType, relation, reportErrors ? node.tagName : undefined, node.attributes, undefined, containingMessageChain, errorOutputContainer);
+ function checkTagNameDoesNotExpectTooManyArguments() {
+ var _a;
+ var tagType = ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node) && !isJsxIntrinsicIdentifier(node.tagName) ? checkExpression(node.tagName) : undefined;
+ if (!tagType) {
+ return true;
+ }
+ var tagCallSignatures = getSignaturesOfType(tagType, 0);
+ if (!ts.length(tagCallSignatures)) {
+ return true;
+ }
+ var factory = getJsxFactoryEntity(node);
+ if (!factory) {
+ return true;
+ }
+ var factorySymbol = resolveEntityName(factory, 111551, true, false, node);
+ if (!factorySymbol) {
+ return true;
+ }
+ var factoryType = getTypeOfSymbol(factorySymbol);
+ var callSignatures = getSignaturesOfType(factoryType, 0);
+ if (!ts.length(callSignatures)) {
+ return true;
+ }
+ var hasFirstParamSignatures = false;
+ var maxParamCount = 0;
+ for (var _i = 0, callSignatures_1 = callSignatures; _i < callSignatures_1.length; _i++) {
+ var sig = callSignatures_1[_i];
+ var firstparam = getTypeAtPosition(sig, 0);
+ var signaturesOfParam = getSignaturesOfType(firstparam, 0);
+ if (!ts.length(signaturesOfParam))
+ continue;
+ for (var _b = 0, signaturesOfParam_1 = signaturesOfParam; _b < signaturesOfParam_1.length; _b++) {
+ var paramSig = signaturesOfParam_1[_b];
+ hasFirstParamSignatures = true;
+ if (hasEffectiveRestParameter(paramSig)) {
+ return true;
+ }
+ var paramCount = getParameterCount(paramSig);
+ if (paramCount > maxParamCount) {
+ maxParamCount = paramCount;
}
}
}
- }
- function isEvalNode(node) {
- return node.kind === 75 && node.escapedText === "eval";
- }
- function checkForDisallowedESSymbolOperand(operator) {
- var offendingSymbolOperand = maybeTypeOfKind(leftType, 12288) ? left :
- maybeTypeOfKind(rightType, 12288) ? right :
- undefined;
- if (offendingSymbolOperand) {
- error(offendingSymbolOperand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(operator));
- return false;
+ if (!hasFirstParamSignatures) {
+ return true;
}
- return true;
- }
- function getSuggestedBooleanOperator(operator) {
- switch (operator) {
- case 51:
- case 73:
- return 56;
- case 52:
- case 74:
- return 37;
- case 50:
- case 72:
- return 55;
- default:
- return undefined;
+ var absoluteMinArgCount = Infinity;
+ for (var _c = 0, tagCallSignatures_1 = tagCallSignatures; _c < tagCallSignatures_1.length; _c++) {
+ var tagSig = tagCallSignatures_1[_c];
+ var tagRequiredArgCount = getMinArgumentCount(tagSig);
+ if (tagRequiredArgCount < absoluteMinArgCount) {
+ absoluteMinArgCount = tagRequiredArgCount;
+ }
}
- }
- function checkAssignmentOperator(valueType) {
- if (produceDiagnostics && ts.isAssignmentOperator(operator)) {
- if (checkReferenceExpression(left, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access)
- && (!ts.isIdentifier(left) || ts.unescapeLeadingUnderscores(left.escapedText) !== "exports")) {
- checkTypeAssignableToAndOptionallyElaborate(valueType, leftType, left, right);
+ if (absoluteMinArgCount <= maxParamCount) {
+ return true;
+ }
+ if (reportErrors) {
+ var diag = ts.createDiagnosticForNode(node.tagName, ts.Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, ts.entityNameToString(node.tagName), absoluteMinArgCount, ts.entityNameToString(factory), maxParamCount);
+ var tagNameDeclaration = (_a = getSymbolAtLocation(node.tagName)) === null || _a === void 0 ? void 0 : _a.valueDeclaration;
+ if (tagNameDeclaration) {
+ ts.addRelatedInfo(diag, ts.createDiagnosticForNode(tagNameDeclaration, ts.Diagnostics._0_is_declared_here, ts.entityNameToString(node.tagName)));
+ }
+ if (errorOutputContainer && errorOutputContainer.skipLogging) {
+ (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
+ }
+ if (!errorOutputContainer.skipLogging) {
+ diagnostics.add(diag);
}
}
+ return false;
}
- function isAssignmentDeclaration(kind) {
- switch (kind) {
- case 2:
- return true;
- case 1:
- case 5:
- case 6:
- case 3:
- case 4:
- var symbol = getSymbolOfNode(left);
- var init = ts.getAssignedExpandoInitializer(right);
- return init && ts.isObjectLiteralExpression(init) &&
- symbol && ts.hasEntries(symbol.exports);
- default:
- return false;
+ }
+ function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors, containingMessageChain) {
+ var errorOutputContainer = { errors: undefined, skipLogging: true };
+ if (ts.isJsxOpeningLikeElement(node)) {
+ if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors, containingMessageChain, errorOutputContainer)) {
+ ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "jsx should have errors when reporting errors");
+ return errorOutputContainer.errors || ts.emptyArray;
}
+ return undefined;
}
- function reportOperatorErrorUnless(typesAreCompatible) {
- if (!typesAreCompatible(leftType, rightType)) {
- reportOperatorError(typesAreCompatible);
- return true;
+ var thisType = getThisTypeOfSignature(signature);
+ if (thisType && thisType !== voidType && node.kind !== 204) {
+ var thisArgumentNode = getThisArgumentOfCall(node);
+ var thisArgumentType = void 0;
+ if (thisArgumentNode) {
+ thisArgumentType = checkExpression(thisArgumentNode);
+ if (ts.isOptionalChainRoot(thisArgumentNode.parent)) {
+ thisArgumentType = getNonNullableType(thisArgumentType);
+ }
+ else if (ts.isOptionalChain(thisArgumentNode.parent)) {
+ thisArgumentType = removeOptionalTypeMarker(thisArgumentType);
+ }
}
- return false;
- }
- function reportOperatorError(isRelated) {
- var _a;
- var wouldWorkWithAwait = false;
- var errNode = errorNode || operatorToken;
- if (isRelated) {
- var awaitedLeftType = getAwaitedType(leftType);
- var awaitedRightType = getAwaitedType(rightType);
- wouldWorkWithAwait = !(awaitedLeftType === leftType && awaitedRightType === rightType)
- && !!(awaitedLeftType && awaitedRightType)
- && isRelated(awaitedLeftType, awaitedRightType);
+ else {
+ thisArgumentType = voidType;
}
- var effectiveLeft = leftType;
- var effectiveRight = rightType;
- if (!wouldWorkWithAwait && isRelated) {
- _a = getBaseTypesIfUnrelated(leftType, rightType, isRelated), effectiveLeft = _a[0], effectiveRight = _a[1];
+ var errorNode = reportErrors ? (thisArgumentNode || node) : undefined;
+ var headMessage_1 = ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1;
+ if (!checkTypeRelatedTo(thisArgumentType, thisType, relation, errorNode, headMessage_1, containingMessageChain, errorOutputContainer)) {
+ ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "this parameter should have errors when reporting errors");
+ return errorOutputContainer.errors || ts.emptyArray;
}
- var _b = getTypeNamesForErrorDisplay(effectiveLeft, effectiveRight), leftStr = _b[0], rightStr = _b[1];
- if (!tryGiveBetterPrimaryError(errNode, wouldWorkWithAwait, leftStr, rightStr)) {
- errorAndMaybeSuggestAwait(errNode, wouldWorkWithAwait, ts.Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, ts.tokenToString(operatorToken.kind), leftStr, rightStr);
+ }
+ var headMessage = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1;
+ var restType = getNonArrayRestType(signature);
+ var argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length;
+ for (var i = 0; i < argCount; i++) {
+ var arg = args[i];
+ if (arg.kind !== 222) {
+ var paramType = getTypeAtPosition(signature, i);
+ var argType = checkExpressionWithContextualType(arg, paramType, undefined, checkMode);
+ var checkArgType = checkMode & 4 ? getRegularTypeOfObjectLiteral(argType) : argType;
+ if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors ? arg : undefined, arg, headMessage, containingMessageChain, errorOutputContainer)) {
+ ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
+ maybeAddMissingAwaitInfo(arg, checkArgType, paramType);
+ return errorOutputContainer.errors || ts.emptyArray;
+ }
}
}
- function tryGiveBetterPrimaryError(errNode, maybeMissingAwait, leftStr, rightStr) {
- var typeName;
- switch (operatorToken.kind) {
- case 36:
- case 34:
- typeName = "false";
- break;
- case 37:
- case 35:
- typeName = "true";
+ if (restType) {
+ var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, undefined, checkMode);
+ var errorNode = reportErrors ? argCount < args.length ? args[argCount] : node : undefined;
+ if (!checkTypeRelatedTo(spreadType, restType, relation, errorNode, headMessage, undefined, errorOutputContainer)) {
+ ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "rest parameter should have errors when reporting errors");
+ maybeAddMissingAwaitInfo(errorNode, spreadType, restType);
+ return errorOutputContainer.errors || ts.emptyArray;
}
- if (typeName) {
- return errorAndMaybeSuggestAwait(errNode, maybeMissingAwait, ts.Diagnostics.This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap, typeName, leftStr, rightStr);
+ }
+ return undefined;
+ function maybeAddMissingAwaitInfo(errorNode, source, target) {
+ if (errorNode && reportErrors && errorOutputContainer.errors && errorOutputContainer.errors.length) {
+ if (getAwaitedTypeOfPromise(target)) {
+ return;
+ }
+ var awaitedTypeOfSource = getAwaitedTypeOfPromise(source);
+ if (awaitedTypeOfSource && isTypeRelatedTo(awaitedTypeOfSource, target, relation)) {
+ ts.addRelatedInfo(errorOutputContainer.errors[0], ts.createDiagnosticForNode(errorNode, ts.Diagnostics.Did_you_forget_to_use_await));
+ }
}
- return undefined;
}
}
- function getBaseTypesIfUnrelated(leftType, rightType, isRelated) {
- var effectiveLeft = leftType;
- var effectiveRight = rightType;
- var leftBase = getBaseTypeOfLiteralType(leftType);
- var rightBase = getBaseTypeOfLiteralType(rightType);
- if (!isRelated(leftBase, rightBase)) {
- effectiveLeft = leftBase;
- effectiveRight = rightBase;
+ function getThisArgumentOfCall(node) {
+ if (node.kind === 203) {
+ var callee = ts.skipOuterExpressions(node.expression);
+ if (ts.isAccessExpression(callee)) {
+ return callee.expression;
+ }
}
- return [effectiveLeft, effectiveRight];
}
- function checkYieldExpression(node) {
- if (produceDiagnostics) {
- if (!(node.flags & 8192)) {
- grammarErrorOnFirstToken(node, ts.Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body);
- }
- if (isInParameterInitializerBeforeContainingFunction(node)) {
- error(node, ts.Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer);
+ function createSyntheticExpression(parent, type, isSpread, tupleNameSource) {
+ var result = ts.parseNodeFactory.createSyntheticExpression(type, isSpread, tupleNameSource);
+ ts.setTextRange(result, parent);
+ ts.setParent(result, parent);
+ return result;
+ }
+ function getEffectiveCallArguments(node) {
+ if (node.kind === 205) {
+ var template = node.template;
+ var args_3 = [createSyntheticExpression(template, getGlobalTemplateStringsArrayType())];
+ if (template.kind === 218) {
+ ts.forEach(template.templateSpans, function (span) {
+ args_3.push(span.expression);
+ });
}
+ return args_3;
}
- var func = ts.getContainingFunction(node);
- if (!func)
- return anyType;
- var functionFlags = ts.getFunctionFlags(func);
- if (!(functionFlags & 1)) {
- return anyType;
+ if (node.kind === 161) {
+ return getEffectiveDecoratorArguments(node);
}
- var isAsync = (functionFlags & 2) !== 0;
- if (node.asteriskToken) {
- if (isAsync && languageVersion < 99) {
- checkExternalEmitHelpers(node, 53248);
- }
- if (!isAsync && languageVersion < 2 && compilerOptions.downlevelIteration) {
- checkExternalEmitHelpers(node, 256);
- }
+ if (ts.isJsxOpeningLikeElement(node)) {
+ return node.attributes.properties.length > 0 || (ts.isJsxOpeningElement(node) && node.parent.children.length > 0) ? [node.attributes] : ts.emptyArray;
}
- var returnType = getReturnTypeFromAnnotation(func);
- var iterationTypes = returnType && getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsync);
- var signatureYieldType = iterationTypes && iterationTypes.yieldType || anyType;
- var signatureNextType = iterationTypes && iterationTypes.nextType || anyType;
- var resolvedSignatureNextType = isAsync ? getAwaitedType(signatureNextType) || anyType : signatureNextType;
- var yieldExpressionType = node.expression ? checkExpression(node.expression) : undefinedWideningType;
- var yieldedType = getYieldedTypeOfYieldExpression(node, yieldExpressionType, resolvedSignatureNextType, isAsync);
- if (returnType && yieldedType) {
- checkTypeAssignableToAndOptionallyElaborate(yieldedType, signatureYieldType, node.expression || node, node.expression);
+ var args = node.arguments || ts.emptyArray;
+ var spreadIndex = getSpreadArgumentIndex(args);
+ if (spreadIndex >= 0) {
+ var effectiveArgs_1 = args.slice(0, spreadIndex);
+ var _loop_20 = function (i) {
+ var arg = args[i];
+ var spreadType = arg.kind === 220 && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
+ if (spreadType && isTupleType(spreadType)) {
+ ts.forEach(getTypeArguments(spreadType), function (t, i) {
+ var _a;
+ var flags = spreadType.target.elementFlags[i];
+ var syntheticArg = createSyntheticExpression(arg, flags & 4 ? createArrayType(t) : t, !!(flags & 12), (_a = spreadType.target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[i]);
+ effectiveArgs_1.push(syntheticArg);
+ });
+ }
+ else {
+ effectiveArgs_1.push(arg);
+ }
+ };
+ for (var i = spreadIndex; i < args.length; i++) {
+ _loop_20(i);
+ }
+ return effectiveArgs_1;
}
- if (node.asteriskToken) {
- var use = isAsync ? 19 : 17;
- return getIterationTypeOfIterable(use, 1, yieldExpressionType, node.expression)
- || anyType;
+ return args;
+ }
+ function getEffectiveDecoratorArguments(node) {
+ var parent = node.parent;
+ var expr = node.expression;
+ switch (parent.kind) {
+ case 252:
+ case 221:
+ return [
+ createSyntheticExpression(expr, getTypeOfSymbol(getSymbolOfNode(parent)))
+ ];
+ case 160:
+ var func = parent.parent;
+ return [
+ createSyntheticExpression(expr, parent.parent.kind === 166 ? getTypeOfSymbol(getSymbolOfNode(func)) : errorType),
+ createSyntheticExpression(expr, anyType),
+ createSyntheticExpression(expr, numberType)
+ ];
+ case 163:
+ case 165:
+ case 167:
+ case 168:
+ var hasPropDesc = parent.kind !== 163 && languageVersion !== 0;
+ return [
+ createSyntheticExpression(expr, getParentTypeOfClassElement(parent)),
+ createSyntheticExpression(expr, getClassElementPropertyKeyType(parent)),
+ createSyntheticExpression(expr, hasPropDesc ? createTypedPropertyDescriptorType(getTypeOfNode(parent)) : anyType)
+ ];
}
- else if (returnType) {
- return getIterationTypeOfGeneratorFunctionReturnType(2, returnType, isAsync)
- || anyType;
+ return ts.Debug.fail();
+ }
+ function getDecoratorArgumentCount(node, signature) {
+ switch (node.parent.kind) {
+ case 252:
+ case 221:
+ return 1;
+ case 163:
+ return 2;
+ case 165:
+ case 167:
+ case 168:
+ return languageVersion === 0 || signature.parameters.length <= 2 ? 2 : 3;
+ case 160:
+ return 3;
+ default:
+ return ts.Debug.fail();
}
- return getContextualIterationType(2, func) || anyType;
}
- function checkConditionalExpression(node, checkMode) {
- var type = checkTruthinessExpression(node.condition);
- checkTestingKnownTruthyCallableType(node.condition, node.whenTrue, type);
- var type1 = checkExpression(node.whenTrue, checkMode);
- var type2 = checkExpression(node.whenFalse, checkMode);
- return getUnionType([type1, type2], 2);
+ function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) {
+ var start;
+ var length;
+ var sourceFile = ts.getSourceFileOfNode(node);
+ if (ts.isPropertyAccessExpression(node.expression)) {
+ var nameSpan = ts.getErrorSpanForNode(sourceFile, node.expression.name);
+ start = nameSpan.start;
+ length = doNotIncludeArguments ? nameSpan.length : node.end - start;
+ }
+ else {
+ var expressionSpan = ts.getErrorSpanForNode(sourceFile, node.expression);
+ start = expressionSpan.start;
+ length = doNotIncludeArguments ? expressionSpan.length : node.end - start;
+ }
+ return { start: start, length: length, sourceFile: sourceFile };
}
- function checkTemplateExpression(node) {
- ts.forEach(node.templateSpans, function (templateSpan) {
- if (maybeTypeOfKind(checkExpression(templateSpan.expression), 12288)) {
- error(templateSpan.expression, ts.Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String);
- }
- });
- return stringType;
+ function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) {
+ if (ts.isCallExpression(node)) {
+ var _a = getDiagnosticSpanForCallNode(node), sourceFile = _a.sourceFile, start = _a.start, length_5 = _a.length;
+ return ts.createFileDiagnostic(sourceFile, start, length_5, message, arg0, arg1, arg2, arg3);
+ }
+ else {
+ return ts.createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3);
+ }
}
- function getContextNode(node) {
- if (node.kind === 274 && !ts.isJsxSelfClosingElement(node.parent)) {
- return node.parent.parent;
+ function isPromiseResolveArityError(node) {
+ if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression))
+ return false;
+ var symbol = resolveName(node.expression, node.expression.escapedText, 111551, undefined, undefined, false);
+ var decl = symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration;
+ if (!decl || !ts.isParameter(decl) || !isFunctionExpressionOrArrowFunction(decl.parent) || !ts.isNewExpression(decl.parent.parent) || !ts.isIdentifier(decl.parent.parent.expression)) {
+ return false;
}
- return node;
+ var globalPromiseSymbol = getGlobalPromiseConstructorSymbol(false);
+ if (!globalPromiseSymbol)
+ return false;
+ var constructorSymbol = getSymbolAtLocation(decl.parent.parent.expression, true);
+ return constructorSymbol === globalPromiseSymbol;
}
- function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
- var context = getContextNode(node);
- var saveContextualType = context.contextualType;
- var saveInferenceContext = context.inferenceContext;
- try {
- context.contextualType = contextualType;
- context.inferenceContext = inferenceContext;
- var type = checkExpression(node, checkMode | 1 | (inferenceContext ? 2 : 0));
- var result = maybeTypeOfKind(type, 2944) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node)) ?
- getRegularTypeOfLiteralType(type) : type;
- return result;
+ function getArgumentArityError(node, signatures, args) {
+ var min = Number.POSITIVE_INFINITY;
+ var max = Number.NEGATIVE_INFINITY;
+ var belowArgCount = Number.NEGATIVE_INFINITY;
+ var aboveArgCount = Number.POSITIVE_INFINITY;
+ var argCount = args.length;
+ var closestSignature;
+ for (var _i = 0, signatures_8 = signatures; _i < signatures_8.length; _i++) {
+ var sig = signatures_8[_i];
+ var minCount = getMinArgumentCount(sig);
+ var maxCount = getParameterCount(sig);
+ if (minCount < argCount && minCount > belowArgCount)
+ belowArgCount = minCount;
+ if (argCount < maxCount && maxCount < aboveArgCount)
+ aboveArgCount = maxCount;
+ if (minCount < min) {
+ min = minCount;
+ closestSignature = sig;
+ }
+ max = Math.max(max, maxCount);
}
- finally {
- context.contextualType = saveContextualType;
- context.inferenceContext = saveInferenceContext;
+ var hasRestParameter = ts.some(signatures, hasEffectiveRestParameter);
+ var paramRange = hasRestParameter ? min :
+ min < max ? min + "-" + max :
+ min;
+ var hasSpreadArgument = getSpreadArgumentIndex(args) > -1;
+ if (argCount <= max && hasSpreadArgument) {
+ argCount--;
}
- }
- function checkExpressionCached(node, checkMode) {
- var links = getNodeLinks(node);
- if (!links.resolvedType) {
- if (checkMode && checkMode !== 0) {
- return checkExpression(node, checkMode);
+ var spanArray;
+ var related;
+ var error = hasRestParameter || hasSpreadArgument ?
+ hasRestParameter && hasSpreadArgument ?
+ ts.Diagnostics.Expected_at_least_0_arguments_but_got_1_or_more :
+ hasRestParameter ?
+ ts.Diagnostics.Expected_at_least_0_arguments_but_got_1 :
+ ts.Diagnostics.Expected_0_arguments_but_got_1_or_more :
+ paramRange === 1 && argCount === 0 && isPromiseResolveArityError(node) ?
+ ts.Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise :
+ ts.Diagnostics.Expected_0_arguments_but_got_1;
+ if (closestSignature && getMinArgumentCount(closestSignature) > argCount && closestSignature.declaration) {
+ var paramDecl = closestSignature.declaration.parameters[closestSignature.thisParameter ? argCount + 1 : argCount];
+ if (paramDecl) {
+ related = ts.createDiagnosticForNode(paramDecl, ts.isBindingPattern(paramDecl.name) ? ts.Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided :
+ ts.isRestParameter(paramDecl) ? ts.Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided : ts.Diagnostics.An_argument_for_0_was_not_provided, !paramDecl.name ? argCount : !ts.isBindingPattern(paramDecl.name) ? ts.idText(ts.getFirstIdentifier(paramDecl.name)) : undefined);
}
- var saveFlowLoopStart = flowLoopStart;
- var saveFlowTypeCache = flowTypeCache;
- flowLoopStart = flowLoopCount;
- flowTypeCache = undefined;
- links.resolvedType = checkExpression(node, checkMode);
- flowTypeCache = saveFlowTypeCache;
- flowLoopStart = saveFlowLoopStart;
}
- return links.resolvedType;
- }
- function isTypeAssertion(node) {
- node = ts.skipParentheses(node);
- return node.kind === 199 || node.kind === 217;
- }
- function checkDeclarationInitializer(declaration, contextualType) {
- var initializer = ts.getEffectiveInitializer(declaration);
- var type = getQuickTypeOfExpression(initializer) ||
- (contextualType ? checkExpressionWithContextualType(initializer, contextualType, undefined, 0) : checkExpressionCached(initializer));
- return ts.isParameter(declaration) && declaration.name.kind === 190 &&
- isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ?
- padTupleType(type, declaration.name) : type;
- }
- function padTupleType(type, pattern) {
- var patternElements = pattern.elements;
- var arity = getTypeReferenceArity(type);
- var elementTypes = arity ? getTypeArguments(type).slice() : [];
- for (var i = arity; i < patternElements.length; i++) {
- var e = patternElements[i];
- if (i < patternElements.length - 1 || !(e.kind === 191 && e.dotDotDotToken)) {
- elementTypes.push(!ts.isOmittedExpression(e) && hasDefaultValue(e) ? getTypeFromBindingElement(e, false, false) : anyType);
- if (!ts.isOmittedExpression(e) && !hasDefaultValue(e)) {
- reportImplicitAny(e, anyType);
- }
+ if (min < argCount && argCount < max) {
+ return getDiagnosticForCallNode(node, ts.Diagnostics.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments, argCount, belowArgCount, aboveArgCount);
+ }
+ if (!hasSpreadArgument && argCount < min) {
+ var diagnostic_1 = getDiagnosticForCallNode(node, error, paramRange, argCount);
+ return related ? ts.addRelatedInfo(diagnostic_1, related) : diagnostic_1;
+ }
+ if (hasRestParameter || hasSpreadArgument) {
+ spanArray = ts.factory.createNodeArray(args);
+ if (hasSpreadArgument && argCount) {
+ var nextArg = ts.elementAt(args, getSpreadArgumentIndex(args) + 1) || undefined;
+ spanArray = ts.factory.createNodeArray(args.slice(max > argCount && nextArg ? args.indexOf(nextArg) : Math.min(max, args.length - 1)));
}
}
- return createTupleType(elementTypes, type.target.minLength, false, type.target.readonly);
+ else {
+ spanArray = ts.factory.createNodeArray(args.slice(max));
+ }
+ var pos = ts.first(spanArray).pos;
+ var end = ts.last(spanArray).end;
+ if (end === pos) {
+ end++;
+ }
+ ts.setTextRangePosEnd(spanArray, pos, end);
+ var diagnostic = ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), spanArray, error, paramRange, argCount);
+ return related ? ts.addRelatedInfo(diagnostic, related) : diagnostic;
}
- function widenTypeInferredFromInitializer(declaration, type) {
- var widened = ts.getCombinedNodeFlags(declaration) & 2 || ts.isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type);
- if (ts.isInJSFile(declaration)) {
- if (widened.flags & 98304) {
- reportImplicitAny(declaration, anyType);
- return anyType;
+ function getTypeArgumentArityError(node, signatures, typeArguments) {
+ var argCount = typeArguments.length;
+ if (signatures.length === 1) {
+ var sig = signatures[0];
+ var min_1 = getMinTypeArgumentCount(sig.typeParameters);
+ var max = ts.length(sig.typeParameters);
+ return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, min_1 < max ? min_1 + "-" + max : min_1, argCount);
+ }
+ var belowArgCount = -Infinity;
+ var aboveArgCount = Infinity;
+ for (var _i = 0, signatures_9 = signatures; _i < signatures_9.length; _i++) {
+ var sig = signatures_9[_i];
+ var min_2 = getMinTypeArgumentCount(sig.typeParameters);
+ var max = ts.length(sig.typeParameters);
+ if (min_2 > argCount) {
+ aboveArgCount = Math.min(aboveArgCount, min_2);
}
- else if (isEmptyArrayLiteralType(widened)) {
- reportImplicitAny(declaration, anyArrayType);
- return anyArrayType;
+ else if (max < argCount) {
+ belowArgCount = Math.max(belowArgCount, max);
}
}
- return widened;
+ if (belowArgCount !== -Infinity && aboveArgCount !== Infinity) {
+ return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, argCount, belowArgCount, aboveArgCount);
+ }
+ return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, belowArgCount === -Infinity ? aboveArgCount : belowArgCount, argCount);
}
- function isLiteralOfContextualType(candidateType, contextualType) {
- if (contextualType) {
- if (contextualType.flags & 3145728) {
- var types = contextualType.types;
- return ts.some(types, function (t) { return isLiteralOfContextualType(candidateType, t); });
+ function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, fallbackError) {
+ var isTaggedTemplate = node.kind === 205;
+ var isDecorator = node.kind === 161;
+ var isJsxOpeningOrSelfClosingElement = ts.isJsxOpeningLikeElement(node);
+ var reportErrors = !candidatesOutArray && produceDiagnostics;
+ var typeArguments;
+ if (!isDecorator) {
+ typeArguments = node.typeArguments;
+ if (isTaggedTemplate || isJsxOpeningOrSelfClosingElement || node.expression.kind !== 105) {
+ ts.forEach(typeArguments, checkSourceElement);
}
- if (contextualType.flags & 58982400) {
- var constraint = getBaseConstraintOfType(contextualType) || unknownType;
- return maybeTypeOfKind(constraint, 4) && maybeTypeOfKind(candidateType, 128) ||
- maybeTypeOfKind(constraint, 8) && maybeTypeOfKind(candidateType, 256) ||
- maybeTypeOfKind(constraint, 64) && maybeTypeOfKind(candidateType, 2048) ||
- maybeTypeOfKind(constraint, 4096) && maybeTypeOfKind(candidateType, 8192) ||
- isLiteralOfContextualType(candidateType, constraint);
+ }
+ var candidates = candidatesOutArray || [];
+ reorderCandidates(signatures, candidates, callChainFlags);
+ if (!candidates.length) {
+ if (reportErrors) {
+ diagnostics.add(getDiagnosticForCallNode(node, ts.Diagnostics.Call_target_does_not_contain_any_signatures));
}
- return !!(contextualType.flags & (128 | 4194304) && maybeTypeOfKind(candidateType, 128) ||
- contextualType.flags & 256 && maybeTypeOfKind(candidateType, 256) ||
- contextualType.flags & 2048 && maybeTypeOfKind(candidateType, 2048) ||
- contextualType.flags & 512 && maybeTypeOfKind(candidateType, 512) ||
- contextualType.flags & 8192 && maybeTypeOfKind(candidateType, 8192));
+ return resolveErrorCall(node);
}
- return false;
- }
- function isConstContext(node) {
- var parent = node.parent;
- return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) ||
- (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) ||
- (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent)) && isConstContext(parent.parent);
- }
- function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) {
- var type = checkExpression(node, checkMode, forceTuple);
- return isConstContext(node) ? getRegularTypeOfLiteralType(type) :
- isTypeAssertion(node) ? type :
- getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node));
- }
- function checkPropertyAssignment(node, checkMode) {
- if (node.name.kind === 154) {
- checkComputedPropertyName(node.name);
+ var args = getEffectiveCallArguments(node);
+ var isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
+ var argCheckMode = !isDecorator && !isSingleNonGenericCandidate && ts.some(args, isContextSensitive) ? 4 : 0;
+ var candidatesForArgumentError;
+ var candidateForArgumentArityError;
+ var candidateForTypeArgumentError;
+ var result;
+ var signatureHelpTrailingComma = !!(checkMode & 16) && node.kind === 203 && node.arguments.hasTrailingComma;
+ if (candidates.length > 1) {
+ result = chooseOverload(candidates, subtypeRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
}
- return checkExpressionForMutableLocation(node.initializer, checkMode);
- }
- function checkObjectLiteralMethod(node, checkMode) {
- checkGrammarMethod(node);
- if (node.name.kind === 154) {
- checkComputedPropertyName(node.name);
+ if (!result) {
+ result = chooseOverload(candidates, assignableRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
}
- var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, checkMode);
- return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
- }
- function instantiateTypeWithSingleGenericCallSignature(node, type, checkMode) {
- if (checkMode && checkMode & (2 | 8)) {
- var callSignature = getSingleSignature(type, 0, true);
- var constructSignature = getSingleSignature(type, 1, true);
- var signature = callSignature || constructSignature;
- if (signature && signature.typeParameters) {
- var contextualType = getApparentTypeOfContextualType(node, 2);
- if (contextualType) {
- var contextualSignature = getSingleSignature(getNonNullableType(contextualType), callSignature ? 0 : 1, false);
- if (contextualSignature && !contextualSignature.typeParameters) {
- if (checkMode & 8) {
- skippedGenericFunction(node, checkMode);
- return anyFunctionType;
- }
- var context = getInferenceContext(node);
- var returnType = context.signature && getReturnTypeOfSignature(context.signature);
- var returnSignature = returnType && getSingleCallOrConstructSignature(returnType);
- if (returnSignature && !returnSignature.typeParameters && !ts.every(context.inferences, hasInferenceCandidates)) {
- var uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
- var instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
- var inferences_3 = ts.map(context.inferences, function (info) { return createInferenceInfo(info.typeParameter); });
- applyToParameterTypes(instantiatedSignature, contextualSignature, function (source, target) {
- inferTypes(inferences_3, source, target, 0, true);
- });
- if (ts.some(inferences_3, hasInferenceCandidates)) {
- applyToReturnTypes(instantiatedSignature, contextualSignature, function (source, target) {
- inferTypes(inferences_3, source, target);
- });
- if (!hasOverlappingInferences(context.inferences, inferences_3)) {
- mergeInferences(context.inferences, inferences_3);
- context.inferredTypeParameters = ts.concatenate(context.inferredTypeParameters, uniqueTypeParameters);
- return getOrCreateTypeFromSignature(instantiatedSignature);
- }
+ if (result) {
+ return result;
+ }
+ if (reportErrors) {
+ if (candidatesForArgumentError) {
+ if (candidatesForArgumentError.length === 1 || candidatesForArgumentError.length > 3) {
+ var last_2 = candidatesForArgumentError[candidatesForArgumentError.length - 1];
+ var chain_1;
+ if (candidatesForArgumentError.length > 3) {
+ chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.The_last_overload_gave_the_following_error);
+ chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.No_overload_matches_this_call);
+ }
+ var diags = getSignatureApplicabilityError(node, args, last_2, assignableRelation, 0, true, function () { return chain_1; });
+ if (diags) {
+ for (var _i = 0, diags_1 = diags; _i < diags_1.length; _i++) {
+ var d = diags_1[_i];
+ if (last_2.declaration && candidatesForArgumentError.length > 3) {
+ ts.addRelatedInfo(d, ts.createDiagnosticForNode(last_2.declaration, ts.Diagnostics.The_last_overload_is_declared_here));
}
+ addImplementationSuccessElaboration(last_2, d);
+ diagnostics.add(d);
}
- return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
+ }
+ else {
+ ts.Debug.fail("No error for last overload signature");
}
}
+ else {
+ var allDiagnostics = [];
+ var max = 0;
+ var min_3 = Number.MAX_VALUE;
+ var minIndex = 0;
+ var i_1 = 0;
+ var _loop_21 = function (c) {
+ var chain_2 = function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); };
+ var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0, true, chain_2);
+ if (diags_2) {
+ if (diags_2.length <= min_3) {
+ min_3 = diags_2.length;
+ minIndex = i_1;
+ }
+ max = Math.max(max, diags_2.length);
+ allDiagnostics.push(diags_2);
+ }
+ else {
+ ts.Debug.fail("No error for 3 or fewer overload signatures");
+ }
+ i_1++;
+ };
+ for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
+ var c = candidatesForArgumentError_1[_a];
+ _loop_21(c);
+ }
+ var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
+ ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
+ var chain = ts.chainDiagnosticMessages(ts.map(diags_3, function (d) { return typeof d.messageText === "string" ? d : d.messageText; }), ts.Diagnostics.No_overload_matches_this_call);
+ var related = __spreadArrays(ts.flatMap(diags_3, function (d) { return d.relatedInformation; }));
+ var diag = void 0;
+ if (ts.every(diags_3, function (d) { return d.start === diags_3[0].start && d.length === diags_3[0].length && d.file === diags_3[0].file; })) {
+ var _b = diags_3[0], file = _b.file, start = _b.start, length_6 = _b.length;
+ diag = { file: file, start: start, length: length_6, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related };
+ }
+ else {
+ diag = ts.createDiagnosticForNodeFromMessageChain(node, chain, related);
+ }
+ addImplementationSuccessElaboration(candidatesForArgumentError[0], diag);
+ diagnostics.add(diag);
+ }
}
- }
- return type;
- }
- function skippedGenericFunction(node, checkMode) {
- if (checkMode & 2) {
- var context = getInferenceContext(node);
- context.flags |= 4;
- }
- }
- function hasInferenceCandidates(info) {
- return !!(info.candidates || info.contraCandidates);
- }
- function hasOverlappingInferences(a, b) {
- for (var i = 0; i < a.length; i++) {
- if (hasInferenceCandidates(a[i]) && hasInferenceCandidates(b[i])) {
- return true;
- }
- }
- return false;
- }
- function mergeInferences(target, source) {
- for (var i = 0; i < target.length; i++) {
- if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
- target[i] = source[i];
+ else if (candidateForArgumentArityError) {
+ diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args));
}
- }
- }
- function getUniqueTypeParameters(context, typeParameters) {
- var result = [];
- var oldTypeParameters;
- var newTypeParameters;
- for (var _i = 0, typeParameters_2 = typeParameters; _i < typeParameters_2.length; _i++) {
- var tp = typeParameters_2[_i];
- var name = tp.symbol.escapedName;
- if (hasTypeParameterByName(context.inferredTypeParameters, name) || hasTypeParameterByName(result, name)) {
- var newName = getUniqueTypeParameterName(ts.concatenate(context.inferredTypeParameters, result), name);
- var symbol = createSymbol(262144, newName);
- var newTypeParameter = createTypeParameter(symbol);
- newTypeParameter.target = tp;
- oldTypeParameters = ts.append(oldTypeParameters, tp);
- newTypeParameters = ts.append(newTypeParameters, newTypeParameter);
- result.push(newTypeParameter);
+ else if (candidateForTypeArgumentError) {
+ checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, true, fallbackError);
}
else {
- result.push(tp);
+ var signaturesWithCorrectTypeArgumentArity = ts.filter(signatures, function (s) { return hasCorrectTypeArgumentArity(s, typeArguments); });
+ if (signaturesWithCorrectTypeArgumentArity.length === 0) {
+ diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments));
+ }
+ else if (!isDecorator) {
+ diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args));
+ }
+ else if (fallbackError) {
+ diagnostics.add(getDiagnosticForCallNode(node, fallbackError));
+ }
}
}
- if (newTypeParameters) {
- var mapper = createTypeMapper(oldTypeParameters, newTypeParameters);
- for (var _a = 0, newTypeParameters_1 = newTypeParameters; _a < newTypeParameters_1.length; _a++) {
- var tp = newTypeParameters_1[_a];
- tp.mapper = mapper;
+ return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray);
+ function addImplementationSuccessElaboration(failed, diagnostic) {
+ var _a, _b;
+ var oldCandidatesForArgumentError = candidatesForArgumentError;
+ var oldCandidateForArgumentArityError = candidateForArgumentArityError;
+ var oldCandidateForTypeArgumentError = candidateForTypeArgumentError;
+ var declCount = ts.length((_a = failed.declaration) === null || _a === void 0 ? void 0 : _a.symbol.declarations);
+ var isOverload = declCount > 1;
+ var implDecl = isOverload ? ts.find(((_b = failed.declaration) === null || _b === void 0 ? void 0 : _b.symbol.declarations) || ts.emptyArray, function (d) { return ts.isFunctionLikeDeclaration(d) && ts.nodeIsPresent(d.body); }) : undefined;
+ if (implDecl) {
+ var candidate = getSignatureFromDeclaration(implDecl);
+ var isSingleNonGenericCandidate_1 = !candidate.typeParameters;
+ if (chooseOverload([candidate], assignableRelation, isSingleNonGenericCandidate_1)) {
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(implDecl, ts.Diagnostics.The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible));
+ }
+ }
+ candidatesForArgumentError = oldCandidatesForArgumentError;
+ candidateForArgumentArityError = oldCandidateForArgumentArityError;
+ candidateForTypeArgumentError = oldCandidateForTypeArgumentError;
+ }
+ function chooseOverload(candidates, relation, isSingleNonGenericCandidate, signatureHelpTrailingComma) {
+ if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; }
+ candidatesForArgumentError = undefined;
+ candidateForArgumentArityError = undefined;
+ candidateForTypeArgumentError = undefined;
+ if (isSingleNonGenericCandidate) {
+ var candidate = candidates[0];
+ if (ts.some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) {
+ return undefined;
+ }
+ if (getSignatureApplicabilityError(node, args, candidate, relation, 0, false, undefined)) {
+ candidatesForArgumentError = [candidate];
+ return undefined;
+ }
+ return candidate;
}
- }
- return result;
- }
- function hasTypeParameterByName(typeParameters, name) {
- return ts.some(typeParameters, function (tp) { return tp.symbol.escapedName === name; });
- }
- function getUniqueTypeParameterName(typeParameters, baseName) {
- var len = baseName.length;
- while (len > 1 && baseName.charCodeAt(len - 1) >= 48 && baseName.charCodeAt(len - 1) <= 57)
- len--;
- var s = baseName.slice(0, len);
- for (var index = 1; true; index++) {
- var augmentedName = (s + index);
- if (!hasTypeParameterByName(typeParameters, augmentedName)) {
- return augmentedName;
+ for (var candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
+ var candidate = candidates[candidateIndex];
+ if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) {
+ continue;
+ }
+ var checkCandidate = void 0;
+ var inferenceContext = void 0;
+ if (candidate.typeParameters) {
+ var typeArgumentTypes = void 0;
+ if (ts.some(typeArguments)) {
+ typeArgumentTypes = checkTypeArguments(candidate, typeArguments, false);
+ if (!typeArgumentTypes) {
+ candidateForTypeArgumentError = candidate;
+ continue;
+ }
+ }
+ else {
+ inferenceContext = createInferenceContext(candidate.typeParameters, candidate, ts.isInJSFile(node) ? 2 : 0);
+ typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8, inferenceContext);
+ argCheckMode |= inferenceContext.flags & 4 ? 8 : 0;
+ }
+ checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
+ if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) {
+ candidateForArgumentArityError = checkCandidate;
+ continue;
+ }
+ }
+ else {
+ checkCandidate = candidate;
+ }
+ if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, undefined)) {
+ (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
+ continue;
+ }
+ if (argCheckMode) {
+ argCheckMode = 0;
+ if (inferenceContext) {
+ var typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
+ checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
+ if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) {
+ candidateForArgumentArityError = checkCandidate;
+ continue;
+ }
+ }
+ if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, undefined)) {
+ (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
+ continue;
+ }
+ }
+ candidates[candidateIndex] = checkCandidate;
+ return checkCandidate;
}
+ return undefined;
}
}
- function getReturnTypeOfSingleNonGenericCallSignature(funcType) {
- var signature = getSingleCallSignature(funcType);
- if (signature && !signature.typeParameters) {
- return getReturnTypeOfSignature(signature);
- }
- }
- function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) {
- var funcType = checkExpression(expr.expression);
- var nonOptionalType = getOptionalExpressionType(funcType, expr.expression);
- var returnType = getReturnTypeOfSingleNonGenericCallSignature(funcType);
- return returnType && propagateOptionalTypeMarker(returnType, expr, nonOptionalType !== funcType);
+ function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray) {
+ ts.Debug.assert(candidates.length > 0);
+ checkNodeDeferred(node);
+ return hasCandidatesOutArray || candidates.length === 1 || candidates.some(function (c) { return !!c.typeParameters; })
+ ? pickLongestCandidateSignature(node, candidates, args)
+ : createUnionOfSignaturesForOverloadFailure(candidates);
}
- function getTypeOfExpression(node) {
- var quickType = getQuickTypeOfExpression(node);
- if (quickType) {
- return quickType;
- }
- if (node.flags & 67108864 && flowTypeCache) {
- var cachedType = flowTypeCache[getNodeId(node)];
- if (cachedType) {
- return cachedType;
- }
- }
- var startInvocationCount = flowInvocationCount;
- var type = checkExpression(node);
- if (flowInvocationCount !== startInvocationCount) {
- var cache = flowTypeCache || (flowTypeCache = []);
- cache[getNodeId(node)] = type;
- node.flags |= 67108864;
+ function createUnionOfSignaturesForOverloadFailure(candidates) {
+ var thisParameters = ts.mapDefined(candidates, function (c) { return c.thisParameter; });
+ var thisParameter;
+ if (thisParameters.length) {
+ thisParameter = createCombinedSymbolFromTypes(thisParameters, thisParameters.map(getTypeOfParameter));
}
- return type;
- }
- function getQuickTypeOfExpression(node) {
- var expr = ts.skipParentheses(node);
- if (ts.isCallExpression(expr) && expr.expression.kind !== 102 && !ts.isRequireCall(expr, true) && !isSymbolOrSymbolForCall(expr)) {
- var type = ts.isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) :
- getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression));
- if (type) {
- return type;
- }
+ var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
+ var parameters = [];
+ var _loop_22 = function (i) {
+ var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ?
+ i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) :
+ i < s.parameters.length ? s.parameters[i] : undefined; });
+ ts.Debug.assert(symbols.length !== 0);
+ parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
+ };
+ for (var i = 0; i < maxNonRestParam; i++) {
+ _loop_22(i);
}
- else if (ts.isAssertionExpression(expr) && !ts.isConstTypeReference(expr.type)) {
- return getTypeFromTypeNode(expr.type);
+ var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
+ var flags = 0;
+ if (restParameterSymbols.length !== 0) {
+ var type = createArrayType(getUnionType(ts.mapDefined(candidates, tryGetRestTypeOfSignature), 2));
+ parameters.push(createCombinedSymbolForOverloadFailure(restParameterSymbols, type));
+ flags |= 1;
}
- else if (node.kind === 8 || node.kind === 10 ||
- node.kind === 106 || node.kind === 91) {
- return checkExpression(node);
+ if (candidates.some(signatureHasLiteralTypes)) {
+ flags |= 2;
}
- return undefined;
+ return createSignature(candidates[0].declaration, undefined, thisParameter, parameters, getIntersectionType(candidates.map(getReturnTypeOfSignature)), undefined, minArgumentCount, flags);
}
- function getContextFreeTypeOfExpression(node) {
- var links = getNodeLinks(node);
- if (links.contextFreeType) {
- return links.contextFreeType;
- }
- var saveContextualType = node.contextualType;
- node.contextualType = anyType;
- try {
- var type = links.contextFreeType = checkExpression(node, 4);
- return type;
- }
- finally {
- node.contextualType = saveContextualType;
- }
+ function getNumNonRestParameters(signature) {
+ var numParams = signature.parameters.length;
+ return signatureHasRestParameter(signature) ? numParams - 1 : numParams;
}
- function checkExpression(node, checkMode, forceTuple) {
- var saveCurrentNode = currentNode;
- currentNode = node;
- instantiationCount = 0;
- var uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple);
- var type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
- if (isConstEnumObjectType(type)) {
- checkConstEnumAccess(node, type);
- }
- currentNode = saveCurrentNode;
- return type;
+ function createCombinedSymbolFromTypes(sources, types) {
+ return createCombinedSymbolForOverloadFailure(sources, getUnionType(types, 2));
}
- function checkConstEnumAccess(node, type) {
- var ok = (node.parent.kind === 194 && node.parent.expression === node) ||
- (node.parent.kind === 195 && node.parent.expression === node) ||
- ((node.kind === 75 || node.kind === 153) && isInRightSideOfImportOrExportAssignment(node) ||
- (node.parent.kind === 172 && node.parent.exprName === node)) ||
- (node.parent.kind === 263);
- if (!ok) {
- error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query);
- }
- if (compilerOptions.isolatedModules) {
- ts.Debug.assert(!!(type.symbol.flags & 128));
- var constEnumDeclaration = type.symbol.valueDeclaration;
- if (constEnumDeclaration.flags & 8388608) {
- error(node, ts.Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided);
- }
- }
+ function createCombinedSymbolForOverloadFailure(sources, type) {
+ return createSymbolWithType(ts.first(sources), type);
}
- function checkParenthesizedExpression(node, checkMode) {
- var tag = ts.isInJSFile(node) ? ts.getJSDocTypeTag(node) : undefined;
- if (tag) {
- return checkAssertionWorker(tag, tag.typeExpression.type, node.expression, checkMode);
+ function pickLongestCandidateSignature(node, candidates, args) {
+ var bestIndex = getLongestCandidateIndex(candidates, apparentArgumentCount === undefined ? args.length : apparentArgumentCount);
+ var candidate = candidates[bestIndex];
+ var typeParameters = candidate.typeParameters;
+ if (!typeParameters) {
+ return candidate;
}
- return checkExpression(node.expression, checkMode);
+ var typeArgumentNodes = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : undefined;
+ var instantiated = typeArgumentNodes
+ ? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, ts.isInJSFile(node)))
+ : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args);
+ candidates[bestIndex] = instantiated;
+ return instantiated;
}
- function checkExpressionWorker(node, checkMode, forceTuple) {
- var kind = node.kind;
- if (cancellationToken) {
- switch (kind) {
- case 214:
- case 201:
- case 202:
- cancellationToken.throwIfCancellationRequested();
- }
+ function getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, isJs) {
+ var typeArguments = typeArgumentNodes.map(getTypeOfNode);
+ while (typeArguments.length > typeParameters.length) {
+ typeArguments.pop();
}
- switch (kind) {
- case 75:
- return checkIdentifier(node);
- case 104:
- return checkThisExpression(node);
- case 102:
- return checkSuperExpression(node);
- case 100:
- return nullWideningType;
- case 14:
- case 10:
- return getFreshTypeOfLiteralType(getLiteralType(node.text));
- case 8:
- checkGrammarNumericLiteral(node);
- return getFreshTypeOfLiteralType(getLiteralType(+node.text));
- case 9:
- checkGrammarBigIntLiteral(node);
- return getFreshTypeOfLiteralType(getBigIntLiteralType(node));
- case 106:
- return trueType;
- case 91:
- return falseType;
- case 211:
- return checkTemplateExpression(node);
- case 13:
- return globalRegExpType;
- case 192:
- return checkArrayLiteral(node, checkMode, forceTuple);
- case 193:
- return checkObjectLiteral(node, checkMode);
- case 194:
- return checkPropertyAccessExpression(node);
- case 153:
- return checkQualifiedName(node);
- case 195:
- return checkIndexedAccess(node);
- case 196:
- if (node.expression.kind === 96) {
- return checkImportCallExpression(node);
- }
- case 197:
- return checkCallExpression(node, checkMode);
- case 198:
- return checkTaggedTemplateExpression(node);
- case 200:
- return checkParenthesizedExpression(node, checkMode);
- case 214:
- return checkClassExpression(node);
- case 201:
- case 202:
- return checkFunctionExpressionOrObjectLiteralMethod(node, checkMode);
- case 204:
- return checkTypeOfExpression(node);
- case 199:
- case 217:
- return checkAssertion(node);
- case 218:
- return checkNonNullAssertion(node);
- case 219:
- return checkMetaProperty(node);
- case 203:
- return checkDeleteExpression(node);
- case 205:
- return checkVoidExpression(node);
- case 206:
- return checkAwaitExpression(node);
- case 207:
- return checkPrefixUnaryExpression(node);
- case 208:
- return checkPostfixUnaryExpression(node);
- case 209:
- return checkBinaryExpression(node, checkMode);
- case 210:
- return checkConditionalExpression(node, checkMode);
- case 213:
- return checkSpreadExpression(node, checkMode);
- case 215:
- return undefinedWideningType;
- case 212:
- return checkYieldExpression(node);
- case 220:
- return node.type;
- case 276:
- return checkJsxExpression(node, checkMode);
- case 266:
- return checkJsxElement(node, checkMode);
- case 267:
- return checkJsxSelfClosingElement(node, checkMode);
- case 270:
- return checkJsxFragment(node);
- case 274:
- return checkJsxAttributes(node, checkMode);
- case 268:
- ts.Debug.fail("Shouldn't ever directly check a JsxOpeningElement");
+ while (typeArguments.length < typeParameters.length) {
+ typeArguments.push(getConstraintOfTypeParameter(typeParameters[typeArguments.length]) || getDefaultTypeArgumentType(isJs));
}
- return errorType;
+ return typeArguments;
}
- function checkTypeParameter(node) {
- if (node.expression) {
- grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected);
- }
- checkSourceElement(node.constraint);
- checkSourceElement(node.default);
- var typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
- getBaseConstraintOfType(typeParameter);
- if (!hasNonCircularTypeParameterDefault(typeParameter)) {
- error(node.default, ts.Diagnostics.Type_parameter_0_has_a_circular_default, typeToString(typeParameter));
- }
- var constraintType = getConstraintOfTypeParameter(typeParameter);
- var defaultType = getDefaultFromTypeParameter(typeParameter);
- if (constraintType && defaultType) {
- checkTypeAssignableTo(defaultType, getTypeWithThisArgument(instantiateType(constraintType, makeUnaryTypeMapper(typeParameter, defaultType)), defaultType), node.default, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
- }
- if (produceDiagnostics) {
- checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0);
- }
+ function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args) {
+ var inferenceContext = createInferenceContext(typeParameters, candidate, ts.isInJSFile(node) ? 2 : 0);
+ var typeArgumentTypes = inferTypeArguments(node, candidate, args, 4 | 8, inferenceContext);
+ return createSignatureInstantiation(candidate, typeArgumentTypes);
}
- function checkParameter(node) {
- checkGrammarDecoratorsAndModifiers(node);
- checkVariableLikeDeclaration(node);
- var func = ts.getContainingFunction(node);
- if (ts.hasModifier(node, 92)) {
- if (!(func.kind === 162 && ts.nodeIsPresent(func.body))) {
- error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
+ function getLongestCandidateIndex(candidates, argsCount) {
+ var maxParamsIndex = -1;
+ var maxParams = -1;
+ for (var i = 0; i < candidates.length; i++) {
+ var candidate = candidates[i];
+ var paramCount = getParameterCount(candidate);
+ if (hasEffectiveRestParameter(candidate) || paramCount >= argsCount) {
+ return i;
}
- if (func.kind === 162 && ts.isIdentifier(node.name) && node.name.escapedText === "constructor") {
- error(node.name, ts.Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name);
+ if (paramCount > maxParams) {
+ maxParams = paramCount;
+ maxParamsIndex = i;
}
}
- if (node.questionToken && ts.isBindingPattern(node.name) && func.body) {
- error(node, ts.Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature);
- }
- if (node.name && ts.isIdentifier(node.name) && (node.name.escapedText === "this" || node.name.escapedText === "new")) {
- if (func.parameters.indexOf(node) !== 0) {
- error(node, ts.Diagnostics.A_0_parameter_must_be_the_first_parameter, node.name.escapedText);
- }
- if (func.kind === 162 || func.kind === 166 || func.kind === 171) {
- error(node, ts.Diagnostics.A_constructor_cannot_have_a_this_parameter);
- }
- if (func.kind === 202) {
- error(node, ts.Diagnostics.An_arrow_function_cannot_have_a_this_parameter);
+ return maxParamsIndex;
+ }
+ function resolveCallExpression(node, candidatesOutArray, checkMode) {
+ if (node.expression.kind === 105) {
+ var superType = checkSuperExpression(node.expression);
+ if (isTypeAny(superType)) {
+ for (var _i = 0, _a = node.arguments; _i < _a.length; _i++) {
+ var arg = _a[_i];
+ checkExpression(arg);
+ }
+ return anySignature;
}
- if (func.kind === 163 || func.kind === 164) {
- error(node, ts.Diagnostics.get_and_set_accessors_cannot_declare_this_parameters);
+ if (superType !== errorType) {
+ var baseTypeNode = ts.getEffectiveBaseTypeNode(ts.getContainingClass(node));
+ if (baseTypeNode) {
+ var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode);
+ return resolveCall(node, baseConstructors, candidatesOutArray, checkMode, 0);
+ }
}
+ return resolveUntypedCall(node);
}
- if (node.dotDotDotToken && !ts.isBindingPattern(node.name) && !isTypeAssignableTo(getReducedType(getTypeOfSymbol(node.symbol)), anyReadonlyArrayType)) {
- error(node, ts.Diagnostics.A_rest_parameter_must_be_of_an_array_type);
+ var callChainFlags;
+ var funcType = checkExpression(node.expression);
+ if (ts.isCallChain(node)) {
+ var nonOptionalType = getOptionalExpressionType(funcType, node.expression);
+ callChainFlags = nonOptionalType === funcType ? 0 :
+ ts.isOutermostOptionalChain(node) ? 8 :
+ 4;
+ funcType = nonOptionalType;
}
- }
- function checkTypePredicate(node) {
- var parent = getTypePredicateParent(node);
- if (!parent) {
- error(node, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods);
- return;
+ else {
+ callChainFlags = 0;
}
- var signature = getSignatureFromDeclaration(parent);
- var typePredicate = getTypePredicateOfSignature(signature);
- if (!typePredicate) {
- return;
+ funcType = checkNonNullTypeWithReporter(funcType, node.expression, reportCannotInvokePossiblyNullOrUndefinedError);
+ if (funcType === silentNeverType) {
+ return silentNeverSignature;
}
- checkSourceElement(node.type);
- var parameterName = node.parameterName;
- if (typePredicate.kind === 0 || typePredicate.kind === 2) {
- getTypeFromThisTypeNode(parameterName);
+ var apparentType = getApparentType(funcType);
+ if (apparentType === errorType) {
+ return resolveErrorCall(node);
}
- else {
- if (typePredicate.parameterIndex >= 0) {
- if (signatureHasRestParameter(signature) && typePredicate.parameterIndex === signature.parameters.length - 1) {
- error(parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter);
- }
- else {
- if (typePredicate.type) {
- var leadingError = function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type); };
- checkTypeAssignableTo(typePredicate.type, getTypeOfSymbol(signature.parameters[typePredicate.parameterIndex]), node.type, undefined, leadingError);
- }
- }
+ var callSignatures = getSignaturesOfType(apparentType, 0);
+ var numConstructSignatures = getSignaturesOfType(apparentType, 1).length;
+ if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
+ if (funcType !== errorType && node.typeArguments) {
+ error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
}
- else if (parameterName) {
- var hasReportedError = false;
- for (var _i = 0, _a = parent.parameters; _i < _a.length; _i++) {
- var name = _a[_i].name;
- if (ts.isBindingPattern(name) &&
- checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, parameterName, typePredicate.parameterName)) {
- hasReportedError = true;
- break;
+ return resolveUntypedCall(node);
+ }
+ if (!callSignatures.length) {
+ if (numConstructSignatures) {
+ error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
+ }
+ else {
+ var relatedInformation = void 0;
+ if (node.arguments.length === 1) {
+ var text = ts.getSourceFileOfNode(node).text;
+ if (ts.isLineBreak(text.charCodeAt(ts.skipTrivia(text, node.expression.end, true) - 1))) {
+ relatedInformation = ts.createDiagnosticForNode(node.expression, ts.Diagnostics.Are_you_missing_a_semicolon);
}
}
- if (!hasReportedError) {
- error(node.parameterName, ts.Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName);
- }
+ invocationError(node.expression, apparentType, 0, relatedInformation);
}
+ return resolveErrorCall(node);
}
- }
- function getTypePredicateParent(node) {
- switch (node.parent.kind) {
- case 202:
- case 165:
- case 244:
- case 201:
- case 170:
- case 161:
- case 160:
- var parent = node.parent;
- if (node === parent.type) {
- return parent;
- }
+ if (checkMode & 8 && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
+ skippedGenericFunction(node, checkMode);
+ return resolvingSignature;
+ }
+ if (callSignatures.some(function (sig) { return ts.isInJSFile(sig.declaration) && !!ts.getJSDocClassTag(sig.declaration); })) {
+ error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
+ return resolveErrorCall(node);
}
+ return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags);
}
- function checkIfTypePredicateVariableIsDeclaredInBindingPattern(pattern, predicateVariableNode, predicateVariableName) {
- for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
- var element = _a[_i];
- if (ts.isOmittedExpression(element)) {
- continue;
- }
- var name = element.name;
- if (name.kind === 75 && name.escapedText === predicateVariableName) {
- error(predicateVariableNode, ts.Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, predicateVariableName);
- return true;
- }
- else if (name.kind === 190 || name.kind === 189) {
- if (checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, predicateVariableNode, predicateVariableName)) {
- return true;
- }
+ function isGenericFunctionReturningFunction(signature) {
+ return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature)));
+ }
+ function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) {
+ return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144) ||
+ !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & (1048576 | 131072)) && isTypeAssignableTo(funcType, globalFunctionType);
+ }
+ function resolveNewExpression(node, candidatesOutArray, checkMode) {
+ if (node.arguments && languageVersion < 1) {
+ var spreadIndex = getSpreadArgumentIndex(node.arguments);
+ if (spreadIndex >= 0) {
+ error(node.arguments[spreadIndex], ts.Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher);
}
}
- }
- function checkSignatureDeclaration(node) {
- if (node.kind === 167) {
- checkGrammarIndexSignature(node);
+ var expressionType = checkNonNullExpression(node.expression);
+ if (expressionType === silentNeverType) {
+ return silentNeverSignature;
}
- else if (node.kind === 170 || node.kind === 244 || node.kind === 171 ||
- node.kind === 165 || node.kind === 162 ||
- node.kind === 166) {
- checkGrammarFunctionLikeDeclaration(node);
+ expressionType = getApparentType(expressionType);
+ if (expressionType === errorType) {
+ return resolveErrorCall(node);
}
- var functionFlags = ts.getFunctionFlags(node);
- if (!(functionFlags & 4)) {
- if ((functionFlags & 3) === 3 && languageVersion < 99) {
- checkExternalEmitHelpers(node, 12288);
+ if (isTypeAny(expressionType)) {
+ if (node.typeArguments) {
+ error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
}
- if ((functionFlags & 3) === 2 && languageVersion < 4) {
- checkExternalEmitHelpers(node, 64);
+ return resolveUntypedCall(node);
+ }
+ var constructSignatures = getSignaturesOfType(expressionType, 1);
+ if (constructSignatures.length) {
+ if (!isConstructorAccessible(node, constructSignatures[0])) {
+ return resolveErrorCall(node);
}
- if ((functionFlags & 3) !== 0 && languageVersion < 2) {
- checkExternalEmitHelpers(node, 128);
+ var valueDecl = expressionType.symbol && ts.getClassLikeDeclarationOfSymbol(expressionType.symbol);
+ if (valueDecl && ts.hasSyntacticModifier(valueDecl, 128)) {
+ error(node, ts.Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
+ return resolveErrorCall(node);
}
+ return resolveCall(node, constructSignatures, candidatesOutArray, checkMode, 0);
}
- checkTypeParameters(node.typeParameters);
- ts.forEach(node.parameters, checkParameter);
- if (node.type) {
- checkSourceElement(node.type);
- }
- if (produceDiagnostics) {
- checkCollisionWithArgumentsInGeneratedCode(node);
- var returnTypeNode = ts.getEffectiveReturnTypeNode(node);
- if (noImplicitAny && !returnTypeNode) {
- switch (node.kind) {
- case 166:
- error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
- break;
- case 165:
- error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
- break;
- }
- }
- if (returnTypeNode) {
- var functionFlags_1 = ts.getFunctionFlags(node);
- if ((functionFlags_1 & (4 | 1)) === 1) {
- var returnType = getTypeFromTypeNode(returnTypeNode);
- if (returnType === voidType) {
- error(returnTypeNode, ts.Diagnostics.A_generator_cannot_have_a_void_type_annotation);
- }
- else {
- var generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0, returnType, (functionFlags_1 & 2) !== 0) || anyType;
- var generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1, returnType, (functionFlags_1 & 2) !== 0) || generatorYieldType;
- var generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2, returnType, (functionFlags_1 & 2) !== 0) || unknownType;
- var generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags_1 & 2));
- checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode);
- }
+ var callSignatures = getSignaturesOfType(expressionType, 0);
+ if (callSignatures.length) {
+ var signature = resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0);
+ if (!noImplicitAny) {
+ if (signature.declaration && !isJSConstructor(signature.declaration) && getReturnTypeOfSignature(signature) !== voidType) {
+ error(node, ts.Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword);
}
- else if ((functionFlags_1 & 3) === 2) {
- checkAsyncFunctionReturnType(node, returnTypeNode);
+ if (getThisTypeOfSignature(signature) === voidType) {
+ error(node, ts.Diagnostics.A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void);
}
}
- if (node.kind !== 167 && node.kind !== 300) {
- registerForUnusedIdentifiersCheck(node);
- }
+ return signature;
}
+ invocationError(node.expression, expressionType, 1);
+ return resolveErrorCall(node);
}
- function checkClassForDuplicateDeclarations(node) {
- var instanceNames = ts.createUnderscoreEscapedMap();
- var staticNames = ts.createUnderscoreEscapedMap();
- var privateIdentifiers = ts.createUnderscoreEscapedMap();
- for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
- var member = _a[_i];
- if (member.kind === 162) {
- for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) {
- var param = _c[_b];
- if (ts.isParameterPropertyDeclaration(param, member) && !ts.isBindingPattern(param.name)) {
- addName(instanceNames, param.name, param.name.escapedText, 3);
- }
- }
- }
- else {
- var isStatic = ts.hasModifier(member, 32);
- var name = member.name;
- if (!name) {
- return;
- }
- var names = ts.isPrivateIdentifier(name) ? privateIdentifiers :
- isStatic ? staticNames :
- instanceNames;
- var memberName = name && ts.getPropertyNameForPropertyNameNode(name);
- if (memberName) {
- switch (member.kind) {
- case 163:
- addName(names, name, memberName, 1);
- break;
- case 164:
- addName(names, name, memberName, 2);
- break;
- case 159:
- addName(names, name, memberName, 3);
- break;
- case 161:
- addName(names, name, memberName, 8);
- break;
- }
- }
- }
+ function typeHasProtectedAccessibleBase(target, type) {
+ var baseTypes = getBaseTypes(type);
+ if (!ts.length(baseTypes)) {
+ return false;
}
- function addName(names, location, name, meaning) {
- var prev = names.get(name);
- if (prev) {
- if (prev & 8) {
- if (meaning !== 8) {
- error(location, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(location));
+ var firstBase = baseTypes[0];
+ if (firstBase.flags & 2097152) {
+ var types = firstBase.types;
+ var mixinFlags = findMixins(types);
+ var i = 0;
+ for (var _i = 0, _a = firstBase.types; _i < _a.length; _i++) {
+ var intersectionMember = _a[_i];
+ if (!mixinFlags[i]) {
+ if (ts.getObjectFlags(intersectionMember) & (1 | 2)) {
+ if (intersectionMember.symbol === target) {
+ return true;
+ }
+ if (typeHasProtectedAccessibleBase(target, intersectionMember)) {
+ return true;
+ }
}
}
- else if (prev & meaning) {
- error(location, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(location));
- }
- else {
- names.set(name, prev | meaning);
- }
- }
- else {
- names.set(name, meaning);
+ i++;
}
+ return false;
+ }
+ if (firstBase.symbol === target) {
+ return true;
}
+ return typeHasProtectedAccessibleBase(target, firstBase);
}
- function checkClassForStaticPropertyNameConflicts(node) {
- for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
- var member = _a[_i];
- var memberNameNode = member.name;
- var isStatic = ts.hasModifier(member, 32);
- if (isStatic && memberNameNode) {
- var memberName = ts.getPropertyNameForPropertyNameNode(memberNameNode);
- switch (memberName) {
- case "name":
- case "length":
- case "caller":
- case "arguments":
- case "prototype":
- var message = ts.Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
- var className = getNameOfSymbolAsWritten(getSymbolOfNode(node));
- error(memberNameNode, message, memberName, className);
- break;
+ function isConstructorAccessible(node, signature) {
+ if (!signature || !signature.declaration) {
+ return true;
+ }
+ var declaration = signature.declaration;
+ var modifiers = ts.getSelectedEffectiveModifierFlags(declaration, 24);
+ if (!modifiers || declaration.kind !== 166) {
+ return true;
+ }
+ var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(declaration.parent.symbol);
+ var declaringClass = getDeclaredTypeOfSymbol(declaration.parent.symbol);
+ if (!isNodeWithinClass(node, declaringClassDeclaration)) {
+ var containingClass = ts.getContainingClass(node);
+ if (containingClass && modifiers & 16) {
+ var containingType = getTypeOfNode(containingClass);
+ if (typeHasProtectedAccessibleBase(declaration.parent.symbol, containingType)) {
+ return true;
}
}
+ if (modifiers & 8) {
+ error(node, ts.Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
+ }
+ if (modifiers & 16) {
+ error(node, ts.Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
+ }
+ return false;
}
+ return true;
}
- function checkObjectTypeForDuplicateDeclarations(node) {
- var names = ts.createMap();
- for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
- var member = _a[_i];
- if (member.kind === 158) {
- var memberName = void 0;
- var name = member.name;
- switch (name.kind) {
- case 10:
- case 8:
- memberName = name.text;
- break;
- case 75:
- memberName = ts.idText(name);
+ function invocationErrorDetails(errorTarget, apparentType, kind) {
+ var errorInfo;
+ var isCall = kind === 0;
+ var awaitedType = getAwaitedType(apparentType);
+ var maybeMissingAwait = awaitedType && getSignaturesOfType(awaitedType, kind).length > 0;
+ if (apparentType.flags & 1048576) {
+ var types = apparentType.types;
+ var hasSignatures = false;
+ for (var _i = 0, types_19 = types; _i < types_19.length; _i++) {
+ var constituent = types_19[_i];
+ var signatures = getSignaturesOfType(constituent, kind);
+ if (signatures.length !== 0) {
+ hasSignatures = true;
+ if (errorInfo) {
break;
- default:
- continue;
- }
- if (names.get(memberName)) {
- error(ts.getNameOfDeclaration(member.symbol.valueDeclaration), ts.Diagnostics.Duplicate_identifier_0, memberName);
- error(member.name, ts.Diagnostics.Duplicate_identifier_0, memberName);
+ }
}
else {
- names.set(memberName, true);
+ if (!errorInfo) {
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ?
+ ts.Diagnostics.Type_0_has_no_call_signatures :
+ ts.Diagnostics.Type_0_has_no_construct_signatures, typeToString(constituent));
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ?
+ ts.Diagnostics.Not_all_constituents_of_type_0_are_callable :
+ ts.Diagnostics.Not_all_constituents_of_type_0_are_constructable, typeToString(apparentType));
+ }
+ if (hasSignatures) {
+ break;
+ }
}
}
- }
- }
- function checkTypeForDuplicateIndexSignatures(node) {
- if (node.kind === 246) {
- var nodeSymbol = getSymbolOfNode(node);
- if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) {
- return;
+ if (!hasSignatures) {
+ errorInfo = ts.chainDiagnosticMessages(undefined, isCall ?
+ ts.Diagnostics.No_constituent_of_type_0_is_callable :
+ ts.Diagnostics.No_constituent_of_type_0_is_constructable, typeToString(apparentType));
+ }
+ if (!errorInfo) {
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ?
+ ts.Diagnostics.Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other :
+ ts.Diagnostics.Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other, typeToString(apparentType));
}
}
- var indexSymbol = getIndexSymbol(getSymbolOfNode(node));
- if (indexSymbol) {
- var seenNumericIndexer = false;
- var seenStringIndexer = false;
- for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
- var decl = _a[_i];
- var declaration = decl;
- if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
- switch (declaration.parameters[0].type.kind) {
- case 143:
- if (!seenStringIndexer) {
- seenStringIndexer = true;
- }
- else {
- error(declaration, ts.Diagnostics.Duplicate_string_index_signature);
- }
- break;
- case 140:
- if (!seenNumericIndexer) {
- seenNumericIndexer = true;
- }
- else {
- error(declaration, ts.Diagnostics.Duplicate_number_index_signature);
- }
- break;
- }
- }
+ else {
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ?
+ ts.Diagnostics.Type_0_has_no_call_signatures :
+ ts.Diagnostics.Type_0_has_no_construct_signatures, typeToString(apparentType));
+ }
+ var headMessage = isCall ? ts.Diagnostics.This_expression_is_not_callable : ts.Diagnostics.This_expression_is_not_constructable;
+ if (ts.isCallExpression(errorTarget.parent) && errorTarget.parent.arguments.length === 0) {
+ var resolvedSymbol = getNodeLinks(errorTarget).resolvedSymbol;
+ if (resolvedSymbol && resolvedSymbol.flags & 32768) {
+ headMessage = ts.Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without;
}
}
+ return {
+ messageChain: ts.chainDiagnosticMessages(errorInfo, headMessage),
+ relatedMessage: maybeMissingAwait ? ts.Diagnostics.Did_you_forget_to_use_await : undefined,
+ };
}
- function checkPropertyDeclaration(node) {
- if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarProperty(node))
- checkGrammarComputedPropertyName(node.name);
- checkVariableLikeDeclaration(node);
- if (ts.isPrivateIdentifier(node.name) && languageVersion < 99) {
- for (var lexicalScope = ts.getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = ts.getEnclosingBlockScopeContainer(lexicalScope)) {
- getNodeLinks(lexicalScope).flags |= 67108864;
- }
+ function invocationError(errorTarget, apparentType, kind, relatedInformation) {
+ var _a = invocationErrorDetails(errorTarget, apparentType, kind), messageChain = _a.messageChain, relatedInfo = _a.relatedMessage;
+ var diagnostic = ts.createDiagnosticForNodeFromMessageChain(errorTarget, messageChain);
+ if (relatedInfo) {
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(errorTarget, relatedInfo));
}
+ if (ts.isCallExpression(errorTarget.parent)) {
+ var _b = getDiagnosticSpanForCallNode(errorTarget.parent, true), start = _b.start, length_7 = _b.length;
+ diagnostic.start = start;
+ diagnostic.length = length_7;
+ }
+ diagnostics.add(diagnostic);
+ invocationErrorRecovery(apparentType, kind, relatedInformation ? ts.addRelatedInfo(diagnostic, relatedInformation) : diagnostic);
}
- function checkPropertySignature(node) {
- if (ts.isPrivateIdentifier(node.name)) {
- error(node, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+ function invocationErrorRecovery(apparentType, kind, diagnostic) {
+ if (!apparentType.symbol) {
+ return;
+ }
+ var importNode = getSymbolLinks(apparentType.symbol).originatingImport;
+ if (importNode && !ts.isImportCall(importNode)) {
+ var sigs = getSignaturesOfType(getTypeOfSymbol(getSymbolLinks(apparentType.symbol).target), kind);
+ if (!sigs || !sigs.length)
+ return;
+ ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(importNode, ts.Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead));
}
- return checkPropertyDeclaration(node);
}
- function checkMethodDeclaration(node) {
- if (!checkGrammarMethod(node))
- checkGrammarComputedPropertyName(node.name);
- if (ts.isPrivateIdentifier(node.name)) {
- error(node, ts.Diagnostics.A_method_cannot_be_named_with_a_private_identifier);
+ function resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode) {
+ var tagType = checkExpression(node.tag);
+ var apparentType = getApparentType(tagType);
+ if (apparentType === errorType) {
+ return resolveErrorCall(node);
}
- checkFunctionOrMethodDeclaration(node);
- if (ts.hasModifier(node, 128) && node.kind === 161 && node.body) {
- error(node, ts.Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
+ var callSignatures = getSignaturesOfType(apparentType, 0);
+ var numConstructSignatures = getSignaturesOfType(apparentType, 1).length;
+ if (isUntypedFunctionCall(tagType, apparentType, callSignatures.length, numConstructSignatures)) {
+ return resolveUntypedCall(node);
+ }
+ if (!callSignatures.length) {
+ if (ts.isArrayLiteralExpression(node.parent)) {
+ var diagnostic = ts.createDiagnosticForNode(node.tag, ts.Diagnostics.It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tagged_template_expression_which_cannot_be_invoked);
+ diagnostics.add(diagnostic);
+ return resolveErrorCall(node);
+ }
+ invocationError(node.tag, apparentType, 0);
+ return resolveErrorCall(node);
}
+ return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0);
}
- function checkConstructorDeclaration(node) {
- checkSignatureDeclaration(node);
- if (!checkGrammarConstructorTypeParameters(node))
- checkGrammarConstructorTypeAnnotation(node);
- checkSourceElement(node.body);
- var symbol = getSymbolOfNode(node);
- var firstDeclaration = ts.getDeclarationOfKind(symbol, node.kind);
- if (node === firstDeclaration) {
- checkFunctionOrConstructorSymbol(symbol);
+ function getDiagnosticHeadMessageForDecoratorResolution(node) {
+ switch (node.parent.kind) {
+ case 252:
+ case 221:
+ return ts.Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression;
+ case 160:
+ return ts.Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression;
+ case 163:
+ return ts.Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression;
+ case 165:
+ case 167:
+ case 168:
+ return ts.Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression;
+ default:
+ return ts.Debug.fail();
}
- if (ts.nodeIsMissing(node.body)) {
- return;
+ }
+ function resolveDecorator(node, candidatesOutArray, checkMode) {
+ var funcType = checkExpression(node.expression);
+ var apparentType = getApparentType(funcType);
+ if (apparentType === errorType) {
+ return resolveErrorCall(node);
}
- if (!produceDiagnostics) {
- return;
+ var callSignatures = getSignaturesOfType(apparentType, 0);
+ var numConstructSignatures = getSignaturesOfType(apparentType, 1).length;
+ if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
+ return resolveUntypedCall(node);
}
- function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) {
- if (ts.isPrivateIdentifierPropertyDeclaration(n)) {
- return true;
- }
- return n.kind === 159 &&
- !ts.hasModifier(n, 32) &&
- !!n.initializer;
+ if (isPotentiallyUncalledDecorator(node, callSignatures)) {
+ var nodeStr = ts.getTextOfNode(node.expression, false);
+ error(node, ts.Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0, nodeStr);
+ return resolveErrorCall(node);
}
- var containingClassDecl = node.parent;
- if (ts.getClassExtendsHeritageElement(containingClassDecl)) {
- captureLexicalThis(node.parent, containingClassDecl);
- var classExtendsNull = classDeclarationExtendsNull(containingClassDecl);
- var superCall = getSuperCallInConstructor(node);
- if (superCall) {
- if (classExtendsNull) {
- error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
- }
- var superCallShouldBeFirst = (compilerOptions.target !== 99 || !compilerOptions.useDefineForClassFields) &&
- (ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) ||
- ts.some(node.parameters, function (p) { return ts.hasModifier(p, 92); }));
- if (superCallShouldBeFirst) {
- var statements = node.body.statements;
- var superCallStatement = void 0;
- for (var _i = 0, statements_3 = statements; _i < statements_3.length; _i++) {
- var statement = statements_3[_i];
- if (statement.kind === 226 && ts.isSuperCall(statement.expression)) {
- superCallStatement = statement;
- break;
- }
- if (!ts.isPrologueDirective(statement)) {
- break;
- }
- }
- if (!superCallStatement) {
- error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_parameter_properties_or_private_identifiers);
- }
- }
- }
- else if (!classExtendsNull) {
- error(node, ts.Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call);
+ var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
+ if (!callSignatures.length) {
+ var errorDetails = invocationErrorDetails(node.expression, apparentType, 0);
+ var messageChain = ts.chainDiagnosticMessages(errorDetails.messageChain, headMessage);
+ var diag = ts.createDiagnosticForNodeFromMessageChain(node.expression, messageChain);
+ if (errorDetails.relatedMessage) {
+ ts.addRelatedInfo(diag, ts.createDiagnosticForNode(node.expression, errorDetails.relatedMessage));
}
+ diagnostics.add(diag);
+ invocationErrorRecovery(apparentType, 0, diag);
+ return resolveErrorCall(node);
}
+ return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0, headMessage);
}
- function checkAccessorDeclaration(node) {
- if (produceDiagnostics) {
- if (!checkGrammarFunctionLikeDeclaration(node) && !checkGrammarAccessor(node))
- checkGrammarComputedPropertyName(node.name);
- checkDecorators(node);
- checkSignatureDeclaration(node);
- if (node.kind === 163) {
- if (!(node.flags & 8388608) && ts.nodeIsPresent(node.body) && (node.flags & 256)) {
- if (!(node.flags & 512)) {
- error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value);
- }
- }
- }
- if (node.name.kind === 154) {
- checkComputedPropertyName(node.name);
- }
- if (ts.isPrivateIdentifier(node.name)) {
- error(node.name, ts.Diagnostics.An_accessor_cannot_be_named_with_a_private_identifier);
- }
- if (!hasNonBindableDynamicName(node)) {
- var otherKind = node.kind === 163 ? 164 : 163;
- var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(node), otherKind);
- if (otherAccessor) {
- var nodeFlags = ts.getModifierFlags(node);
- var otherFlags = ts.getModifierFlags(otherAccessor);
- if ((nodeFlags & 28) !== (otherFlags & 28)) {
- error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility);
- }
- if ((nodeFlags & 128) !== (otherFlags & 128)) {
- error(node.name, ts.Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
- }
- checkAccessorDeclarationTypesIdentical(node, otherAccessor, getAnnotatedAccessorType, ts.Diagnostics.get_and_set_accessor_must_have_the_same_type);
- checkAccessorDeclarationTypesIdentical(node, otherAccessor, getThisTypeOfDeclaration, ts.Diagnostics.get_and_set_accessor_must_have_the_same_this_type);
- }
- }
- var returnType = getTypeOfAccessors(getSymbolOfNode(node));
- if (node.kind === 163) {
- checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
+ function createSignatureForJSXIntrinsic(node, result) {
+ var namespace = getJsxNamespaceAt(node);
+ var exports = namespace && getExportsOfSymbol(namespace);
+ var typeSymbol = exports && getSymbol(exports, JsxNames.Element, 788968);
+ var returnNode = typeSymbol && nodeBuilder.symbolToEntityName(typeSymbol, 788968, node);
+ var declaration = ts.factory.createFunctionTypeNode(undefined, [ts.factory.createParameterDeclaration(undefined, undefined, undefined, "props", undefined, nodeBuilder.typeToTypeNode(result, node))], returnNode ? ts.factory.createTypeReferenceNode(returnNode, undefined) : ts.factory.createKeywordTypeNode(128));
+ var parameterSymbol = createSymbol(1, "props");
+ parameterSymbol.type = result;
+ return createSignature(declaration, undefined, undefined, [parameterSymbol], typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType, undefined, 1, 0);
+ }
+ function resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode) {
+ if (isJsxIntrinsicIdentifier(node.tagName)) {
+ var result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node);
+ var fakeSignature = createSignatureForJSXIntrinsic(node, result);
+ checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType(node.attributes, getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), undefined, 0), result, node.tagName, node.attributes);
+ if (ts.length(node.typeArguments)) {
+ ts.forEach(node.typeArguments, checkSourceElement);
+ diagnostics.add(ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), node.typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, 0, ts.length(node.typeArguments)));
}
+ return fakeSignature;
}
- checkSourceElement(node.body);
- }
- function checkAccessorDeclarationTypesIdentical(first, second, getAnnotatedType, message) {
- var firstType = getAnnotatedType(first);
- var secondType = getAnnotatedType(second);
- if (firstType && secondType && !isTypeIdenticalTo(firstType, secondType)) {
- error(first, message);
+ var exprTypes = checkExpression(node.tagName);
+ var apparentType = getApparentType(exprTypes);
+ if (apparentType === errorType) {
+ return resolveErrorCall(node);
+ }
+ var signatures = getUninstantiatedJsxSignaturesOfType(exprTypes, node);
+ if (isUntypedFunctionCall(exprTypes, apparentType, signatures.length, 0)) {
+ return resolveUntypedCall(node);
+ }
+ if (signatures.length === 0) {
+ error(node.tagName, ts.Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, ts.getTextOfNode(node.tagName));
+ return resolveErrorCall(node);
}
+ return resolveCall(node, signatures, candidatesOutArray, checkMode, 0);
}
- function checkMissingDeclaration(node) {
- checkDecorators(node);
+ function isPotentiallyUncalledDecorator(decorator, signatures) {
+ return signatures.length && ts.every(signatures, function (signature) {
+ return signature.minArgumentCount === 0 &&
+ !signatureHasRestParameter(signature) &&
+ signature.parameters.length < getDecoratorArgumentCount(decorator, signature);
+ });
}
- function getEffectiveTypeArguments(node, typeParameters) {
- return fillMissingTypeArguments(ts.map(node.typeArguments, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(node));
+ function resolveSignature(node, candidatesOutArray, checkMode) {
+ switch (node.kind) {
+ case 203:
+ return resolveCallExpression(node, candidatesOutArray, checkMode);
+ case 204:
+ return resolveNewExpression(node, candidatesOutArray, checkMode);
+ case 205:
+ return resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode);
+ case 161:
+ return resolveDecorator(node, candidatesOutArray, checkMode);
+ case 275:
+ case 274:
+ return resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode);
+ }
+ throw ts.Debug.assertNever(node, "Branch in 'resolveSignature' should be unreachable.");
}
- function checkTypeArgumentConstraints(node, typeParameters) {
- var typeArguments;
- var mapper;
- var result = true;
- for (var i = 0; i < typeParameters.length; i++) {
- var constraint = getConstraintOfTypeParameter(typeParameters[i]);
- if (constraint) {
- if (!typeArguments) {
- typeArguments = getEffectiveTypeArguments(node, typeParameters);
- mapper = createTypeMapper(typeParameters, typeArguments);
- }
- result = result && checkTypeAssignableTo(typeArguments[i], instantiateType(constraint, mapper), node.typeArguments[i], ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
- }
+ function getResolvedSignature(node, candidatesOutArray, checkMode) {
+ var links = getNodeLinks(node);
+ var cached = links.resolvedSignature;
+ if (cached && cached !== resolvingSignature && !candidatesOutArray) {
+ return cached;
+ }
+ links.resolvedSignature = resolvingSignature;
+ var result = resolveSignature(node, candidatesOutArray, checkMode || 0);
+ if (result !== resolvingSignature) {
+ links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;
}
return result;
}
- function getTypeParametersForTypeReference(node) {
- var type = getTypeFromTypeReference(node);
- if (type !== errorType) {
- var symbol = getNodeLinks(node).resolvedSymbol;
- if (symbol) {
- return symbol.flags & 524288 && getSymbolLinks(symbol).typeParameters ||
- (ts.getObjectFlags(type) & 4 ? type.target.localTypeParameters : undefined);
- }
+ function isJSConstructor(node) {
+ var _a;
+ if (!node || !ts.isInJSFile(node)) {
+ return false;
}
- return undefined;
- }
- function checkTypeReferenceNode(node) {
- checkGrammarTypeArguments(node, node.typeArguments);
- if (node.kind === 169 && node.typeName.jsdocDotPos !== undefined && !ts.isInJSFile(node) && !ts.isInJSDoc(node)) {
- grammarErrorAtPos(node, node.typeName.jsdocDotPos, 1, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
+ var func = ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) ? node :
+ ts.isVariableDeclaration(node) && node.initializer && ts.isFunctionExpression(node.initializer) ? node.initializer :
+ undefined;
+ if (func) {
+ if (ts.getJSDocClassTag(node))
+ return true;
+ var symbol = getSymbolOfNode(func);
+ return !!((_a = symbol === null || symbol === void 0 ? void 0 : symbol.members) === null || _a === void 0 ? void 0 : _a.size);
}
- ts.forEach(node.typeArguments, checkSourceElement);
- var type = getTypeFromTypeReference(node);
- if (type !== errorType) {
- if (node.typeArguments && produceDiagnostics) {
- var typeParameters = getTypeParametersForTypeReference(node);
- if (typeParameters) {
- checkTypeArgumentConstraints(node, typeParameters);
+ return false;
+ }
+ function mergeJSSymbols(target, source) {
+ var _a, _b;
+ if (source) {
+ var links = getSymbolLinks(source);
+ if (!links.inferredClassSymbol || !links.inferredClassSymbol.has(getSymbolId(target))) {
+ var inferred = ts.isTransientSymbol(target) ? target : cloneSymbol(target);
+ inferred.exports = inferred.exports || ts.createSymbolTable();
+ inferred.members = inferred.members || ts.createSymbolTable();
+ inferred.flags |= source.flags & 32;
+ if ((_a = source.exports) === null || _a === void 0 ? void 0 : _a.size) {
+ mergeSymbolTable(inferred.exports, source.exports);
}
+ if ((_b = source.members) === null || _b === void 0 ? void 0 : _b.size) {
+ mergeSymbolTable(inferred.members, source.members);
+ }
+ (links.inferredClassSymbol || (links.inferredClassSymbol = new ts.Map())).set(getSymbolId(inferred), inferred);
+ return inferred;
}
- if (type.flags & 32 && getNodeLinks(node).resolvedSymbol.flags & 8) {
- error(node, ts.Diagnostics.Enum_type_0_has_members_with_initializers_that_are_not_literals, typeToString(type));
- }
+ return links.inferredClassSymbol.get(getSymbolId(target));
}
}
- function getTypeArgumentConstraint(node) {
- var typeReferenceNode = ts.tryCast(node.parent, ts.isTypeReferenceType);
- if (!typeReferenceNode)
- return undefined;
- var typeParameters = getTypeParametersForTypeReference(typeReferenceNode);
- var constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments.indexOf(node)]);
- return constraint && instantiateType(constraint, createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReferenceNode, typeParameters)));
- }
- function checkTypeQuery(node) {
- getTypeFromTypeQueryNode(node);
+ function getAssignedClassSymbol(decl) {
+ var _a;
+ var assignmentSymbol = decl && getSymbolOfExpando(decl, true);
+ var prototype = (_a = assignmentSymbol === null || assignmentSymbol === void 0 ? void 0 : assignmentSymbol.exports) === null || _a === void 0 ? void 0 : _a.get("prototype");
+ var init = (prototype === null || prototype === void 0 ? void 0 : prototype.valueDeclaration) && getAssignedJSPrototype(prototype.valueDeclaration);
+ return init ? getSymbolOfNode(init) : undefined;
}
- function checkTypeLiteral(node) {
- ts.forEach(node.members, checkSourceElement);
- if (produceDiagnostics) {
- var type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
- checkIndexConstraints(type);
- checkTypeForDuplicateIndexSignatures(node);
- checkObjectTypeForDuplicateDeclarations(node);
+ function getSymbolOfExpando(node, allowDeclaration) {
+ if (!node.parent) {
+ return undefined;
}
- }
- function checkArrayType(node) {
- checkSourceElement(node.elementType);
- }
- function checkTupleType(node) {
- var elementTypes = node.elementTypes;
- var seenOptionalElement = false;
- for (var i = 0; i < elementTypes.length; i++) {
- var e = elementTypes[i];
- if (e.kind === 177) {
- if (i !== elementTypes.length - 1) {
- grammarErrorOnNode(e, ts.Diagnostics.A_rest_element_must_be_last_in_a_tuple_type);
- break;
- }
- if (!isArrayType(getTypeFromTypeNode(e.type))) {
- error(e, ts.Diagnostics.A_rest_element_type_must_be_an_array_type);
- }
+ var name;
+ var decl;
+ if (ts.isVariableDeclaration(node.parent) && node.parent.initializer === node) {
+ if (!ts.isInJSFile(node) && !(ts.isVarConst(node.parent) && ts.isFunctionLikeDeclaration(node))) {
+ return undefined;
}
- else if (e.kind === 176) {
- seenOptionalElement = true;
+ name = node.parent.name;
+ decl = node.parent;
+ }
+ else if (ts.isBinaryExpression(node.parent)) {
+ var parentNode = node.parent;
+ var parentNodeOperator = node.parent.operatorToken.kind;
+ if (parentNodeOperator === 62 && (allowDeclaration || parentNode.right === node)) {
+ name = parentNode.left;
+ decl = name;
}
- else if (seenOptionalElement) {
- grammarErrorOnNode(e, ts.Diagnostics.A_required_element_cannot_follow_an_optional_element);
- break;
+ else if (parentNodeOperator === 56 || parentNodeOperator === 60) {
+ if (ts.isVariableDeclaration(parentNode.parent) && parentNode.parent.initializer === parentNode) {
+ name = parentNode.parent.name;
+ decl = parentNode.parent;
+ }
+ else if (ts.isBinaryExpression(parentNode.parent) && parentNode.parent.operatorToken.kind === 62 && (allowDeclaration || parentNode.parent.right === parentNode)) {
+ name = parentNode.parent.left;
+ decl = name;
+ }
+ if (!name || !ts.isBindableStaticNameExpression(name) || !ts.isSameEntityName(name, parentNode.left)) {
+ return undefined;
+ }
}
}
- ts.forEach(node.elementTypes, checkSourceElement);
+ else if (allowDeclaration && ts.isFunctionDeclaration(node)) {
+ name = node.name;
+ decl = node;
+ }
+ if (!decl || !name || (!allowDeclaration && !ts.getExpandoInitializer(node, ts.isPrototypeAccess(name)))) {
+ return undefined;
+ }
+ return getSymbolOfNode(decl);
}
- function checkUnionOrIntersectionType(node) {
- ts.forEach(node.types, checkSourceElement);
+ function getAssignedJSPrototype(node) {
+ if (!node.parent) {
+ return false;
+ }
+ var parent = node.parent;
+ while (parent && parent.kind === 201) {
+ parent = parent.parent;
+ }
+ if (parent && ts.isBinaryExpression(parent) && ts.isPrototypeAccess(parent.left) && parent.operatorToken.kind === 62) {
+ var right = ts.getInitializerOfBinaryExpression(parent);
+ return ts.isObjectLiteralExpression(right) && right;
+ }
}
- function checkIndexedAccessIndexType(type, accessNode) {
- if (!(type.flags & 8388608)) {
- return type;
+ function checkCallExpression(node, checkMode) {
+ var _a;
+ if (!checkGrammarTypeArguments(node, node.typeArguments))
+ checkGrammarArguments(node.arguments);
+ var signature = getResolvedSignature(node, undefined, checkMode);
+ if (signature === resolvingSignature) {
+ return nonInferrableType;
}
- var objectType = type.objectType;
- var indexType = type.indexType;
- if (isTypeAssignableTo(indexType, getIndexType(objectType, false))) {
- if (accessNode.kind === 195 && ts.isAssignmentTarget(accessNode) &&
- ts.getObjectFlags(objectType) & 32 && getMappedTypeModifiers(objectType) & 1) {
- error(accessNode, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
+ checkDeprecatedSignature(signature, node);
+ if (node.expression.kind === 105) {
+ return voidType;
+ }
+ if (node.kind === 204) {
+ var declaration = signature.declaration;
+ if (declaration &&
+ declaration.kind !== 166 &&
+ declaration.kind !== 170 &&
+ declaration.kind !== 175 &&
+ !ts.isJSDocConstructSignature(declaration) &&
+ !isJSConstructor(declaration)) {
+ if (noImplicitAny) {
+ error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type);
+ }
+ return anyType;
}
- return type;
}
- var apparentObjectType = getApparentType(objectType);
- if (getIndexInfoOfType(apparentObjectType, 1) && isTypeAssignableToKind(indexType, 296)) {
- return type;
+ if (ts.isInJSFile(node) && isCommonJsRequire(node)) {
+ return resolveExternalModuleTypeByLiteral(node.arguments[0]);
}
- if (isGenericObjectType(objectType)) {
- var propertyName_1 = getPropertyNameFromIndex(indexType, accessNode);
- if (propertyName_1) {
- var propertySymbol = forEachType(apparentObjectType, function (t) { return getPropertyOfType(t, propertyName_1); });
- if (propertySymbol && ts.getDeclarationModifierFlagsFromSymbol(propertySymbol) & 24) {
- error(accessNode, ts.Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, ts.unescapeLeadingUnderscores(propertyName_1));
- return errorType;
- }
+ var returnType = getReturnTypeOfSignature(signature);
+ if (returnType.flags & 12288 && isSymbolOrSymbolForCall(node)) {
+ return getESSymbolLikeTypeForNode(ts.walkUpParenthesizedExpressions(node.parent));
+ }
+ if (node.kind === 203 && node.parent.kind === 233 &&
+ returnType.flags & 16384 && getTypePredicateOfSignature(signature)) {
+ if (!ts.isDottedName(node.expression)) {
+ error(node.expression, ts.Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name);
+ }
+ else if (!getEffectsSignature(node)) {
+ var diagnostic = error(node.expression, ts.Diagnostics.Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation);
+ getTypeOfDottedName(node.expression, diagnostic);
}
}
- error(accessNode, ts.Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(objectType));
- return errorType;
- }
- function checkIndexedAccessType(node) {
- checkSourceElement(node.objectType);
- checkSourceElement(node.indexType);
- checkIndexedAccessIndexType(getTypeFromIndexedAccessTypeNode(node), node);
- }
- function checkMappedType(node) {
- checkSourceElement(node.typeParameter);
- checkSourceElement(node.type);
- if (!node.type) {
- reportImplicitAny(node, anyType);
+ if (ts.isInJSFile(node)) {
+ var jsSymbol = getSymbolOfExpando(node, false);
+ if ((_a = jsSymbol === null || jsSymbol === void 0 ? void 0 : jsSymbol.exports) === null || _a === void 0 ? void 0 : _a.size) {
+ var jsAssignmentType = createAnonymousType(jsSymbol, jsSymbol.exports, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ jsAssignmentType.objectFlags |= 16384;
+ return getIntersectionType([returnType, jsAssignmentType]);
+ }
}
- var type = getTypeFromMappedTypeNode(node);
- var constraintType = getConstraintTypeFromMappedType(type);
- checkTypeAssignableTo(constraintType, keyofConstraintType, ts.getEffectiveConstraintOfTypeParameter(node.typeParameter));
- }
- function checkThisType(node) {
- getTypeFromThisTypeNode(node);
- }
- function checkTypeOperator(node) {
- checkGrammarTypeOperatorNode(node);
- checkSourceElement(node.type);
- }
- function checkConditionalType(node) {
- ts.forEachChild(node, checkSourceElement);
+ return returnType;
}
- function checkInferType(node) {
- if (!ts.findAncestor(node, function (n) { return n.parent && n.parent.kind === 180 && n.parent.extendsType === n; })) {
- grammarErrorOnNode(node, ts.Diagnostics.infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type);
+ function checkDeprecatedSignature(signature, node) {
+ if (signature.declaration && signature.declaration.flags & 134217728) {
+ var suggestionNode = getDeprecatedSuggestionNode(node);
+ errorOrSuggestion(false, suggestionNode, ts.Diagnostics._0_is_deprecated, signatureToString(signature));
}
- checkSourceElement(node.typeParameter);
- registerForUnusedIdentifiersCheck(node);
- }
- function checkImportType(node) {
- checkSourceElement(node.argument);
- getTypeFromTypeNode(node);
}
- function isPrivateWithinAmbient(node) {
- return (ts.hasModifier(node, 8) || ts.isPrivateIdentifierPropertyDeclaration(node)) && !!(node.flags & 8388608);
+ function getDeprecatedSuggestionNode(node) {
+ node = ts.skipParentheses(node);
+ switch (node.kind) {
+ case 203:
+ case 161:
+ case 204:
+ return getDeprecatedSuggestionNode(node.expression);
+ case 205:
+ return getDeprecatedSuggestionNode(node.tag);
+ case 275:
+ case 274:
+ return getDeprecatedSuggestionNode(node.tagName);
+ case 202:
+ return node.argumentExpression;
+ case 201:
+ return node.name;
+ case 173:
+ var typeReference = node;
+ return ts.isQualifiedName(typeReference.typeName) ? typeReference.typeName.right : typeReference;
+ default:
+ return node;
+ }
}
- function getEffectiveDeclarationFlags(n, flagsToCheck) {
- var flags = ts.getCombinedModifierFlags(n);
- if (n.parent.kind !== 246 &&
- n.parent.kind !== 245 &&
- n.parent.kind !== 214 &&
- n.flags & 8388608) {
- if (!(flags & 2) && !(ts.isModuleBlock(n.parent) && ts.isModuleDeclaration(n.parent.parent) && ts.isGlobalScopeAugmentation(n.parent.parent))) {
- flags |= 1;
- }
- flags |= 2;
+ function isSymbolOrSymbolForCall(node) {
+ if (!ts.isCallExpression(node))
+ return false;
+ var left = node.expression;
+ if (ts.isPropertyAccessExpression(left) && left.name.escapedText === "for") {
+ left = left.expression;
}
- return flags & flagsToCheck;
+ if (!ts.isIdentifier(left) || left.escapedText !== "Symbol") {
+ return false;
+ }
+ var globalESSymbol = getGlobalESSymbolConstructorSymbol(false);
+ if (!globalESSymbol) {
+ return false;
+ }
+ return globalESSymbol === resolveName(left, "Symbol", 111551, undefined, undefined, false);
}
- function checkFunctionOrConstructorSymbol(symbol) {
- if (!produceDiagnostics) {
- return;
+ function checkImportCallExpression(node) {
+ if (!checkGrammarArguments(node.arguments))
+ checkGrammarImportCallExpression(node);
+ if (node.arguments.length === 0) {
+ return createPromiseReturnType(node, anyType);
}
- function getCanonicalOverload(overloads, implementation) {
- var implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent;
- return implementationSharesContainerWithFirstOverload ? implementation : overloads[0];
+ var specifier = node.arguments[0];
+ var specifierType = checkExpressionCached(specifier);
+ for (var i = 1; i < node.arguments.length; ++i) {
+ checkExpressionCached(node.arguments[i]);
}
- function checkFlagAgreementBetweenOverloads(overloads, implementation, flagsToCheck, someOverloadFlags, allOverloadFlags) {
- var someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags;
- if (someButNotAllOverloadFlags !== 0) {
- var canonicalFlags_1 = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck);
- ts.forEach(overloads, function (o) {
- var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags_1;
- if (deviation & 1) {
- error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported);
- }
- else if (deviation & 2) {
- error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
- }
- else if (deviation & (8 | 16)) {
- error(ts.getNameOfDeclaration(o) || o, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
- }
- else if (deviation & 128) {
- error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract);
- }
- });
- }
+ if (specifierType.flags & 32768 || specifierType.flags & 65536 || !isTypeAssignableTo(specifierType, stringType)) {
+ error(specifier, ts.Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0, typeToString(specifierType));
}
- function checkQuestionTokenAgreementBetweenOverloads(overloads, implementation, someHaveQuestionToken, allHaveQuestionToken) {
- if (someHaveQuestionToken !== allHaveQuestionToken) {
- var canonicalHasQuestionToken_1 = ts.hasQuestionToken(getCanonicalOverload(overloads, implementation));
- ts.forEach(overloads, function (o) {
- var deviation = ts.hasQuestionToken(o) !== canonicalHasQuestionToken_1;
- if (deviation) {
- error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_optional_or_required);
- }
- });
+ var moduleSymbol = resolveExternalModuleName(node, specifier);
+ if (moduleSymbol) {
+ var esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, true, false);
+ if (esModuleSymbol) {
+ return createPromiseReturnType(node, getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol));
}
}
- var flagsToCheck = 1 | 2 | 8 | 16 | 128;
- var someNodeFlags = 0;
- var allNodeFlags = flagsToCheck;
- var someHaveQuestionToken = false;
- var allHaveQuestionToken = true;
- var hasOverloads = false;
- var bodyDeclaration;
- var lastSeenNonAmbientDeclaration;
- var previousDeclaration;
- var declarations = symbol.declarations;
- var isConstructor = (symbol.flags & 16384) !== 0;
- function reportImplementationExpectedError(node) {
- if (node.name && ts.nodeIsMissing(node.name)) {
- return;
- }
- var seen = false;
- var subsequentNode = ts.forEachChild(node.parent, function (c) {
- if (seen) {
- return c;
- }
- else {
- seen = c === node;
- }
- });
- if (subsequentNode && subsequentNode.pos === node.end) {
- if (subsequentNode.kind === node.kind) {
- var errorNode_1 = subsequentNode.name || subsequentNode;
- var subsequentName = subsequentNode.name;
- if (node.name && subsequentName && (ts.isPrivateIdentifier(node.name) && ts.isPrivateIdentifier(subsequentName) && node.name.escapedText === subsequentName.escapedText ||
- ts.isComputedPropertyName(node.name) && ts.isComputedPropertyName(subsequentName) ||
- ts.isPropertyNameLiteral(node.name) && ts.isPropertyNameLiteral(subsequentName) &&
- ts.getEscapedTextOfIdentifierOrLiteral(node.name) === ts.getEscapedTextOfIdentifierOrLiteral(subsequentName))) {
- var reportError = (node.kind === 161 || node.kind === 160) &&
- ts.hasModifier(node, 32) !== ts.hasModifier(subsequentNode, 32);
- if (reportError) {
- var diagnostic = ts.hasModifier(node, 32) ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
- error(errorNode_1, diagnostic);
- }
- return;
- }
- if (ts.nodeIsPresent(subsequentNode.body)) {
- error(errorNode_1, ts.Diagnostics.Function_implementation_name_must_be_0, ts.declarationNameToString(node.name));
- return;
- }
- }
- }
- var errorNode = node.name || node;
- if (isConstructor) {
- error(errorNode, ts.Diagnostics.Constructor_implementation_is_missing);
- }
- else {
- if (ts.hasModifier(node, 128)) {
- error(errorNode, ts.Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
+ return createPromiseReturnType(node, anyType);
+ }
+ function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol) {
+ if (allowSyntheticDefaultImports && type && type !== errorType) {
+ var synthType = type;
+ if (!synthType.syntheticType) {
+ var file = ts.find(originalSymbol.declarations, ts.isSourceFile);
+ var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, false);
+ if (hasSyntheticDefault) {
+ var memberTable = ts.createSymbolTable();
+ var newSymbol = createSymbol(2097152, "default");
+ newSymbol.parent = originalSymbol;
+ newSymbol.nameType = getLiteralType("default");
+ newSymbol.target = resolveSymbol(symbol);
+ memberTable.set("default", newSymbol);
+ var anonymousSymbol = createSymbol(2048, "__type");
+ var defaultContainingObject = createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ anonymousSymbol.type = defaultContainingObject;
+ synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, 0, false) : defaultContainingObject;
}
else {
- error(errorNode, ts.Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration);
+ synthType.syntheticType = type;
}
}
+ return synthType.syntheticType;
}
- var duplicateFunctionDeclaration = false;
- var multipleConstructorImplementation = false;
- var hasNonAmbientClass = false;
- for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
- var current = declarations_4[_i];
- var node = current;
- var inAmbientContext = node.flags & 8388608;
- var inAmbientContextOrInterface = node.parent.kind === 246 || node.parent.kind === 173 || inAmbientContext;
- if (inAmbientContextOrInterface) {
- previousDeclaration = undefined;
- }
- if ((node.kind === 245 || node.kind === 214) && !inAmbientContext) {
- hasNonAmbientClass = true;
- }
- if (node.kind === 244 || node.kind === 161 || node.kind === 160 || node.kind === 162) {
- var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck);
- someNodeFlags |= currentNodeFlags;
- allNodeFlags &= currentNodeFlags;
- someHaveQuestionToken = someHaveQuestionToken || ts.hasQuestionToken(node);
- allHaveQuestionToken = allHaveQuestionToken && ts.hasQuestionToken(node);
- if (ts.nodeIsPresent(node.body) && bodyDeclaration) {
- if (isConstructor) {
- multipleConstructorImplementation = true;
- }
- else {
- duplicateFunctionDeclaration = true;
- }
- }
- else if (previousDeclaration && previousDeclaration.parent === node.parent && previousDeclaration.end !== node.pos) {
- reportImplementationExpectedError(previousDeclaration);
- }
- if (ts.nodeIsPresent(node.body)) {
- if (!bodyDeclaration) {
- bodyDeclaration = node;
+ return type;
+ }
+ function isCommonJsRequire(node) {
+ if (!ts.isRequireCall(node, true)) {
+ return false;
+ }
+ if (!ts.isIdentifier(node.expression))
+ return ts.Debug.fail();
+ var resolvedRequire = resolveName(node.expression, node.expression.escapedText, 111551, undefined, undefined, true);
+ if (resolvedRequire === requireSymbol) {
+ return true;
+ }
+ if (resolvedRequire.flags & 2097152) {
+ return false;
+ }
+ var targetDeclarationKind = resolvedRequire.flags & 16
+ ? 251
+ : resolvedRequire.flags & 3
+ ? 249
+ : 0;
+ if (targetDeclarationKind !== 0) {
+ var decl = ts.getDeclarationOfKind(resolvedRequire, targetDeclarationKind);
+ return !!decl && !!(decl.flags & 8388608);
+ }
+ return false;
+ }
+ function checkTaggedTemplateExpression(node) {
+ if (!checkGrammarTaggedTemplateChain(node))
+ checkGrammarTypeArguments(node, node.typeArguments);
+ if (languageVersion < 2) {
+ checkExternalEmitHelpers(node, 524288);
+ }
+ var signature = getResolvedSignature(node);
+ checkDeprecatedSignature(signature, node);
+ return getReturnTypeOfSignature(signature);
+ }
+ function checkAssertion(node) {
+ return checkAssertionWorker(node, node.type, node.expression);
+ }
+ function isValidConstAssertionArgument(node) {
+ switch (node.kind) {
+ case 10:
+ case 14:
+ case 8:
+ case 9:
+ case 109:
+ case 94:
+ case 199:
+ case 200:
+ case 218:
+ return true;
+ case 207:
+ return isValidConstAssertionArgument(node.expression);
+ case 214:
+ var op = node.operator;
+ var arg = node.operand;
+ return op === 40 && (arg.kind === 8 || arg.kind === 9) ||
+ op === 39 && arg.kind === 8;
+ case 201:
+ case 202:
+ var expr = node.expression;
+ if (ts.isIdentifier(expr)) {
+ var symbol = getSymbolAtLocation(expr);
+ if (symbol && symbol.flags & 2097152) {
+ symbol = resolveAlias(symbol);
}
+ return !!(symbol && (symbol.flags & 384) && getEnumKind(symbol) === 1);
}
- else {
- hasOverloads = true;
- }
- previousDeclaration = node;
- if (!inAmbientContextOrInterface) {
- lastSeenNonAmbientDeclaration = node;
- }
+ }
+ return false;
+ }
+ function checkAssertionWorker(errNode, type, expression, checkMode) {
+ var exprType = checkExpression(expression, checkMode);
+ if (ts.isConstTypeReference(type)) {
+ if (!isValidConstAssertionArgument(expression)) {
+ error(expression, ts.Diagnostics.A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals);
}
+ return getRegularTypeOfLiteralType(exprType);
}
- if (multipleConstructorImplementation) {
- ts.forEach(declarations, function (declaration) {
- error(declaration, ts.Diagnostics.Multiple_constructor_implementations_are_not_allowed);
- });
+ checkSourceElement(type);
+ exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(exprType));
+ var targetType = getTypeFromTypeNode(type);
+ if (produceDiagnostics && targetType !== errorType) {
+ var widenedType = getWidenedType(exprType);
+ if (!isTypeComparableTo(targetType, widenedType)) {
+ checkTypeComparableTo(exprType, targetType, errNode, ts.Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first);
+ }
}
- if (duplicateFunctionDeclaration) {
- ts.forEach(declarations, function (declaration) {
- error(ts.getNameOfDeclaration(declaration), ts.Diagnostics.Duplicate_function_implementation);
- });
+ return targetType;
+ }
+ function checkNonNullChain(node) {
+ var leftType = checkExpression(node.expression);
+ var nonOptionalType = getOptionalExpressionType(leftType, node.expression);
+ return propagateOptionalTypeMarker(getNonNullableType(nonOptionalType), node, nonOptionalType !== leftType);
+ }
+ function checkNonNullAssertion(node) {
+ return node.flags & 32 ? checkNonNullChain(node) :
+ getNonNullableType(checkExpression(node.expression));
+ }
+ function checkMetaProperty(node) {
+ checkGrammarMetaProperty(node);
+ if (node.keywordToken === 102) {
+ return checkNewTargetMetaProperty(node);
}
- if (hasNonAmbientClass && !isConstructor && symbol.flags & 16) {
- ts.forEach(declarations, function (declaration) {
- addDuplicateDeclarationError(declaration, ts.Diagnostics.Duplicate_identifier_0, ts.symbolName(symbol), declarations);
- });
+ if (node.keywordToken === 99) {
+ return checkImportMetaProperty(node);
}
- if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
- !ts.hasModifier(lastSeenNonAmbientDeclaration, 128) && !lastSeenNonAmbientDeclaration.questionToken) {
- reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
+ return ts.Debug.assertNever(node.keywordToken);
+ }
+ function checkNewTargetMetaProperty(node) {
+ var container = ts.getNewTargetContainer(node);
+ if (!container) {
+ error(node, ts.Diagnostics.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, "new.target");
+ return errorType;
}
- if (hasOverloads) {
- checkFlagAgreementBetweenOverloads(declarations, bodyDeclaration, flagsToCheck, someNodeFlags, allNodeFlags);
- checkQuestionTokenAgreementBetweenOverloads(declarations, bodyDeclaration, someHaveQuestionToken, allHaveQuestionToken);
- if (bodyDeclaration) {
- var signatures = getSignaturesOfSymbol(symbol);
- var bodySignature = getSignatureFromDeclaration(bodyDeclaration);
- for (var _a = 0, signatures_10 = signatures; _a < signatures_10.length; _a++) {
- var signature = signatures_10[_a];
- if (!isImplementationCompatibleWithOverload(bodySignature, signature)) {
- ts.addRelatedInfo(error(signature.declaration, ts.Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature), ts.createDiagnosticForNode(bodyDeclaration, ts.Diagnostics.The_implementation_signature_is_declared_here));
- break;
- }
- }
+ else if (container.kind === 166) {
+ var symbol = getSymbolOfNode(container.parent);
+ return getTypeOfSymbol(symbol);
+ }
+ else {
+ var symbol = getSymbolOfNode(container);
+ return getTypeOfSymbol(symbol);
+ }
+ }
+ function checkImportMetaProperty(node) {
+ if (moduleKind !== ts.ModuleKind.ES2020 && moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System) {
+ error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_or_system);
+ }
+ var file = ts.getSourceFileOfNode(node);
+ ts.Debug.assert(!!(file.flags & 2097152), "Containing file is missing import meta node flag.");
+ ts.Debug.assert(!!file.externalModuleIndicator, "Containing file should be a module.");
+ return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType;
+ }
+ function getTypeOfParameter(symbol) {
+ var type = getTypeOfSymbol(symbol);
+ if (strictNullChecks) {
+ var declaration = symbol.valueDeclaration;
+ if (declaration && ts.hasInitializer(declaration)) {
+ return getOptionalType(type);
}
}
+ return type;
}
- function checkExportsOnMergedDeclarations(node) {
- if (!produceDiagnostics) {
- return;
+ function getTupleElementLabel(d) {
+ ts.Debug.assert(ts.isIdentifier(d.name));
+ return d.name.escapedText;
+ }
+ function getParameterNameAtPosition(signature, pos, overrideRestType) {
+ var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
+ if (pos < paramCount) {
+ return signature.parameters[pos].escapedName;
}
- var symbol = node.localSymbol;
- if (!symbol) {
- symbol = getSymbolOfNode(node);
- if (!symbol.exportSymbol) {
- return;
+ var restParameter = signature.parameters[paramCount] || unknownSymbol;
+ var restType = overrideRestType || getTypeOfSymbol(restParameter);
+ if (isTupleType(restType)) {
+ var associatedNames = restType.target.labeledElementDeclarations;
+ var index = pos - paramCount;
+ return associatedNames && getTupleElementLabel(associatedNames[index]) || restParameter.escapedName + "_" + index;
+ }
+ return restParameter.escapedName;
+ }
+ function isValidDeclarationForTupleLabel(d) {
+ return d.kind === 192 || (ts.isParameter(d) && d.name && ts.isIdentifier(d.name));
+ }
+ function getNameableDeclarationAtPosition(signature, pos) {
+ var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
+ if (pos < paramCount) {
+ var decl = signature.parameters[pos].valueDeclaration;
+ return decl && isValidDeclarationForTupleLabel(decl) ? decl : undefined;
+ }
+ var restParameter = signature.parameters[paramCount] || unknownSymbol;
+ var restType = getTypeOfSymbol(restParameter);
+ if (isTupleType(restType)) {
+ var associatedNames = restType.target.labeledElementDeclarations;
+ var index = pos - paramCount;
+ return associatedNames && associatedNames[index];
+ }
+ return restParameter.valueDeclaration && isValidDeclarationForTupleLabel(restParameter.valueDeclaration) ? restParameter.valueDeclaration : undefined;
+ }
+ function getTypeAtPosition(signature, pos) {
+ return tryGetTypeAtPosition(signature, pos) || anyType;
+ }
+ function tryGetTypeAtPosition(signature, pos) {
+ var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
+ if (pos < paramCount) {
+ return getTypeOfParameter(signature.parameters[pos]);
+ }
+ if (signatureHasRestParameter(signature)) {
+ var restType = getTypeOfSymbol(signature.parameters[paramCount]);
+ var index = pos - paramCount;
+ if (!isTupleType(restType) || restType.target.hasRestElement || index < restType.target.fixedLength) {
+ return getIndexedAccessType(restType, getLiteralType(index));
}
}
- if (ts.getDeclarationOfKind(symbol, node.kind) !== node) {
- return;
+ return undefined;
+ }
+ function getRestTypeAtPosition(source, pos) {
+ var parameterCount = getParameterCount(source);
+ var minArgumentCount = getMinArgumentCount(source);
+ var restType = getEffectiveRestType(source);
+ if (restType && pos >= parameterCount - 1) {
+ return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType));
}
- var exportedDeclarationSpaces = 0;
- var nonExportedDeclarationSpaces = 0;
- var defaultExportedDeclarationSpaces = 0;
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var d = _a[_i];
- var declarationSpaces = getDeclarationSpaces(d);
- var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 | 512);
- if (effectiveDeclarationFlags & 1) {
- if (effectiveDeclarationFlags & 512) {
- defaultExportedDeclarationSpaces |= declarationSpaces;
- }
- else {
- exportedDeclarationSpaces |= declarationSpaces;
- }
+ var types = [];
+ var flags = [];
+ var names = [];
+ for (var i = pos; i < parameterCount; i++) {
+ if (!restType || i < parameterCount - 1) {
+ types.push(getTypeAtPosition(source, i));
+ flags.push(i < minArgumentCount ? 1 : 2);
}
else {
- nonExportedDeclarationSpaces |= declarationSpaces;
+ types.push(restType);
+ flags.push(8);
+ }
+ var name = getNameableDeclarationAtPosition(source, i);
+ if (name) {
+ names.push(name);
}
}
- var nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces;
- var commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces;
- var commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces;
- if (commonDeclarationSpacesForExportsAndLocals || commonDeclarationSpacesForDefaultAndNonDefault) {
- for (var _b = 0, _c = symbol.declarations; _b < _c.length; _b++) {
- var d = _c[_b];
- var declarationSpaces = getDeclarationSpaces(d);
- var name = ts.getNameOfDeclaration(d);
- if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) {
- error(name, ts.Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, ts.declarationNameToString(name));
- }
- else if (declarationSpaces & commonDeclarationSpacesForExportsAndLocals) {
- error(name, ts.Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, ts.declarationNameToString(name));
- }
+ return createTupleType(types, flags, false, ts.length(names) === ts.length(types) ? names : undefined);
+ }
+ function getParameterCount(signature) {
+ var length = signature.parameters.length;
+ if (signatureHasRestParameter(signature)) {
+ var restType = getTypeOfSymbol(signature.parameters[length - 1]);
+ if (isTupleType(restType)) {
+ return length + restType.target.fixedLength - (restType.target.hasRestElement ? 0 : 1);
}
}
- function getDeclarationSpaces(decl) {
- var d = decl;
- switch (d.kind) {
- case 246:
- case 247:
- case 322:
- case 315:
- case 316:
- return 2;
- case 249:
- return ts.isAmbientModule(d) || ts.getModuleInstanceState(d) !== 0
- ? 4 | 1
- : 4;
- case 245:
- case 248:
- case 284:
- return 2 | 1;
- case 290:
- return 2 | 1 | 4;
- case 259:
- if (!ts.isEntityNameExpression(d.expression)) {
- return 1;
+ return length;
+ }
+ function getMinArgumentCount(signature, flags) {
+ var strongArityForUntypedJS = flags & 1;
+ var voidIsNonOptional = flags & 2;
+ if (voidIsNonOptional || signature.resolvedMinArgumentCount === undefined) {
+ var minArgumentCount = void 0;
+ if (signatureHasRestParameter(signature)) {
+ var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
+ if (isTupleType(restType)) {
+ var firstOptionalIndex = ts.findIndex(restType.target.elementFlags, function (f) { return !(f & 1); });
+ var requiredCount = firstOptionalIndex < 0 ? restType.target.fixedLength : firstOptionalIndex;
+ if (requiredCount > 0) {
+ minArgumentCount = signature.parameters.length - 1 + requiredCount;
}
- d = d.expression;
- case 253:
- case 256:
- case 255:
- var result_10 = 0;
- var target = resolveAlias(getSymbolOfNode(d));
- ts.forEach(target.declarations, function (d) { result_10 |= getDeclarationSpaces(d); });
- return result_10;
- case 242:
- case 191:
- case 244:
- case 258:
- case 75:
- return 1;
- default:
- return ts.Debug.failBadSyntaxKind(d);
+ }
}
+ if (minArgumentCount === undefined) {
+ if (!strongArityForUntypedJS && signature.flags & 16) {
+ return 0;
+ }
+ minArgumentCount = signature.minArgumentCount;
+ }
+ if (voidIsNonOptional) {
+ return minArgumentCount;
+ }
+ for (var i = minArgumentCount - 1; i >= 0; i--) {
+ var type = getTypeAtPosition(signature, i);
+ if (filterType(type, acceptsVoid).flags & 131072) {
+ break;
+ }
+ minArgumentCount = i;
+ }
+ signature.resolvedMinArgumentCount = minArgumentCount;
}
+ return signature.resolvedMinArgumentCount;
}
- function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, arg0) {
- var promisedType = getPromisedTypeOfPromise(type, errorNode);
- return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
- }
- function getPromisedTypeOfPromise(type, errorNode) {
- if (isTypeAny(type)) {
- return undefined;
- }
- var typeAsPromise = type;
- if (typeAsPromise.promisedTypeOfPromise) {
- return typeAsPromise.promisedTypeOfPromise;
- }
- if (isReferenceToType(type, getGlobalPromiseType(false))) {
- return typeAsPromise.promisedTypeOfPromise = getTypeArguments(type)[0];
- }
- var thenFunction = getTypeOfPropertyOfType(type, "then");
- if (isTypeAny(thenFunction)) {
- return undefined;
+ function hasEffectiveRestParameter(signature) {
+ if (signatureHasRestParameter(signature)) {
+ var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
+ return !isTupleType(restType) || restType.target.hasRestElement;
}
- var thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, 0) : ts.emptyArray;
- if (thenSignatures.length === 0) {
- if (errorNode) {
- error(errorNode, ts.Diagnostics.A_promise_must_have_a_then_method);
+ return false;
+ }
+ function getEffectiveRestType(signature) {
+ if (signatureHasRestParameter(signature)) {
+ var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
+ if (!isTupleType(restType)) {
+ return restType;
}
- return undefined;
- }
- var onfulfilledParameterType = getTypeWithFacts(getUnionType(ts.map(thenSignatures, getTypeOfFirstParameterOfSignature)), 2097152);
- if (isTypeAny(onfulfilledParameterType)) {
- return undefined;
- }
- var onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, 0);
- if (onfulfilledParameterSignatures.length === 0) {
- if (errorNode) {
- error(errorNode, ts.Diagnostics.The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback);
+ if (restType.target.hasRestElement) {
+ return sliceTupleType(restType, restType.target.fixedLength);
}
- return undefined;
}
- return typeAsPromise.promisedTypeOfPromise = getUnionType(ts.map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), 2);
+ return undefined;
}
- function checkAwaitedType(type, errorNode, diagnosticMessage, arg0) {
- var awaitedType = getAwaitedType(type, errorNode, diagnosticMessage, arg0);
- return awaitedType || errorType;
+ function getNonArrayRestType(signature) {
+ var restType = getEffectiveRestType(signature);
+ return restType && !isArrayType(restType) && !isTypeAny(restType) && (getReducedType(restType).flags & 131072) === 0 ? restType : undefined;
}
- function isThenableType(type) {
- var thenFunction = getTypeOfPropertyOfType(type, "then");
- return !!thenFunction && getSignaturesOfType(getTypeWithFacts(thenFunction, 2097152), 0).length > 0;
+ function getTypeOfFirstParameterOfSignature(signature) {
+ return getTypeOfFirstParameterOfSignatureWithFallback(signature, neverType);
}
- function getAwaitedType(type, errorNode, diagnosticMessage, arg0) {
- if (isTypeAny(type)) {
- return type;
+ function getTypeOfFirstParameterOfSignatureWithFallback(signature, fallbackType) {
+ return signature.parameters.length > 0 ? getTypeAtPosition(signature, 0) : fallbackType;
+ }
+ function inferFromAnnotatedParameters(signature, context, inferenceContext) {
+ var len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
+ for (var i = 0; i < len; i++) {
+ var declaration = signature.parameters[i].valueDeclaration;
+ if (declaration.type) {
+ var typeNode = ts.getEffectiveTypeAnnotationNode(declaration);
+ if (typeNode) {
+ inferTypes(inferenceContext.inferences, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
+ }
+ }
}
- var typeAsAwaitable = type;
- if (typeAsAwaitable.awaitedTypeOfType) {
- return typeAsAwaitable.awaitedTypeOfType;
+ var restType = getEffectiveRestType(context);
+ if (restType && restType.flags & 262144) {
+ var instantiatedContext = instantiateSignature(context, inferenceContext.nonFixingMapper);
+ assignContextualParameterTypes(signature, instantiatedContext);
+ var restPos = getParameterCount(context) - 1;
+ inferTypes(inferenceContext.inferences, getRestTypeAtPosition(signature, restPos), restType);
}
- return typeAsAwaitable.awaitedTypeOfType =
- mapType(type, errorNode ? function (constituentType) { return getAwaitedTypeWorker(constituentType, errorNode, diagnosticMessage, arg0); } : getAwaitedTypeWorker);
}
- function getAwaitedTypeWorker(type, errorNode, diagnosticMessage, arg0) {
- var typeAsAwaitable = type;
- if (typeAsAwaitable.awaitedTypeOfType) {
- return typeAsAwaitable.awaitedTypeOfType;
- }
- var promisedType = getPromisedTypeOfPromise(type);
- if (promisedType) {
- if (type.id === promisedType.id || awaitedTypeStack.lastIndexOf(promisedType.id) >= 0) {
- if (errorNode) {
- error(errorNode, ts.Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method);
+ function assignContextualParameterTypes(signature, context) {
+ signature.typeParameters = context.typeParameters;
+ if (context.thisParameter) {
+ var parameter = signature.thisParameter;
+ if (!parameter || parameter.valueDeclaration && !parameter.valueDeclaration.type) {
+ if (!parameter) {
+ signature.thisParameter = createSymbolWithType(context.thisParameter, undefined);
}
- return undefined;
+ assignParameterType(signature.thisParameter, getTypeOfSymbol(context.thisParameter));
}
- awaitedTypeStack.push(type.id);
- var awaitedType = getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
- awaitedTypeStack.pop();
- if (!awaitedType) {
- return undefined;
+ }
+ var len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
+ for (var i = 0; i < len; i++) {
+ var parameter = signature.parameters[i];
+ if (!ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) {
+ var contextualParameterType = tryGetTypeAtPosition(context, i);
+ assignParameterType(parameter, contextualParameterType);
}
- return typeAsAwaitable.awaitedTypeOfType = awaitedType;
}
- if (isThenableType(type)) {
- if (errorNode) {
- if (!diagnosticMessage)
- return ts.Debug.fail();
- error(errorNode, diagnosticMessage, arg0);
+ if (signatureHasRestParameter(signature)) {
+ var parameter = ts.last(signature.parameters);
+ if (ts.isTransientSymbol(parameter) || !ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) {
+ var contextualParameterType = getRestTypeAtPosition(context, len);
+ assignParameterType(parameter, contextualParameterType);
}
- return undefined;
}
- return typeAsAwaitable.awaitedTypeOfType = type;
}
- function checkAsyncFunctionReturnType(node, returnTypeNode) {
- var returnType = getTypeFromTypeNode(returnTypeNode);
- if (languageVersion >= 2) {
- if (returnType === errorType) {
- return;
- }
- var globalPromiseType = getGlobalPromiseType(true);
- if (globalPromiseType !== emptyGenericType && !isReferenceToType(returnType, globalPromiseType)) {
- error(returnTypeNode, ts.Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type);
- return;
- }
+ function assignNonContextualParameterTypes(signature) {
+ if (signature.thisParameter) {
+ assignParameterType(signature.thisParameter);
}
- else {
- markTypeNodeAsReferenced(returnTypeNode);
- if (returnType === errorType) {
- return;
- }
- var promiseConstructorName = ts.getEntityNameFromTypeNode(returnTypeNode);
- if (promiseConstructorName === undefined) {
- error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, typeToString(returnType));
- return;
+ for (var _i = 0, _a = signature.parameters; _i < _a.length; _i++) {
+ var parameter = _a[_i];
+ assignParameterType(parameter);
+ }
+ }
+ function assignParameterType(parameter, type) {
+ var links = getSymbolLinks(parameter);
+ if (!links.type) {
+ var declaration = parameter.valueDeclaration;
+ links.type = type || getWidenedTypeForVariableLikeDeclaration(declaration, true);
+ if (declaration.name.kind !== 78) {
+ if (links.type === unknownType) {
+ links.type = getTypeFromBindingPattern(declaration.name);
+ }
+ assignBindingElementTypes(declaration.name);
}
- var promiseConstructorSymbol = resolveEntityName(promiseConstructorName, 111551, true);
- var promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : errorType;
- if (promiseConstructorType === errorType) {
- if (promiseConstructorName.kind === 75 && promiseConstructorName.escapedText === "Promise" && getTargetType(returnType) === getGlobalPromiseType(false)) {
- error(returnTypeNode, ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
+ }
+ }
+ function assignBindingElementTypes(pattern) {
+ for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
+ var element = _a[_i];
+ if (!ts.isOmittedExpression(element)) {
+ if (element.name.kind === 78) {
+ getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element);
}
else {
- error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, ts.entityNameToString(promiseConstructorName));
+ assignBindingElementTypes(element.name);
}
- return;
- }
- var globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(true);
- if (globalPromiseConstructorLikeType === emptyObjectType) {
- error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, ts.entityNameToString(promiseConstructorName));
- return;
- }
- if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value)) {
- return;
- }
- var rootName = promiseConstructorName && ts.getFirstIdentifier(promiseConstructorName);
- var collidingSymbol = getSymbol(node.locals, rootName.escapedText, 111551);
- if (collidingSymbol) {
- error(collidingSymbol.valueDeclaration, ts.Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, ts.idText(rootName), ts.entityNameToString(promiseConstructorName));
- return;
}
}
- checkAwaitedType(returnType, node, ts.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) {
- var signature = getResolvedSignature(node);
- var returnType = getReturnTypeOfSignature(signature);
- if (returnType.flags & 1) {
- return;
- }
- var expectedReturnType;
- var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
- var errorInfo;
- switch (node.parent.kind) {
- case 245:
- var classSymbol = getSymbolOfNode(node.parent);
- var classConstructorType = getTypeOfSymbol(classSymbol);
- expectedReturnType = getUnionType([classConstructorType, voidType]);
- break;
- case 156:
- expectedReturnType = voidType;
- errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any);
- break;
- case 159:
- expectedReturnType = voidType;
- errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any);
- break;
- case 161:
- case 163:
- case 164:
- var methodType = getTypeOfNode(node.parent);
- var descriptorType = createTypedPropertyDescriptorType(methodType);
- expectedReturnType = getUnionType([descriptorType, voidType]);
- break;
- default:
- return ts.Debug.fail();
+ function createPromiseType(promisedType) {
+ var globalPromiseType = getGlobalPromiseType(true);
+ if (globalPromiseType !== emptyGenericType) {
+ promisedType = getAwaitedType(promisedType) || unknownType;
+ return createTypeReference(globalPromiseType, [promisedType]);
}
- checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, function () { return errorInfo; });
- }
- function markTypeNodeAsReferenced(node) {
- markEntityNameOrEntityExpressionAsReference(node && ts.getEntityNameFromTypeNode(node));
+ return unknownType;
}
- function markEntityNameOrEntityExpressionAsReference(typeName) {
- if (!typeName)
- return;
- var rootName = ts.getFirstIdentifier(typeName);
- var meaning = (typeName.kind === 75 ? 788968 : 1920) | 2097152;
- var rootSymbol = resolveName(rootName, rootName.escapedText, meaning, undefined, undefined, true);
- if (rootSymbol
- && rootSymbol.flags & 2097152
- && symbolIsValue(rootSymbol)
- && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol))
- && !getTypeOnlyAliasDeclaration(rootSymbol)) {
- markAliasSymbolAsReferenced(rootSymbol);
+ function createPromiseLikeType(promisedType) {
+ var globalPromiseLikeType = getGlobalPromiseLikeType(true);
+ if (globalPromiseLikeType !== emptyGenericType) {
+ promisedType = getAwaitedType(promisedType) || unknownType;
+ return createTypeReference(globalPromiseLikeType, [promisedType]);
}
+ return unknownType;
}
- function markDecoratorMedataDataTypeNodeAsReferenced(node) {
- var entityName = getEntityNameForDecoratorMetadata(node);
- if (entityName && ts.isEntityName(entityName)) {
- markEntityNameOrEntityExpressionAsReference(entityName);
+ function createPromiseReturnType(func, promisedType) {
+ var promiseType = createPromiseType(promisedType);
+ if (promiseType === unknownType) {
+ error(func, ts.isImportCall(func) ?
+ ts.Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option :
+ ts.Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option);
+ return errorType;
+ }
+ else if (!getGlobalPromiseConstructorSymbol(true)) {
+ error(func, ts.isImportCall(func) ?
+ ts.Diagnostics.A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option :
+ ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
}
+ return promiseType;
}
- function getEntityNameForDecoratorMetadata(node) {
- if (node) {
- switch (node.kind) {
- case 179:
- case 178:
- return getEntityNameForDecoratorMetadataFromTypeList(node.types);
- case 180:
- return getEntityNameForDecoratorMetadataFromTypeList([node.trueType, node.falseType]);
- case 182:
- return getEntityNameForDecoratorMetadata(node.type);
- case 169:
- return node.typeName;
+ function getReturnTypeFromBody(func, checkMode) {
+ if (!func.body) {
+ return errorType;
+ }
+ var functionFlags = ts.getFunctionFlags(func);
+ var isAsync = (functionFlags & 2) !== 0;
+ var isGenerator = (functionFlags & 1) !== 0;
+ var returnType;
+ var yieldType;
+ var nextType;
+ var fallbackReturnType = voidType;
+ if (func.body.kind !== 230) {
+ returnType = checkExpressionCached(func.body, checkMode && checkMode & ~8);
+ if (isAsync) {
+ returnType = checkAwaitedType(returnType, func, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
}
}
- }
- function getEntityNameForDecoratorMetadataFromTypeList(types) {
- var commonEntityName;
- for (var _i = 0, types_20 = types; _i < types_20.length; _i++) {
- var typeNode = types_20[_i];
- while (typeNode.kind === 182) {
- typeNode = typeNode.type;
+ else if (isGenerator) {
+ var returnTypes = checkAndAggregateReturnExpressionTypes(func, checkMode);
+ if (!returnTypes) {
+ fallbackReturnType = neverType;
}
- if (typeNode.kind === 137) {
- continue;
+ else if (returnTypes.length > 0) {
+ returnType = getUnionType(returnTypes, 2);
}
- if (!strictNullChecks && (typeNode.kind === 100 || typeNode.kind === 146)) {
- continue;
+ var _a = checkAndAggregateYieldOperandTypes(func, checkMode), yieldTypes = _a.yieldTypes, nextTypes = _a.nextTypes;
+ yieldType = ts.some(yieldTypes) ? getUnionType(yieldTypes, 2) : undefined;
+ nextType = ts.some(nextTypes) ? getIntersectionType(nextTypes) : undefined;
+ }
+ else {
+ var types = checkAndAggregateReturnExpressionTypes(func, checkMode);
+ if (!types) {
+ return functionFlags & 2
+ ? createPromiseReturnType(func, neverType)
+ : neverType;
}
- var individualEntityName = getEntityNameForDecoratorMetadata(typeNode);
- if (!individualEntityName) {
- return undefined;
+ if (types.length === 0) {
+ return functionFlags & 2
+ ? createPromiseReturnType(func, voidType)
+ : voidType;
}
- if (commonEntityName) {
- if (!ts.isIdentifier(commonEntityName) ||
- !ts.isIdentifier(individualEntityName) ||
- commonEntityName.escapedText !== individualEntityName.escapedText) {
- return undefined;
+ returnType = getUnionType(types, 2);
+ }
+ if (returnType || yieldType || nextType) {
+ if (yieldType)
+ reportErrorsFromWidening(func, yieldType, 3);
+ if (returnType)
+ reportErrorsFromWidening(func, returnType, 1);
+ if (nextType)
+ reportErrorsFromWidening(func, nextType, 2);
+ if (returnType && isUnitType(returnType) ||
+ yieldType && isUnitType(yieldType) ||
+ nextType && isUnitType(nextType)) {
+ var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
+ var contextualType = !contextualSignature ? undefined :
+ contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? undefined : returnType :
+ instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func);
+ if (isGenerator) {
+ yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, 0, isAsync);
+ returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, 1, isAsync);
+ nextType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(nextType, contextualType, 2, isAsync);
+ }
+ else {
+ returnType = getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(returnType, contextualType, isAsync);
}
}
- else {
- commonEntityName = individualEntityName;
- }
+ if (yieldType)
+ yieldType = getWidenedType(yieldType);
+ if (returnType)
+ returnType = getWidenedType(returnType);
+ if (nextType)
+ nextType = getWidenedType(nextType);
}
- return commonEntityName;
- }
- function getParameterTypeNodeForDecoratorCheck(node) {
- var typeNode = ts.getEffectiveTypeAnnotationNode(node);
- return ts.isRestParameter(node) ? ts.getRestParameterElementType(typeNode) : typeNode;
- }
- function checkDecorators(node) {
- if (!node.decorators) {
- return;
+ if (isGenerator) {
+ return createGeneratorReturnType(yieldType || neverType, returnType || fallbackReturnType, nextType || getContextualIterationType(2, func) || unknownType, isAsync);
}
- if (!ts.nodeCanBeDecorated(node, node.parent, node.parent.parent)) {
- return;
+ else {
+ return isAsync
+ ? createPromiseType(returnType || fallbackReturnType)
+ : returnType || fallbackReturnType;
}
- if (!compilerOptions.experimentalDecorators) {
- error(node, ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning);
+ }
+ function createGeneratorReturnType(yieldType, returnType, nextType, isAsyncGenerator) {
+ var resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
+ var globalGeneratorType = resolver.getGlobalGeneratorType(false);
+ yieldType = resolver.resolveIterationType(yieldType, undefined) || unknownType;
+ returnType = resolver.resolveIterationType(returnType, undefined) || unknownType;
+ nextType = resolver.resolveIterationType(nextType, undefined) || unknownType;
+ if (globalGeneratorType === emptyGenericType) {
+ var globalType = resolver.getGlobalIterableIteratorType(false);
+ var iterationTypes = globalType !== emptyGenericType ? getIterationTypesOfGlobalIterableType(globalType, resolver) : undefined;
+ var iterableIteratorReturnType = iterationTypes ? iterationTypes.returnType : anyType;
+ var iterableIteratorNextType = iterationTypes ? iterationTypes.nextType : undefinedType;
+ if (isTypeAssignableTo(returnType, iterableIteratorReturnType) &&
+ isTypeAssignableTo(iterableIteratorNextType, nextType)) {
+ if (globalType !== emptyGenericType) {
+ return createTypeFromGenericGlobalType(globalType, [yieldType]);
+ }
+ resolver.getGlobalIterableIteratorType(true);
+ return emptyObjectType;
+ }
+ resolver.getGlobalGeneratorType(true);
+ return emptyObjectType;
}
- var firstDecorator = node.decorators[0];
- checkExternalEmitHelpers(firstDecorator, 8);
- if (node.kind === 156) {
- checkExternalEmitHelpers(firstDecorator, 32);
+ return createTypeFromGenericGlobalType(globalGeneratorType, [yieldType, returnType, nextType]);
+ }
+ function checkAndAggregateYieldOperandTypes(func, checkMode) {
+ var yieldTypes = [];
+ var nextTypes = [];
+ var isAsync = (ts.getFunctionFlags(func) & 2) !== 0;
+ ts.forEachYieldExpression(func.body, function (yieldExpression) {
+ var yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType;
+ ts.pushIfUnique(yieldTypes, getYieldedTypeOfYieldExpression(yieldExpression, yieldExpressionType, anyType, isAsync));
+ var nextType;
+ if (yieldExpression.asteriskToken) {
+ var iterationTypes = getIterationTypesOfIterable(yieldExpressionType, isAsync ? 19 : 17, yieldExpression.expression);
+ nextType = iterationTypes && iterationTypes.nextType;
+ }
+ else {
+ nextType = getContextualType(yieldExpression);
+ }
+ if (nextType)
+ ts.pushIfUnique(nextTypes, nextType);
+ });
+ return { yieldTypes: yieldTypes, nextTypes: nextTypes };
+ }
+ function getYieldedTypeOfYieldExpression(node, expressionType, sentType, isAsync) {
+ var errorNode = node.expression || node;
+ var yieldedType = node.asteriskToken ? checkIteratedTypeOrElementType(isAsync ? 19 : 17, expressionType, sentType, errorNode) : expressionType;
+ return !isAsync ? yieldedType : getAwaitedType(yieldedType, errorNode, node.asteriskToken
+ ? ts.Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
+ : ts.Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+ }
+ function getFactsFromTypeofSwitch(start, end, witnesses, hasDefault) {
+ var facts = 0;
+ if (hasDefault) {
+ for (var i = end; i < witnesses.length; i++) {
+ facts |= typeofNEFacts.get(witnesses[i]) || 32768;
+ }
+ for (var i = start; i < end; i++) {
+ facts &= ~(typeofNEFacts.get(witnesses[i]) || 0);
+ }
+ for (var i = 0; i < start; i++) {
+ facts |= typeofNEFacts.get(witnesses[i]) || 32768;
+ }
}
- if (compilerOptions.emitDecoratorMetadata) {
- checkExternalEmitHelpers(firstDecorator, 16);
- switch (node.kind) {
- case 245:
- var constructor = ts.getFirstConstructorWithBody(node);
- if (constructor) {
- for (var _i = 0, _a = constructor.parameters; _i < _a.length; _i++) {
- var parameter = _a[_i];
- markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
- }
- }
- break;
- case 163:
- case 164:
- var otherKind = node.kind === 163 ? 164 : 163;
- var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(node), otherKind);
- markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
- break;
- case 161:
- for (var _b = 0, _c = node.parameters; _b < _c.length; _b++) {
- var parameter = _c[_b];
- markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
- }
- markDecoratorMedataDataTypeNodeAsReferenced(ts.getEffectiveReturnTypeNode(node));
- break;
- case 159:
- markDecoratorMedataDataTypeNodeAsReferenced(ts.getEffectiveTypeAnnotationNode(node));
- break;
- case 156:
- markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
- var containingSignature = node.parent;
- for (var _d = 0, _e = containingSignature.parameters; _d < _e.length; _d++) {
- var parameter = _e[_d];
- markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
- }
- break;
+ else {
+ for (var i = start; i < end; i++) {
+ facts |= typeofEQFacts.get(witnesses[i]) || 128;
+ }
+ for (var i = 0; i < start; i++) {
+ facts &= ~(typeofEQFacts.get(witnesses[i]) || 0);
}
}
- ts.forEach(node.decorators, checkDecorator);
+ return facts;
}
- function checkFunctionDeclaration(node) {
- if (produceDiagnostics) {
- checkFunctionOrMethodDeclaration(node);
- checkGrammarForGenerator(node);
- checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
- checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
- }
+ function isExhaustiveSwitchStatement(node) {
+ var links = getNodeLinks(node);
+ return links.isExhaustive !== undefined ? links.isExhaustive : (links.isExhaustive = computeExhaustiveSwitchStatement(node));
}
- function checkJSDocTypeAliasTag(node) {
- if (!node.typeExpression) {
- error(node.name, ts.Diagnostics.JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags);
+ function computeExhaustiveSwitchStatement(node) {
+ if (node.expression.kind === 211) {
+ var operandType = getTypeOfExpression(node.expression.expression);
+ var witnesses = getSwitchClauseTypeOfWitnesses(node, false);
+ var notEqualFacts_1 = getFactsFromTypeofSwitch(0, 0, witnesses, true);
+ var type_4 = getBaseConstraintOfType(operandType) || operandType;
+ if (type_4.flags & 3) {
+ return (556800 & notEqualFacts_1) === 556800;
+ }
+ return !!(filterType(type_4, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072);
}
- if (node.name) {
- checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0);
+ var type = getTypeOfExpression(node.expression);
+ if (!isLiteralType(type)) {
+ return false;
}
- checkSourceElement(node.typeExpression);
- }
- function checkJSDocTemplateTag(node) {
- checkSourceElement(node.constraint);
- for (var _i = 0, _a = node.typeParameters; _i < _a.length; _i++) {
- var tp = _a[_i];
- checkSourceElement(tp);
+ var switchTypes = getSwitchClauseTypes(node);
+ if (!switchTypes.length || ts.some(switchTypes, isNeitherUnitTypeNorNever)) {
+ return false;
}
+ return eachTypeContainedIn(mapType(type, getRegularTypeOfLiteralType), switchTypes);
}
- function checkJSDocTypeTag(node) {
- checkSourceElement(node.typeExpression);
+ function functionHasImplicitReturn(func) {
+ return func.endFlowNode && isReachableFlowNode(func.endFlowNode);
}
- function checkJSDocParameterTag(node) {
- checkSourceElement(node.typeExpression);
- if (!ts.getParameterSymbolFromJSDoc(node)) {
- var decl = ts.getHostSignatureFromJSDoc(node);
- if (decl) {
- var i = ts.getJSDocTags(decl).filter(ts.isJSDocParameterTag).indexOf(node);
- if (i > -1 && i < decl.parameters.length && ts.isBindingPattern(decl.parameters[i].name)) {
- return;
- }
- if (!containsArgumentsReference(decl)) {
- if (ts.isQualifiedName(node.name)) {
- error(node.name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(node.name), ts.entityNameToString(node.name.left));
- }
- else {
- error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(node.name));
- }
+ function checkAndAggregateReturnExpressionTypes(func, checkMode) {
+ var functionFlags = ts.getFunctionFlags(func);
+ var aggregatedTypes = [];
+ var hasReturnWithNoExpression = functionHasImplicitReturn(func);
+ var hasReturnOfTypeNever = false;
+ ts.forEachReturnStatement(func.body, function (returnStatement) {
+ var expr = returnStatement.expression;
+ if (expr) {
+ var type = checkExpressionCached(expr, checkMode && checkMode & ~8);
+ if (functionFlags & 2) {
+ type = checkAwaitedType(type, func, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
}
- else if (ts.findLast(ts.getJSDocTags(decl), ts.isJSDocParameterTag) === node &&
- node.typeExpression && node.typeExpression.type &&
- !isArrayType(getTypeFromTypeNode(node.typeExpression.type))) {
- error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(node.name.kind === 153 ? node.name.right : node.name));
+ if (type.flags & 131072) {
+ hasReturnOfTypeNever = true;
}
+ ts.pushIfUnique(aggregatedTypes, type);
+ }
+ else {
+ hasReturnWithNoExpression = true;
}
+ });
+ if (aggregatedTypes.length === 0 && !hasReturnWithNoExpression && (hasReturnOfTypeNever || mayReturnNever(func))) {
+ return undefined;
}
- }
- function checkJSDocPropertyTag(node) {
- checkSourceElement(node.typeExpression);
- }
- function checkJSDocFunctionType(node) {
- if (produceDiagnostics && !node.type && !ts.isJSDocConstructSignature(node)) {
- reportImplicitAny(node, anyType);
+ if (strictNullChecks && aggregatedTypes.length && hasReturnWithNoExpression &&
+ !(isJSConstructor(func) && aggregatedTypes.some(function (t) { return t.symbol === func.symbol; }))) {
+ ts.pushIfUnique(aggregatedTypes, undefinedType);
}
- checkSignatureDeclaration(node);
+ return aggregatedTypes;
}
- function checkJSDocImplementsTag(node) {
- var classLike = ts.getEffectiveJSDocHost(node);
- if (!classLike || !ts.isClassDeclaration(classLike) && !ts.isClassExpression(classLike)) {
- error(classLike, ts.Diagnostics.JSDoc_0_is_not_attached_to_a_class, ts.idText(node.tagName));
+ function mayReturnNever(func) {
+ switch (func.kind) {
+ case 208:
+ case 209:
+ return true;
+ case 165:
+ return func.parent.kind === 200;
+ default:
+ return false;
}
}
- function checkJSDocAugmentsTag(node) {
- var classLike = ts.getEffectiveJSDocHost(node);
- if (!classLike || !ts.isClassDeclaration(classLike) && !ts.isClassExpression(classLike)) {
- error(classLike, ts.Diagnostics.JSDoc_0_is_not_attached_to_a_class, ts.idText(node.tagName));
+ function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
+ if (!produceDiagnostics) {
return;
}
- var augmentsTags = ts.getJSDocTags(classLike).filter(ts.isJSDocAugmentsTag);
- ts.Debug.assert(augmentsTags.length > 0);
- if (augmentsTags.length > 1) {
- error(augmentsTags[1], ts.Diagnostics.Class_declarations_cannot_have_more_than_one_augments_or_extends_tag);
- }
- var name = getIdentifierFromEntityNameExpression(node.class.expression);
- var extend = ts.getClassExtendsHeritageElement(classLike);
- if (extend) {
- var className = getIdentifierFromEntityNameExpression(extend.expression);
- if (className && name.escapedText !== className.escapedText) {
- error(name, ts.Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause, ts.idText(node.tagName), ts.idText(name), ts.idText(className));
- }
+ var functionFlags = ts.getFunctionFlags(func);
+ var type = returnType && unwrapReturnType(returnType, functionFlags);
+ if (type && maybeTypeOfKind(type, 1 | 16384)) {
+ return;
}
- }
- function getIdentifierFromEntityNameExpression(node) {
- switch (node.kind) {
- case 75:
- return node;
- case 194:
- return node.name;
- default:
- return undefined;
+ if (func.kind === 164 || ts.nodeIsMissing(func.body) || func.body.kind !== 230 || !functionHasImplicitReturn(func)) {
+ return;
}
- }
- function checkFunctionOrMethodDeclaration(node) {
- checkDecorators(node);
- checkSignatureDeclaration(node);
- var functionFlags = ts.getFunctionFlags(node);
- if (node.name && node.name.kind === 154) {
- checkComputedPropertyName(node.name);
+ var hasExplicitReturn = func.flags & 512;
+ if (type && type.flags & 131072) {
+ error(ts.getEffectiveReturnTypeNode(func), ts.Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
}
- if (!hasNonBindableDynamicName(node)) {
- var symbol = getSymbolOfNode(node);
- var localSymbol = node.localSymbol || symbol;
- var firstDeclaration = ts.find(localSymbol.declarations, function (declaration) { return declaration.kind === node.kind && !(declaration.flags & 131072); });
- if (node === firstDeclaration) {
- checkFunctionOrConstructorSymbol(localSymbol);
- }
- if (symbol.parent) {
- if (ts.getDeclarationOfKind(symbol, node.kind) === node) {
- checkFunctionOrConstructorSymbol(symbol);
- }
- }
+ else if (type && !hasExplicitReturn) {
+ error(ts.getEffectiveReturnTypeNode(func), ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
}
- var body = node.kind === 160 ? undefined : node.body;
- checkSourceElement(body);
- checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, getReturnTypeFromAnnotation(node));
- if (produceDiagnostics && !ts.getEffectiveReturnTypeNode(node)) {
- if (ts.nodeIsMissing(body) && !isPrivateWithinAmbient(node)) {
- reportImplicitAny(node, anyType);
- }
- if (functionFlags & 1 && ts.nodeIsPresent(body)) {
- getReturnTypeOfSignature(getSignatureFromDeclaration(node));
- }
+ else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {
+ error(ts.getEffectiveReturnTypeNode(func) || func, ts.Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
}
- if (ts.isInJSFile(node)) {
- var typeTag = ts.getJSDocTypeTag(node);
- if (typeTag && typeTag.typeExpression && !getContextualCallSignature(getTypeFromTypeNode(typeTag.typeExpression), node)) {
- error(typeTag, ts.Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature);
+ else if (compilerOptions.noImplicitReturns) {
+ if (!type) {
+ if (!hasExplicitReturn) {
+ return;
+ }
+ var inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
+ if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) {
+ return;
+ }
}
+ error(ts.getEffectiveReturnTypeNode(func) || func, ts.Diagnostics.Not_all_code_paths_return_a_value);
}
}
- function registerForUnusedIdentifiersCheck(node) {
- if (produceDiagnostics) {
- var sourceFile = ts.getSourceFileOfNode(node);
- var potentiallyUnusedIdentifiers = allPotentiallyUnusedIdentifiers.get(sourceFile.path);
- if (!potentiallyUnusedIdentifiers) {
- potentiallyUnusedIdentifiers = [];
- allPotentiallyUnusedIdentifiers.set(sourceFile.path, potentiallyUnusedIdentifiers);
+ function checkFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
+ ts.Debug.assert(node.kind !== 165 || ts.isObjectLiteralMethod(node));
+ checkNodeDeferred(node);
+ if (checkMode && checkMode & 4 && isContextSensitive(node)) {
+ if (!ts.getEffectiveReturnTypeNode(node) && !hasContextSensitiveParameters(node)) {
+ var contextualSignature = getContextualSignature(node);
+ if (contextualSignature && couldContainTypeVariables(getReturnTypeOfSignature(contextualSignature))) {
+ var links = getNodeLinks(node);
+ if (links.contextFreeType) {
+ return links.contextFreeType;
+ }
+ var returnType = getReturnTypeFromBody(node, checkMode);
+ var returnOnlySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, returnType, undefined, 0, 0);
+ var returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], ts.emptyArray, undefined, undefined);
+ returnOnlyType.objectFlags |= 2097152;
+ return links.contextFreeType = returnOnlyType;
+ }
}
- potentiallyUnusedIdentifiers.push(node);
+ return anyFunctionType;
+ }
+ var hasGrammarError = checkGrammarFunctionLikeDeclaration(node);
+ if (!hasGrammarError && node.kind === 208) {
+ checkGrammarForGenerator(node);
}
+ contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode);
+ return getTypeOfSymbol(getSymbolOfNode(node));
}
- function checkUnusedIdentifiers(potentiallyUnusedIdentifiers, addDiagnostic) {
- for (var _i = 0, potentiallyUnusedIdentifiers_1 = potentiallyUnusedIdentifiers; _i < potentiallyUnusedIdentifiers_1.length; _i++) {
- var node = potentiallyUnusedIdentifiers_1[_i];
- switch (node.kind) {
- case 245:
- case 214:
- checkUnusedClassMembers(node, addDiagnostic);
- checkUnusedTypeParameters(node, addDiagnostic);
- break;
- case 290:
- case 249:
- case 223:
- case 251:
- case 230:
- case 231:
- case 232:
- checkUnusedLocalsAndParameters(node, addDiagnostic);
- break;
- case 162:
- case 201:
- case 244:
- case 202:
- case 161:
- case 163:
- case 164:
- if (node.body) {
- checkUnusedLocalsAndParameters(node, addDiagnostic);
+ function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
+ var links = getNodeLinks(node);
+ if (!(links.flags & 1024)) {
+ var contextualSignature = getContextualSignature(node);
+ if (!(links.flags & 1024)) {
+ links.flags |= 1024;
+ var signature = ts.firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfNode(node)), 0));
+ if (!signature) {
+ return;
+ }
+ if (isContextSensitive(node)) {
+ if (contextualSignature) {
+ var inferenceContext = getInferenceContext(node);
+ if (checkMode && checkMode & 2) {
+ inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext);
+ }
+ var instantiatedContextualSignature = inferenceContext ?
+ instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature;
+ assignContextualParameterTypes(signature, instantiatedContextualSignature);
}
- checkUnusedTypeParameters(node, addDiagnostic);
- break;
- case 160:
- case 165:
- case 166:
- case 170:
- case 171:
- case 247:
- case 246:
- checkUnusedTypeParameters(node, addDiagnostic);
- break;
- case 181:
- checkUnusedInferTypeParameter(node, addDiagnostic);
- break;
- default:
- ts.Debug.assertNever(node, "Node should not have been registered for unused identifiers check");
+ else {
+ assignNonContextualParameterTypes(signature);
+ }
+ }
+ if (contextualSignature && !getReturnTypeFromAnnotation(node) && !signature.resolvedReturnType) {
+ var returnType = getReturnTypeFromBody(node, checkMode);
+ if (!signature.resolvedReturnType) {
+ signature.resolvedReturnType = returnType;
+ }
+ }
+ checkSignatureDeclaration(node);
}
}
}
- function errorUnusedLocal(declaration, name, addDiagnostic) {
- var node = ts.getNameOfDeclaration(declaration) || declaration;
- var message = isTypeDeclaration(declaration) ? ts.Diagnostics._0_is_declared_but_never_used : ts.Diagnostics._0_is_declared_but_its_value_is_never_read;
- addDiagnostic(declaration, 0, ts.createDiagnosticForNode(node, message, name));
- }
- function isIdentifierThatStartsWithUnderscore(node) {
- return ts.isIdentifier(node) && ts.idText(node).charCodeAt(0) === 95;
- }
- function checkUnusedClassMembers(node, addDiagnostic) {
- for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
- var member = _a[_i];
- switch (member.kind) {
- case 161:
- case 159:
- case 163:
- case 164:
- if (member.kind === 164 && member.symbol.flags & 32768) {
- break;
- }
- var symbol = getSymbolOfNode(member);
- if (!symbol.isReferenced
- && (ts.hasModifier(member, 8) || ts.isNamedDeclaration(member) && ts.isPrivateIdentifier(member.name))
- && !(member.flags & 8388608)) {
- addDiagnostic(member, 0, ts.createDiagnosticForNode(member.name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol)));
+ function checkFunctionExpressionOrObjectLiteralMethodDeferred(node) {
+ ts.Debug.assert(node.kind !== 165 || ts.isObjectLiteralMethod(node));
+ var functionFlags = ts.getFunctionFlags(node);
+ var returnType = getReturnTypeFromAnnotation(node);
+ checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
+ if (node.body) {
+ if (!ts.getEffectiveReturnTypeNode(node)) {
+ getReturnTypeOfSignature(getSignatureFromDeclaration(node));
+ }
+ if (node.body.kind === 230) {
+ checkSourceElement(node.body);
+ }
+ else {
+ var exprType = checkExpression(node.body);
+ var returnOrPromisedType = returnType && unwrapReturnType(returnType, functionFlags);
+ if (returnOrPromisedType) {
+ if ((functionFlags & 3) === 2) {
+ var awaitedType = checkAwaitedType(exprType, node.body, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+ checkTypeAssignableToAndOptionallyElaborate(awaitedType, returnOrPromisedType, node.body, node.body);
}
- break;
- case 162:
- for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) {
- var parameter = _c[_b];
- if (!parameter.symbol.isReferenced && ts.hasModifier(parameter, 8)) {
- addDiagnostic(parameter, 0, ts.createDiagnosticForNode(parameter.name, ts.Diagnostics.Property_0_is_declared_but_its_value_is_never_read, ts.symbolName(parameter.symbol)));
- }
+ else {
+ checkTypeAssignableToAndOptionallyElaborate(exprType, returnOrPromisedType, node.body, node.body);
}
- break;
- case 167:
- case 222:
- break;
- default:
- ts.Debug.fail();
+ }
}
}
}
- function checkUnusedInferTypeParameter(node, addDiagnostic) {
- var typeParameter = node.typeParameter;
- if (isTypeParameterUnused(typeParameter)) {
- addDiagnostic(node, 1, ts.createDiagnosticForNode(node, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.idText(typeParameter.name)));
+ function checkArithmeticOperandType(operand, type, diagnostic, isAwaitValid) {
+ if (isAwaitValid === void 0) { isAwaitValid = false; }
+ if (!isTypeAssignableTo(type, numberOrBigIntType)) {
+ var awaitedType = isAwaitValid && getAwaitedTypeOfPromise(type);
+ errorAndMaybeSuggestAwait(operand, !!awaitedType && isTypeAssignableTo(awaitedType, numberOrBigIntType), diagnostic);
+ return false;
}
+ return true;
}
- function checkUnusedTypeParameters(node, addDiagnostic) {
- if (ts.last(getSymbolOfNode(node).declarations) !== node)
- return;
- var typeParameters = ts.getEffectiveTypeParameterDeclarations(node);
- var seenParentsWithEveryUnused = new ts.NodeSet();
- for (var _i = 0, typeParameters_3 = typeParameters; _i < typeParameters_3.length; _i++) {
- var typeParameter = typeParameters_3[_i];
- if (!isTypeParameterUnused(typeParameter))
- continue;
- var name = ts.idText(typeParameter.name);
- var parent = typeParameter.parent;
- if (parent.kind !== 181 && parent.typeParameters.every(isTypeParameterUnused)) {
- if (seenParentsWithEveryUnused.tryAdd(parent)) {
- var range = ts.isJSDocTemplateTag(parent)
- ? ts.rangeOfNode(parent)
- : ts.rangeOfTypeParameters(parent.typeParameters);
- var only = parent.typeParameters.length === 1;
- var message = only ? ts.Diagnostics._0_is_declared_but_its_value_is_never_read : ts.Diagnostics.All_type_parameters_are_unused;
- var arg0 = only ? name : undefined;
- addDiagnostic(typeParameter, 1, ts.createFileDiagnostic(ts.getSourceFileOfNode(parent), range.pos, range.end - range.pos, message, arg0));
- }
+ function isReadonlyAssignmentDeclaration(d) {
+ if (!ts.isCallExpression(d)) {
+ return false;
+ }
+ if (!ts.isBindableObjectDefinePropertyCall(d)) {
+ return false;
+ }
+ var objectLitType = checkExpressionCached(d.arguments[2]);
+ var valueType = getTypeOfPropertyOfType(objectLitType, "value");
+ if (valueType) {
+ var writableProp = getPropertyOfType(objectLitType, "writable");
+ var writableType = writableProp && getTypeOfSymbol(writableProp);
+ if (!writableType || writableType === falseType || writableType === regularFalseType) {
+ return true;
}
- else {
- addDiagnostic(typeParameter, 1, ts.createDiagnosticForNode(typeParameter, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, name));
+ if (writableProp && writableProp.valueDeclaration && ts.isPropertyAssignment(writableProp.valueDeclaration)) {
+ var initializer = writableProp.valueDeclaration.initializer;
+ var rawOriginalType = checkExpression(initializer);
+ if (rawOriginalType === falseType || rawOriginalType === regularFalseType) {
+ return true;
+ }
}
+ return false;
}
+ var setProp = getPropertyOfType(objectLitType, "set");
+ return !setProp;
}
- function isTypeParameterUnused(typeParameter) {
- return !(getMergedSymbol(typeParameter.symbol).isReferenced & 262144) && !isIdentifierThatStartsWithUnderscore(typeParameter.name);
+ function isReadonlySymbol(symbol) {
+ return !!(ts.getCheckFlags(symbol) & 8 ||
+ symbol.flags & 4 && ts.getDeclarationModifierFlagsFromSymbol(symbol) & 64 ||
+ symbol.flags & 3 && getDeclarationNodeFlagsFromSymbol(symbol) & 2 ||
+ symbol.flags & 98304 && !(symbol.flags & 65536) ||
+ symbol.flags & 8 ||
+ ts.some(symbol.declarations, isReadonlyAssignmentDeclaration));
}
- function addToGroup(map, key, value, getKey) {
- var keyString = String(getKey(key));
- var group = map.get(keyString);
- if (group) {
- group[1].push(value);
+ function isAssignmentToReadonlyEntity(expr, symbol, assignmentKind) {
+ var _a, _b;
+ if (assignmentKind === 0) {
+ return false;
}
- else {
- map.set(keyString, [key, [value]]);
+ if (isReadonlySymbol(symbol)) {
+ if (symbol.flags & 4 &&
+ ts.isAccessExpression(expr) &&
+ expr.expression.kind === 107) {
+ var ctor = ts.getContainingFunction(expr);
+ if (!(ctor && (ctor.kind === 166 || isJSConstructor(ctor)))) {
+ return true;
+ }
+ if (symbol.valueDeclaration) {
+ var isAssignmentDeclaration_1 = ts.isBinaryExpression(symbol.valueDeclaration);
+ var isLocalPropertyDeclaration = ctor.parent === symbol.valueDeclaration.parent;
+ var isLocalParameterProperty = ctor === symbol.valueDeclaration.parent;
+ var isLocalThisPropertyAssignment = isAssignmentDeclaration_1 && ((_a = symbol.parent) === null || _a === void 0 ? void 0 : _a.valueDeclaration) === ctor.parent;
+ var isLocalThisPropertyAssignmentConstructorFunction = isAssignmentDeclaration_1 && ((_b = symbol.parent) === null || _b === void 0 ? void 0 : _b.valueDeclaration) === ctor;
+ var isWriteableSymbol = isLocalPropertyDeclaration
+ || isLocalParameterProperty
+ || isLocalThisPropertyAssignment
+ || isLocalThisPropertyAssignmentConstructorFunction;
+ return !isWriteableSymbol;
+ }
+ }
+ return true;
}
+ if (ts.isAccessExpression(expr)) {
+ var node = ts.skipParentheses(expr.expression);
+ if (node.kind === 78) {
+ var symbol_2 = getNodeLinks(node).resolvedSymbol;
+ if (symbol_2.flags & 2097152) {
+ var declaration = getDeclarationOfAliasSymbol(symbol_2);
+ return !!declaration && declaration.kind === 263;
+ }
+ }
+ }
+ return false;
}
- function tryGetRootParameterDeclaration(node) {
- return ts.tryCast(ts.getRootDeclaration(node), ts.isParameter);
- }
- function isValidUnusedLocalDeclaration(declaration) {
- if (ts.isBindingElement(declaration) && isIdentifierThatStartsWithUnderscore(declaration.name)) {
- return !!ts.findAncestor(declaration.parent, function (ancestor) {
- return ts.isArrayBindingPattern(ancestor) || ts.isVariableDeclaration(ancestor) || ts.isVariableDeclarationList(ancestor) ? false :
- ts.isForOfStatement(ancestor) ? true : "quit";
- });
+ function checkReferenceExpression(expr, invalidReferenceMessage, invalidOptionalChainMessage) {
+ var node = ts.skipOuterExpressions(expr, 6 | 1);
+ if (node.kind !== 78 && !ts.isAccessExpression(node)) {
+ error(expr, invalidReferenceMessage);
+ return false;
}
- return ts.isAmbientModule(declaration) ||
- (ts.isVariableDeclaration(declaration) && ts.isForInOrOfStatement(declaration.parent.parent) || isImportedDeclaration(declaration)) && isIdentifierThatStartsWithUnderscore(declaration.name);
+ if (node.flags & 32) {
+ error(expr, invalidOptionalChainMessage);
+ return false;
+ }
+ return true;
}
- function checkUnusedLocalsAndParameters(nodeWithLocals, addDiagnostic) {
- var unusedImports = ts.createMap();
- var unusedDestructures = ts.createMap();
- var unusedVariables = ts.createMap();
- nodeWithLocals.locals.forEach(function (local) {
- if (local.flags & 262144 ? !(local.flags & 3 && !(local.isReferenced & 3)) : local.isReferenced || local.exportSymbol) {
- return;
+ function checkDeleteExpression(node) {
+ checkExpression(node.expression);
+ var expr = ts.skipParentheses(node.expression);
+ if (!ts.isAccessExpression(expr)) {
+ error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference);
+ return booleanType;
+ }
+ if (ts.isPropertyAccessExpression(expr) && ts.isPrivateIdentifier(expr.name)) {
+ error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier);
+ }
+ var links = getNodeLinks(expr);
+ var symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol);
+ if (symbol) {
+ if (isReadonlySymbol(symbol)) {
+ error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property);
}
- for (var _i = 0, _a = local.declarations; _i < _a.length; _i++) {
- var declaration = _a[_i];
- if (isValidUnusedLocalDeclaration(declaration)) {
- continue;
- }
- if (isImportedDeclaration(declaration)) {
- addToGroup(unusedImports, importClauseFromImported(declaration), declaration, getNodeId);
- }
- else if (ts.isBindingElement(declaration) && ts.isObjectBindingPattern(declaration.parent)) {
- var lastElement = ts.last(declaration.parent.elements);
- if (declaration === lastElement || !ts.last(declaration.parent.elements).dotDotDotToken) {
- addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId);
+ checkDeleteExpressionMustBeOptional(expr, getTypeOfSymbol(symbol));
+ }
+ return booleanType;
+ }
+ function checkDeleteExpressionMustBeOptional(expr, type) {
+ var AnyOrUnknownOrNeverFlags = 3 | 131072;
+ if (strictNullChecks && !(type.flags & AnyOrUnknownOrNeverFlags) && !(getFalsyFlags(type) & 32768)) {
+ error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_must_be_optional);
+ }
+ }
+ function checkTypeOfExpression(node) {
+ checkExpression(node.expression);
+ return typeofType;
+ }
+ function checkVoidExpression(node) {
+ checkExpression(node.expression);
+ return undefinedWideningType;
+ }
+ function checkAwaitExpression(node) {
+ if (produceDiagnostics) {
+ if (!(node.flags & 32768)) {
+ if (ts.isInTopLevelContext(node)) {
+ var sourceFile = ts.getSourceFileOfNode(node);
+ if (!hasParseDiagnostics(sourceFile)) {
+ var span = void 0;
+ if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
+ if (!span)
+ span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+ var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module);
+ diagnostics.add(diagnostic);
+ }
+ if ((moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System) || languageVersion < 4) {
+ span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+ var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher);
+ diagnostics.add(diagnostic);
+ }
}
}
- else if (ts.isVariableDeclaration(declaration)) {
- addToGroup(unusedVariables, declaration.parent, declaration, getNodeId);
- }
else {
- var parameter = local.valueDeclaration && tryGetRootParameterDeclaration(local.valueDeclaration);
- var name = local.valueDeclaration && ts.getNameOfDeclaration(local.valueDeclaration);
- if (parameter && name) {
- if (!ts.isParameterPropertyDeclaration(parameter, parameter.parent) && !ts.parameterIsThisKeyword(parameter) && !isIdentifierThatStartsWithUnderscore(name)) {
- addDiagnostic(parameter, 1, ts.createDiagnosticForNode(name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.symbolName(local)));
+ var sourceFile = ts.getSourceFileOfNode(node);
+ if (!hasParseDiagnostics(sourceFile)) {
+ var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+ var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);
+ var func = ts.getContainingFunction(node);
+ if (func && func.kind !== 166 && (ts.getFunctionFlags(func) & 2) === 0) {
+ var relatedInfo = ts.createDiagnosticForNode(func, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async);
+ ts.addRelatedInfo(diagnostic, relatedInfo);
}
- }
- else {
- errorUnusedLocal(declaration, ts.symbolName(local), addDiagnostic);
+ diagnostics.add(diagnostic);
}
}
}
- });
- unusedImports.forEach(function (_a) {
- var importClause = _a[0], unuseds = _a[1];
- var importDecl = importClause.parent;
- var nDeclarations = (importClause.name ? 1 : 0) +
- (importClause.namedBindings ?
- (importClause.namedBindings.kind === 256 ? 1 : importClause.namedBindings.elements.length)
- : 0);
- if (nDeclarations === unuseds.length) {
- addDiagnostic(importDecl, 0, unuseds.length === 1
- ? ts.createDiagnosticForNode(importDecl, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.idText(ts.first(unuseds).name))
- : ts.createDiagnosticForNode(importDecl, ts.Diagnostics.All_imports_in_import_declaration_are_unused));
+ if (isInParameterInitializerBeforeContainingFunction(node)) {
+ error(node, ts.Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer);
}
- else {
- for (var _i = 0, unuseds_1 = unuseds; _i < unuseds_1.length; _i++) {
- var unused = unuseds_1[_i];
- errorUnusedLocal(unused, ts.idText(unused.name), addDiagnostic);
+ }
+ var operandType = checkExpression(node.expression);
+ var awaitedType = checkAwaitedType(operandType, node, ts.Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+ if (awaitedType === operandType && awaitedType !== errorType && !(operandType.flags & 3)) {
+ addErrorOrSuggestion(false, ts.createDiagnosticForNode(node, ts.Diagnostics.await_has_no_effect_on_the_type_of_this_expression));
+ }
+ return awaitedType;
+ }
+ function checkPrefixUnaryExpression(node) {
+ var operandType = checkExpression(node.operand);
+ if (operandType === silentNeverType) {
+ return silentNeverType;
+ }
+ switch (node.operand.kind) {
+ case 8:
+ switch (node.operator) {
+ case 40:
+ return getFreshTypeOfLiteralType(getLiteralType(-node.operand.text));
+ case 39:
+ return getFreshTypeOfLiteralType(getLiteralType(+node.operand.text));
}
- }
- });
- unusedDestructures.forEach(function (_a) {
- var bindingPattern = _a[0], bindingElements = _a[1];
- var kind = tryGetRootParameterDeclaration(bindingPattern.parent) ? 1 : 0;
- if (bindingPattern.elements.length === bindingElements.length) {
- if (bindingElements.length === 1 && bindingPattern.parent.kind === 242 && bindingPattern.parent.parent.kind === 243) {
- addToGroup(unusedVariables, bindingPattern.parent.parent, bindingPattern.parent, getNodeId);
+ break;
+ case 9:
+ if (node.operator === 40) {
+ return getFreshTypeOfLiteralType(getLiteralType({
+ negative: true,
+ base10Value: ts.parsePseudoBigInt(node.operand.text)
+ }));
}
- else {
- addDiagnostic(bindingPattern, kind, bindingElements.length === 1
- ? ts.createDiagnosticForNode(bindingPattern, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(ts.first(bindingElements).name))
- : ts.createDiagnosticForNode(bindingPattern, ts.Diagnostics.All_destructured_elements_are_unused));
+ }
+ switch (node.operator) {
+ case 39:
+ case 40:
+ case 54:
+ checkNonNullType(operandType, node.operand);
+ if (maybeTypeOfKind(operandType, 12288)) {
+ error(node.operand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(node.operator));
}
- }
- else {
- for (var _i = 0, bindingElements_1 = bindingElements; _i < bindingElements_1.length; _i++) {
- var e = bindingElements_1[_i];
- addDiagnostic(e, kind, ts.createDiagnosticForNode(e, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(e.name)));
+ if (node.operator === 39) {
+ if (maybeTypeOfKind(operandType, 2112)) {
+ error(node.operand, ts.Diagnostics.Operator_0_cannot_be_applied_to_type_1, ts.tokenToString(node.operator), typeToString(getBaseTypeOfLiteralType(operandType)));
+ }
+ return numberType;
}
- }
- });
- unusedVariables.forEach(function (_a) {
- var declarationList = _a[0], declarations = _a[1];
- if (declarationList.declarations.length === declarations.length) {
- addDiagnostic(declarationList, 0, declarations.length === 1
- ? ts.createDiagnosticForNode(ts.first(declarations).name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(ts.first(declarations).name))
- : ts.createDiagnosticForNode(declarationList.parent.kind === 225 ? declarationList.parent : declarationList, ts.Diagnostics.All_variables_are_unused));
- }
- else {
- for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
- var decl = declarations_5[_i];
- addDiagnostic(decl, 0, ts.createDiagnosticForNode(decl, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(decl.name)));
+ return getUnaryResultType(operandType);
+ case 53:
+ checkTruthinessExpression(node.operand);
+ var facts = getTypeFacts(operandType) & (4194304 | 8388608);
+ return facts === 4194304 ? falseType :
+ facts === 8388608 ? trueType :
+ booleanType;
+ case 45:
+ case 46:
+ var ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type);
+ if (ok) {
+ checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access);
+ }
+ return getUnaryResultType(operandType);
+ }
+ return errorType;
+ }
+ function checkPostfixUnaryExpression(node) {
+ var operandType = checkExpression(node.operand);
+ if (operandType === silentNeverType) {
+ return silentNeverType;
+ }
+ var ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type);
+ if (ok) {
+ checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access);
+ }
+ return getUnaryResultType(operandType);
+ }
+ function getUnaryResultType(operandType) {
+ if (maybeTypeOfKind(operandType, 2112)) {
+ return isTypeAssignableToKind(operandType, 3) || maybeTypeOfKind(operandType, 296)
+ ? numberOrBigIntType
+ : bigintType;
+ }
+ return numberType;
+ }
+ function maybeTypeOfKind(type, kind) {
+ if (type.flags & kind) {
+ return true;
+ }
+ if (type.flags & 3145728) {
+ var types = type.types;
+ for (var _i = 0, types_20 = types; _i < types_20.length; _i++) {
+ var t = types_20[_i];
+ if (maybeTypeOfKind(t, kind)) {
+ return true;
}
}
- });
+ }
+ return false;
}
- function bindingNameText(name) {
- switch (name.kind) {
- case 75:
- return ts.idText(name);
- case 190:
- case 189:
- return bindingNameText(ts.cast(ts.first(name.elements), ts.isBindingElement).name);
- default:
- return ts.Debug.assertNever(name);
+ function isTypeAssignableToKind(source, kind, strict) {
+ if (source.flags & kind) {
+ return true;
+ }
+ if (strict && source.flags & (3 | 16384 | 32768 | 65536)) {
+ return false;
}
+ return !!(kind & 296) && isTypeAssignableTo(source, numberType) ||
+ !!(kind & 2112) && isTypeAssignableTo(source, bigintType) ||
+ !!(kind & 402653316) && isTypeAssignableTo(source, stringType) ||
+ !!(kind & 528) && isTypeAssignableTo(source, booleanType) ||
+ !!(kind & 16384) && isTypeAssignableTo(source, voidType) ||
+ !!(kind & 131072) && isTypeAssignableTo(source, neverType) ||
+ !!(kind & 65536) && isTypeAssignableTo(source, nullType) ||
+ !!(kind & 32768) && isTypeAssignableTo(source, undefinedType) ||
+ !!(kind & 4096) && isTypeAssignableTo(source, esSymbolType) ||
+ !!(kind & 67108864) && isTypeAssignableTo(source, nonPrimitiveType);
}
- function isImportedDeclaration(node) {
- return node.kind === 255 || node.kind === 258 || node.kind === 256;
+ function allTypesAssignableToKind(source, kind, strict) {
+ return source.flags & 1048576 ?
+ ts.every(source.types, function (subType) { return allTypesAssignableToKind(subType, kind, strict); }) :
+ isTypeAssignableToKind(source, kind, strict);
}
- function importClauseFromImported(decl) {
- return decl.kind === 255 ? decl : decl.kind === 256 ? decl.parent : decl.parent.parent;
+ function isConstEnumObjectType(type) {
+ return !!(ts.getObjectFlags(type) & 16) && !!type.symbol && isConstEnumSymbol(type.symbol);
}
- function checkBlock(node) {
- if (node.kind === 223) {
- checkGrammarStatementInAmbientContext(node);
+ function isConstEnumSymbol(symbol) {
+ return (symbol.flags & 128) !== 0;
+ }
+ function checkInstanceOfExpression(left, right, leftType, rightType) {
+ if (leftType === silentNeverType || rightType === silentNeverType) {
+ return silentNeverType;
}
- if (ts.isFunctionOrModuleBlock(node)) {
- var saveFlowAnalysisDisabled = flowAnalysisDisabled;
- ts.forEach(node.statements, checkSourceElement);
- flowAnalysisDisabled = saveFlowAnalysisDisabled;
+ if (!isTypeAny(leftType) &&
+ allTypesAssignableToKind(leftType, 131068)) {
+ error(left, ts.Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
}
- else {
- ts.forEach(node.statements, checkSourceElement);
+ if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
+ error(right, ts.Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
}
- if (node.locals) {
- registerForUnusedIdentifiersCheck(node);
+ return booleanType;
+ }
+ function checkInExpression(left, right, leftType, rightType) {
+ if (leftType === silentNeverType || rightType === silentNeverType) {
+ return silentNeverType;
+ }
+ leftType = checkNonNullType(leftType, left);
+ rightType = checkNonNullType(rightType, right);
+ if (!(allTypesAssignableToKind(leftType, 402653316 | 296 | 12288) ||
+ isTypeAssignableToKind(leftType, 4194304 | 134217728 | 268435456 | 262144))) {
+ error(left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
+ }
+ if (!allTypesAssignableToKind(rightType, 67108864 | 58982400)) {
+ error(right, ts.Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
}
+ return booleanType;
}
- function checkCollisionWithArgumentsInGeneratedCode(node) {
- if (languageVersion >= 2 || compilerOptions.noEmit || !ts.hasRestParameter(node) || node.flags & 8388608 || ts.nodeIsMissing(node.body)) {
- return;
+ function checkObjectLiteralAssignment(node, sourceType, rightIsThis) {
+ var properties = node.properties;
+ if (strictNullChecks && properties.length === 0) {
+ return checkNonNullType(sourceType, node);
}
- ts.forEach(node.parameters, function (p) {
- if (p.name && !ts.isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.escapedName) {
- error(p, ts.Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);
- }
- });
+ for (var i = 0; i < properties.length; i++) {
+ checkObjectLiteralDestructuringPropertyAssignment(node, sourceType, i, properties, rightIsThis);
+ }
+ return sourceType;
}
- function needCollisionCheckForIdentifier(node, identifier, name) {
- if (!(identifier && identifier.escapedText === name)) {
- return false;
+ function checkObjectLiteralDestructuringPropertyAssignment(node, objectLiteralType, propertyIndex, allProperties, rightIsThis) {
+ if (rightIsThis === void 0) { rightIsThis = false; }
+ var properties = node.properties;
+ var property = properties[propertyIndex];
+ if (property.kind === 288 || property.kind === 289) {
+ var name = property.name;
+ var exprType = getLiteralTypeFromPropertyName(name);
+ if (isTypeUsableAsPropertyName(exprType)) {
+ var text = getPropertyNameFromType(exprType);
+ var prop = getPropertyOfType(objectLiteralType, text);
+ if (prop) {
+ markPropertyAsReferenced(prop, property, rightIsThis);
+ checkPropertyAccessibility(property, false, objectLiteralType, prop);
+ }
+ }
+ var elementType = getIndexedAccessType(objectLiteralType, exprType, undefined, name, undefined, undefined, 16);
+ var type = getFlowTypeOfDestructuring(property, elementType);
+ return checkDestructuringAssignment(property.kind === 289 ? property : property.initializer, type);
}
- if (node.kind === 159 ||
- node.kind === 158 ||
- node.kind === 161 ||
- node.kind === 160 ||
- node.kind === 163 ||
- node.kind === 164) {
- return false;
+ else if (property.kind === 290) {
+ if (propertyIndex < properties.length - 1) {
+ error(property, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
+ }
+ else {
+ if (languageVersion < 99) {
+ checkExternalEmitHelpers(property, 4);
+ }
+ var nonRestNames = [];
+ if (allProperties) {
+ for (var _i = 0, allProperties_1 = allProperties; _i < allProperties_1.length; _i++) {
+ var otherProperty = allProperties_1[_i];
+ if (!ts.isSpreadAssignment(otherProperty)) {
+ nonRestNames.push(otherProperty.name);
+ }
+ }
+ }
+ var type = getRestType(objectLiteralType, nonRestNames, objectLiteralType.symbol);
+ checkGrammarForDisallowedTrailingComma(allProperties, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
+ return checkDestructuringAssignment(property.expression, type);
+ }
}
- if (node.flags & 8388608) {
- return false;
+ else {
+ error(property, ts.Diagnostics.Property_assignment_expected);
}
- var root = ts.getRootDeclaration(node);
- if (root.kind === 156 && ts.nodeIsMissing(root.parent.body)) {
- return false;
+ }
+ function checkArrayLiteralAssignment(node, sourceType, checkMode) {
+ var elements = node.elements;
+ if (languageVersion < 2 && compilerOptions.downlevelIteration) {
+ checkExternalEmitHelpers(node, 512);
}
- return true;
+ var possiblyOutOfBoundsType = checkIteratedTypeOrElementType(65 | 128, sourceType, undefinedType, node) || errorType;
+ var inBoundsType = compilerOptions.noUncheckedIndexedAccess ? undefined : possiblyOutOfBoundsType;
+ for (var i = 0; i < elements.length; i++) {
+ var type = possiblyOutOfBoundsType;
+ if (node.elements[i].kind === 220) {
+ type = inBoundsType = inBoundsType !== null && inBoundsType !== void 0 ? inBoundsType : (checkIteratedTypeOrElementType(65, sourceType, undefinedType, node) || errorType);
+ }
+ checkArrayLiteralDestructuringElementAssignment(node, sourceType, i, type, checkMode);
+ }
+ return sourceType;
}
- function checkIfThisIsCapturedInEnclosingScope(node) {
- ts.findAncestor(node, function (current) {
- if (getNodeCheckFlags(current) & 4) {
- var isDeclaration_1 = node.kind !== 75;
- if (isDeclaration_1) {
- error(ts.getNameOfDeclaration(node), ts.Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference);
+ function checkArrayLiteralDestructuringElementAssignment(node, sourceType, elementIndex, elementType, checkMode) {
+ var elements = node.elements;
+ var element = elements[elementIndex];
+ if (element.kind !== 222) {
+ if (element.kind !== 220) {
+ var indexType = getLiteralType(elementIndex);
+ if (isArrayLikeType(sourceType)) {
+ var accessFlags = 16 | (hasDefaultValue(element) ? 8 : 0);
+ var elementType_2 = getIndexedAccessTypeOrUndefined(sourceType, indexType, undefined, createSyntheticExpression(element, indexType), accessFlags) || errorType;
+ var assignedType = hasDefaultValue(element) ? getTypeWithFacts(elementType_2, 524288) : elementType_2;
+ var type = getFlowTypeOfDestructuring(element, assignedType);
+ return checkDestructuringAssignment(element, type, checkMode);
+ }
+ return checkDestructuringAssignment(element, elementType, checkMode);
+ }
+ if (elementIndex < elements.length - 1) {
+ error(element, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
+ }
+ else {
+ var restExpression = element.expression;
+ if (restExpression.kind === 216 && restExpression.operatorToken.kind === 62) {
+ error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer);
}
else {
- error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference);
+ checkGrammarForDisallowedTrailingComma(node.elements, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
+ var type = everyType(sourceType, isTupleType) ?
+ mapType(sourceType, function (t) { return sliceTupleType(t, elementIndex); }) :
+ createArrayType(elementType);
+ return checkDestructuringAssignment(restExpression, type, checkMode);
}
- return true;
}
- return false;
- });
+ }
+ return undefined;
}
- function checkIfNewTargetIsCapturedInEnclosingScope(node) {
- ts.findAncestor(node, function (current) {
- if (getNodeCheckFlags(current) & 8) {
- var isDeclaration_2 = node.kind !== 75;
- if (isDeclaration_2) {
- error(ts.getNameOfDeclaration(node), ts.Diagnostics.Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference);
- }
- else {
- error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference);
+ function checkDestructuringAssignment(exprOrAssignment, sourceType, checkMode, rightIsThis) {
+ var target;
+ if (exprOrAssignment.kind === 289) {
+ var prop = exprOrAssignment;
+ if (prop.objectAssignmentInitializer) {
+ if (strictNullChecks &&
+ !(getFalsyFlags(checkExpression(prop.objectAssignmentInitializer)) & 32768)) {
+ sourceType = getTypeWithFacts(sourceType, 524288);
}
- return true;
+ checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode);
}
- return false;
- });
- }
- function checkWeakMapCollision(node) {
- var enclosingBlockScope = ts.getEnclosingBlockScopeContainer(node);
- if (getNodeCheckFlags(enclosingBlockScope) & 67108864) {
- error(node, ts.Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, "WeakMap");
+ target = exprOrAssignment.name;
}
- }
- function checkCollisionWithRequireExportsInGeneratedCode(node, name) {
- if (moduleKind >= ts.ModuleKind.ES2015 || compilerOptions.noEmit) {
- return;
+ else {
+ target = exprOrAssignment;
}
- if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) {
- return;
+ if (target.kind === 216 && target.operatorToken.kind === 62) {
+ checkBinaryExpression(target, checkMode);
+ target = target.left;
}
- if (ts.isModuleDeclaration(node) && ts.getModuleInstanceState(node) !== 1) {
- return;
+ if (target.kind === 200) {
+ return checkObjectLiteralAssignment(target, sourceType, rightIsThis);
}
- var parent = getDeclarationContainer(node);
- if (parent.kind === 290 && ts.isExternalOrCommonJsModule(parent)) {
- error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name));
+ if (target.kind === 199) {
+ return checkArrayLiteralAssignment(target, sourceType, checkMode);
}
+ return checkReferenceAssignment(target, sourceType, checkMode);
}
- function checkCollisionWithGlobalPromiseInGeneratedCode(node, name) {
- if (languageVersion >= 4 || compilerOptions.noEmit || !needCollisionCheckForIdentifier(node, name, "Promise")) {
- return;
- }
- if (ts.isModuleDeclaration(node) && ts.getModuleInstanceState(node) !== 1) {
- return;
+ function checkReferenceAssignment(target, sourceType, checkMode) {
+ var targetType = checkExpression(target, checkMode);
+ var error = target.parent.kind === 290 ?
+ ts.Diagnostics.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access :
+ ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access;
+ var optionalError = target.parent.kind === 290 ?
+ ts.Diagnostics.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access :
+ ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access;
+ if (checkReferenceExpression(target, error, optionalError)) {
+ checkTypeAssignableToAndOptionallyElaborate(sourceType, targetType, target, target);
}
- var parent = getDeclarationContainer(node);
- if (parent.kind === 290 && ts.isExternalOrCommonJsModule(parent) && parent.flags & 2048) {
- error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions, ts.declarationNameToString(name), ts.declarationNameToString(name));
+ if (ts.isPrivateIdentifierPropertyAccessExpression(target)) {
+ checkExternalEmitHelpers(target.parent, 2097152);
}
+ return sourceType;
}
- function checkVarDeclaredNamesNotShadowed(node) {
- if ((ts.getCombinedNodeFlags(node) & 3) !== 0 || ts.isParameterDeclaration(node)) {
- return;
- }
- if (node.kind === 242 && !node.initializer) {
- return;
+ function isSideEffectFree(node) {
+ node = ts.skipParentheses(node);
+ switch (node.kind) {
+ case 78:
+ case 10:
+ case 13:
+ case 205:
+ case 218:
+ case 14:
+ case 8:
+ case 9:
+ case 109:
+ case 94:
+ case 103:
+ case 150:
+ case 208:
+ case 221:
+ case 209:
+ case 199:
+ case 200:
+ case 211:
+ case 225:
+ case 274:
+ case 273:
+ return true;
+ case 217:
+ return isSideEffectFree(node.whenTrue) &&
+ isSideEffectFree(node.whenFalse);
+ case 216:
+ if (ts.isAssignmentOperator(node.operatorToken.kind)) {
+ return false;
+ }
+ return isSideEffectFree(node.left) &&
+ isSideEffectFree(node.right);
+ case 214:
+ case 215:
+ switch (node.operator) {
+ case 53:
+ case 39:
+ case 40:
+ case 54:
+ return true;
+ }
+ return false;
+ case 212:
+ case 206:
+ case 224:
+ default:
+ return false;
}
- var symbol = getSymbolOfNode(node);
- if (symbol.flags & 1) {
- if (!ts.isIdentifier(node.name))
- return ts.Debug.fail();
- var localDeclarationSymbol = resolveName(node, node.name.escapedText, 3, undefined, undefined, false);
- if (localDeclarationSymbol &&
- localDeclarationSymbol !== symbol &&
- localDeclarationSymbol.flags & 2) {
- if (getDeclarationNodeFlagsFromSymbol(localDeclarationSymbol) & 3) {
- var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 243);
- var container = varDeclList.parent.kind === 225 && varDeclList.parent.parent
- ? varDeclList.parent.parent
- : undefined;
- var namesShareScope = container &&
- (container.kind === 223 && ts.isFunctionLike(container.parent) ||
- container.kind === 250 ||
- container.kind === 249 ||
- container.kind === 290);
- if (!namesShareScope) {
- var name = symbolToString(localDeclarationSymbol);
- error(node, ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name);
+ }
+ function isTypeEqualityComparableTo(source, target) {
+ return (target.flags & 98304) !== 0 || isTypeComparableTo(source, target);
+ }
+ function checkBinaryExpression(node, checkMode) {
+ var workStacks = {
+ expr: [node],
+ state: [0],
+ leftType: [undefined]
+ };
+ var stackIndex = 0;
+ var lastResult;
+ while (stackIndex >= 0) {
+ node = workStacks.expr[stackIndex];
+ switch (workStacks.state[stackIndex]) {
+ case 0: {
+ if (ts.isInJSFile(node) && ts.getAssignedExpandoInitializer(node)) {
+ finishInvocation(checkExpression(node.right, checkMode));
+ break;
+ }
+ checkGrammarNullishCoalesceWithLogicalExpression(node);
+ var operator = node.operatorToken.kind;
+ if (operator === 62 && (node.left.kind === 200 || node.left.kind === 199)) {
+ finishInvocation(checkDestructuringAssignment(node.left, checkExpression(node.right, checkMode), checkMode, node.right.kind === 107));
+ break;
+ }
+ advanceState(1);
+ maybeCheckExpression(node.left);
+ break;
+ }
+ case 1: {
+ var leftType = lastResult;
+ workStacks.leftType[stackIndex] = leftType;
+ var operator = node.operatorToken.kind;
+ if (operator === 55 || operator === 56 || operator === 60) {
+ checkTruthinessOfType(leftType, node.left);
}
+ advanceState(2);
+ maybeCheckExpression(node.right);
+ break;
+ }
+ case 2: {
+ var leftType = workStacks.leftType[stackIndex];
+ var rightType = lastResult;
+ finishInvocation(checkBinaryLikeExpressionWorker(node.left, node.operatorToken, node.right, leftType, rightType, node));
+ break;
}
+ default: return ts.Debug.fail("Invalid state " + workStacks.state[stackIndex] + " for checkBinaryExpression");
}
}
- }
- function convertAutoToAny(type) {
- return type === autoType ? anyType : type === autoArrayType ? anyArrayType : type;
- }
- function checkVariableLikeDeclaration(node) {
- checkDecorators(node);
- if (!ts.isBindingElement(node)) {
- checkSourceElement(node.type);
+ return lastResult;
+ function finishInvocation(result) {
+ lastResult = result;
+ stackIndex--;
}
- if (!node.name) {
- return;
+ function advanceState(nextState) {
+ workStacks.state[stackIndex] = nextState;
}
- if (node.name.kind === 154) {
- checkComputedPropertyName(node.name);
- if (node.initializer) {
- checkExpressionCached(node.initializer);
+ function maybeCheckExpression(node) {
+ if (ts.isBinaryExpression(node)) {
+ stackIndex++;
+ workStacks.expr[stackIndex] = node;
+ workStacks.state[stackIndex] = 0;
+ workStacks.leftType[stackIndex] = undefined;
}
- }
- if (node.kind === 191) {
- if (node.parent.kind === 189 && languageVersion < 99) {
- checkExternalEmitHelpers(node, 4);
+ else {
+ lastResult = checkExpression(node, checkMode);
}
- if (node.propertyName && node.propertyName.kind === 154) {
- checkComputedPropertyName(node.propertyName);
+ }
+ }
+ function checkGrammarNullishCoalesceWithLogicalExpression(node) {
+ var left = node.left, operatorToken = node.operatorToken, right = node.right;
+ if (operatorToken.kind === 60) {
+ if (ts.isBinaryExpression(left) && (left.operatorToken.kind === 56 || left.operatorToken.kind === 55)) {
+ grammarErrorOnNode(left, ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, ts.tokenToString(left.operatorToken.kind), ts.tokenToString(operatorToken.kind));
}
- var parent = node.parent.parent;
- var parentType = getTypeForBindingElementParent(parent);
- var name = node.propertyName || node.name;
- if (parentType && !ts.isBindingPattern(name)) {
- var exprType = getLiteralTypeFromPropertyName(name);
- if (isTypeUsableAsPropertyName(exprType)) {
- var nameText = getPropertyNameFromType(exprType);
- var property = getPropertyOfType(parentType, nameText);
- if (property) {
- markPropertyAsReferenced(property, undefined, false);
- checkPropertyAccessibility(parent, !!parent.initializer && parent.initializer.kind === 102, parentType, property);
- }
- }
+ if (ts.isBinaryExpression(right) && (right.operatorToken.kind === 56 || right.operatorToken.kind === 55)) {
+ grammarErrorOnNode(right, ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, ts.tokenToString(right.operatorToken.kind), ts.tokenToString(operatorToken.kind));
}
}
- if (ts.isBindingPattern(node.name)) {
- if (node.name.kind === 190 && languageVersion < 2 && compilerOptions.downlevelIteration) {
- checkExternalEmitHelpers(node, 512);
- }
- ts.forEach(node.name.elements, checkSourceElement);
+ }
+ function checkBinaryLikeExpression(left, operatorToken, right, checkMode, errorNode) {
+ var operator = operatorToken.kind;
+ if (operator === 62 && (left.kind === 200 || left.kind === 199)) {
+ return checkDestructuringAssignment(left, checkExpression(right, checkMode), checkMode, right.kind === 107);
}
- if (node.initializer && ts.getRootDeclaration(node).kind === 156 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) {
- error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation);
- return;
+ var leftType;
+ if (operator === 55 || operator === 56 || operator === 60) {
+ leftType = checkTruthinessExpression(left, checkMode);
}
- if (ts.isBindingPattern(node.name)) {
- var needCheckInitializer = node.initializer && node.parent.parent.kind !== 231;
- var needCheckWidenedType = node.name.elements.length === 0;
- if (needCheckInitializer || needCheckWidenedType) {
- var widenedType = getWidenedTypeForVariableLikeDeclaration(node);
- if (needCheckInitializer) {
- var initializerType = checkExpressionCached(node.initializer);
- if (strictNullChecks && needCheckWidenedType) {
- checkNonNullNonVoidType(initializerType, node);
+ else {
+ leftType = checkExpression(left, checkMode);
+ }
+ var rightType = checkExpression(right, checkMode);
+ return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode);
+ }
+ function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode) {
+ var operator = operatorToken.kind;
+ switch (operator) {
+ case 41:
+ case 42:
+ case 65:
+ case 66:
+ case 43:
+ case 67:
+ case 44:
+ case 68:
+ case 40:
+ case 64:
+ case 47:
+ case 69:
+ case 48:
+ case 70:
+ case 49:
+ case 71:
+ case 51:
+ case 73:
+ case 52:
+ case 77:
+ case 50:
+ case 72:
+ if (leftType === silentNeverType || rightType === silentNeverType) {
+ return silentNeverType;
+ }
+ leftType = checkNonNullType(leftType, left);
+ rightType = checkNonNullType(rightType, right);
+ var suggestedOperator = void 0;
+ if ((leftType.flags & 528) &&
+ (rightType.flags & 528) &&
+ (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== undefined) {
+ error(errorNode || operatorToken, ts.Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, ts.tokenToString(operatorToken.kind), ts.tokenToString(suggestedOperator));
+ return numberType;
+ }
+ else {
+ var leftOk = checkArithmeticOperandType(left, leftType, ts.Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true);
+ var rightOk = checkArithmeticOperandType(right, rightType, ts.Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true);
+ var resultType_1;
+ if ((isTypeAssignableToKind(leftType, 3) && isTypeAssignableToKind(rightType, 3)) ||
+ !(maybeTypeOfKind(leftType, 2112) || maybeTypeOfKind(rightType, 2112))) {
+ resultType_1 = numberType;
}
- else {
- checkTypeAssignableToAndOptionallyElaborate(initializerType, getWidenedTypeForVariableLikeDeclaration(node), node, node.initializer);
+ else if (bothAreBigIntLike(leftType, rightType)) {
+ switch (operator) {
+ case 49:
+ case 71:
+ reportOperatorError();
+ break;
+ case 42:
+ case 66:
+ if (languageVersion < 3) {
+ error(errorNode, ts.Diagnostics.Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later);
+ }
+ }
+ resultType_1 = bigintType;
}
- }
- if (needCheckWidenedType) {
- if (ts.isArrayBindingPattern(node.name)) {
- checkIteratedTypeOrElementType(65, widenedType, undefinedType, node);
+ else {
+ reportOperatorError(bothAreBigIntLike);
+ resultType_1 = errorType;
}
- else if (strictNullChecks) {
- checkNonNullNonVoidType(widenedType, node);
+ if (leftOk && rightOk) {
+ checkAssignmentOperator(resultType_1);
}
+ return resultType_1;
}
- }
- return;
- }
- var symbol = getSymbolOfNode(node);
- var type = convertAutoToAny(getTypeOfSymbol(symbol));
- if (node === symbol.valueDeclaration) {
- var initializer = ts.getEffectiveInitializer(node);
- if (initializer) {
- var isJSObjectLiteralInitializer = ts.isInJSFile(node) &&
- ts.isObjectLiteralExpression(initializer) &&
- (initializer.properties.length === 0 || ts.isPrototypeAccess(node.name)) &&
- ts.hasEntries(symbol.exports);
- if (!isJSObjectLiteralInitializer && node.parent.parent.kind !== 231) {
- checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(initializer), type, node, initializer, undefined);
+ case 39:
+ case 63:
+ if (leftType === silentNeverType || rightType === silentNeverType) {
+ return silentNeverType;
}
- }
- if (symbol.declarations.length > 1) {
- if (ts.some(symbol.declarations, function (d) { return d !== node && ts.isVariableLike(d) && !areDeclarationFlagsIdentical(d, node); })) {
- error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name));
+ if (!isTypeAssignableToKind(leftType, 402653316) && !isTypeAssignableToKind(rightType, 402653316)) {
+ leftType = checkNonNullType(leftType, left);
+ rightType = checkNonNullType(rightType, right);
}
+ var resultType = void 0;
+ if (isTypeAssignableToKind(leftType, 296, true) && isTypeAssignableToKind(rightType, 296, true)) {
+ resultType = numberType;
+ }
+ else if (isTypeAssignableToKind(leftType, 2112, true) && isTypeAssignableToKind(rightType, 2112, true)) {
+ resultType = bigintType;
+ }
+ else if (isTypeAssignableToKind(leftType, 402653316, true) || isTypeAssignableToKind(rightType, 402653316, true)) {
+ resultType = stringType;
+ }
+ else if (isTypeAny(leftType) || isTypeAny(rightType)) {
+ resultType = leftType === errorType || rightType === errorType ? errorType : anyType;
+ }
+ if (resultType && !checkForDisallowedESSymbolOperand(operator)) {
+ return resultType;
+ }
+ if (!resultType) {
+ var closeEnoughKind_1 = 296 | 2112 | 402653316 | 3;
+ reportOperatorError(function (left, right) {
+ return isTypeAssignableToKind(left, closeEnoughKind_1) &&
+ isTypeAssignableToKind(right, closeEnoughKind_1);
+ });
+ return anyType;
+ }
+ if (operator === 63) {
+ checkAssignmentOperator(resultType);
+ }
+ return resultType;
+ case 29:
+ case 31:
+ case 32:
+ case 33:
+ if (checkForDisallowedESSymbolOperand(operator)) {
+ leftType = getBaseTypeOfLiteralType(checkNonNullType(leftType, left));
+ rightType = getBaseTypeOfLiteralType(checkNonNullType(rightType, right));
+ reportOperatorErrorUnless(function (left, right) {
+ return isTypeComparableTo(left, right) || isTypeComparableTo(right, left) || (isTypeAssignableTo(left, numberOrBigIntType) && isTypeAssignableTo(right, numberOrBigIntType));
+ });
+ }
+ return booleanType;
+ case 34:
+ case 35:
+ case 36:
+ case 37:
+ reportOperatorErrorUnless(function (left, right) { return isTypeEqualityComparableTo(left, right) || isTypeEqualityComparableTo(right, left); });
+ return booleanType;
+ case 101:
+ return checkInstanceOfExpression(left, right, leftType, rightType);
+ case 100:
+ return checkInExpression(left, right, leftType, rightType);
+ case 55:
+ case 75: {
+ var resultType_2 = getTypeFacts(leftType) & 4194304 ?
+ getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) :
+ leftType;
+ if (operator === 75) {
+ checkAssignmentOperator(rightType);
+ }
+ return resultType_2;
}
- }
- else {
- var declarationType = convertAutoToAny(getWidenedTypeForVariableLikeDeclaration(node));
- if (type !== errorType && declarationType !== errorType &&
- !isTypeIdenticalTo(type, declarationType) &&
- !(symbol.flags & 67108864)) {
- errorNextVariableOrPropertyDeclarationMustHaveSameType(symbol.valueDeclaration, type, node, declarationType);
- }
- if (node.initializer) {
- checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(node.initializer), declarationType, node, node.initializer, undefined);
- }
- if (!areDeclarationFlagsIdentical(node, symbol.valueDeclaration)) {
- error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name));
- }
- }
- if (node.kind !== 159 && node.kind !== 158) {
- checkExportsOnMergedDeclarations(node);
- if (node.kind === 242 || node.kind === 191) {
- checkVarDeclaredNamesNotShadowed(node);
+ case 56:
+ case 74: {
+ var resultType_3 = getTypeFacts(leftType) & 8388608 ?
+ getUnionType([removeDefinitelyFalsyTypes(leftType), rightType], 2) :
+ leftType;
+ if (operator === 74) {
+ checkAssignmentOperator(rightType);
+ }
+ return resultType_3;
}
- checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
- checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
- if (!compilerOptions.noEmit && languageVersion < 99 && needCollisionCheckForIdentifier(node, node.name, "WeakMap")) {
- potentialWeakMapCollisions.push(node);
+ case 60:
+ case 76: {
+ var resultType_4 = getTypeFacts(leftType) & 262144 ?
+ getUnionType([getNonNullableType(leftType), rightType], 2) :
+ leftType;
+ if (operator === 76) {
+ checkAssignmentOperator(rightType);
+ }
+ return resultType_4;
}
- }
- }
- function errorNextVariableOrPropertyDeclarationMustHaveSameType(firstDeclaration, firstType, nextDeclaration, nextType) {
- var nextDeclarationName = ts.getNameOfDeclaration(nextDeclaration);
- var message = nextDeclaration.kind === 159 || nextDeclaration.kind === 158
- ? ts.Diagnostics.Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2
- : ts.Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2;
- var declName = ts.declarationNameToString(nextDeclarationName);
- var err = error(nextDeclarationName, message, declName, typeToString(firstType), typeToString(nextType));
- if (firstDeclaration) {
- ts.addRelatedInfo(err, ts.createDiagnosticForNode(firstDeclaration, ts.Diagnostics._0_was_also_declared_here, declName));
- }
- }
- function areDeclarationFlagsIdentical(left, right) {
- if ((left.kind === 156 && right.kind === 242) ||
- (left.kind === 242 && right.kind === 156)) {
- return true;
- }
- if (ts.hasQuestionToken(left) !== ts.hasQuestionToken(right)) {
- return false;
- }
- var interestingFlags = 8 |
- 16 |
- 256 |
- 128 |
- 64 |
- 32;
- return ts.getSelectedModifierFlags(left, interestingFlags) === ts.getSelectedModifierFlags(right, interestingFlags);
- }
- function checkVariableDeclaration(node) {
- checkGrammarVariableDeclaration(node);
- return checkVariableLikeDeclaration(node);
- }
- function checkBindingElement(node) {
- checkGrammarBindingElement(node);
- return checkVariableLikeDeclaration(node);
- }
- function checkVariableStatement(node) {
- if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarVariableDeclarationList(node.declarationList))
- checkGrammarForDisallowedLetOrConstStatement(node);
- ts.forEach(node.declarationList.declarations, checkSourceElement);
- }
- function checkExpressionStatement(node) {
- checkGrammarStatementInAmbientContext(node);
- checkExpression(node.expression);
- }
- function checkIfStatement(node) {
- checkGrammarStatementInAmbientContext(node);
- var type = checkTruthinessExpression(node.expression);
- checkTestingKnownTruthyCallableType(node.expression, node.thenStatement, type);
- checkSourceElement(node.thenStatement);
- if (node.thenStatement.kind === 224) {
- error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
- }
- checkSourceElement(node.elseStatement);
- }
- function checkTestingKnownTruthyCallableType(condExpr, body, type) {
- if (!strictNullChecks) {
- return;
- }
- var testedNode = ts.isIdentifier(condExpr)
- ? condExpr
- : ts.isPropertyAccessExpression(condExpr)
- ? condExpr.name
- : undefined;
- if (!testedNode) {
- return;
- }
- var possiblyFalsy = getFalsyFlags(type);
- if (possiblyFalsy) {
- return;
- }
- var callSignatures = getSignaturesOfType(type, 0);
- if (callSignatures.length === 0) {
- return;
- }
- var testedFunctionSymbol = getSymbolAtLocation(testedNode);
- if (!testedFunctionSymbol) {
- return;
- }
- var functionIsUsedInBody = ts.forEachChild(body, function check(childNode) {
- if (ts.isIdentifier(childNode)) {
- var childSymbol = getSymbolAtLocation(childNode);
- if (childSymbol && childSymbol === testedFunctionSymbol) {
- if (ts.isIdentifier(condExpr)) {
- return true;
+ case 62:
+ var declKind = ts.isBinaryExpression(left.parent) ? ts.getAssignmentDeclarationKind(left.parent) : 0;
+ checkAssignmentDeclaration(declKind, rightType);
+ if (isAssignmentDeclaration(declKind)) {
+ if (!(rightType.flags & 524288) ||
+ declKind !== 2 &&
+ declKind !== 6 &&
+ !isEmptyObjectType(rightType) &&
+ !isFunctionObjectType(rightType) &&
+ !(ts.getObjectFlags(rightType) & 1)) {
+ checkAssignmentOperator(rightType);
}
- var testedExpression = testedNode.parent;
- var childExpression = childNode.parent;
- while (testedExpression && childExpression) {
- if (ts.isIdentifier(testedExpression) && ts.isIdentifier(childExpression) ||
- testedExpression.kind === 104 && childExpression.kind === 104) {
- return getSymbolAtLocation(testedExpression) === getSymbolAtLocation(childExpression);
- }
- if (ts.isPropertyAccessExpression(testedExpression) && ts.isPropertyAccessExpression(childExpression)) {
- if (getSymbolAtLocation(testedExpression.name) !== getSymbolAtLocation(childExpression.name)) {
- return false;
- }
- childExpression = childExpression.expression;
- testedExpression = testedExpression.expression;
- }
- else {
+ return leftType;
+ }
+ else {
+ checkAssignmentOperator(rightType);
+ return getRegularTypeOfObjectLiteral(rightType);
+ }
+ case 27:
+ if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isEvalNode(right)) {
+ var sf = ts.getSourceFileOfNode(left);
+ var sourceText = sf.text;
+ var start_3 = ts.skipTrivia(sourceText, left.pos);
+ var isInDiag2657 = sf.parseDiagnostics.some(function (diag) {
+ if (diag.code !== ts.Diagnostics.JSX_expressions_must_have_one_parent_element.code)
return false;
+ return ts.textSpanContainsPosition(diag, start_3);
+ });
+ if (!isInDiag2657)
+ error(left, ts.Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects);
+ }
+ return rightType;
+ default:
+ return ts.Debug.fail();
+ }
+ function bothAreBigIntLike(left, right) {
+ return isTypeAssignableToKind(left, 2112) && isTypeAssignableToKind(right, 2112);
+ }
+ function checkAssignmentDeclaration(kind, rightType) {
+ if (kind === 2) {
+ for (var _i = 0, _a = getPropertiesOfObjectType(rightType); _i < _a.length; _i++) {
+ var prop = _a[_i];
+ var propType = getTypeOfSymbol(prop);
+ if (propType.symbol && propType.symbol.flags & 32) {
+ var name = prop.escapedName;
+ var symbol = resolveName(prop.valueDeclaration, name, 788968, undefined, name, false);
+ if (symbol && symbol.declarations.some(ts.isJSDocTypedefTag)) {
+ addDuplicateDeclarationErrorsForSymbols(symbol, ts.Diagnostics.Duplicate_identifier_0, ts.unescapeLeadingUnderscores(name), prop);
+ addDuplicateDeclarationErrorsForSymbols(prop, ts.Diagnostics.Duplicate_identifier_0, ts.unescapeLeadingUnderscores(name), symbol);
}
}
}
}
- return ts.forEachChild(childNode, check);
- });
- if (!functionIsUsedInBody) {
- error(condExpr, ts.Diagnostics.This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it_instead);
}
- }
- 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) {
- error(node, ts.Diagnostics.An_expression_of_type_void_cannot_be_tested_for_truthiness);
+ function isEvalNode(node) {
+ return node.kind === 78 && node.escapedText === "eval";
}
- return type;
- }
- function checkTruthinessExpression(node, checkMode) {
- return checkTruthinessOfType(checkExpression(node, checkMode), node);
- }
- function checkForStatement(node) {
- if (!checkGrammarStatementInAmbientContext(node)) {
- if (node.initializer && node.initializer.kind === 243) {
- checkGrammarVariableDeclarationList(node.initializer);
+ function checkForDisallowedESSymbolOperand(operator) {
+ var offendingSymbolOperand = maybeTypeOfKind(leftType, 12288) ? left :
+ maybeTypeOfKind(rightType, 12288) ? right :
+ undefined;
+ if (offendingSymbolOperand) {
+ error(offendingSymbolOperand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(operator));
+ return false;
}
+ return true;
}
- if (node.initializer) {
- if (node.initializer.kind === 243) {
- ts.forEach(node.initializer.declarations, checkVariableDeclaration);
- }
- else {
- checkExpression(node.initializer);
+ function getSuggestedBooleanOperator(operator) {
+ switch (operator) {
+ case 51:
+ case 73:
+ return 56;
+ case 52:
+ case 77:
+ return 37;
+ case 50:
+ case 72:
+ return 55;
+ default:
+ return undefined;
}
}
- if (node.condition)
- checkTruthinessExpression(node.condition);
- if (node.incrementor)
- checkExpression(node.incrementor);
- checkSourceElement(node.statement);
- if (node.locals) {
- registerForUnusedIdentifiersCheck(node);
+ function checkAssignmentOperator(valueType) {
+ if (produceDiagnostics && ts.isAssignmentOperator(operator)) {
+ if (checkReferenceExpression(left, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access)
+ && (!ts.isIdentifier(left) || ts.unescapeLeadingUnderscores(left.escapedText) !== "exports")) {
+ checkTypeAssignableToAndOptionallyElaborate(valueType, leftType, left, right);
+ }
+ }
}
- }
- function checkForOfStatement(node) {
- checkGrammarForInOrForOfStatement(node);
- if (node.awaitModifier) {
- var functionFlags = ts.getFunctionFlags(ts.getContainingFunction(node));
- if ((functionFlags & (4 | 2)) === 2 && languageVersion < 99) {
- checkExternalEmitHelpers(node, 32768);
+ function isAssignmentDeclaration(kind) {
+ var _a;
+ switch (kind) {
+ case 2:
+ return true;
+ case 1:
+ case 5:
+ case 6:
+ case 3:
+ case 4:
+ var symbol = getSymbolOfNode(left);
+ var init = ts.getAssignedExpandoInitializer(right);
+ return !!init && ts.isObjectLiteralExpression(init) &&
+ !!((_a = symbol === null || symbol === void 0 ? void 0 : symbol.exports) === null || _a === void 0 ? void 0 : _a.size);
+ default:
+ return false;
}
}
- else if (compilerOptions.downlevelIteration && languageVersion < 2) {
- checkExternalEmitHelpers(node, 256);
+ function reportOperatorErrorUnless(typesAreCompatible) {
+ if (!typesAreCompatible(leftType, rightType)) {
+ reportOperatorError(typesAreCompatible);
+ return true;
+ }
+ return false;
}
- if (node.initializer.kind === 243) {
- checkForInOrForOfVariableDeclaration(node);
+ function reportOperatorError(isRelated) {
+ var _a;
+ var wouldWorkWithAwait = false;
+ var errNode = errorNode || operatorToken;
+ if (isRelated) {
+ var awaitedLeftType = getAwaitedType(leftType);
+ var awaitedRightType = getAwaitedType(rightType);
+ wouldWorkWithAwait = !(awaitedLeftType === leftType && awaitedRightType === rightType)
+ && !!(awaitedLeftType && awaitedRightType)
+ && isRelated(awaitedLeftType, awaitedRightType);
+ }
+ var effectiveLeft = leftType;
+ var effectiveRight = rightType;
+ if (!wouldWorkWithAwait && isRelated) {
+ _a = getBaseTypesIfUnrelated(leftType, rightType, isRelated), effectiveLeft = _a[0], effectiveRight = _a[1];
+ }
+ var _b = getTypeNamesForErrorDisplay(effectiveLeft, effectiveRight), leftStr = _b[0], rightStr = _b[1];
+ if (!tryGiveBetterPrimaryError(errNode, wouldWorkWithAwait, leftStr, rightStr)) {
+ errorAndMaybeSuggestAwait(errNode, wouldWorkWithAwait, ts.Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, ts.tokenToString(operatorToken.kind), leftStr, rightStr);
+ }
}
- else {
- var varExpr = node.initializer;
- var iteratedType = checkRightHandSideOfForOf(node);
- if (varExpr.kind === 192 || varExpr.kind === 193) {
- checkDestructuringAssignment(varExpr, iteratedType || errorType);
+ function tryGiveBetterPrimaryError(errNode, maybeMissingAwait, leftStr, rightStr) {
+ var typeName;
+ switch (operatorToken.kind) {
+ case 36:
+ case 34:
+ typeName = "false";
+ break;
+ case 37:
+ case 35:
+ typeName = "true";
}
- else {
- var leftType = checkExpression(varExpr);
- checkReferenceExpression(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access);
- if (iteratedType) {
- checkTypeAssignableToAndOptionallyElaborate(iteratedType, leftType, varExpr, node.expression);
- }
+ if (typeName) {
+ return errorAndMaybeSuggestAwait(errNode, maybeMissingAwait, ts.Diagnostics.This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap, typeName, leftStr, rightStr);
}
+ return undefined;
}
- checkSourceElement(node.statement);
- if (node.locals) {
- registerForUnusedIdentifiersCheck(node);
+ }
+ function getBaseTypesIfUnrelated(leftType, rightType, isRelated) {
+ var effectiveLeft = leftType;
+ var effectiveRight = rightType;
+ var leftBase = getBaseTypeOfLiteralType(leftType);
+ var rightBase = getBaseTypeOfLiteralType(rightType);
+ if (!isRelated(leftBase, rightBase)) {
+ effectiveLeft = leftBase;
+ effectiveRight = rightBase;
}
+ return [effectiveLeft, effectiveRight];
}
- function checkForInStatement(node) {
- checkGrammarForInOrForOfStatement(node);
- var rightType = getNonNullableTypeIfNeeded(checkExpression(node.expression));
- if (node.initializer.kind === 243) {
- var variable = node.initializer.declarations[0];
- if (variable && ts.isBindingPattern(variable.name)) {
- error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
+ function checkYieldExpression(node) {
+ if (produceDiagnostics) {
+ if (!(node.flags & 8192)) {
+ grammarErrorOnFirstToken(node, ts.Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body);
}
- checkForInOrForOfVariableDeclaration(node);
- }
- else {
- var varExpr = node.initializer;
- var leftType = checkExpression(varExpr);
- if (varExpr.kind === 192 || varExpr.kind === 193) {
- error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
+ if (isInParameterInitializerBeforeContainingFunction(node)) {
+ error(node, ts.Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer);
}
- else if (!isTypeAssignableTo(getIndexTypeOrString(rightType), leftType)) {
- error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any);
+ }
+ var func = ts.getContainingFunction(node);
+ if (!func)
+ return anyType;
+ var functionFlags = ts.getFunctionFlags(func);
+ if (!(functionFlags & 1)) {
+ return anyType;
+ }
+ var isAsync = (functionFlags & 2) !== 0;
+ if (node.asteriskToken) {
+ if (isAsync && languageVersion < 99) {
+ checkExternalEmitHelpers(node, 53248);
}
- else {
- checkReferenceExpression(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access);
+ if (!isAsync && languageVersion < 2 && compilerOptions.downlevelIteration) {
+ checkExternalEmitHelpers(node, 256);
}
}
- if (rightType === neverType || !isTypeAssignableToKind(rightType, 67108864 | 58982400)) {
- error(node.expression, ts.Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0, typeToString(rightType));
+ var returnType = getReturnTypeFromAnnotation(func);
+ var iterationTypes = returnType && getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsync);
+ var signatureYieldType = iterationTypes && iterationTypes.yieldType || anyType;
+ var signatureNextType = iterationTypes && iterationTypes.nextType || anyType;
+ var resolvedSignatureNextType = isAsync ? getAwaitedType(signatureNextType) || anyType : signatureNextType;
+ var yieldExpressionType = node.expression ? checkExpression(node.expression) : undefinedWideningType;
+ var yieldedType = getYieldedTypeOfYieldExpression(node, yieldExpressionType, resolvedSignatureNextType, isAsync);
+ if (returnType && yieldedType) {
+ checkTypeAssignableToAndOptionallyElaborate(yieldedType, signatureYieldType, node.expression || node, node.expression);
}
- checkSourceElement(node.statement);
- if (node.locals) {
- registerForUnusedIdentifiersCheck(node);
+ if (node.asteriskToken) {
+ var use = isAsync ? 19 : 17;
+ return getIterationTypeOfIterable(use, 1, yieldExpressionType, node.expression)
+ || anyType;
}
- }
- function checkForInOrForOfVariableDeclaration(iterationStatement) {
- var variableDeclarationList = iterationStatement.initializer;
- if (variableDeclarationList.declarations.length >= 1) {
- var decl = variableDeclarationList.declarations[0];
- checkVariableDeclaration(decl);
+ else if (returnType) {
+ return getIterationTypeOfGeneratorFunctionReturnType(2, returnType, isAsync)
+ || anyType;
}
+ return getContextualIterationType(2, func) || anyType;
}
- function checkRightHandSideOfForOf(statement) {
- var use = statement.awaitModifier ? 15 : 13;
- return checkIteratedTypeOrElementType(use, checkNonNullExpression(statement.expression), undefinedType, statement.expression);
+ function checkConditionalExpression(node, checkMode) {
+ var type = checkTruthinessExpression(node.condition);
+ checkTestingKnownTruthyCallableType(node.condition, node.whenTrue, type);
+ var type1 = checkExpression(node.whenTrue, checkMode);
+ var type2 = checkExpression(node.whenFalse, checkMode);
+ return getUnionType([type1, type2], 2);
}
- function checkIteratedTypeOrElementType(use, inputType, sentType, errorNode) {
- if (isTypeAny(inputType)) {
- return inputType;
+ function checkTemplateExpression(node) {
+ var texts = [node.head.text];
+ var types = [];
+ for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) {
+ var span = _a[_i];
+ var type = checkExpression(span.expression);
+ if (maybeTypeOfKind(type, 12288)) {
+ error(span.expression, ts.Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String);
+ }
+ texts.push(span.literal.text);
+ types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
}
- return getIteratedTypeOrElementType(use, inputType, sentType, errorNode, true) || anyType;
+ return isConstContext(node) ? getTemplateLiteralType(texts, types) : stringType;
}
- function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) {
- var allowAsyncIterables = (use & 2) !== 0;
- if (inputType === neverType) {
- reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
- return undefined;
+ function getContextNode(node) {
+ if (node.kind === 281 && !ts.isJsxSelfClosingElement(node.parent)) {
+ return node.parent.parent;
}
- var uplevelIteration = languageVersion >= 2;
- var downlevelIteration = !uplevelIteration && compilerOptions.downlevelIteration;
- if (uplevelIteration || downlevelIteration || allowAsyncIterables) {
- var iterationTypes = getIterationTypesOfIterable(inputType, use, uplevelIteration ? errorNode : undefined);
- if (checkAssignability) {
- if (iterationTypes) {
- var diagnostic = use & 8 ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 :
- use & 32 ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 :
- use & 64 ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 :
- use & 16 ? ts.Diagnostics.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 :
- undefined;
- if (diagnostic) {
- checkTypeAssignableTo(sentType, iterationTypes.nextType, errorNode, diagnostic);
- }
- }
- }
- if (iterationTypes || uplevelIteration) {
- return iterationTypes && iterationTypes.yieldType;
+ return node;
+ }
+ function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
+ var context = getContextNode(node);
+ var saveContextualType = context.contextualType;
+ var saveInferenceContext = context.inferenceContext;
+ try {
+ context.contextualType = contextualType;
+ context.inferenceContext = inferenceContext;
+ var type = checkExpression(node, checkMode | 1 | (inferenceContext ? 2 : 0));
+ var result = maybeTypeOfKind(type, 2944) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node)) ?
+ getRegularTypeOfLiteralType(type) : type;
+ return result;
+ }
+ finally {
+ context.contextualType = saveContextualType;
+ context.inferenceContext = saveInferenceContext;
+ }
+ }
+ function checkExpressionCached(node, checkMode) {
+ var links = getNodeLinks(node);
+ if (!links.resolvedType) {
+ if (checkMode && checkMode !== 0) {
+ return checkExpression(node, checkMode);
}
+ var saveFlowLoopStart = flowLoopStart;
+ var saveFlowTypeCache = flowTypeCache;
+ flowLoopStart = flowLoopCount;
+ flowTypeCache = undefined;
+ links.resolvedType = checkExpression(node, checkMode);
+ flowTypeCache = saveFlowTypeCache;
+ flowLoopStart = saveFlowLoopStart;
}
- var arrayType = inputType;
- var reportedError = false;
- var hasStringConstituent = false;
- if (use & 4) {
- if (arrayType.flags & 1048576) {
- var arrayTypes = inputType.types;
- var filteredTypes = ts.filter(arrayTypes, function (t) { return !(t.flags & 132); });
- if (filteredTypes !== arrayTypes) {
- arrayType = getUnionType(filteredTypes, 2);
+ return links.resolvedType;
+ }
+ function isTypeAssertion(node) {
+ node = ts.skipParentheses(node);
+ return node.kind === 206 || node.kind === 224;
+ }
+ function checkDeclarationInitializer(declaration, contextualType) {
+ var initializer = ts.getEffectiveInitializer(declaration);
+ var type = getQuickTypeOfExpression(initializer) ||
+ (contextualType ? checkExpressionWithContextualType(initializer, contextualType, undefined, 0) : checkExpressionCached(initializer));
+ return ts.isParameter(declaration) && declaration.name.kind === 197 &&
+ isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ?
+ padTupleType(type, declaration.name) : type;
+ }
+ function padTupleType(type, pattern) {
+ var patternElements = pattern.elements;
+ var elementTypes = getTypeArguments(type).slice();
+ var elementFlags = type.target.elementFlags.slice();
+ for (var i = getTypeReferenceArity(type); i < patternElements.length; i++) {
+ var e = patternElements[i];
+ if (i < patternElements.length - 1 || !(e.kind === 198 && e.dotDotDotToken)) {
+ elementTypes.push(!ts.isOmittedExpression(e) && hasDefaultValue(e) ? getTypeFromBindingElement(e, false, false) : anyType);
+ elementFlags.push(2);
+ if (!ts.isOmittedExpression(e) && !hasDefaultValue(e)) {
+ reportImplicitAny(e, anyType);
}
}
- else if (arrayType.flags & 132) {
- arrayType = neverType;
+ }
+ return createTupleType(elementTypes, elementFlags, type.target.readonly);
+ }
+ function widenTypeInferredFromInitializer(declaration, type) {
+ var widened = ts.getCombinedNodeFlags(declaration) & 2 || ts.isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type);
+ if (ts.isInJSFile(declaration)) {
+ if (widened.flags & 98304) {
+ reportImplicitAny(declaration, anyType);
+ return anyType;
}
- hasStringConstituent = arrayType !== inputType;
- if (hasStringConstituent) {
- if (languageVersion < 1) {
- if (errorNode) {
- error(errorNode, ts.Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher);
- reportedError = true;
- }
- }
- if (arrayType.flags & 131072) {
- return stringType;
- }
+ else if (isEmptyArrayLiteralType(widened)) {
+ reportImplicitAny(declaration, anyArrayType);
+ return anyArrayType;
}
}
- if (!isArrayLikeType(arrayType)) {
- if (errorNode && !reportedError) {
- var yieldType = getIterationTypeOfIterable(use, 0, inputType, undefined);
- var _a = !(use & 4) || hasStringConstituent
- ? downlevelIteration
- ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true]
- : yieldType
- ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators, false]
- : [ts.Diagnostics.Type_0_is_not_an_array_type, true]
- : downlevelIteration
- ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true]
- : yieldType
- ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators, false]
- : [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type, true], defaultDiagnostic = _a[0], maybeMissingAwait = _a[1];
- errorAndMaybeSuggestAwait(errorNode, maybeMissingAwait && !!getAwaitedTypeOfPromise(arrayType), defaultDiagnostic, typeToString(arrayType));
+ return widened;
+ }
+ function isLiteralOfContextualType(candidateType, contextualType) {
+ if (contextualType) {
+ if (contextualType.flags & 3145728) {
+ var types = contextualType.types;
+ return ts.some(types, function (t) { return isLiteralOfContextualType(candidateType, t); });
}
- return hasStringConstituent ? stringType : undefined;
- }
- var arrayElementType = getIndexTypeOfType(arrayType, 1);
- if (hasStringConstituent && arrayElementType) {
- if (arrayElementType.flags & 132) {
- return stringType;
+ if (contextualType.flags & 58982400) {
+ var constraint = getBaseConstraintOfType(contextualType) || unknownType;
+ return maybeTypeOfKind(constraint, 4) && maybeTypeOfKind(candidateType, 128) ||
+ maybeTypeOfKind(constraint, 8) && maybeTypeOfKind(candidateType, 256) ||
+ maybeTypeOfKind(constraint, 64) && maybeTypeOfKind(candidateType, 2048) ||
+ maybeTypeOfKind(constraint, 4096) && maybeTypeOfKind(candidateType, 8192) ||
+ isLiteralOfContextualType(candidateType, constraint);
}
- return getUnionType([arrayElementType, stringType], 2);
+ return !!(contextualType.flags & (128 | 4194304 | 134217728 | 268435456) && maybeTypeOfKind(candidateType, 128) ||
+ contextualType.flags & 256 && maybeTypeOfKind(candidateType, 256) ||
+ contextualType.flags & 2048 && maybeTypeOfKind(candidateType, 2048) ||
+ contextualType.flags & 512 && maybeTypeOfKind(candidateType, 512) ||
+ contextualType.flags & 8192 && maybeTypeOfKind(candidateType, 8192));
}
- return arrayElementType;
+ return false;
}
- function getIterationTypeOfIterable(use, typeKind, inputType, errorNode) {
- if (isTypeAny(inputType)) {
- return undefined;
+ function isConstContext(node) {
+ var parent = node.parent;
+ return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) ||
+ (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) ||
+ (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent) || ts.isTemplateSpan(parent)) && isConstContext(parent.parent);
+ }
+ function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) {
+ var type = checkExpression(node, checkMode, forceTuple);
+ return isConstContext(node) ? getRegularTypeOfLiteralType(type) :
+ isTypeAssertion(node) ? type :
+ getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node));
+ }
+ function checkPropertyAssignment(node, checkMode) {
+ if (node.name.kind === 158) {
+ checkComputedPropertyName(node.name);
}
- var iterationTypes = getIterationTypesOfIterable(inputType, use, errorNode);
- return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(typeKind)];
+ return checkExpressionForMutableLocation(node.initializer, checkMode);
}
- function createIterationTypes(yieldType, returnType, nextType) {
- if (yieldType === void 0) { yieldType = neverType; }
- if (returnType === void 0) { returnType = neverType; }
- if (nextType === void 0) { nextType = unknownType; }
- if (yieldType.flags & 67359327 &&
- returnType.flags & (1 | 131072 | 2 | 16384 | 32768) &&
- nextType.flags & (1 | 131072 | 2 | 16384 | 32768)) {
- var id = getTypeListId([yieldType, returnType, nextType]);
- var iterationTypes = iterationTypesCache.get(id);
- if (!iterationTypes) {
- iterationTypes = { yieldType: yieldType, returnType: returnType, nextType: nextType };
- iterationTypesCache.set(id, iterationTypes);
- }
- return iterationTypes;
+ function checkObjectLiteralMethod(node, checkMode) {
+ checkGrammarMethod(node);
+ if (node.name.kind === 158) {
+ checkComputedPropertyName(node.name);
}
- return { yieldType: yieldType, returnType: returnType, nextType: nextType };
+ var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, checkMode);
+ return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
}
- function combineIterationTypes(array) {
- var yieldTypes;
- var returnTypes;
- var nextTypes;
- for (var _i = 0, array_10 = array; _i < array_10.length; _i++) {
- var iterationTypes = array_10[_i];
- if (iterationTypes === undefined || iterationTypes === noIterationTypes) {
- continue;
- }
- if (iterationTypes === anyIterationTypes) {
- return anyIterationTypes;
+ function instantiateTypeWithSingleGenericCallSignature(node, type, checkMode) {
+ if (checkMode && checkMode & (2 | 8)) {
+ var callSignature = getSingleSignature(type, 0, true);
+ var constructSignature = getSingleSignature(type, 1, true);
+ var signature = callSignature || constructSignature;
+ if (signature && signature.typeParameters) {
+ var contextualType = getApparentTypeOfContextualType(node, 2);
+ if (contextualType) {
+ var contextualSignature = getSingleSignature(getNonNullableType(contextualType), callSignature ? 0 : 1, false);
+ if (contextualSignature && !contextualSignature.typeParameters) {
+ if (checkMode & 8) {
+ skippedGenericFunction(node, checkMode);
+ return anyFunctionType;
+ }
+ var context = getInferenceContext(node);
+ var returnType = context.signature && getReturnTypeOfSignature(context.signature);
+ var returnSignature = returnType && getSingleCallOrConstructSignature(returnType);
+ if (returnSignature && !returnSignature.typeParameters && !ts.every(context.inferences, hasInferenceCandidates)) {
+ var uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
+ var instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
+ var inferences_3 = ts.map(context.inferences, function (info) { return createInferenceInfo(info.typeParameter); });
+ applyToParameterTypes(instantiatedSignature, contextualSignature, function (source, target) {
+ inferTypes(inferences_3, source, target, 0, true);
+ });
+ if (ts.some(inferences_3, hasInferenceCandidates)) {
+ applyToReturnTypes(instantiatedSignature, contextualSignature, function (source, target) {
+ inferTypes(inferences_3, source, target);
+ });
+ if (!hasOverlappingInferences(context.inferences, inferences_3)) {
+ mergeInferences(context.inferences, inferences_3);
+ context.inferredTypeParameters = ts.concatenate(context.inferredTypeParameters, uniqueTypeParameters);
+ return getOrCreateTypeFromSignature(instantiatedSignature);
+ }
+ }
+ }
+ return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
+ }
+ }
}
- yieldTypes = ts.append(yieldTypes, iterationTypes.yieldType);
- returnTypes = ts.append(returnTypes, iterationTypes.returnType);
- nextTypes = ts.append(nextTypes, iterationTypes.nextType);
}
- if (yieldTypes || returnTypes || nextTypes) {
- return createIterationTypes(yieldTypes && getUnionType(yieldTypes), returnTypes && getUnionType(returnTypes), nextTypes && getIntersectionType(nextTypes));
- }
- return noIterationTypes;
+ return type;
}
- function getCachedIterationTypes(type, cacheKey) {
- return type[cacheKey];
+ function skippedGenericFunction(node, checkMode) {
+ if (checkMode & 2) {
+ var context = getInferenceContext(node);
+ context.flags |= 4;
+ }
}
- function setCachedIterationTypes(type, cacheKey, cachedTypes) {
- return type[cacheKey] = cachedTypes;
+ function hasInferenceCandidates(info) {
+ return !!(info.candidates || info.contraCandidates);
}
- function getIterationTypesOfIterable(type, use, errorNode) {
- if (isTypeAny(type)) {
- return anyIterationTypes;
- }
- if (!(type.flags & 1048576)) {
- var iterationTypes_1 = getIterationTypesOfIterableWorker(type, use, errorNode);
- if (iterationTypes_1 === noIterationTypes) {
- if (errorNode) {
- reportTypeNotIterableError(errorNode, type, !!(use & 2));
- }
- return undefined;
- }
- return iterationTypes_1;
- }
- var cacheKey = use & 2 ? "iterationTypesOfAsyncIterable" : "iterationTypesOfIterable";
- var cachedTypes = getCachedIterationTypes(type, cacheKey);
- if (cachedTypes)
- return cachedTypes === noIterationTypes ? undefined : cachedTypes;
- var allIterationTypes;
- for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
- var constituent = _a[_i];
- var iterationTypes_2 = getIterationTypesOfIterableWorker(constituent, use, errorNode);
- if (iterationTypes_2 === noIterationTypes) {
- if (errorNode) {
- reportTypeNotIterableError(errorNode, type, !!(use & 2));
- errorNode = undefined;
- }
- }
- else {
- allIterationTypes = ts.append(allIterationTypes, iterationTypes_2);
+ function hasOverlappingInferences(a, b) {
+ for (var i = 0; i < a.length; i++) {
+ if (hasInferenceCandidates(a[i]) && hasInferenceCandidates(b[i])) {
+ return true;
}
}
- var iterationTypes = allIterationTypes ? combineIterationTypes(allIterationTypes) : noIterationTypes;
- setCachedIterationTypes(type, cacheKey, iterationTypes);
- return iterationTypes === noIterationTypes ? undefined : iterationTypes;
- }
- function getAsyncFromSyncIterationTypes(iterationTypes, errorNode) {
- if (iterationTypes === noIterationTypes)
- return noIterationTypes;
- if (iterationTypes === anyIterationTypes)
- return anyIterationTypes;
- var yieldType = iterationTypes.yieldType, returnType = iterationTypes.returnType, nextType = iterationTypes.nextType;
- return createIterationTypes(getAwaitedType(yieldType, errorNode) || anyType, getAwaitedType(returnType, errorNode) || anyType, nextType);
+ return false;
}
- function getIterationTypesOfIterableWorker(type, use, errorNode) {
- if (isTypeAny(type)) {
- return anyIterationTypes;
- }
- if (use & 2) {
- var iterationTypes = getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) ||
- getIterationTypesOfIterableFast(type, asyncIterationTypesResolver);
- if (iterationTypes) {
- return iterationTypes;
+ function mergeInferences(target, source) {
+ for (var i = 0; i < target.length; i++) {
+ if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
+ target[i] = source[i];
}
}
- if (use & 1) {
- var iterationTypes = getIterationTypesOfIterableCached(type, syncIterationTypesResolver) ||
- getIterationTypesOfIterableFast(type, syncIterationTypesResolver);
- if (iterationTypes) {
- if (use & 2) {
- if (iterationTypes !== noIterationTypes) {
- return setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", getAsyncFromSyncIterationTypes(iterationTypes, errorNode));
- }
- }
- else {
- return iterationTypes;
- }
+ }
+ function getUniqueTypeParameters(context, typeParameters) {
+ var result = [];
+ var oldTypeParameters;
+ var newTypeParameters;
+ for (var _i = 0, typeParameters_2 = typeParameters; _i < typeParameters_2.length; _i++) {
+ var tp = typeParameters_2[_i];
+ var name = tp.symbol.escapedName;
+ if (hasTypeParameterByName(context.inferredTypeParameters, name) || hasTypeParameterByName(result, name)) {
+ var newName = getUniqueTypeParameterName(ts.concatenate(context.inferredTypeParameters, result), name);
+ var symbol = createSymbol(262144, newName);
+ var newTypeParameter = createTypeParameter(symbol);
+ newTypeParameter.target = tp;
+ oldTypeParameters = ts.append(oldTypeParameters, tp);
+ newTypeParameters = ts.append(newTypeParameters, newTypeParameter);
+ result.push(newTypeParameter);
}
- }
- if (use & 2) {
- var iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode);
- if (iterationTypes !== noIterationTypes) {
- return iterationTypes;
+ else {
+ result.push(tp);
}
}
- if (use & 1) {
- var iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode);
- if (iterationTypes !== noIterationTypes) {
- if (use & 2) {
- return setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes
- ? getAsyncFromSyncIterationTypes(iterationTypes, errorNode)
- : noIterationTypes);
- }
- else {
- return iterationTypes;
- }
+ if (newTypeParameters) {
+ var mapper = createTypeMapper(oldTypeParameters, newTypeParameters);
+ for (var _a = 0, newTypeParameters_1 = newTypeParameters; _a < newTypeParameters_1.length; _a++) {
+ var tp = newTypeParameters_1[_a];
+ tp.mapper = mapper;
}
}
- return noIterationTypes;
- }
- function getIterationTypesOfIterableCached(type, resolver) {
- return getCachedIterationTypes(type, resolver.iterableCacheKey);
+ return result;
}
- function getIterationTypesOfGlobalIterableType(globalType, resolver) {
- var globalIterationTypes = getIterationTypesOfIterableCached(globalType, resolver) ||
- getIterationTypesOfIterableSlow(globalType, resolver, undefined);
- return globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
+ function hasTypeParameterByName(typeParameters, name) {
+ return ts.some(typeParameters, function (tp) { return tp.symbol.escapedName === name; });
}
- function getIterationTypesOfIterableFast(type, resolver) {
- var globalType;
- if (isReferenceToType(type, globalType = resolver.getGlobalIterableType(false)) ||
- isReferenceToType(type, globalType = resolver.getGlobalIterableIteratorType(false))) {
- var yieldType = getTypeArguments(type)[0];
- var _a = getIterationTypesOfGlobalIterableType(globalType, resolver), returnType = _a.returnType, nextType = _a.nextType;
- return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(yieldType, returnType, nextType));
- }
- if (isReferenceToType(type, resolver.getGlobalGeneratorType(false))) {
- var _b = getTypeArguments(type), yieldType = _b[0], returnType = _b[1], nextType = _b[2];
- return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(yieldType, returnType, nextType));
+ function getUniqueTypeParameterName(typeParameters, baseName) {
+ var len = baseName.length;
+ while (len > 1 && baseName.charCodeAt(len - 1) >= 48 && baseName.charCodeAt(len - 1) <= 57)
+ len--;
+ var s = baseName.slice(0, len);
+ for (var index = 1; true; index++) {
+ var augmentedName = (s + index);
+ if (!hasTypeParameterByName(typeParameters, augmentedName)) {
+ return augmentedName;
+ }
}
}
- function getIterationTypesOfIterableSlow(type, resolver, errorNode) {
- var _a;
- var method = getPropertyOfType(type, ts.getPropertyNameForKnownSymbolName(resolver.iteratorSymbolName));
- var methodType = method && !(method.flags & 16777216) ? getTypeOfSymbol(method) : undefined;
- if (isTypeAny(methodType)) {
- return setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes);
- }
- var signatures = methodType ? getSignaturesOfType(methodType, 0) : undefined;
- if (!ts.some(signatures)) {
- return setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes);
+ function getReturnTypeOfSingleNonGenericCallSignature(funcType) {
+ var signature = getSingleCallSignature(funcType);
+ if (signature && !signature.typeParameters) {
+ return getReturnTypeOfSignature(signature);
}
- var iteratorType = getUnionType(ts.map(signatures, getReturnTypeOfSignature), 2);
- var iterationTypes = (_a = getIterationTypesOfIterator(iteratorType, resolver, errorNode)) !== null && _a !== void 0 ? _a : noIterationTypes;
- return setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes);
}
- function reportTypeNotIterableError(errorNode, type, allowAsyncIterables) {
- var message = allowAsyncIterables
- ? ts.Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator
- : ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator;
- errorAndMaybeSuggestAwait(errorNode, !!getAwaitedTypeOfPromise(type), message, typeToString(type));
+ function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) {
+ var funcType = checkExpression(expr.expression);
+ var nonOptionalType = getOptionalExpressionType(funcType, expr.expression);
+ var returnType = getReturnTypeOfSingleNonGenericCallSignature(funcType);
+ return returnType && propagateOptionalTypeMarker(returnType, expr, nonOptionalType !== funcType);
}
- function getIterationTypesOfIterator(type, resolver, errorNode) {
- if (isTypeAny(type)) {
- return anyIterationTypes;
+ function getTypeOfExpression(node) {
+ var quickType = getQuickTypeOfExpression(node);
+ if (quickType) {
+ return quickType;
}
- var iterationTypes = getIterationTypesOfIteratorCached(type, resolver) ||
- getIterationTypesOfIteratorFast(type, resolver) ||
- getIterationTypesOfIteratorSlow(type, resolver, errorNode);
- return iterationTypes === noIterationTypes ? undefined : iterationTypes;
- }
- function getIterationTypesOfIteratorCached(type, resolver) {
- return getCachedIterationTypes(type, resolver.iteratorCacheKey);
- }
- function getIterationTypesOfIteratorFast(type, resolver) {
- var globalType = resolver.getGlobalIterableIteratorType(false);
- if (isReferenceToType(type, globalType)) {
- var yieldType = getTypeArguments(type)[0];
- var globalIterationTypes = getIterationTypesOfIteratorCached(globalType, resolver) ||
- getIterationTypesOfIteratorSlow(globalType, resolver, undefined);
- var _a = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes, returnType = _a.returnType, nextType = _a.nextType;
- return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
+ if (node.flags & 67108864 && flowTypeCache) {
+ var cachedType = flowTypeCache[getNodeId(node)];
+ if (cachedType) {
+ return cachedType;
+ }
}
- if (isReferenceToType(type, resolver.getGlobalIteratorType(false)) ||
- isReferenceToType(type, resolver.getGlobalGeneratorType(false))) {
- var _b = getTypeArguments(type), yieldType = _b[0], returnType = _b[1], nextType = _b[2];
- return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
+ var startInvocationCount = flowInvocationCount;
+ var type = checkExpression(node);
+ if (flowInvocationCount !== startInvocationCount) {
+ var cache = flowTypeCache || (flowTypeCache = []);
+ cache[getNodeId(node)] = type;
+ ts.setNodeFlags(node, node.flags | 67108864);
}
+ return type;
}
- function isIteratorResult(type, kind) {
- var doneType = getTypeOfPropertyOfType(type, "done") || falseType;
- return isTypeAssignableTo(kind === 0 ? falseType : trueType, doneType);
- }
- function isYieldIteratorResult(type) {
- return isIteratorResult(type, 0);
- }
- function isReturnIteratorResult(type) {
- return isIteratorResult(type, 1);
- }
- function getIterationTypesOfIteratorResult(type) {
- if (isTypeAny(type)) {
- return anyIterationTypes;
+ function getQuickTypeOfExpression(node) {
+ var expr = ts.skipParentheses(node);
+ if (ts.isCallExpression(expr) && expr.expression.kind !== 105 && !ts.isRequireCall(expr, true) && !isSymbolOrSymbolForCall(expr)) {
+ var type = ts.isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) :
+ getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression));
+ if (type) {
+ return type;
+ }
}
- var cachedTypes = getCachedIterationTypes(type, "iterationTypesOfIteratorResult");
- if (cachedTypes) {
- return cachedTypes;
+ else if (ts.isAssertionExpression(expr) && !ts.isConstTypeReference(expr.type)) {
+ return getTypeFromTypeNode(expr.type);
}
- if (isReferenceToType(type, getGlobalIteratorYieldResultType(false))) {
- var yieldType_1 = getTypeArguments(type)[0];
- return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType_1, undefined, undefined));
+ else if (node.kind === 8 || node.kind === 10 ||
+ node.kind === 109 || node.kind === 94) {
+ return checkExpression(node);
}
- if (isReferenceToType(type, getGlobalIteratorReturnResultType(false))) {
- var returnType_1 = getTypeArguments(type)[0];
- return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(undefined, returnType_1, undefined));
+ return undefined;
+ }
+ function getContextFreeTypeOfExpression(node) {
+ var links = getNodeLinks(node);
+ if (links.contextFreeType) {
+ return links.contextFreeType;
}
- var yieldIteratorResult = filterType(type, isYieldIteratorResult);
- var yieldType = yieldIteratorResult !== neverType ? getTypeOfPropertyOfType(yieldIteratorResult, "value") : undefined;
- var returnIteratorResult = filterType(type, isReturnIteratorResult);
- var returnType = returnIteratorResult !== neverType ? getTypeOfPropertyOfType(returnIteratorResult, "value") : undefined;
- if (!yieldType && !returnType) {
- return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", noIterationTypes);
+ var saveContextualType = node.contextualType;
+ node.contextualType = anyType;
+ try {
+ var type = links.contextFreeType = checkExpression(node, 4);
+ return type;
}
- return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType, returnType || voidType, undefined));
- }
- function getIterationTypesOfMethod(type, resolver, methodName, errorNode) {
- var method = getPropertyOfType(type, methodName);
- if (!method && methodName !== "next") {
- return undefined;
+ finally {
+ node.contextualType = saveContextualType;
}
- var methodType = method && !(methodName === "next" && (method.flags & 16777216))
- ? methodName === "next" ? getTypeOfSymbol(method) : getTypeWithFacts(getTypeOfSymbol(method), 2097152)
- : undefined;
- if (isTypeAny(methodType)) {
- return methodName === "next" ? anyIterationTypes : anyIterationTypesExceptNext;
+ }
+ function checkExpression(node, checkMode, forceTuple) {
+ ts.tracing.push("check", "checkExpression", { kind: node.kind, pos: node.pos, end: node.end });
+ var saveCurrentNode = currentNode;
+ currentNode = node;
+ instantiationCount = 0;
+ var uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple);
+ var type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
+ if (isConstEnumObjectType(type)) {
+ checkConstEnumAccess(node, type);
}
- var methodSignatures = methodType ? getSignaturesOfType(methodType, 0) : ts.emptyArray;
- if (methodSignatures.length === 0) {
- if (errorNode) {
- var diagnostic = methodName === "next"
- ? resolver.mustHaveANextMethodDiagnostic
- : resolver.mustBeAMethodDiagnostic;
- error(errorNode, diagnostic, methodName);
- }
- return methodName === "next" ? anyIterationTypes : undefined;
+ currentNode = saveCurrentNode;
+ ts.tracing.pop();
+ return type;
+ }
+ function checkConstEnumAccess(node, type) {
+ var ok = (node.parent.kind === 201 && node.parent.expression === node) ||
+ (node.parent.kind === 202 && node.parent.expression === node) ||
+ ((node.kind === 78 || node.kind === 157) && isInRightSideOfImportOrExportAssignment(node) ||
+ (node.parent.kind === 176 && node.parent.exprName === node)) ||
+ (node.parent.kind === 270);
+ if (!ok) {
+ error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query);
}
- var methodParameterTypes;
- var methodReturnTypes;
- for (var _i = 0, methodSignatures_1 = methodSignatures; _i < methodSignatures_1.length; _i++) {
- var signature = methodSignatures_1[_i];
- if (methodName !== "throw" && ts.some(signature.parameters)) {
- methodParameterTypes = ts.append(methodParameterTypes, getTypeAtPosition(signature, 0));
+ if (compilerOptions.isolatedModules) {
+ ts.Debug.assert(!!(type.symbol.flags & 128));
+ var constEnumDeclaration = type.symbol.valueDeclaration;
+ if (constEnumDeclaration.flags & 8388608) {
+ error(node, ts.Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided);
}
- methodReturnTypes = ts.append(methodReturnTypes, getReturnTypeOfSignature(signature));
}
- var returnTypes;
- var nextType;
- if (methodName !== "throw") {
- var methodParameterType = methodParameterTypes ? getUnionType(methodParameterTypes) : unknownType;
- if (methodName === "next") {
- nextType = methodParameterType;
- }
- else if (methodName === "return") {
- var resolvedMethodParameterType = resolver.resolveIterationType(methodParameterType, errorNode) || anyType;
- returnTypes = ts.append(returnTypes, resolvedMethodParameterType);
- }
+ }
+ function checkParenthesizedExpression(node, checkMode) {
+ var tag = ts.isInJSFile(node) ? ts.getJSDocTypeTag(node) : undefined;
+ if (tag) {
+ return checkAssertionWorker(tag, tag.typeExpression.type, node.expression, checkMode);
}
- var yieldType;
- var methodReturnType = methodReturnTypes ? getUnionType(methodReturnTypes, 2) : neverType;
- var resolvedMethodReturnType = resolver.resolveIterationType(methodReturnType, errorNode) || anyType;
- var iterationTypes = getIterationTypesOfIteratorResult(resolvedMethodReturnType);
- if (iterationTypes === noIterationTypes) {
- if (errorNode) {
- error(errorNode, resolver.mustHaveAValueDiagnostic, methodName);
+ return checkExpression(node.expression, checkMode);
+ }
+ function checkExpressionWorker(node, checkMode, forceTuple) {
+ var kind = node.kind;
+ if (cancellationToken) {
+ switch (kind) {
+ case 221:
+ case 208:
+ case 209:
+ cancellationToken.throwIfCancellationRequested();
}
- yieldType = anyType;
- returnTypes = ts.append(returnTypes, anyType);
}
- else {
- yieldType = iterationTypes.yieldType;
- returnTypes = ts.append(returnTypes, iterationTypes.returnType);
+ switch (kind) {
+ case 78:
+ return checkIdentifier(node);
+ case 107:
+ return checkThisExpression(node);
+ case 105:
+ return checkSuperExpression(node);
+ case 103:
+ return nullWideningType;
+ case 14:
+ case 10:
+ return getFreshTypeOfLiteralType(getLiteralType(node.text));
+ case 8:
+ checkGrammarNumericLiteral(node);
+ return getFreshTypeOfLiteralType(getLiteralType(+node.text));
+ case 9:
+ checkGrammarBigIntLiteral(node);
+ return getFreshTypeOfLiteralType(getBigIntLiteralType(node));
+ case 109:
+ return trueType;
+ case 94:
+ return falseType;
+ case 218:
+ return checkTemplateExpression(node);
+ case 13:
+ return globalRegExpType;
+ case 199:
+ return checkArrayLiteral(node, checkMode, forceTuple);
+ case 200:
+ return checkObjectLiteral(node, checkMode);
+ case 201:
+ return checkPropertyAccessExpression(node);
+ case 157:
+ return checkQualifiedName(node);
+ case 202:
+ return checkIndexedAccess(node);
+ case 203:
+ if (node.expression.kind === 99) {
+ return checkImportCallExpression(node);
+ }
+ case 204:
+ return checkCallExpression(node, checkMode);
+ case 205:
+ return checkTaggedTemplateExpression(node);
+ case 207:
+ return checkParenthesizedExpression(node, checkMode);
+ case 221:
+ return checkClassExpression(node);
+ case 208:
+ case 209:
+ return checkFunctionExpressionOrObjectLiteralMethod(node, checkMode);
+ case 211:
+ return checkTypeOfExpression(node);
+ case 206:
+ case 224:
+ return checkAssertion(node);
+ case 225:
+ return checkNonNullAssertion(node);
+ case 226:
+ return checkMetaProperty(node);
+ case 210:
+ return checkDeleteExpression(node);
+ case 212:
+ return checkVoidExpression(node);
+ case 213:
+ return checkAwaitExpression(node);
+ case 214:
+ return checkPrefixUnaryExpression(node);
+ case 215:
+ return checkPostfixUnaryExpression(node);
+ case 216:
+ return checkBinaryExpression(node, checkMode);
+ case 217:
+ return checkConditionalExpression(node, checkMode);
+ case 220:
+ return checkSpreadExpression(node, checkMode);
+ case 222:
+ return undefinedWideningType;
+ case 219:
+ return checkYieldExpression(node);
+ case 227:
+ return checkSyntheticExpression(node);
+ case 283:
+ return checkJsxExpression(node, checkMode);
+ case 273:
+ return checkJsxElement(node, checkMode);
+ case 274:
+ return checkJsxSelfClosingElement(node, checkMode);
+ case 277:
+ return checkJsxFragment(node);
+ case 281:
+ return checkJsxAttributes(node, checkMode);
+ case 275:
+ ts.Debug.fail("Shouldn't ever directly check a JsxOpeningElement");
}
- return createIterationTypes(yieldType, getUnionType(returnTypes), nextType);
- }
- function getIterationTypesOfIteratorSlow(type, resolver, errorNode) {
- var iterationTypes = combineIterationTypes([
- getIterationTypesOfMethod(type, resolver, "next", errorNode),
- getIterationTypesOfMethod(type, resolver, "return", errorNode),
- getIterationTypesOfMethod(type, resolver, "throw", errorNode),
- ]);
- return setCachedIterationTypes(type, resolver.iteratorCacheKey, iterationTypes);
+ return errorType;
}
- function getIterationTypeOfGeneratorFunctionReturnType(kind, returnType, isAsyncGenerator) {
- if (isTypeAny(returnType)) {
- return undefined;
+ function checkTypeParameter(node) {
+ if (node.expression) {
+ grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected);
}
- var iterationTypes = getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsyncGenerator);
- return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(kind)];
- }
- function getIterationTypesOfGeneratorFunctionReturnType(type, isAsyncGenerator) {
- if (isTypeAny(type)) {
- return anyIterationTypes;
+ checkSourceElement(node.constraint);
+ checkSourceElement(node.default);
+ var typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
+ getBaseConstraintOfType(typeParameter);
+ if (!hasNonCircularTypeParameterDefault(typeParameter)) {
+ error(node.default, ts.Diagnostics.Type_parameter_0_has_a_circular_default, typeToString(typeParameter));
}
- var use = isAsyncGenerator ? 2 : 1;
- var resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
- return getIterationTypesOfIterable(type, use, undefined) ||
- getIterationTypesOfIterator(type, resolver, undefined);
- }
- function checkBreakOrContinueStatement(node) {
- if (!checkGrammarStatementInAmbientContext(node))
- checkGrammarBreakOrContinueStatement(node);
- }
- function unwrapReturnType(returnType, functionFlags) {
- var _a, _b;
- var isGenerator = !!(functionFlags & 1);
- var isAsync = !!(functionFlags & 2);
- return isGenerator ? (_a = getIterationTypeOfGeneratorFunctionReturnType(1, returnType, isAsync)) !== null && _a !== void 0 ? _a : errorType :
- isAsync ? (_b = getAwaitedType(returnType)) !== null && _b !== void 0 ? _b : errorType :
- returnType;
- }
- function isUnwrappedReturnTypeVoidOrAny(func, returnType) {
- var unwrappedReturnType = unwrapReturnType(returnType, ts.getFunctionFlags(func));
- return !!unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, 16384 | 3);
- }
- function checkReturnStatement(node) {
- var _a;
- if (checkGrammarStatementInAmbientContext(node)) {
- return;
+ var constraintType = getConstraintOfTypeParameter(typeParameter);
+ var defaultType = getDefaultFromTypeParameter(typeParameter);
+ if (constraintType && defaultType) {
+ checkTypeAssignableTo(defaultType, getTypeWithThisArgument(instantiateType(constraintType, makeUnaryTypeMapper(typeParameter, defaultType)), defaultType), node.default, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
+ }
+ if (produceDiagnostics) {
+ checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0);
}
+ }
+ function checkParameter(node) {
+ checkGrammarDecoratorsAndModifiers(node);
+ checkVariableLikeDeclaration(node);
var func = ts.getContainingFunction(node);
- if (!func) {
- grammarErrorOnFirstToken(node, ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);
- return;
+ if (ts.hasSyntacticModifier(node, 92)) {
+ if (!(func.kind === 166 && ts.nodeIsPresent(func.body))) {
+ error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
+ }
+ if (func.kind === 166 && ts.isIdentifier(node.name) && node.name.escapedText === "constructor") {
+ error(node.name, ts.Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name);
+ }
}
- var signature = getSignatureFromDeclaration(func);
- var returnType = getReturnTypeOfSignature(signature);
- var functionFlags = ts.getFunctionFlags(func);
- if (strictNullChecks || node.expression || returnType.flags & 131072) {
- var exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
- if (func.kind === 164) {
- if (node.expression) {
- error(node, ts.Diagnostics.Setters_cannot_return_a_value);
- }
+ if (node.questionToken && ts.isBindingPattern(node.name) && func.body) {
+ error(node, ts.Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature);
+ }
+ if (node.name && ts.isIdentifier(node.name) && (node.name.escapedText === "this" || node.name.escapedText === "new")) {
+ if (func.parameters.indexOf(node) !== 0) {
+ error(node, ts.Diagnostics.A_0_parameter_must_be_the_first_parameter, node.name.escapedText);
}
- else if (func.kind === 162) {
- if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
- error(node, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
- }
+ if (func.kind === 166 || func.kind === 170 || func.kind === 175) {
+ error(node, ts.Diagnostics.A_constructor_cannot_have_a_this_parameter);
}
- else if (getReturnTypeFromAnnotation(func)) {
- var unwrappedReturnType = (_a = unwrapReturnType(returnType, functionFlags)) !== null && _a !== void 0 ? _a : returnType;
- var unwrappedExprType = functionFlags & 2
- ? checkAwaitedType(exprType, node, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)
- : exprType;
- if (unwrappedReturnType) {
- checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
- }
+ if (func.kind === 209) {
+ error(node, ts.Diagnostics.An_arrow_function_cannot_have_a_this_parameter);
+ }
+ if (func.kind === 167 || func.kind === 168) {
+ error(node, ts.Diagnostics.get_and_set_accessors_cannot_declare_this_parameters);
}
}
- else if (func.kind !== 162 && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(func, returnType)) {
- error(node, ts.Diagnostics.Not_all_code_paths_return_a_value);
+ if (node.dotDotDotToken && !ts.isBindingPattern(node.name) && !isTypeAssignableTo(getReducedType(getTypeOfSymbol(node.symbol)), anyReadonlyArrayType)) {
+ error(node, ts.Diagnostics.A_rest_parameter_must_be_of_an_array_type);
}
}
- function checkWithStatement(node) {
- if (!checkGrammarStatementInAmbientContext(node)) {
- if (node.flags & 32768) {
- grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_an_async_function_block);
- }
+ function checkTypePredicate(node) {
+ var parent = getTypePredicateParent(node);
+ if (!parent) {
+ error(node, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods);
+ return;
}
- checkExpression(node.expression);
- var sourceFile = ts.getSourceFileOfNode(node);
- if (!hasParseDiagnostics(sourceFile)) {
- var start = ts.getSpanOfTokenAtPosition(sourceFile, node.pos).start;
- var end = node.statement.pos;
- grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any);
+ var signature = getSignatureFromDeclaration(parent);
+ var typePredicate = getTypePredicateOfSignature(signature);
+ if (!typePredicate) {
+ return;
}
- }
- function checkSwitchStatement(node) {
- checkGrammarStatementInAmbientContext(node);
- var firstDefaultClause;
- var hasDuplicateDefaultClause = false;
- var expressionType = checkExpression(node.expression);
- var expressionIsLiteral = isLiteralType(expressionType);
- ts.forEach(node.caseBlock.clauses, function (clause) {
- if (clause.kind === 278 && !hasDuplicateDefaultClause) {
- if (firstDefaultClause === undefined) {
- firstDefaultClause = clause;
+ checkSourceElement(node.type);
+ var parameterName = node.parameterName;
+ if (typePredicate.kind === 0 || typePredicate.kind === 2) {
+ getTypeFromThisTypeNode(parameterName);
+ }
+ else {
+ if (typePredicate.parameterIndex >= 0) {
+ if (signatureHasRestParameter(signature) && typePredicate.parameterIndex === signature.parameters.length - 1) {
+ error(parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter);
}
else {
- grammarErrorOnNode(clause, ts.Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement);
- hasDuplicateDefaultClause = true;
+ if (typePredicate.type) {
+ var leadingError = function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type); };
+ checkTypeAssignableTo(typePredicate.type, getTypeOfSymbol(signature.parameters[typePredicate.parameterIndex]), node.type, undefined, leadingError);
+ }
}
}
- if (produceDiagnostics && clause.kind === 277) {
- var caseType = checkExpression(clause.expression);
- var caseIsLiteral = isLiteralType(caseType);
- var comparedExpressionType = expressionType;
- if (!caseIsLiteral || !expressionIsLiteral) {
- caseType = caseIsLiteral ? getBaseTypeOfLiteralType(caseType) : caseType;
- comparedExpressionType = getBaseTypeOfLiteralType(expressionType);
+ else if (parameterName) {
+ var hasReportedError = false;
+ for (var _i = 0, _a = parent.parameters; _i < _a.length; _i++) {
+ var name = _a[_i].name;
+ if (ts.isBindingPattern(name) &&
+ checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, parameterName, typePredicate.parameterName)) {
+ hasReportedError = true;
+ break;
+ }
}
- if (!isTypeEqualityComparableTo(comparedExpressionType, caseType)) {
- checkTypeComparableTo(caseType, comparedExpressionType, clause.expression, undefined);
+ if (!hasReportedError) {
+ error(node.parameterName, ts.Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName);
}
}
- ts.forEach(clause.statements, checkSourceElement);
- if (compilerOptions.noFallthroughCasesInSwitch && clause.fallthroughFlowNode && isReachableFlowNode(clause.fallthroughFlowNode)) {
- error(clause, ts.Diagnostics.Fallthrough_case_in_switch);
- }
- });
- if (node.caseBlock.locals) {
- registerForUnusedIdentifiersCheck(node.caseBlock);
}
}
- function checkLabeledStatement(node) {
- if (!checkGrammarStatementInAmbientContext(node)) {
- ts.findAncestor(node.parent, function (current) {
- if (ts.isFunctionLike(current)) {
- return "quit";
+ function getTypePredicateParent(node) {
+ switch (node.parent.kind) {
+ case 209:
+ case 169:
+ case 251:
+ case 208:
+ case 174:
+ case 165:
+ case 164:
+ var parent = node.parent;
+ if (node === parent.type) {
+ return parent;
}
- if (current.kind === 238 && current.label.escapedText === node.label.escapedText) {
- grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNode(node.label));
+ }
+ }
+ function checkIfTypePredicateVariableIsDeclaredInBindingPattern(pattern, predicateVariableNode, predicateVariableName) {
+ for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
+ var element = _a[_i];
+ if (ts.isOmittedExpression(element)) {
+ continue;
+ }
+ var name = element.name;
+ if (name.kind === 78 && name.escapedText === predicateVariableName) {
+ error(predicateVariableNode, ts.Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, predicateVariableName);
+ return true;
+ }
+ else if (name.kind === 197 || name.kind === 196) {
+ if (checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, predicateVariableNode, predicateVariableName)) {
return true;
}
- return false;
- });
+ }
}
- checkSourceElement(node.statement);
}
- function checkThrowStatement(node) {
- if (!checkGrammarStatementInAmbientContext(node)) {
- if (node.expression === undefined) {
- grammarErrorAfterFirstToken(node, ts.Diagnostics.Line_break_not_permitted_here);
+ function checkSignatureDeclaration(node) {
+ if (node.kind === 171) {
+ checkGrammarIndexSignature(node);
+ }
+ else if (node.kind === 174 || node.kind === 251 || node.kind === 175 ||
+ node.kind === 169 || node.kind === 166 ||
+ node.kind === 170) {
+ checkGrammarFunctionLikeDeclaration(node);
+ }
+ var functionFlags = ts.getFunctionFlags(node);
+ if (!(functionFlags & 4)) {
+ if ((functionFlags & 3) === 3 && languageVersion < 99) {
+ checkExternalEmitHelpers(node, 12288);
+ }
+ if ((functionFlags & 3) === 2 && languageVersion < 4) {
+ checkExternalEmitHelpers(node, 64);
+ }
+ if ((functionFlags & 3) !== 0 && languageVersion < 2) {
+ checkExternalEmitHelpers(node, 128);
}
}
- if (node.expression) {
- checkExpression(node.expression);
+ checkTypeParameters(node.typeParameters);
+ ts.forEach(node.parameters, checkParameter);
+ if (node.type) {
+ checkSourceElement(node.type);
}
- }
- function checkTryStatement(node) {
- checkGrammarStatementInAmbientContext(node);
- checkBlock(node.tryBlock);
- var catchClause = node.catchClause;
- if (catchClause) {
- if (catchClause.variableDeclaration) {
- if (catchClause.variableDeclaration.type) {
- grammarErrorOnFirstToken(catchClause.variableDeclaration.type, ts.Diagnostics.Catch_clause_variable_cannot_have_a_type_annotation);
- }
- else if (catchClause.variableDeclaration.initializer) {
- grammarErrorOnFirstToken(catchClause.variableDeclaration.initializer, ts.Diagnostics.Catch_clause_variable_cannot_have_an_initializer);
+ if (produceDiagnostics) {
+ checkCollisionWithArgumentsInGeneratedCode(node);
+ var returnTypeNode = ts.getEffectiveReturnTypeNode(node);
+ if (noImplicitAny && !returnTypeNode) {
+ switch (node.kind) {
+ case 170:
+ error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
+ break;
+ case 169:
+ error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
+ break;
}
- else {
- var blockLocals_1 = catchClause.block.locals;
- if (blockLocals_1) {
- ts.forEachKey(catchClause.locals, function (caughtName) {
- var blockLocal = blockLocals_1.get(caughtName);
- if (blockLocal && (blockLocal.flags & 2) !== 0) {
- grammarErrorOnNode(blockLocal.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName);
- }
- });
+ }
+ if (returnTypeNode) {
+ var functionFlags_1 = ts.getFunctionFlags(node);
+ if ((functionFlags_1 & (4 | 1)) === 1) {
+ var returnType = getTypeFromTypeNode(returnTypeNode);
+ if (returnType === voidType) {
+ error(returnTypeNode, ts.Diagnostics.A_generator_cannot_have_a_void_type_annotation);
+ }
+ else {
+ var generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0, returnType, (functionFlags_1 & 2) !== 0) || anyType;
+ var generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1, returnType, (functionFlags_1 & 2) !== 0) || generatorYieldType;
+ var generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2, returnType, (functionFlags_1 & 2) !== 0) || unknownType;
+ var generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags_1 & 2));
+ checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode);
}
}
+ else if ((functionFlags_1 & 3) === 2) {
+ checkAsyncFunctionReturnType(node, returnTypeNode);
+ }
+ }
+ if (node.kind !== 171 && node.kind !== 308) {
+ registerForUnusedIdentifiersCheck(node);
}
- checkBlock(catchClause.block);
- }
- if (node.finallyBlock) {
- checkBlock(node.finallyBlock);
}
}
- function checkIndexConstraints(type) {
- var declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, 1);
- var declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, 0);
- var stringIndexType = getIndexTypeOfType(type, 0);
- var numberIndexType = getIndexTypeOfType(type, 1);
- if (stringIndexType || numberIndexType) {
- ts.forEach(getPropertiesOfObjectType(type), function (prop) {
- var propType = getTypeOfSymbol(prop);
- checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0);
- checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1);
- });
- var classDeclaration = type.symbol.valueDeclaration;
- if (ts.getObjectFlags(type) & 1 && ts.isClassLike(classDeclaration)) {
- for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) {
- var member = _a[_i];
- if (!ts.hasModifier(member, 32) && hasNonBindableDynamicName(member)) {
- var symbol = getSymbolOfNode(member);
- var propType = getTypeOfSymbol(symbol);
- checkIndexConstraintForProperty(symbol, propType, type, declaredStringIndexer, stringIndexType, 0);
- checkIndexConstraintForProperty(symbol, propType, type, declaredNumberIndexer, numberIndexType, 1);
+ function checkClassForDuplicateDeclarations(node) {
+ var instanceNames = new ts.Map();
+ var staticNames = new ts.Map();
+ var privateIdentifiers = new ts.Map();
+ for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+ var member = _a[_i];
+ if (member.kind === 166) {
+ for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) {
+ var param = _c[_b];
+ if (ts.isParameterPropertyDeclaration(param, member) && !ts.isBindingPattern(param.name)) {
+ addName(instanceNames, param.name, param.name.escapedText, 3);
}
}
}
- }
- var errorNode;
- if (stringIndexType && numberIndexType) {
- errorNode = declaredNumberIndexer || declaredStringIndexer;
- if (!errorNode && (ts.getObjectFlags(type) & 2)) {
- var someBaseTypeHasBothIndexers = ts.forEach(getBaseTypes(type), function (base) { return getIndexTypeOfType(base, 0) && getIndexTypeOfType(base, 1); });
- errorNode = someBaseTypeHasBothIndexers ? undefined : type.symbol.declarations[0];
+ else {
+ var isStatic = ts.hasSyntacticModifier(member, 32);
+ var name = member.name;
+ if (!name) {
+ return;
+ }
+ var names = ts.isPrivateIdentifier(name) ? privateIdentifiers :
+ isStatic ? staticNames :
+ instanceNames;
+ var memberName = name && ts.getPropertyNameForPropertyNameNode(name);
+ if (memberName) {
+ switch (member.kind) {
+ case 167:
+ addName(names, name, memberName, 1);
+ break;
+ case 168:
+ addName(names, name, memberName, 2);
+ break;
+ case 163:
+ addName(names, name, memberName, 3);
+ break;
+ case 165:
+ addName(names, name, memberName, 8);
+ break;
+ }
+ }
}
}
- if (errorNode && !isTypeAssignableTo(numberIndexType, stringIndexType)) {
- error(errorNode, ts.Diagnostics.Numeric_index_type_0_is_not_assignable_to_string_index_type_1, typeToString(numberIndexType), typeToString(stringIndexType));
- }
- function checkIndexConstraintForProperty(prop, propertyType, containingType, indexDeclaration, indexType, indexKind) {
- if (!indexType || ts.isKnownSymbol(prop)) {
- return;
+ function addName(names, location, name, meaning) {
+ var prev = names.get(name);
+ if (prev) {
+ if (prev & 8) {
+ if (meaning !== 8) {
+ error(location, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(location));
+ }
+ }
+ else if (prev & meaning) {
+ error(location, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(location));
+ }
+ else {
+ names.set(name, prev | meaning);
+ }
}
- var propDeclaration = prop.valueDeclaration;
- var name = propDeclaration && ts.getNameOfDeclaration(propDeclaration);
- if (name && ts.isPrivateIdentifier(name)) {
- return;
+ else {
+ names.set(name, meaning);
}
- if (indexKind === 1 && !(name ? isNumericName(name) : isNumericLiteralName(prop.escapedName))) {
- return;
+ }
+ }
+ function checkClassForStaticPropertyNameConflicts(node) {
+ for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+ var member = _a[_i];
+ var memberNameNode = member.name;
+ var isStatic = ts.hasSyntacticModifier(member, 32);
+ if (isStatic && memberNameNode) {
+ var memberName = ts.getPropertyNameForPropertyNameNode(memberNameNode);
+ switch (memberName) {
+ case "name":
+ case "length":
+ case "caller":
+ case "arguments":
+ case "prototype":
+ var message = ts.Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
+ var className = getNameOfSymbolAsWritten(getSymbolOfNode(node));
+ error(memberNameNode, message, memberName, className);
+ break;
+ }
}
- var errorNode;
- if (propDeclaration && name &&
- (propDeclaration.kind === 209 ||
- name.kind === 154 ||
- prop.parent === containingType.symbol)) {
- errorNode = propDeclaration;
+ }
+ }
+ function checkObjectTypeForDuplicateDeclarations(node) {
+ var names = new ts.Map();
+ for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+ var member = _a[_i];
+ if (member.kind === 162) {
+ var memberName = void 0;
+ var name = member.name;
+ switch (name.kind) {
+ case 10:
+ case 8:
+ memberName = name.text;
+ break;
+ case 78:
+ memberName = ts.idText(name);
+ break;
+ default:
+ continue;
+ }
+ if (names.get(memberName)) {
+ error(ts.getNameOfDeclaration(member.symbol.valueDeclaration), ts.Diagnostics.Duplicate_identifier_0, memberName);
+ error(member.name, ts.Diagnostics.Duplicate_identifier_0, memberName);
+ }
+ else {
+ names.set(memberName, true);
+ }
}
- else if (indexDeclaration) {
- errorNode = indexDeclaration;
+ }
+ }
+ function checkTypeForDuplicateIndexSignatures(node) {
+ if (node.kind === 253) {
+ var nodeSymbol = getSymbolOfNode(node);
+ if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) {
+ return;
}
- else if (ts.getObjectFlags(containingType) & 2) {
- var someBaseClassHasBothPropertyAndIndexer = ts.forEach(getBaseTypes(containingType), function (base) { return getPropertyOfObjectType(base, prop.escapedName) && getIndexTypeOfType(base, indexKind); });
- errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : containingType.symbol.declarations[0];
+ }
+ var indexSymbol = getIndexSymbol(getSymbolOfNode(node));
+ if (indexSymbol) {
+ var seenNumericIndexer = false;
+ var seenStringIndexer = false;
+ for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ var declaration = decl;
+ if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
+ switch (declaration.parameters[0].type.kind) {
+ case 147:
+ if (!seenStringIndexer) {
+ seenStringIndexer = true;
+ }
+ else {
+ error(declaration, ts.Diagnostics.Duplicate_string_index_signature);
+ }
+ break;
+ case 144:
+ if (!seenNumericIndexer) {
+ seenNumericIndexer = true;
+ }
+ else {
+ error(declaration, ts.Diagnostics.Duplicate_number_index_signature);
+ }
+ break;
+ }
+ }
}
- if (errorNode && !isTypeAssignableTo(propertyType, indexType)) {
- var errorMessage = indexKind === 0
- ? ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_string_index_type_2
- : ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2;
- error(errorNode, errorMessage, symbolToString(prop), typeToString(propertyType), typeToString(indexType));
+ }
+ }
+ function checkPropertyDeclaration(node) {
+ if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarProperty(node))
+ checkGrammarComputedPropertyName(node.name);
+ checkVariableLikeDeclaration(node);
+ if (ts.isPrivateIdentifier(node.name) && languageVersion < 99) {
+ for (var lexicalScope = ts.getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = ts.getEnclosingBlockScopeContainer(lexicalScope)) {
+ getNodeLinks(lexicalScope).flags |= 67108864;
}
}
}
- function checkTypeNameIsReserved(name, message) {
- switch (name.escapedText) {
- case "any":
- case "unknown":
- case "number":
- case "bigint":
- case "boolean":
- case "string":
- case "symbol":
- case "void":
- case "object":
- error(name, message, name.escapedText);
+ function checkPropertySignature(node) {
+ if (ts.isPrivateIdentifier(node.name)) {
+ error(node, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
}
+ return checkPropertyDeclaration(node);
}
- function checkClassNameCollisionWithObject(name) {
- if (languageVersion === 1 && name.escapedText === "Object"
- && moduleKind < ts.ModuleKind.ES2015) {
- error(name, ts.Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ts.ModuleKind[moduleKind]);
+ function checkMethodDeclaration(node) {
+ if (!checkGrammarMethod(node))
+ checkGrammarComputedPropertyName(node.name);
+ if (ts.isPrivateIdentifier(node.name)) {
+ error(node, ts.Diagnostics.A_method_cannot_be_named_with_a_private_identifier);
+ }
+ checkFunctionOrMethodDeclaration(node);
+ if (ts.hasSyntacticModifier(node, 128) && node.kind === 165 && node.body) {
+ error(node, ts.Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
}
}
- function checkTypeParameters(typeParameterDeclarations) {
- if (typeParameterDeclarations) {
- var seenDefault = false;
- for (var i = 0; i < typeParameterDeclarations.length; i++) {
- var node = typeParameterDeclarations[i];
- checkTypeParameter(node);
- if (produceDiagnostics) {
- if (node.default) {
- seenDefault = true;
- checkTypeParametersNotReferenced(node.default, typeParameterDeclarations, i);
+ function checkConstructorDeclaration(node) {
+ checkSignatureDeclaration(node);
+ if (!checkGrammarConstructorTypeParameters(node))
+ checkGrammarConstructorTypeAnnotation(node);
+ checkSourceElement(node.body);
+ var symbol = getSymbolOfNode(node);
+ var firstDeclaration = ts.getDeclarationOfKind(symbol, node.kind);
+ if (node === firstDeclaration) {
+ checkFunctionOrConstructorSymbol(symbol);
+ }
+ if (ts.nodeIsMissing(node.body)) {
+ return;
+ }
+ if (!produceDiagnostics) {
+ return;
+ }
+ function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) {
+ if (ts.isPrivateIdentifierPropertyDeclaration(n)) {
+ return true;
+ }
+ return n.kind === 163 &&
+ !ts.hasSyntacticModifier(n, 32) &&
+ !!n.initializer;
+ }
+ var containingClassDecl = node.parent;
+ if (ts.getClassExtendsHeritageElement(containingClassDecl)) {
+ captureLexicalThis(node.parent, containingClassDecl);
+ var classExtendsNull = classDeclarationExtendsNull(containingClassDecl);
+ var superCall = findFirstSuperCall(node.body);
+ if (superCall) {
+ if (classExtendsNull) {
+ error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
+ }
+ var superCallShouldBeFirst = (compilerOptions.target !== 99 || !compilerOptions.useDefineForClassFields) &&
+ (ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) ||
+ ts.some(node.parameters, function (p) { return ts.hasSyntacticModifier(p, 92); }));
+ if (superCallShouldBeFirst) {
+ var statements = node.body.statements;
+ var superCallStatement = void 0;
+ for (var _i = 0, statements_4 = statements; _i < statements_4.length; _i++) {
+ var statement = statements_4[_i];
+ if (statement.kind === 233 && ts.isSuperCall(statement.expression)) {
+ superCallStatement = statement;
+ break;
+ }
+ if (!ts.isPrologueDirective(statement)) {
+ break;
+ }
}
- else if (seenDefault) {
- error(node, ts.Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters);
+ if (!superCallStatement) {
+ error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_parameter_properties_or_private_identifiers);
}
- for (var j = 0; j < i; j++) {
- if (typeParameterDeclarations[j].symbol === node.symbol) {
- error(node.name, ts.Diagnostics.Duplicate_identifier_0, ts.declarationNameToString(node.name));
- }
+ }
+ }
+ else if (!classExtendsNull) {
+ error(node, ts.Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call);
+ }
+ }
+ }
+ function checkAccessorDeclaration(node) {
+ if (produceDiagnostics) {
+ if (!checkGrammarFunctionLikeDeclaration(node) && !checkGrammarAccessor(node))
+ checkGrammarComputedPropertyName(node.name);
+ checkDecorators(node);
+ checkSignatureDeclaration(node);
+ if (node.kind === 167) {
+ if (!(node.flags & 8388608) && ts.nodeIsPresent(node.body) && (node.flags & 256)) {
+ if (!(node.flags & 512)) {
+ error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value);
}
}
}
- }
- }
- function checkTypeParametersNotReferenced(root, typeParameters, index) {
- visit(root);
- function visit(node) {
- if (node.kind === 169) {
- var type = getTypeFromTypeReference(node);
- if (type.flags & 262144) {
- for (var i = index; i < typeParameters.length; i++) {
- if (type.symbol === getSymbolOfNode(typeParameters[i])) {
- error(node, ts.Diagnostics.Type_parameter_defaults_can_only_reference_previously_declared_type_parameters);
- }
+ if (node.name.kind === 158) {
+ checkComputedPropertyName(node.name);
+ }
+ if (ts.isPrivateIdentifier(node.name)) {
+ error(node.name, ts.Diagnostics.An_accessor_cannot_be_named_with_a_private_identifier);
+ }
+ if (!hasNonBindableDynamicName(node)) {
+ var otherKind = node.kind === 167 ? 168 : 167;
+ var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(node), otherKind);
+ if (otherAccessor) {
+ var nodeFlags = ts.getEffectiveModifierFlags(node);
+ var otherFlags = ts.getEffectiveModifierFlags(otherAccessor);
+ if ((nodeFlags & 28) !== (otherFlags & 28)) {
+ error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility);
+ }
+ if ((nodeFlags & 128) !== (otherFlags & 128)) {
+ error(node.name, ts.Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
}
+ checkAccessorDeclarationTypesIdentical(node, otherAccessor, getAnnotatedAccessorType, ts.Diagnostics.get_and_set_accessor_must_have_the_same_type);
+ checkAccessorDeclarationTypesIdentical(node, otherAccessor, getThisTypeOfDeclaration, ts.Diagnostics.get_and_set_accessor_must_have_the_same_this_type);
}
}
- ts.forEachChild(node, visit);
+ var returnType = getTypeOfAccessors(getSymbolOfNode(node));
+ if (node.kind === 167) {
+ checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
+ }
}
+ checkSourceElement(node.body);
}
- function checkTypeParameterListsIdentical(symbol) {
- if (symbol.declarations.length === 1) {
- return;
+ function checkAccessorDeclarationTypesIdentical(first, second, getAnnotatedType, message) {
+ var firstType = getAnnotatedType(first);
+ var secondType = getAnnotatedType(second);
+ if (firstType && secondType && !isTypeIdenticalTo(firstType, secondType)) {
+ error(first, message);
}
- var links = getSymbolLinks(symbol);
- if (!links.typeParametersChecked) {
- links.typeParametersChecked = true;
- var declarations = getClassOrInterfaceDeclarationsOfSymbol(symbol);
- if (declarations.length <= 1) {
- return;
- }
- var type = getDeclaredTypeOfSymbol(symbol);
- if (!areTypeParametersIdentical(declarations, type.localTypeParameters)) {
- var name = symbolToString(symbol);
- for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
- var declaration = declarations_6[_i];
- error(declaration.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_type_parameters, name);
+ }
+ function checkMissingDeclaration(node) {
+ checkDecorators(node);
+ }
+ function getEffectiveTypeArguments(node, typeParameters) {
+ return fillMissingTypeArguments(ts.map(node.typeArguments, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(node));
+ }
+ function checkTypeArgumentConstraints(node, typeParameters) {
+ var typeArguments;
+ var mapper;
+ var result = true;
+ for (var i = 0; i < typeParameters.length; i++) {
+ var constraint = getConstraintOfTypeParameter(typeParameters[i]);
+ if (constraint) {
+ if (!typeArguments) {
+ typeArguments = getEffectiveTypeArguments(node, typeParameters);
+ mapper = createTypeMapper(typeParameters, typeArguments);
}
+ result = result && checkTypeAssignableTo(typeArguments[i], instantiateType(constraint, mapper), node.typeArguments[i], ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
}
}
+ return result;
}
- function areTypeParametersIdentical(declarations, targetParameters) {
- var maxTypeArgumentCount = ts.length(targetParameters);
- var minTypeArgumentCount = getMinTypeArgumentCount(targetParameters);
- for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
- var declaration = declarations_7[_i];
- var sourceParameters = ts.getEffectiveTypeParameterDeclarations(declaration);
- var numTypeParameters = sourceParameters.length;
- if (numTypeParameters < minTypeArgumentCount || numTypeParameters > maxTypeArgumentCount) {
- return false;
+ function getTypeParametersForTypeReference(node) {
+ var type = getTypeFromTypeReference(node);
+ if (type !== errorType) {
+ var symbol = getNodeLinks(node).resolvedSymbol;
+ if (symbol) {
+ return symbol.flags & 524288 && getSymbolLinks(symbol).typeParameters ||
+ (ts.getObjectFlags(type) & 4 ? type.target.localTypeParameters : undefined);
}
- for (var i = 0; i < numTypeParameters; i++) {
- var source = sourceParameters[i];
- var target = targetParameters[i];
- if (source.name.escapedText !== target.symbol.escapedName) {
- return false;
+ }
+ return undefined;
+ }
+ function checkTypeReferenceNode(node) {
+ checkGrammarTypeArguments(node, node.typeArguments);
+ if (node.kind === 173 && node.typeName.jsdocDotPos !== undefined && !ts.isInJSFile(node) && !ts.isInJSDoc(node)) {
+ grammarErrorAtPos(node, node.typeName.jsdocDotPos, 1, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
+ }
+ ts.forEach(node.typeArguments, checkSourceElement);
+ var type = getTypeFromTypeReference(node);
+ if (type !== errorType) {
+ if (node.typeArguments && produceDiagnostics) {
+ var typeParameters = getTypeParametersForTypeReference(node);
+ if (typeParameters) {
+ checkTypeArgumentConstraints(node, typeParameters);
}
- var constraint = ts.getEffectiveConstraintOfTypeParameter(source);
- var sourceConstraint = constraint && getTypeFromTypeNode(constraint);
- var targetConstraint = getConstraintOfTypeParameter(target);
- if (sourceConstraint && targetConstraint && !isTypeIdenticalTo(sourceConstraint, targetConstraint)) {
- return false;
+ }
+ var symbol = getNodeLinks(node).resolvedSymbol;
+ if (symbol) {
+ if (ts.some(symbol.declarations, function (d) { return isTypeDeclaration(d) && !!(d.flags & 134217728); })) {
+ errorOrSuggestion(false, getDeprecatedSuggestionNode(node), ts.Diagnostics._0_is_deprecated, symbol.escapedName);
}
- var sourceDefault = source.default && getTypeFromTypeNode(source.default);
- var targetDefault = getDefaultFromTypeParameter(target);
- if (sourceDefault && targetDefault && !isTypeIdenticalTo(sourceDefault, targetDefault)) {
- return false;
+ if (type.flags & 32 && symbol.flags & 8) {
+ error(node, ts.Diagnostics.Enum_type_0_has_members_with_initializers_that_are_not_literals, typeToString(type));
}
}
}
- return true;
}
- function checkClassExpression(node) {
- checkClassLikeDeclaration(node);
- checkNodeDeferred(node);
- return getTypeOfSymbol(getSymbolOfNode(node));
+ function getTypeArgumentConstraint(node) {
+ var typeReferenceNode = ts.tryCast(node.parent, ts.isTypeReferenceType);
+ if (!typeReferenceNode)
+ return undefined;
+ var typeParameters = getTypeParametersForTypeReference(typeReferenceNode);
+ var constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments.indexOf(node)]);
+ return constraint && instantiateType(constraint, createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReferenceNode, typeParameters)));
}
- function checkClassExpressionDeferred(node) {
- ts.forEach(node.members, checkSourceElement);
- registerForUnusedIdentifiersCheck(node);
+ function checkTypeQuery(node) {
+ getTypeFromTypeQueryNode(node);
}
- function checkClassDeclaration(node) {
- if (!node.name && !ts.hasModifier(node, 512)) {
- grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
- }
- checkClassLikeDeclaration(node);
+ function checkTypeLiteral(node) {
ts.forEach(node.members, checkSourceElement);
- registerForUnusedIdentifiersCheck(node);
- }
- function checkClassLikeDeclaration(node) {
- checkGrammarClassLikeDeclaration(node);
- checkDecorators(node);
- if (node.name) {
- checkTypeNameIsReserved(node.name, ts.Diagnostics.Class_name_cannot_be_0);
- checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
- checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
- if (!(node.flags & 8388608)) {
- checkClassNameCollisionWithObject(node.name);
- }
- }
- checkTypeParameters(ts.getEffectiveTypeParameterDeclarations(node));
- checkExportsOnMergedDeclarations(node);
- var symbol = getSymbolOfNode(node);
- var type = getDeclaredTypeOfSymbol(symbol);
- var typeWithThis = getTypeWithThisArgument(type);
- var staticType = getTypeOfSymbol(symbol);
- checkTypeParameterListsIdentical(symbol);
- checkClassForDuplicateDeclarations(node);
- if (!(node.flags & 8388608)) {
- checkClassForStaticPropertyNameConflicts(node);
+ if (produceDiagnostics) {
+ var type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
+ checkIndexConstraints(type);
+ checkTypeForDuplicateIndexSignatures(node);
+ checkObjectTypeForDuplicateDeclarations(node);
}
- var baseTypeNode = ts.getEffectiveBaseTypeNode(node);
- if (baseTypeNode) {
- ts.forEach(baseTypeNode.typeArguments, checkSourceElement);
- if (languageVersion < 2) {
- checkExternalEmitHelpers(baseTypeNode.parent, 1);
- }
- var extendsNode = ts.getClassExtendsHeritageElement(node);
- if (extendsNode && extendsNode !== baseTypeNode) {
- checkExpression(extendsNode.expression);
+ }
+ function checkArrayType(node) {
+ checkSourceElement(node.elementType);
+ }
+ function checkTupleType(node) {
+ var elementTypes = node.elements;
+ var seenOptionalElement = false;
+ var seenRestElement = false;
+ var hasNamedElement = ts.some(elementTypes, ts.isNamedTupleMember);
+ for (var i = 0; i < elementTypes.length; i++) {
+ var e = elementTypes[i];
+ if (e.kind !== 192 && hasNamedElement) {
+ grammarErrorOnNode(e, ts.Diagnostics.Tuple_members_must_all_have_names_or_all_not_have_names);
+ break;
}
- var baseTypes = getBaseTypes(type);
- if (baseTypes.length && produceDiagnostics) {
- var baseType_1 = baseTypes[0];
- var baseConstructorType = getBaseConstructorTypeOfClass(type);
- var staticBaseType = getApparentType(baseConstructorType);
- checkBaseTypeAccessibility(staticBaseType, baseTypeNode);
- checkSourceElement(baseTypeNode.expression);
- if (ts.some(baseTypeNode.typeArguments)) {
- ts.forEach(baseTypeNode.typeArguments, checkSourceElement);
- for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); _i < _a.length; _i++) {
- var constructor = _a[_i];
- if (!checkTypeArgumentConstraints(baseTypeNode, constructor.typeParameters)) {
- break;
- }
- }
- }
- var baseWithThis = getTypeWithThisArgument(baseType_1, type.thisType);
- if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) {
- issueMemberSpecificError(node, typeWithThis, baseWithThis, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1);
- }
- else {
- checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
- }
- if (baseConstructorType.flags & 8650752 && !isMixinConstructorType(staticType)) {
- error(node.name || node, ts.Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any);
+ var flags = getTupleElementFlags(e);
+ if (flags & 8) {
+ var type = getTypeFromTypeNode(e.type);
+ if (!isArrayLikeType(type)) {
+ error(e, ts.Diagnostics.A_rest_element_type_must_be_an_array_type);
+ break;
}
- if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32) && !(baseConstructorType.flags & 8650752)) {
- var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode);
- if (ts.forEach(constructors, function (sig) { return !isJSConstructor(sig.declaration) && !isTypeIdenticalTo(getReturnTypeOfSignature(sig), baseType_1); })) {
- error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type);
- }
+ if (isArrayType(type) || isTupleType(type) && type.target.combinedFlags & 4) {
+ seenRestElement = true;
}
- checkKindsOfPropertyMemberOverrides(type, baseType_1);
}
- }
- var implementedTypeNodes = ts.getEffectiveImplementsTypeNodes(node);
- if (implementedTypeNodes) {
- for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
- var typeRefNode = implementedTypeNodes_1[_b];
- if (!ts.isEntityNameExpression(typeRefNode.expression)) {
- error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
- }
- checkTypeReferenceNode(typeRefNode);
- if (produceDiagnostics) {
- var t = getReducedType(getTypeFromTypeNode(typeRefNode));
- if (t !== errorType) {
- if (isValidBaseType(t)) {
- var genericDiag = t.symbol && t.symbol.flags & 32 ?
- ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass :
- ts.Diagnostics.Class_0_incorrectly_implements_interface_1;
- var baseWithThis = getTypeWithThisArgument(t, type.thisType);
- if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) {
- issueMemberSpecificError(node, typeWithThis, baseWithThis, genericDiag);
- }
- }
- else {
- error(typeRefNode, ts.Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members);
- }
- }
- }
+ else if (flags & 4) {
+ seenRestElement = true;
+ }
+ else if (flags & 2) {
+ seenOptionalElement = true;
+ }
+ else if (seenOptionalElement) {
+ grammarErrorOnNode(e, ts.Diagnostics.A_required_element_cannot_follow_an_optional_element);
+ break;
+ }
+ if (seenRestElement && i !== elementTypes.length - 1) {
+ grammarErrorOnNode(e, ts.Diagnostics.A_rest_element_must_be_last_in_a_tuple_type);
+ break;
}
}
- if (produceDiagnostics) {
- checkIndexConstraints(type);
- checkTypeForDuplicateIndexSignatures(node);
- checkPropertyInitialization(node);
- }
+ ts.forEach(node.elements, checkSourceElement);
+ getTypeFromTypeNode(node);
}
- function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
- var issuedMemberError = false;
- var _loop_19 = function (member) {
- if (ts.hasStaticModifier(member)) {
- return "continue";
+ function checkUnionOrIntersectionType(node) {
+ ts.forEach(node.types, checkSourceElement);
+ getTypeFromTypeNode(node);
+ }
+ function checkIndexedAccessIndexType(type, accessNode) {
+ if (!(type.flags & 8388608)) {
+ return type;
+ }
+ var objectType = type.objectType;
+ var indexType = type.indexType;
+ if (isTypeAssignableTo(indexType, getIndexType(objectType, false))) {
+ if (accessNode.kind === 202 && ts.isAssignmentTarget(accessNode) &&
+ ts.getObjectFlags(objectType) & 32 && getMappedTypeModifiers(objectType) & 1) {
+ error(accessNode, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
}
- var declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
- if (declaredProp) {
- var prop = getPropertyOfType(typeWithThis, declaredProp.escapedName);
- var baseProp = getPropertyOfType(baseWithThis, declaredProp.escapedName);
- if (prop && baseProp) {
- var rootChain = function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2, symbolToString(declaredProp), typeToString(typeWithThis), typeToString(baseWithThis)); };
- if (!checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(baseProp), member.name || member, undefined, rootChain)) {
- issuedMemberError = true;
- }
+ return type;
+ }
+ var apparentObjectType = getApparentType(objectType);
+ if (getIndexInfoOfType(apparentObjectType, 1) && isTypeAssignableToKind(indexType, 296)) {
+ return type;
+ }
+ if (isGenericObjectType(objectType)) {
+ var propertyName_1 = getPropertyNameFromIndex(indexType, accessNode);
+ if (propertyName_1) {
+ var propertySymbol = forEachType(apparentObjectType, function (t) { return getPropertyOfType(t, propertyName_1); });
+ if (propertySymbol && ts.getDeclarationModifierFlagsFromSymbol(propertySymbol) & 24) {
+ error(accessNode, ts.Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, ts.unescapeLeadingUnderscores(propertyName_1));
+ return errorType;
}
}
- };
- for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
- var member = _a[_i];
- _loop_19(member);
}
- if (!issuedMemberError) {
- checkTypeAssignableTo(typeWithThis, baseWithThis, node.name || node, broadDiag);
+ error(accessNode, ts.Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(objectType));
+ return errorType;
+ }
+ function checkIndexedAccessType(node) {
+ checkSourceElement(node.objectType);
+ checkSourceElement(node.indexType);
+ checkIndexedAccessIndexType(getTypeFromIndexedAccessTypeNode(node), node);
+ }
+ function checkMappedType(node) {
+ checkSourceElement(node.typeParameter);
+ checkSourceElement(node.nameType);
+ checkSourceElement(node.type);
+ if (!node.type) {
+ reportImplicitAny(node, anyType);
+ }
+ var type = getTypeFromMappedTypeNode(node);
+ var nameType = getNameTypeFromMappedType(type);
+ if (nameType) {
+ checkTypeAssignableTo(nameType, keyofConstraintType, node.nameType);
+ }
+ else {
+ var constraintType = getConstraintTypeFromMappedType(type);
+ checkTypeAssignableTo(constraintType, keyofConstraintType, ts.getEffectiveConstraintOfTypeParameter(node.typeParameter));
}
}
- function checkBaseTypeAccessibility(type, node) {
- var signatures = getSignaturesOfType(type, 1);
- if (signatures.length) {
- var declaration = signatures[0].declaration;
- if (declaration && ts.hasModifier(declaration, 8)) {
- var typeClassDeclaration = ts.getClassLikeDeclarationOfSymbol(type.symbol);
- if (!isNodeWithinClass(node, typeClassDeclaration)) {
- error(node, ts.Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, getFullyQualifiedName(type.symbol));
- }
- }
+ function checkThisType(node) {
+ getTypeFromThisTypeNode(node);
+ }
+ function checkTypeOperator(node) {
+ checkGrammarTypeOperatorNode(node);
+ checkSourceElement(node.type);
+ }
+ function checkConditionalType(node) {
+ ts.forEachChild(node, checkSourceElement);
+ }
+ function checkInferType(node) {
+ if (!ts.findAncestor(node, function (n) { return n.parent && n.parent.kind === 184 && n.parent.extendsType === n; })) {
+ grammarErrorOnNode(node, ts.Diagnostics.infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type);
}
+ checkSourceElement(node.typeParameter);
+ registerForUnusedIdentifiersCheck(node);
}
- function getTargetSymbol(s) {
- return ts.getCheckFlags(s) & 1 ? s.target : s;
+ function checkTemplateLiteralType(node) {
+ for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) {
+ var span = _a[_i];
+ checkSourceElement(span.type);
+ var type = getTypeFromTypeNode(span.type);
+ checkTypeAssignableTo(type, templateConstraintType, span.type);
+ }
+ getTypeFromTypeNode(node);
}
- function getClassOrInterfaceDeclarationsOfSymbol(symbol) {
- return ts.filter(symbol.declarations, function (d) {
- return d.kind === 245 || d.kind === 246;
- });
+ function checkImportType(node) {
+ checkSourceElement(node.argument);
+ getTypeFromTypeNode(node);
}
- function checkKindsOfPropertyMemberOverrides(type, baseType) {
- var baseProperties = getPropertiesOfType(baseType);
- basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
- var baseProperty = baseProperties_1[_i];
- var base = getTargetSymbol(baseProperty);
- if (base.flags & 4194304) {
- continue;
- }
- var baseSymbol = getPropertyOfObjectType(type, base.escapedName);
- if (!baseSymbol) {
- continue;
+ function checkNamedTupleMember(node) {
+ if (node.dotDotDotToken && node.questionToken) {
+ grammarErrorOnNode(node, ts.Diagnostics.A_tuple_member_cannot_be_both_optional_and_rest);
+ }
+ if (node.type.kind === 180) {
+ grammarErrorOnNode(node.type, ts.Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type);
+ }
+ if (node.type.kind === 181) {
+ grammarErrorOnNode(node.type, ts.Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type);
+ }
+ checkSourceElement(node.type);
+ getTypeFromTypeNode(node);
+ }
+ function isPrivateWithinAmbient(node) {
+ return (ts.hasEffectiveModifier(node, 8) || ts.isPrivateIdentifierPropertyDeclaration(node)) && !!(node.flags & 8388608);
+ }
+ function getEffectiveDeclarationFlags(n, flagsToCheck) {
+ var flags = ts.getCombinedModifierFlags(n);
+ if (n.parent.kind !== 253 &&
+ n.parent.kind !== 252 &&
+ n.parent.kind !== 221 &&
+ n.flags & 8388608) {
+ if (!(flags & 2) && !(ts.isModuleBlock(n.parent) && ts.isModuleDeclaration(n.parent.parent) && ts.isGlobalScopeAugmentation(n.parent.parent))) {
+ flags |= 1;
}
- var derived = getTargetSymbol(baseSymbol);
- var baseDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(base);
- ts.Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration.");
- if (derived === base) {
- var derivedClassDecl = ts.getClassLikeDeclarationOfSymbol(type.symbol);
- if (baseDeclarationFlags & 128 && (!derivedClassDecl || !ts.hasModifier(derivedClassDecl, 128))) {
- for (var _a = 0, _b = getBaseTypes(type); _a < _b.length; _a++) {
- var otherBaseType = _b[_a];
- if (otherBaseType === baseType)
- continue;
- var baseSymbol_1 = getPropertyOfObjectType(otherBaseType, base.escapedName);
- var derivedElsewhere = baseSymbol_1 && getTargetSymbol(baseSymbol_1);
- if (derivedElsewhere && derivedElsewhere !== base) {
- continue basePropertyCheck;
- }
+ flags |= 2;
+ }
+ return flags & flagsToCheck;
+ }
+ function checkFunctionOrConstructorSymbol(symbol) {
+ if (!produceDiagnostics) {
+ return;
+ }
+ function getCanonicalOverload(overloads, implementation) {
+ var implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent;
+ return implementationSharesContainerWithFirstOverload ? implementation : overloads[0];
+ }
+ function checkFlagAgreementBetweenOverloads(overloads, implementation, flagsToCheck, someOverloadFlags, allOverloadFlags) {
+ var someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags;
+ if (someButNotAllOverloadFlags !== 0) {
+ var canonicalFlags_1 = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck);
+ ts.forEach(overloads, function (o) {
+ var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags_1;
+ if (deviation & 1) {
+ error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported);
}
- if (derivedClassDecl.kind === 214) {
- error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, symbolToString(baseProperty), typeToString(baseType));
+ else if (deviation & 2) {
+ error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
}
- else {
- error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, typeToString(type), symbolToString(baseProperty), typeToString(baseType));
+ else if (deviation & (8 | 16)) {
+ error(ts.getNameOfDeclaration(o) || o, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
}
- }
- }
- else {
- var derivedDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(derived);
- if (baseDeclarationFlags & 8 || derivedDeclarationFlags & 8) {
- continue;
- }
- var errorMessage = void 0;
- var basePropertyFlags = base.flags & 98308;
- var derivedPropertyFlags = derived.flags & 98308;
- if (basePropertyFlags && derivedPropertyFlags) {
- if (!compilerOptions.useDefineForClassFields
- || baseDeclarationFlags & 128 && !(base.valueDeclaration && ts.isPropertyDeclaration(base.valueDeclaration) && base.valueDeclaration.initializer)
- || base.valueDeclaration && base.valueDeclaration.parent.kind === 246
- || derived.valueDeclaration && ts.isBinaryExpression(derived.valueDeclaration)) {
- continue;
+ else if (deviation & 128) {
+ error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract);
}
- var overriddenInstanceProperty = basePropertyFlags !== 4 && derivedPropertyFlags === 4;
- var overriddenInstanceAccessor = basePropertyFlags === 4 && derivedPropertyFlags !== 4;
- if (overriddenInstanceProperty || overriddenInstanceAccessor) {
- var errorMessage_1 = overriddenInstanceProperty ?
- ts.Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property :
- ts.Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor;
- error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_1, symbolToString(base), typeToString(baseType), typeToString(type));
+ });
+ }
+ }
+ function checkQuestionTokenAgreementBetweenOverloads(overloads, implementation, someHaveQuestionToken, allHaveQuestionToken) {
+ if (someHaveQuestionToken !== allHaveQuestionToken) {
+ var canonicalHasQuestionToken_1 = ts.hasQuestionToken(getCanonicalOverload(overloads, implementation));
+ ts.forEach(overloads, function (o) {
+ var deviation = ts.hasQuestionToken(o) !== canonicalHasQuestionToken_1;
+ if (deviation) {
+ error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_optional_or_required);
}
- else {
- var uninitialized = ts.find(derived.declarations, function (d) { return d.kind === 159 && !d.initializer; });
- if (uninitialized
- && !(derived.flags & 33554432)
- && !(baseDeclarationFlags & 128)
- && !(derivedDeclarationFlags & 128)
- && !derived.declarations.some(function (d) { return !!(d.flags & 8388608); })) {
- var constructor = findConstructorDeclaration(ts.getClassLikeDeclarationOfSymbol(type.symbol));
- var propName = uninitialized.name;
- if (uninitialized.exclamationToken
- || !constructor
- || !ts.isIdentifier(propName)
- || !strictNullChecks
- || !isPropertyInitializedInConstructor(propName, type, constructor)) {
- var errorMessage_2 = ts.Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration;
- error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_2, symbolToString(base), typeToString(baseType));
- }
+ });
+ }
+ }
+ var flagsToCheck = 1 | 2 | 8 | 16 | 128;
+ var someNodeFlags = 0;
+ var allNodeFlags = flagsToCheck;
+ var someHaveQuestionToken = false;
+ var allHaveQuestionToken = true;
+ var hasOverloads = false;
+ var bodyDeclaration;
+ var lastSeenNonAmbientDeclaration;
+ var previousDeclaration;
+ var declarations = symbol.declarations;
+ var isConstructor = (symbol.flags & 16384) !== 0;
+ function reportImplementationExpectedError(node) {
+ if (node.name && ts.nodeIsMissing(node.name)) {
+ return;
+ }
+ var seen = false;
+ var subsequentNode = ts.forEachChild(node.parent, function (c) {
+ if (seen) {
+ return c;
+ }
+ else {
+ seen = c === node;
+ }
+ });
+ if (subsequentNode && subsequentNode.pos === node.end) {
+ if (subsequentNode.kind === node.kind) {
+ var errorNode_1 = subsequentNode.name || subsequentNode;
+ var subsequentName = subsequentNode.name;
+ if (node.name && subsequentName && (ts.isPrivateIdentifier(node.name) && ts.isPrivateIdentifier(subsequentName) && node.name.escapedText === subsequentName.escapedText ||
+ ts.isComputedPropertyName(node.name) && ts.isComputedPropertyName(subsequentName) ||
+ ts.isPropertyNameLiteral(node.name) && ts.isPropertyNameLiteral(subsequentName) &&
+ ts.getEscapedTextOfIdentifierOrLiteral(node.name) === ts.getEscapedTextOfIdentifierOrLiteral(subsequentName))) {
+ var reportError = (node.kind === 165 || node.kind === 164) &&
+ ts.hasSyntacticModifier(node, 32) !== ts.hasSyntacticModifier(subsequentNode, 32);
+ if (reportError) {
+ var diagnostic = ts.hasSyntacticModifier(node, 32) ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
+ error(errorNode_1, diagnostic);
}
+ return;
+ }
+ if (ts.nodeIsPresent(subsequentNode.body)) {
+ error(errorNode_1, ts.Diagnostics.Function_implementation_name_must_be_0, ts.declarationNameToString(node.name));
+ return;
}
- continue;
}
- else if (isPrototypeProperty(base)) {
- if (isPrototypeProperty(derived) || derived.flags & 4) {
- continue;
+ }
+ var errorNode = node.name || node;
+ if (isConstructor) {
+ error(errorNode, ts.Diagnostics.Constructor_implementation_is_missing);
+ }
+ else {
+ if (ts.hasSyntacticModifier(node, 128)) {
+ error(errorNode, ts.Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
+ }
+ else {
+ error(errorNode, ts.Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration);
+ }
+ }
+ }
+ var duplicateFunctionDeclaration = false;
+ var multipleConstructorImplementation = false;
+ var hasNonAmbientClass = false;
+ var functionDeclarations = [];
+ for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
+ var current = declarations_4[_i];
+ var node = current;
+ var inAmbientContext = node.flags & 8388608;
+ var inAmbientContextOrInterface = node.parent && (node.parent.kind === 253 || node.parent.kind === 177) || inAmbientContext;
+ if (inAmbientContextOrInterface) {
+ previousDeclaration = undefined;
+ }
+ if ((node.kind === 252 || node.kind === 221) && !inAmbientContext) {
+ hasNonAmbientClass = true;
+ }
+ if (node.kind === 251 || node.kind === 165 || node.kind === 164 || node.kind === 166) {
+ functionDeclarations.push(node);
+ var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck);
+ someNodeFlags |= currentNodeFlags;
+ allNodeFlags &= currentNodeFlags;
+ someHaveQuestionToken = someHaveQuestionToken || ts.hasQuestionToken(node);
+ allHaveQuestionToken = allHaveQuestionToken && ts.hasQuestionToken(node);
+ var bodyIsPresent = ts.nodeIsPresent(node.body);
+ if (bodyIsPresent && bodyDeclaration) {
+ if (isConstructor) {
+ multipleConstructorImplementation = true;
}
else {
- ts.Debug.assert(!!(derived.flags & 98304));
- errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
+ duplicateFunctionDeclaration = true;
}
}
- else if (base.flags & 98304) {
- errorMessage = ts.Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
+ else if ((previousDeclaration === null || previousDeclaration === void 0 ? void 0 : previousDeclaration.parent) === node.parent && previousDeclaration.end !== node.pos) {
+ reportImplementationExpectedError(previousDeclaration);
+ }
+ if (bodyIsPresent) {
+ if (!bodyDeclaration) {
+ bodyDeclaration = node;
+ }
}
else {
- errorMessage = ts.Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
+ hasOverloads = true;
+ }
+ previousDeclaration = node;
+ if (!inAmbientContextOrInterface) {
+ lastSeenNonAmbientDeclaration = node;
}
- error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type));
}
}
- }
- function getNonInterhitedProperties(type, baseTypes, properties) {
- if (!ts.length(baseTypes)) {
- return properties;
+ if (multipleConstructorImplementation) {
+ ts.forEach(functionDeclarations, function (declaration) {
+ error(declaration, ts.Diagnostics.Multiple_constructor_implementations_are_not_allowed);
+ });
}
- var seen = ts.createUnderscoreEscapedMap();
- ts.forEach(properties, function (p) { seen.set(p.escapedName, p); });
- for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {
- var base = baseTypes_2[_i];
- var properties_5 = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
- for (var _a = 0, properties_4 = properties_5; _a < properties_4.length; _a++) {
- var prop = properties_4[_a];
- var existing = seen.get(prop.escapedName);
- if (existing && !isPropertyIdenticalTo(existing, prop)) {
- seen.delete(prop.escapedName);
+ if (duplicateFunctionDeclaration) {
+ ts.forEach(functionDeclarations, function (declaration) {
+ error(ts.getNameOfDeclaration(declaration) || declaration, ts.Diagnostics.Duplicate_function_implementation);
+ });
+ }
+ if (hasNonAmbientClass && !isConstructor && symbol.flags & 16) {
+ ts.forEach(declarations, function (declaration) {
+ addDuplicateDeclarationError(declaration, ts.Diagnostics.Duplicate_identifier_0, ts.symbolName(symbol), declarations);
+ });
+ }
+ if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
+ !ts.hasSyntacticModifier(lastSeenNonAmbientDeclaration, 128) && !lastSeenNonAmbientDeclaration.questionToken) {
+ reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
+ }
+ if (hasOverloads) {
+ checkFlagAgreementBetweenOverloads(declarations, bodyDeclaration, flagsToCheck, someNodeFlags, allNodeFlags);
+ checkQuestionTokenAgreementBetweenOverloads(declarations, bodyDeclaration, someHaveQuestionToken, allHaveQuestionToken);
+ if (bodyDeclaration) {
+ var signatures = getSignaturesOfSymbol(symbol);
+ var bodySignature = getSignatureFromDeclaration(bodyDeclaration);
+ for (var _a = 0, signatures_10 = signatures; _a < signatures_10.length; _a++) {
+ var signature = signatures_10[_a];
+ if (!isImplementationCompatibleWithOverload(bodySignature, signature)) {
+ ts.addRelatedInfo(error(signature.declaration, ts.Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature), ts.createDiagnosticForNode(bodyDeclaration, ts.Diagnostics.The_implementation_signature_is_declared_here));
+ break;
+ }
}
}
}
- return ts.arrayFrom(seen.values());
}
- function checkInheritedPropertiesAreIdentical(type, typeNode) {
- var baseTypes = getBaseTypes(type);
- if (baseTypes.length < 2) {
- return true;
+ function checkExportsOnMergedDeclarations(node) {
+ if (!produceDiagnostics) {
+ return;
}
- var seen = ts.createUnderscoreEscapedMap();
- ts.forEach(resolveDeclaredMembers(type).declaredProperties, function (p) { seen.set(p.escapedName, { prop: p, containingType: type }); });
- var ok = true;
- for (var _i = 0, baseTypes_3 = baseTypes; _i < baseTypes_3.length; _i++) {
- var base = baseTypes_3[_i];
- var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
- for (var _a = 0, properties_6 = properties; _a < properties_6.length; _a++) {
- var prop = properties_6[_a];
- var existing = seen.get(prop.escapedName);
- if (!existing) {
- seen.set(prop.escapedName, { prop: prop, containingType: base });
+ var symbol = node.localSymbol;
+ if (!symbol) {
+ symbol = getSymbolOfNode(node);
+ if (!symbol.exportSymbol) {
+ return;
+ }
+ }
+ if (ts.getDeclarationOfKind(symbol, node.kind) !== node) {
+ return;
+ }
+ var exportedDeclarationSpaces = 0;
+ var nonExportedDeclarationSpaces = 0;
+ var defaultExportedDeclarationSpaces = 0;
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var d = _a[_i];
+ var declarationSpaces = getDeclarationSpaces(d);
+ var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 | 512);
+ if (effectiveDeclarationFlags & 1) {
+ if (effectiveDeclarationFlags & 512) {
+ defaultExportedDeclarationSpaces |= declarationSpaces;
}
else {
- var isInheritedProperty = existing.containingType !== type;
- if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) {
- ok = false;
- var typeName1 = typeToString(existing.containingType);
- var typeName2 = typeToString(base);
- var errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical, symbolToString(prop), typeName1, typeName2);
- errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2);
- diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(typeNode, errorInfo));
- }
+ exportedDeclarationSpaces |= declarationSpaces;
}
}
+ else {
+ nonExportedDeclarationSpaces |= declarationSpaces;
+ }
}
- return ok;
- }
- function checkPropertyInitialization(node) {
- if (!strictNullChecks || !strictPropertyInitialization || node.flags & 8388608) {
- return;
- }
- var constructor = findConstructorDeclaration(node);
- for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
- var member = _a[_i];
- if (ts.getModifierFlags(member) & 2) {
- continue;
+ var nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces;
+ var commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces;
+ var commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces;
+ if (commonDeclarationSpacesForExportsAndLocals || commonDeclarationSpacesForDefaultAndNonDefault) {
+ for (var _b = 0, _c = symbol.declarations; _b < _c.length; _b++) {
+ var d = _c[_b];
+ var declarationSpaces = getDeclarationSpaces(d);
+ var name = ts.getNameOfDeclaration(d);
+ if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) {
+ error(name, ts.Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, ts.declarationNameToString(name));
+ }
+ else if (declarationSpaces & commonDeclarationSpacesForExportsAndLocals) {
+ error(name, ts.Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, ts.declarationNameToString(name));
+ }
}
- if (isInstancePropertyWithoutInitializer(member)) {
- var propName = member.name;
- if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName)) {
- var type = getTypeOfSymbol(getSymbolOfNode(member));
- if (!(type.flags & 3 || getFalsyFlags(type) & 32768)) {
- if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) {
- error(member.name, ts.Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor, ts.declarationNameToString(propName));
- }
+ }
+ function getDeclarationSpaces(decl) {
+ var d = decl;
+ switch (d.kind) {
+ case 253:
+ case 254:
+ case 331:
+ case 324:
+ case 325:
+ return 2;
+ case 256:
+ return ts.isAmbientModule(d) || ts.getModuleInstanceState(d) !== 0
+ ? 4 | 1
+ : 4;
+ case 252:
+ case 255:
+ case 291:
+ return 2 | 1;
+ case 297:
+ return 2 | 1 | 4;
+ case 266:
+ if (!ts.isEntityNameExpression(d.expression)) {
+ return 1;
}
- }
+ d = d.expression;
+ case 260:
+ case 263:
+ case 262:
+ var result_12 = 0;
+ var target = resolveAlias(getSymbolOfNode(d));
+ ts.forEach(target.declarations, function (d) { result_12 |= getDeclarationSpaces(d); });
+ return result_12;
+ case 249:
+ case 198:
+ case 251:
+ case 265:
+ case 78:
+ return 1;
+ default:
+ return ts.Debug.failBadSyntaxKind(d);
}
}
}
- function isInstancePropertyWithoutInitializer(node) {
- return node.kind === 159 &&
- !ts.hasModifier(node, 32 | 128) &&
- !node.exclamationToken &&
- !node.initializer;
- }
- function isPropertyInitializedInConstructor(propName, propType, constructor) {
- var reference = ts.createPropertyAccess(ts.createThis(), propName);
- reference.expression.parent = reference;
- reference.parent = constructor;
- reference.flowNode = constructor.returnFlowNode;
- var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
- return !(getFalsyFlags(flowType) & 32768);
+ function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, arg0) {
+ var promisedType = getPromisedTypeOfPromise(type, errorNode);
+ return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
}
- function checkInterfaceDeclaration(node) {
- if (!checkGrammarDecoratorsAndModifiers(node))
- checkGrammarInterfaceDeclaration(node);
- checkTypeParameters(node.typeParameters);
- if (produceDiagnostics) {
- checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0);
- checkExportsOnMergedDeclarations(node);
- var symbol = getSymbolOfNode(node);
- checkTypeParameterListsIdentical(symbol);
- var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 246);
- if (node === firstInterfaceDecl) {
- var type = getDeclaredTypeOfSymbol(symbol);
- var typeWithThis = getTypeWithThisArgument(type);
- if (checkInheritedPropertiesAreIdentical(type, node.name)) {
- for (var _i = 0, _a = getBaseTypes(type); _i < _a.length; _i++) {
- var baseType = _a[_i];
- checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name, ts.Diagnostics.Interface_0_incorrectly_extends_interface_1);
- }
- checkIndexConstraints(type);
- }
+ function getPromisedTypeOfPromise(type, errorNode) {
+ if (isTypeAny(type)) {
+ return undefined;
+ }
+ var typeAsPromise = type;
+ if (typeAsPromise.promisedTypeOfPromise) {
+ return typeAsPromise.promisedTypeOfPromise;
+ }
+ if (isReferenceToType(type, getGlobalPromiseType(false))) {
+ return typeAsPromise.promisedTypeOfPromise = getTypeArguments(type)[0];
+ }
+ var thenFunction = getTypeOfPropertyOfType(type, "then");
+ if (isTypeAny(thenFunction)) {
+ return undefined;
+ }
+ var thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, 0) : ts.emptyArray;
+ if (thenSignatures.length === 0) {
+ if (errorNode) {
+ error(errorNode, ts.Diagnostics.A_promise_must_have_a_then_method);
}
- checkObjectTypeForDuplicateDeclarations(node);
+ return undefined;
}
- ts.forEach(ts.getInterfaceBaseTypeNodes(node), function (heritageElement) {
- if (!ts.isEntityNameExpression(heritageElement.expression)) {
- error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
+ var onfulfilledParameterType = getTypeWithFacts(getUnionType(ts.map(thenSignatures, getTypeOfFirstParameterOfSignature)), 2097152);
+ if (isTypeAny(onfulfilledParameterType)) {
+ return undefined;
+ }
+ var onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, 0);
+ if (onfulfilledParameterSignatures.length === 0) {
+ if (errorNode) {
+ error(errorNode, ts.Diagnostics.The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback);
}
- checkTypeReferenceNode(heritageElement);
- });
- ts.forEach(node.members, checkSourceElement);
- if (produceDiagnostics) {
- checkTypeForDuplicateIndexSignatures(node);
- registerForUnusedIdentifiersCheck(node);
+ return undefined;
}
+ return typeAsPromise.promisedTypeOfPromise = getUnionType(ts.map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), 2);
}
- function checkTypeAliasDeclaration(node) {
- checkGrammarDecoratorsAndModifiers(node);
- checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0);
- checkExportsOnMergedDeclarations(node);
- checkTypeParameters(node.typeParameters);
- checkSourceElement(node.type);
- registerForUnusedIdentifiersCheck(node);
+ function checkAwaitedType(type, errorNode, diagnosticMessage, arg0) {
+ var awaitedType = getAwaitedType(type, errorNode, diagnosticMessage, arg0);
+ return awaitedType || errorType;
}
- function computeEnumMemberValues(node) {
- var nodeLinks = getNodeLinks(node);
- if (!(nodeLinks.flags & 16384)) {
- nodeLinks.flags |= 16384;
- var autoValue = 0;
- for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
- var member = _a[_i];
- var value = computeMemberValue(member, autoValue);
- getNodeLinks(member).enumMemberValue = value;
- autoValue = typeof value === "number" ? value + 1 : undefined;
+ function isThenableType(type) {
+ var thenFunction = getTypeOfPropertyOfType(type, "then");
+ return !!thenFunction && getSignaturesOfType(getTypeWithFacts(thenFunction, 2097152), 0).length > 0;
+ }
+ function getAwaitedType(type, errorNode, diagnosticMessage, arg0) {
+ if (isTypeAny(type)) {
+ return type;
+ }
+ var typeAsAwaitable = type;
+ if (typeAsAwaitable.awaitedTypeOfType) {
+ return typeAsAwaitable.awaitedTypeOfType;
+ }
+ return typeAsAwaitable.awaitedTypeOfType =
+ mapType(type, errorNode ? function (constituentType) { return getAwaitedTypeWorker(constituentType, errorNode, diagnosticMessage, arg0); } : getAwaitedTypeWorker);
+ }
+ function getAwaitedTypeWorker(type, errorNode, diagnosticMessage, arg0) {
+ var typeAsAwaitable = type;
+ if (typeAsAwaitable.awaitedTypeOfType) {
+ return typeAsAwaitable.awaitedTypeOfType;
+ }
+ var promisedType = getPromisedTypeOfPromise(type);
+ if (promisedType) {
+ if (type.id === promisedType.id || awaitedTypeStack.lastIndexOf(promisedType.id) >= 0) {
+ if (errorNode) {
+ error(errorNode, ts.Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method);
+ }
+ return undefined;
+ }
+ awaitedTypeStack.push(type.id);
+ var awaitedType = getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
+ awaitedTypeStack.pop();
+ if (!awaitedType) {
+ return undefined;
+ }
+ return typeAsAwaitable.awaitedTypeOfType = awaitedType;
+ }
+ if (isThenableType(type)) {
+ if (errorNode) {
+ if (!diagnosticMessage)
+ return ts.Debug.fail();
+ error(errorNode, diagnosticMessage, arg0);
}
+ return undefined;
}
+ return typeAsAwaitable.awaitedTypeOfType = type;
}
- function computeMemberValue(member, autoValue) {
- if (ts.isComputedNonLiteralName(member.name)) {
- error(member.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums);
+ function checkAsyncFunctionReturnType(node, returnTypeNode) {
+ var returnType = getTypeFromTypeNode(returnTypeNode);
+ if (languageVersion >= 2) {
+ if (returnType === errorType) {
+ return;
+ }
+ var globalPromiseType = getGlobalPromiseType(true);
+ if (globalPromiseType !== emptyGenericType && !isReferenceToType(returnType, globalPromiseType)) {
+ error(returnTypeNode, ts.Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, typeToString(getAwaitedType(returnType) || voidType));
+ return;
+ }
}
else {
- var text = ts.getTextOfPropertyName(member.name);
- if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
- error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name);
+ markTypeNodeAsReferenced(returnTypeNode);
+ if (returnType === errorType) {
+ return;
+ }
+ var promiseConstructorName = ts.getEntityNameFromTypeNode(returnTypeNode);
+ if (promiseConstructorName === undefined) {
+ error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, typeToString(returnType));
+ return;
+ }
+ var promiseConstructorSymbol = resolveEntityName(promiseConstructorName, 111551, true);
+ var promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : errorType;
+ if (promiseConstructorType === errorType) {
+ if (promiseConstructorName.kind === 78 && promiseConstructorName.escapedText === "Promise" && getTargetType(returnType) === getGlobalPromiseType(false)) {
+ error(returnTypeNode, ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
+ }
+ else {
+ error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, ts.entityNameToString(promiseConstructorName));
+ }
+ return;
+ }
+ var globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(true);
+ if (globalPromiseConstructorLikeType === emptyObjectType) {
+ error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, ts.entityNameToString(promiseConstructorName));
+ return;
+ }
+ if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value)) {
+ return;
+ }
+ var rootName = promiseConstructorName && ts.getFirstIdentifier(promiseConstructorName);
+ var collidingSymbol = getSymbol(node.locals, rootName.escapedText, 111551);
+ if (collidingSymbol) {
+ error(collidingSymbol.valueDeclaration, ts.Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, ts.idText(rootName), ts.entityNameToString(promiseConstructorName));
+ return;
}
}
- if (member.initializer) {
- return computeConstantValue(member);
+ checkAwaitedType(returnType, node, ts.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) {
+ var signature = getResolvedSignature(node);
+ checkDeprecatedSignature(signature, node);
+ var returnType = getReturnTypeOfSignature(signature);
+ if (returnType.flags & 1) {
+ return;
}
- if (member.parent.flags & 8388608 && !ts.isEnumConst(member.parent) && getEnumKind(getSymbolOfNode(member.parent)) === 0) {
- return undefined;
+ var expectedReturnType;
+ var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
+ var errorInfo;
+ switch (node.parent.kind) {
+ case 252:
+ var classSymbol = getSymbolOfNode(node.parent);
+ var classConstructorType = getTypeOfSymbol(classSymbol);
+ expectedReturnType = getUnionType([classConstructorType, voidType]);
+ break;
+ case 160:
+ expectedReturnType = voidType;
+ errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any);
+ break;
+ case 163:
+ expectedReturnType = voidType;
+ errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any);
+ break;
+ case 165:
+ case 167:
+ case 168:
+ var methodType = getTypeOfNode(node.parent);
+ var descriptorType = createTypedPropertyDescriptorType(methodType);
+ expectedReturnType = getUnionType([descriptorType, voidType]);
+ break;
+ default:
+ return ts.Debug.fail();
}
- if (autoValue !== undefined) {
- return autoValue;
+ checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, function () { return errorInfo; });
+ }
+ function markTypeNodeAsReferenced(node) {
+ markEntityNameOrEntityExpressionAsReference(node && ts.getEntityNameFromTypeNode(node));
+ }
+ function markEntityNameOrEntityExpressionAsReference(typeName) {
+ if (!typeName)
+ return;
+ var rootName = ts.getFirstIdentifier(typeName);
+ var meaning = (typeName.kind === 78 ? 788968 : 1920) | 2097152;
+ var rootSymbol = resolveName(rootName, rootName.escapedText, meaning, undefined, undefined, true);
+ if (rootSymbol
+ && rootSymbol.flags & 2097152
+ && symbolIsValue(rootSymbol)
+ && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol))
+ && !getTypeOnlyAliasDeclaration(rootSymbol)) {
+ markAliasSymbolAsReferenced(rootSymbol);
}
- error(member.name, ts.Diagnostics.Enum_member_must_have_initializer);
- return undefined;
}
- function computeConstantValue(member) {
- var enumKind = getEnumKind(getSymbolOfNode(member.parent));
- var isConstEnum = ts.isEnumConst(member.parent);
- var initializer = member.initializer;
- var value = enumKind === 1 && !isLiteralEnumMember(member) ? undefined : evaluate(initializer);
- if (value !== undefined) {
- if (isConstEnum && typeof value === "number" && !isFinite(value)) {
- error(initializer, isNaN(value) ?
- ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN :
- ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value);
+ function markDecoratorMedataDataTypeNodeAsReferenced(node) {
+ var entityName = getEntityNameForDecoratorMetadata(node);
+ if (entityName && ts.isEntityName(entityName)) {
+ markEntityNameOrEntityExpressionAsReference(entityName);
+ }
+ }
+ function getEntityNameForDecoratorMetadata(node) {
+ if (node) {
+ switch (node.kind) {
+ case 183:
+ case 182:
+ return getEntityNameForDecoratorMetadataFromTypeList(node.types);
+ case 184:
+ return getEntityNameForDecoratorMetadataFromTypeList([node.trueType, node.falseType]);
+ case 186:
+ case 192:
+ return getEntityNameForDecoratorMetadata(node.type);
+ case 173:
+ return node.typeName;
}
}
- else if (enumKind === 1) {
- error(initializer, ts.Diagnostics.Computed_values_are_not_permitted_in_an_enum_with_string_valued_members);
- return 0;
+ }
+ function getEntityNameForDecoratorMetadataFromTypeList(types) {
+ var commonEntityName;
+ for (var _i = 0, types_21 = types; _i < types_21.length; _i++) {
+ var typeNode = types_21[_i];
+ while (typeNode.kind === 186 || typeNode.kind === 192) {
+ typeNode = typeNode.type;
+ }
+ if (typeNode.kind === 141) {
+ continue;
+ }
+ if (!strictNullChecks && (typeNode.kind === 191 && typeNode.literal.kind === 103 || typeNode.kind === 150)) {
+ continue;
+ }
+ var individualEntityName = getEntityNameForDecoratorMetadata(typeNode);
+ if (!individualEntityName) {
+ return undefined;
+ }
+ if (commonEntityName) {
+ if (!ts.isIdentifier(commonEntityName) ||
+ !ts.isIdentifier(individualEntityName) ||
+ commonEntityName.escapedText !== individualEntityName.escapedText) {
+ return undefined;
+ }
+ }
+ else {
+ commonEntityName = individualEntityName;
+ }
+ }
+ return commonEntityName;
+ }
+ function getParameterTypeNodeForDecoratorCheck(node) {
+ var typeNode = ts.getEffectiveTypeAnnotationNode(node);
+ return ts.isRestParameter(node) ? ts.getRestParameterElementType(typeNode) : typeNode;
+ }
+ function checkDecorators(node) {
+ if (!node.decorators) {
+ return;
}
- else if (isConstEnum) {
- error(initializer, ts.Diagnostics.const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values);
+ if (!ts.nodeCanBeDecorated(node, node.parent, node.parent.parent)) {
+ return;
}
- else if (member.parent.flags & 8388608) {
- error(initializer, ts.Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);
+ if (!compilerOptions.experimentalDecorators) {
+ error(node, ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning);
}
- else {
- var source = checkExpression(initializer);
- if (!isTypeAssignableToKind(source, 296)) {
- error(initializer, ts.Diagnostics.Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhaustiveness_checks_consider_using_an_object_literal_instead, typeToString(source));
- }
- else {
- checkTypeAssignableTo(source, getDeclaredTypeOfSymbol(getSymbolOfNode(member.parent)), initializer, undefined);
- }
+ var firstDecorator = node.decorators[0];
+ checkExternalEmitHelpers(firstDecorator, 8);
+ if (node.kind === 160) {
+ checkExternalEmitHelpers(firstDecorator, 32);
}
- return value;
- function evaluate(expr) {
- switch (expr.kind) {
- case 207:
- var value_2 = evaluate(expr.operand);
- if (typeof value_2 === "number") {
- switch (expr.operator) {
- case 39: return value_2;
- case 40: return -value_2;
- case 54: return ~value_2;
+ if (compilerOptions.emitDecoratorMetadata) {
+ checkExternalEmitHelpers(firstDecorator, 16);
+ switch (node.kind) {
+ case 252:
+ var constructor = ts.getFirstConstructorWithBody(node);
+ if (constructor) {
+ for (var _i = 0, _a = constructor.parameters; _i < _a.length; _i++) {
+ var parameter = _a[_i];
+ markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
}
}
break;
- case 209:
- var left = evaluate(expr.left);
- var right = evaluate(expr.right);
- if (typeof left === "number" && typeof right === "number") {
- switch (expr.operatorToken.kind) {
- case 51: return left | right;
- case 50: return left & right;
- case 48: return left >> right;
- case 49: return left >>> right;
- case 47: return left << right;
- case 52: return left ^ right;
- case 41: return left * right;
- case 43: return left / right;
- case 39: return left + right;
- case 40: return left - right;
- case 44: return left % right;
- case 42: return Math.pow(left, right);
- }
- }
- else if (typeof left === "string" && typeof right === "string" && expr.operatorToken.kind === 39) {
- return left + right;
- }
+ case 167:
+ case 168:
+ var otherKind = node.kind === 167 ? 168 : 167;
+ var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(node), otherKind);
+ markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
break;
- case 10:
- case 14:
- return expr.text;
- case 8:
- checkGrammarNumericLiteral(expr);
- return +expr.text;
- case 200:
- return evaluate(expr.expression);
- case 75:
- var identifier = expr;
- if (isInfinityOrNaNString(identifier.escapedText)) {
- return +(identifier.escapedText);
+ case 165:
+ for (var _b = 0, _c = node.parameters; _b < _c.length; _b++) {
+ var parameter = _c[_b];
+ markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
}
- return ts.nodeIsMissing(expr) ? 0 : evaluateEnumMember(expr, getSymbolOfNode(member.parent), identifier.escapedText);
- case 195:
- case 194:
- var ex = expr;
- if (isConstantMemberAccess(ex)) {
- var type = getTypeOfExpression(ex.expression);
- if (type.symbol && type.symbol.flags & 384) {
- var name = void 0;
- if (ex.kind === 194) {
- name = ex.name.escapedText;
- }
- else {
- name = ts.escapeLeadingUnderscores(ts.cast(ex.argumentExpression, ts.isLiteralExpression).text);
- }
- return evaluateEnumMember(expr, type.symbol, name);
- }
+ markDecoratorMedataDataTypeNodeAsReferenced(ts.getEffectiveReturnTypeNode(node));
+ break;
+ case 163:
+ markDecoratorMedataDataTypeNodeAsReferenced(ts.getEffectiveTypeAnnotationNode(node));
+ break;
+ case 160:
+ markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
+ var containingSignature = node.parent;
+ for (var _d = 0, _e = containingSignature.parameters; _d < _e.length; _d++) {
+ var parameter = _e[_d];
+ markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
}
break;
}
- return undefined;
}
- function evaluateEnumMember(expr, enumSymbol, name) {
- var memberSymbol = enumSymbol.exports.get(name);
- if (memberSymbol) {
- var declaration = memberSymbol.valueDeclaration;
- if (declaration !== member) {
- if (isBlockScopedNameDeclaredBeforeUse(declaration, member)) {
- return getEnumMemberValue(declaration);
- }
- error(expr, ts.Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
- return 0;
- }
- else {
- error(expr, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(memberSymbol));
- }
- }
- return undefined;
+ ts.forEach(node.decorators, checkDecorator);
+ }
+ function checkFunctionDeclaration(node) {
+ if (produceDiagnostics) {
+ checkFunctionOrMethodDeclaration(node);
+ checkGrammarForGenerator(node);
+ checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+ checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
}
}
- function isConstantMemberAccess(node) {
- return node.kind === 75 ||
- node.kind === 194 && isConstantMemberAccess(node.expression) ||
- node.kind === 195 && isConstantMemberAccess(node.expression) &&
- ts.isStringLiteralLike(node.argumentExpression);
+ function checkJSDocTypeAliasTag(node) {
+ if (!node.typeExpression) {
+ error(node.name, ts.Diagnostics.JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags);
+ }
+ if (node.name) {
+ checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0);
+ }
+ checkSourceElement(node.typeExpression);
}
- function checkEnumDeclaration(node) {
- if (!produceDiagnostics) {
- return;
+ function checkJSDocTemplateTag(node) {
+ checkSourceElement(node.constraint);
+ for (var _i = 0, _a = node.typeParameters; _i < _a.length; _i++) {
+ var tp = _a[_i];
+ checkSourceElement(tp);
}
- checkGrammarDecoratorsAndModifiers(node);
- checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0);
- checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
- checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
- checkExportsOnMergedDeclarations(node);
- node.members.forEach(checkEnumMember);
- computeEnumMemberValues(node);
- var enumSymbol = getSymbolOfNode(node);
- var firstDeclaration = ts.getDeclarationOfKind(enumSymbol, node.kind);
- if (node === firstDeclaration) {
- if (enumSymbol.declarations.length > 1) {
- var enumIsConst_1 = ts.isEnumConst(node);
- ts.forEach(enumSymbol.declarations, function (decl) {
- if (ts.isEnumDeclaration(decl) && ts.isEnumConst(decl) !== enumIsConst_1) {
- error(ts.getNameOfDeclaration(decl), ts.Diagnostics.Enum_declarations_must_all_be_const_or_non_const);
- }
- });
- }
- var seenEnumMissingInitialInitializer_1 = false;
- ts.forEach(enumSymbol.declarations, function (declaration) {
- if (declaration.kind !== 248) {
- return false;
- }
- var enumDeclaration = declaration;
- if (!enumDeclaration.members.length) {
- return false;
+ }
+ function checkJSDocTypeTag(node) {
+ checkSourceElement(node.typeExpression);
+ }
+ function checkJSDocParameterTag(node) {
+ checkSourceElement(node.typeExpression);
+ if (!ts.getParameterSymbolFromJSDoc(node)) {
+ var decl = ts.getHostSignatureFromJSDoc(node);
+ if (decl) {
+ var i = ts.getJSDocTags(decl).filter(ts.isJSDocParameterTag).indexOf(node);
+ if (i > -1 && i < decl.parameters.length && ts.isBindingPattern(decl.parameters[i].name)) {
+ return;
}
- var firstEnumMember = enumDeclaration.members[0];
- if (!firstEnumMember.initializer) {
- if (seenEnumMissingInitialInitializer_1) {
- error(firstEnumMember.name, ts.Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element);
+ if (!containsArgumentsReference(decl)) {
+ if (ts.isQualifiedName(node.name)) {
+ error(node.name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(node.name), ts.entityNameToString(node.name.left));
}
else {
- seenEnumMissingInitialInitializer_1 = true;
+ error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(node.name));
}
}
- });
+ else if (ts.findLast(ts.getJSDocTags(decl), ts.isJSDocParameterTag) === node &&
+ node.typeExpression && node.typeExpression.type &&
+ !isArrayType(getTypeFromTypeNode(node.typeExpression.type))) {
+ error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(node.name.kind === 157 ? node.name.right : node.name));
+ }
+ }
}
}
- function checkEnumMember(node) {
- if (ts.isPrivateIdentifier(node.name)) {
- error(node, ts.Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier);
- }
+ function checkJSDocPropertyTag(node) {
+ checkSourceElement(node.typeExpression);
}
- function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
- var declarations = symbol.declarations;
- for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
- var declaration = declarations_8[_i];
- if ((declaration.kind === 245 ||
- (declaration.kind === 244 && ts.nodeIsPresent(declaration.body))) &&
- !(declaration.flags & 8388608)) {
- return declaration;
- }
+ function checkJSDocFunctionType(node) {
+ if (produceDiagnostics && !node.type && !ts.isJSDocConstructSignature(node)) {
+ reportImplicitAny(node, anyType);
}
- return undefined;
+ checkSignatureDeclaration(node);
}
- function inSameLexicalScope(node1, node2) {
- var container1 = ts.getEnclosingBlockScopeContainer(node1);
- var container2 = ts.getEnclosingBlockScopeContainer(node2);
- if (isGlobalSourceFile(container1)) {
- return isGlobalSourceFile(container2);
- }
- else if (isGlobalSourceFile(container2)) {
- return false;
- }
- else {
- return container1 === container2;
+ function checkJSDocImplementsTag(node) {
+ var classLike = ts.getEffectiveJSDocHost(node);
+ if (!classLike || !ts.isClassDeclaration(classLike) && !ts.isClassExpression(classLike)) {
+ error(classLike, ts.Diagnostics.JSDoc_0_is_not_attached_to_a_class, ts.idText(node.tagName));
}
}
- function checkModuleDeclaration(node) {
- if (produceDiagnostics) {
- var isGlobalAugmentation = ts.isGlobalScopeAugmentation(node);
- var inAmbientContext = node.flags & 8388608;
- if (isGlobalAugmentation && !inAmbientContext) {
- error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context);
- }
- var isAmbientExternalModule = ts.isAmbientModule(node);
- var contextErrorMessage = isAmbientExternalModule
- ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file
- : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module;
- if (checkGrammarModuleElementContext(node, contextErrorMessage)) {
- return;
- }
- if (!checkGrammarDecoratorsAndModifiers(node)) {
- if (!inAmbientContext && node.name.kind === 10) {
- grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names);
- }
- }
- if (ts.isIdentifier(node.name)) {
- checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
- checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
- }
- checkExportsOnMergedDeclarations(node);
- var symbol = getSymbolOfNode(node);
- if (symbol.flags & 512
- && !inAmbientContext
- && symbol.declarations.length > 1
- && isInstantiatedModule(node, !!compilerOptions.preserveConstEnums || !!compilerOptions.isolatedModules)) {
- var firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
- if (firstNonAmbientClassOrFunc) {
- if (ts.getSourceFileOfNode(node) !== ts.getSourceFileOfNode(firstNonAmbientClassOrFunc)) {
- error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged);
- }
- else if (node.pos < firstNonAmbientClassOrFunc.pos) {
- error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged);
- }
- }
- var mergedClass = ts.getDeclarationOfKind(symbol, 245);
- if (mergedClass &&
- inSameLexicalScope(node, mergedClass)) {
- getNodeLinks(node).flags |= 32768;
- }
- }
- if (isAmbientExternalModule) {
- if (ts.isExternalModuleAugmentation(node)) {
- var checkBody = isGlobalAugmentation || (getSymbolOfNode(node).flags & 33554432);
- if (checkBody && node.body) {
- for (var _i = 0, _a = node.body.statements; _i < _a.length; _i++) {
- var statement = _a[_i];
- checkModuleAugmentationElement(statement, isGlobalAugmentation);
- }
- }
- }
- else if (isGlobalSourceFile(node.parent)) {
- if (isGlobalAugmentation) {
- error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
- }
- else if (ts.isExternalModuleNameRelative(ts.getTextOfIdentifierOrLiteral(node.name))) {
- error(node.name, ts.Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name);
- }
- }
- else {
- if (isGlobalAugmentation) {
- error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
- }
- else {
- error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces);
- }
- }
- }
+ function checkJSDocAugmentsTag(node) {
+ var classLike = ts.getEffectiveJSDocHost(node);
+ if (!classLike || !ts.isClassDeclaration(classLike) && !ts.isClassExpression(classLike)) {
+ error(classLike, ts.Diagnostics.JSDoc_0_is_not_attached_to_a_class, ts.idText(node.tagName));
+ return;
}
- if (node.body) {
- checkSourceElement(node.body);
- if (!ts.isGlobalScopeAugmentation(node)) {
- registerForUnusedIdentifiersCheck(node);
- }
+ var augmentsTags = ts.getJSDocTags(classLike).filter(ts.isJSDocAugmentsTag);
+ ts.Debug.assert(augmentsTags.length > 0);
+ if (augmentsTags.length > 1) {
+ error(augmentsTags[1], ts.Diagnostics.Class_declarations_cannot_have_more_than_one_augments_or_extends_tag);
}
- }
- function checkModuleAugmentationElement(node, isGlobalAugmentation) {
- switch (node.kind) {
- case 225:
- for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) {
- var decl = _a[_i];
- checkModuleAugmentationElement(decl, isGlobalAugmentation);
- }
- break;
- case 259:
- case 260:
- grammarErrorOnFirstToken(node, ts.Diagnostics.Exports_and_export_assignments_are_not_permitted_in_module_augmentations);
- break;
- case 253:
- case 254:
- grammarErrorOnFirstToken(node, ts.Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module);
- break;
- case 191:
- case 242:
- var name = node.name;
- if (ts.isBindingPattern(name)) {
- for (var _b = 0, _c = name.elements; _b < _c.length; _b++) {
- var el = _c[_b];
- checkModuleAugmentationElement(el, isGlobalAugmentation);
- }
- break;
- }
- case 245:
- case 248:
- case 244:
- case 246:
- case 249:
- case 247:
- if (isGlobalAugmentation) {
- return;
- }
- var symbol = getSymbolOfNode(node);
- if (symbol) {
- var reportError = !(symbol.flags & 33554432);
- if (!reportError) {
- reportError = !!symbol.parent && ts.isExternalModuleAugmentation(symbol.parent.declarations[0]);
- }
- }
- break;
+ var name = getIdentifierFromEntityNameExpression(node.class.expression);
+ var extend = ts.getClassExtendsHeritageElement(classLike);
+ if (extend) {
+ var className = getIdentifierFromEntityNameExpression(extend.expression);
+ if (className && name.escapedText !== className.escapedText) {
+ error(name, ts.Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause, ts.idText(node.tagName), ts.idText(name), ts.idText(className));
+ }
}
}
- function getFirstNonModuleExportsIdentifier(node) {
+ function getIdentifierFromEntityNameExpression(node) {
switch (node.kind) {
- case 75:
- return node;
- case 153:
- do {
- node = node.left;
- } while (node.kind !== 75);
- return node;
- case 194:
- do {
- if (ts.isModuleExportsAccessExpression(node.expression) && !ts.isPrivateIdentifier(node.name)) {
- return node.name;
- }
- node = node.expression;
- } while (node.kind !== 75);
+ case 78:
return node;
+ case 201:
+ return node.name;
+ default:
+ return undefined;
}
}
- function checkExternalImportOrExportDeclaration(node) {
- var moduleName = ts.getExternalModuleName(node);
- if (!moduleName || ts.nodeIsMissing(moduleName)) {
- return false;
+ function checkFunctionOrMethodDeclaration(node) {
+ checkDecorators(node);
+ checkSignatureDeclaration(node);
+ var functionFlags = ts.getFunctionFlags(node);
+ if (node.name && node.name.kind === 158) {
+ checkComputedPropertyName(node.name);
}
- if (!ts.isStringLiteral(moduleName)) {
- error(moduleName, ts.Diagnostics.String_literal_expected);
- return false;
+ if (!hasNonBindableDynamicName(node)) {
+ var symbol = getSymbolOfNode(node);
+ var localSymbol = node.localSymbol || symbol;
+ var firstDeclaration = ts.find(localSymbol.declarations, function (declaration) { return declaration.kind === node.kind && !(declaration.flags & 131072); });
+ if (node === firstDeclaration) {
+ checkFunctionOrConstructorSymbol(localSymbol);
+ }
+ if (symbol.parent) {
+ checkFunctionOrConstructorSymbol(symbol);
+ }
}
- var inAmbientExternalModule = node.parent.kind === 250 && ts.isAmbientModule(node.parent.parent);
- if (node.parent.kind !== 290 && !inAmbientExternalModule) {
- error(moduleName, node.kind === 260 ?
- ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace :
- ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module);
- return false;
+ var body = node.kind === 164 ? undefined : node.body;
+ checkSourceElement(body);
+ checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, getReturnTypeFromAnnotation(node));
+ if (produceDiagnostics && !ts.getEffectiveReturnTypeNode(node)) {
+ if (ts.nodeIsMissing(body) && !isPrivateWithinAmbient(node)) {
+ reportImplicitAny(node, anyType);
+ }
+ if (functionFlags & 1 && ts.nodeIsPresent(body)) {
+ getReturnTypeOfSignature(getSignatureFromDeclaration(node));
+ }
}
- if (inAmbientExternalModule && ts.isExternalModuleNameRelative(moduleName.text)) {
- if (!isTopLevelInExternalModuleAugmentation(node)) {
- error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name);
- return false;
+ if (ts.isInJSFile(node)) {
+ var typeTag = ts.getJSDocTypeTag(node);
+ if (typeTag && typeTag.typeExpression && !getContextualCallSignature(getTypeFromTypeNode(typeTag.typeExpression), node)) {
+ error(typeTag, ts.Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature);
}
}
- return true;
}
- function checkAliasSymbol(node) {
- var symbol = getSymbolOfNode(node);
- var target = resolveAlias(symbol);
- var shouldSkipWithJSExpandoTargets = symbol.flags & 67108864;
- if (!shouldSkipWithJSExpandoTargets && target !== unknownSymbol) {
- symbol = getMergedSymbol(symbol.exportSymbol || symbol);
- var excludedMeanings = (symbol.flags & (111551 | 1048576) ? 111551 : 0) |
- (symbol.flags & 788968 ? 788968 : 0) |
- (symbol.flags & 1920 ? 1920 : 0);
- if (target.flags & excludedMeanings) {
- var message = node.kind === 263 ?
- ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 :
- ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
- error(node, message, symbolToString(symbol));
- }
- if (compilerOptions.isolatedModules
- && node.kind === 263
- && !node.parent.parent.isTypeOnly
- && !(target.flags & 111551)
- && !(node.flags & 8388608)) {
- error(node, ts.Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type);
+ function registerForUnusedIdentifiersCheck(node) {
+ if (produceDiagnostics) {
+ var sourceFile = ts.getSourceFileOfNode(node);
+ var potentiallyUnusedIdentifiers = allPotentiallyUnusedIdentifiers.get(sourceFile.path);
+ if (!potentiallyUnusedIdentifiers) {
+ potentiallyUnusedIdentifiers = [];
+ allPotentiallyUnusedIdentifiers.set(sourceFile.path, potentiallyUnusedIdentifiers);
}
+ potentiallyUnusedIdentifiers.push(node);
}
}
- function checkImportBinding(node) {
- checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
- checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
- checkAliasSymbol(node);
- }
- function checkImportDeclaration(node) {
- if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
- return;
- }
- if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasModifiers(node)) {
- grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers);
- }
- if (checkExternalImportOrExportDeclaration(node)) {
- var importClause = node.importClause;
- if (importClause && !checkGrammarImportClause(importClause)) {
- if (importClause.name) {
- checkImportBinding(importClause);
- }
- if (importClause.namedBindings) {
- if (importClause.namedBindings.kind === 256) {
- checkImportBinding(importClause.namedBindings);
- }
- else {
- var moduleExisted = resolveExternalModuleName(node, node.moduleSpecifier);
- if (moduleExisted) {
- ts.forEach(importClause.namedBindings.elements, checkImportBinding);
- }
+ function checkUnusedIdentifiers(potentiallyUnusedIdentifiers, addDiagnostic) {
+ for (var _i = 0, potentiallyUnusedIdentifiers_1 = potentiallyUnusedIdentifiers; _i < potentiallyUnusedIdentifiers_1.length; _i++) {
+ var node = potentiallyUnusedIdentifiers_1[_i];
+ switch (node.kind) {
+ case 252:
+ case 221:
+ checkUnusedClassMembers(node, addDiagnostic);
+ checkUnusedTypeParameters(node, addDiagnostic);
+ break;
+ case 297:
+ case 256:
+ case 230:
+ case 258:
+ case 237:
+ case 238:
+ case 239:
+ checkUnusedLocalsAndParameters(node, addDiagnostic);
+ break;
+ case 166:
+ case 208:
+ case 251:
+ case 209:
+ case 165:
+ case 167:
+ case 168:
+ if (node.body) {
+ checkUnusedLocalsAndParameters(node, addDiagnostic);
}
- }
+ checkUnusedTypeParameters(node, addDiagnostic);
+ break;
+ case 164:
+ case 169:
+ case 170:
+ case 174:
+ case 175:
+ case 254:
+ case 253:
+ checkUnusedTypeParameters(node, addDiagnostic);
+ break;
+ case 185:
+ checkUnusedInferTypeParameter(node, addDiagnostic);
+ break;
+ default:
+ ts.Debug.assertNever(node, "Node should not have been registered for unused identifiers check");
}
}
}
- function checkImportEqualsDeclaration(node) {
- if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
- return;
- }
- checkGrammarDecoratorsAndModifiers(node);
- if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
- checkImportBinding(node);
- if (ts.hasModifier(node, 1)) {
- markExportAsReferenced(node);
- }
- if (node.moduleReference.kind !== 265) {
- var target = resolveAlias(getSymbolOfNode(node));
- if (target !== unknownSymbol) {
- if (target.flags & 111551) {
- var moduleName = ts.getFirstIdentifier(node.moduleReference);
- if (!(resolveEntityName(moduleName, 111551 | 1920).flags & 1920)) {
- error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName));
- }
+ function errorUnusedLocal(declaration, name, addDiagnostic) {
+ var node = ts.getNameOfDeclaration(declaration) || declaration;
+ var message = isTypeDeclaration(declaration) ? ts.Diagnostics._0_is_declared_but_never_used : ts.Diagnostics._0_is_declared_but_its_value_is_never_read;
+ addDiagnostic(declaration, 0, ts.createDiagnosticForNode(node, message, name));
+ }
+ function isIdentifierThatStartsWithUnderscore(node) {
+ return ts.isIdentifier(node) && ts.idText(node).charCodeAt(0) === 95;
+ }
+ function checkUnusedClassMembers(node, addDiagnostic) {
+ for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+ var member = _a[_i];
+ switch (member.kind) {
+ case 165:
+ case 163:
+ case 167:
+ case 168:
+ if (member.kind === 168 && member.symbol.flags & 32768) {
+ break;
}
- if (target.flags & 788968) {
- checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0);
+ var symbol = getSymbolOfNode(member);
+ if (!symbol.isReferenced
+ && (ts.hasEffectiveModifier(member, 8) || ts.isNamedDeclaration(member) && ts.isPrivateIdentifier(member.name))
+ && !(member.flags & 8388608)) {
+ addDiagnostic(member, 0, ts.createDiagnosticForNode(member.name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol)));
}
- }
- }
- else {
- if (moduleKind >= ts.ModuleKind.ES2015 && !(node.flags & 8388608)) {
- grammarErrorOnNode(node, ts.Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
- }
+ break;
+ case 166:
+ for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) {
+ var parameter = _c[_b];
+ if (!parameter.symbol.isReferenced && ts.hasSyntacticModifier(parameter, 8)) {
+ addDiagnostic(parameter, 0, ts.createDiagnosticForNode(parameter.name, ts.Diagnostics.Property_0_is_declared_but_its_value_is_never_read, ts.symbolName(parameter.symbol)));
+ }
+ }
+ break;
+ case 171:
+ case 229:
+ break;
+ default:
+ ts.Debug.fail();
}
}
}
- function checkExportDeclaration(node) {
- if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) {
- return;
- }
- if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasModifiers(node)) {
- grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers);
- }
- if (node.moduleSpecifier && node.exportClause && ts.isNamedExports(node.exportClause) && ts.length(node.exportClause.elements) && languageVersion === 0) {
- checkExternalEmitHelpers(node, 1048576);
+ function checkUnusedInferTypeParameter(node, addDiagnostic) {
+ var typeParameter = node.typeParameter;
+ if (isTypeParameterUnused(typeParameter)) {
+ addDiagnostic(node, 1, ts.createDiagnosticForNode(node, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.idText(typeParameter.name)));
}
- checkGrammarExportDeclaration(node);
- if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
- if (node.exportClause && !ts.isNamespaceExport(node.exportClause)) {
- ts.forEach(node.exportClause.elements, checkExportSpecifier);
- var inAmbientExternalModule = node.parent.kind === 250 && ts.isAmbientModule(node.parent.parent);
- var inAmbientNamespaceDeclaration = !inAmbientExternalModule && node.parent.kind === 250 &&
- !node.moduleSpecifier && node.flags & 8388608;
- if (node.parent.kind !== 290 && !inAmbientExternalModule && !inAmbientNamespaceDeclaration) {
- error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace);
+ }
+ function checkUnusedTypeParameters(node, addDiagnostic) {
+ if (ts.last(getSymbolOfNode(node).declarations) !== node)
+ return;
+ var typeParameters = ts.getEffectiveTypeParameterDeclarations(node);
+ var seenParentsWithEveryUnused = new ts.Set();
+ for (var _i = 0, typeParameters_3 = typeParameters; _i < typeParameters_3.length; _i++) {
+ var typeParameter = typeParameters_3[_i];
+ if (!isTypeParameterUnused(typeParameter))
+ continue;
+ var name = ts.idText(typeParameter.name);
+ var parent = typeParameter.parent;
+ if (parent.kind !== 185 && parent.typeParameters.every(isTypeParameterUnused)) {
+ if (ts.tryAddToSet(seenParentsWithEveryUnused, parent)) {
+ var range = ts.isJSDocTemplateTag(parent)
+ ? ts.rangeOfNode(parent)
+ : ts.rangeOfTypeParameters(parent.typeParameters);
+ var only = parent.typeParameters.length === 1;
+ var message = only ? ts.Diagnostics._0_is_declared_but_its_value_is_never_read : ts.Diagnostics.All_type_parameters_are_unused;
+ var arg0 = only ? name : undefined;
+ addDiagnostic(typeParameter, 1, ts.createFileDiagnostic(ts.getSourceFileOfNode(parent), range.pos, range.end - range.pos, message, arg0));
}
}
else {
- var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
- if (moduleSymbol && hasExportAssignmentSymbol(moduleSymbol)) {
- error(node.moduleSpecifier, ts.Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol));
- }
- else if (node.exportClause) {
- checkAliasSymbol(node.exportClause);
- }
- if (moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015) {
- checkExternalEmitHelpers(node, 65536);
- }
+ addDiagnostic(typeParameter, 1, ts.createDiagnosticForNode(typeParameter, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, name));
}
}
}
- function checkGrammarExportDeclaration(node) {
- var _a;
- var isTypeOnlyExportStar = node.isTypeOnly && ((_a = node.exportClause) === null || _a === void 0 ? void 0 : _a.kind) !== 261;
- if (isTypeOnlyExportStar) {
- grammarErrorOnNode(node, ts.Diagnostics.Only_named_exports_may_use_export_type);
- }
- return !isTypeOnlyExportStar;
+ function isTypeParameterUnused(typeParameter) {
+ return !(getMergedSymbol(typeParameter.symbol).isReferenced & 262144) && !isIdentifierThatStartsWithUnderscore(typeParameter.name);
}
- function checkGrammarModuleElementContext(node, errorMessage) {
- var isInAppropriateContext = node.parent.kind === 290 || node.parent.kind === 250 || node.parent.kind === 249;
- if (!isInAppropriateContext) {
- grammarErrorOnFirstToken(node, errorMessage);
+ function addToGroup(map, key, value, getKey) {
+ var keyString = String(getKey(key));
+ var group = map.get(keyString);
+ if (group) {
+ group[1].push(value);
+ }
+ else {
+ map.set(keyString, [key, [value]]);
}
- return !isInAppropriateContext;
- }
- function importClauseContainsReferencedImport(importClause) {
- return ts.forEachImportClauseDeclaration(importClause, function (declaration) {
- return !!getSymbolOfNode(declaration).isReferenced;
- });
}
- function importClauseContainsConstEnumUsedAsValue(importClause) {
- return ts.forEachImportClauseDeclaration(importClause, function (declaration) {
- return !!getSymbolLinks(getSymbolOfNode(declaration)).constEnumReferenced;
- });
+ function tryGetRootParameterDeclaration(node) {
+ return ts.tryCast(ts.getRootDeclaration(node), ts.isParameter);
}
- function checkImportsForTypeOnlyConversion(sourceFile) {
- for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) {
- var statement = _a[_i];
- if (ts.isImportDeclaration(statement) &&
- statement.importClause &&
- !statement.importClause.isTypeOnly &&
- importClauseContainsReferencedImport(statement.importClause) &&
- !isReferencedAliasDeclaration(statement.importClause, true) &&
- !importClauseContainsConstEnumUsedAsValue(statement.importClause)) {
- error(statement, ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error);
- }
+ function isValidUnusedLocalDeclaration(declaration) {
+ if (ts.isBindingElement(declaration) && isIdentifierThatStartsWithUnderscore(declaration.name)) {
+ return !!ts.findAncestor(declaration.parent, function (ancestor) {
+ return ts.isArrayBindingPattern(ancestor) || ts.isVariableDeclaration(ancestor) || ts.isVariableDeclarationList(ancestor) ? false :
+ ts.isForOfStatement(ancestor) ? true : "quit";
+ });
}
+ return ts.isAmbientModule(declaration) ||
+ (ts.isVariableDeclaration(declaration) && ts.isForInOrOfStatement(declaration.parent.parent) || isImportedDeclaration(declaration)) && isIdentifierThatStartsWithUnderscore(declaration.name);
}
- function checkExportSpecifier(node) {
- checkAliasSymbol(node);
- if (ts.getEmitDeclarations(compilerOptions)) {
- collectLinkedAliases(node.propertyName || node.name, true);
- }
- if (!node.parent.parent.moduleSpecifier) {
- var exportedName = node.propertyName || node.name;
- var symbol = resolveName(exportedName, exportedName.escapedText, 111551 | 788968 | 1920 | 2097152, undefined, undefined, true);
- if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
- error(exportedName, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, ts.idText(exportedName));
+ function checkUnusedLocalsAndParameters(nodeWithLocals, addDiagnostic) {
+ var unusedImports = new ts.Map();
+ var unusedDestructures = new ts.Map();
+ var unusedVariables = new ts.Map();
+ nodeWithLocals.locals.forEach(function (local) {
+ if (local.flags & 262144 ? !(local.flags & 3 && !(local.isReferenced & 3)) : local.isReferenced || local.exportSymbol) {
+ return;
}
- else {
- markExportAsReferenced(node);
- var target = symbol && (symbol.flags & 2097152 ? resolveAlias(symbol) : symbol);
- if (!target || target === unknownSymbol || target.flags & 111551) {
- checkExpressionCached(node.propertyName || node.name);
+ for (var _i = 0, _a = local.declarations; _i < _a.length; _i++) {
+ var declaration = _a[_i];
+ if (isValidUnusedLocalDeclaration(declaration)) {
+ continue;
+ }
+ if (isImportedDeclaration(declaration)) {
+ addToGroup(unusedImports, importClauseFromImported(declaration), declaration, getNodeId);
+ }
+ else if (ts.isBindingElement(declaration) && ts.isObjectBindingPattern(declaration.parent)) {
+ var lastElement = ts.last(declaration.parent.elements);
+ if (declaration === lastElement || !ts.last(declaration.parent.elements).dotDotDotToken) {
+ addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId);
+ }
+ }
+ else if (ts.isVariableDeclaration(declaration)) {
+ addToGroup(unusedVariables, declaration.parent, declaration, getNodeId);
+ }
+ else {
+ var parameter = local.valueDeclaration && tryGetRootParameterDeclaration(local.valueDeclaration);
+ var name = local.valueDeclaration && ts.getNameOfDeclaration(local.valueDeclaration);
+ if (parameter && name) {
+ if (!ts.isParameterPropertyDeclaration(parameter, parameter.parent) && !ts.parameterIsThisKeyword(parameter) && !isIdentifierThatStartsWithUnderscore(name)) {
+ addDiagnostic(parameter, 1, ts.createDiagnosticForNode(name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.symbolName(local)));
+ }
+ }
+ else {
+ errorUnusedLocal(declaration, ts.symbolName(local), addDiagnostic);
+ }
}
}
- }
- }
- function checkExportAssignment(node) {
- if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_assignment_can_only_be_used_in_a_module)) {
- return;
- }
- var container = node.parent.kind === 290 ? node.parent : node.parent.parent;
- if (container.kind === 249 && !ts.isAmbientModule(container)) {
- if (node.isExportEquals) {
- error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace);
+ });
+ unusedImports.forEach(function (_a) {
+ var importClause = _a[0], unuseds = _a[1];
+ var importDecl = importClause.parent;
+ var nDeclarations = (importClause.name ? 1 : 0) +
+ (importClause.namedBindings ?
+ (importClause.namedBindings.kind === 263 ? 1 : importClause.namedBindings.elements.length)
+ : 0);
+ if (nDeclarations === unuseds.length) {
+ addDiagnostic(importDecl, 0, unuseds.length === 1
+ ? ts.createDiagnosticForNode(importDecl, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.idText(ts.first(unuseds).name))
+ : ts.createDiagnosticForNode(importDecl, ts.Diagnostics.All_imports_in_import_declaration_are_unused));
}
else {
- error(node, ts.Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module);
- }
- return;
- }
- if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasModifiers(node)) {
- grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers);
- }
- if (node.expression.kind === 75) {
- var id = node.expression;
- var sym = resolveEntityName(id, 67108863, true, true, node);
- if (sym) {
- markAliasReferenced(sym, id);
- var target = sym.flags & 2097152 ? resolveAlias(sym) : sym;
- if (target === unknownSymbol || target.flags & 111551) {
- checkExpressionCached(node.expression);
+ for (var _i = 0, unuseds_1 = unuseds; _i < unuseds_1.length; _i++) {
+ var unused = unuseds_1[_i];
+ errorUnusedLocal(unused, ts.idText(unused.name), addDiagnostic);
}
}
- if (ts.getEmitDeclarations(compilerOptions)) {
- collectLinkedAliases(node.expression, true);
+ });
+ unusedDestructures.forEach(function (_a) {
+ var bindingPattern = _a[0], bindingElements = _a[1];
+ var kind = tryGetRootParameterDeclaration(bindingPattern.parent) ? 1 : 0;
+ if (bindingPattern.elements.length === bindingElements.length) {
+ if (bindingElements.length === 1 && bindingPattern.parent.kind === 249 && bindingPattern.parent.parent.kind === 250) {
+ addToGroup(unusedVariables, bindingPattern.parent.parent, bindingPattern.parent, getNodeId);
+ }
+ else {
+ addDiagnostic(bindingPattern, kind, bindingElements.length === 1
+ ? ts.createDiagnosticForNode(bindingPattern, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(ts.first(bindingElements).name))
+ : ts.createDiagnosticForNode(bindingPattern, ts.Diagnostics.All_destructured_elements_are_unused));
+ }
}
- }
- else {
- checkExpressionCached(node.expression);
- }
- checkExternalModuleExports(container);
- if ((node.flags & 8388608) && !ts.isEntityNameExpression(node.expression)) {
- grammarErrorOnNode(node.expression, ts.Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context);
- }
- if (node.isExportEquals && !(node.flags & 8388608)) {
- if (moduleKind >= ts.ModuleKind.ES2015) {
- grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead);
+ else {
+ for (var _i = 0, bindingElements_1 = bindingElements; _i < bindingElements_1.length; _i++) {
+ var e = bindingElements_1[_i];
+ addDiagnostic(e, kind, ts.createDiagnosticForNode(e, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(e.name)));
+ }
}
- else if (moduleKind === ts.ModuleKind.System) {
- grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system);
+ });
+ unusedVariables.forEach(function (_a) {
+ var declarationList = _a[0], declarations = _a[1];
+ if (declarationList.declarations.length === declarations.length) {
+ addDiagnostic(declarationList, 0, declarations.length === 1
+ ? ts.createDiagnosticForNode(ts.first(declarations).name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(ts.first(declarations).name))
+ : ts.createDiagnosticForNode(declarationList.parent.kind === 232 ? declarationList.parent : declarationList, ts.Diagnostics.All_variables_are_unused));
}
- }
- }
- function hasExportedMembers(moduleSymbol) {
- return ts.forEachEntry(moduleSymbol.exports, function (_, id) { return id !== "export="; });
- }
- function checkExternalModuleExports(node) {
- var moduleSymbol = getSymbolOfNode(node);
- var links = getSymbolLinks(moduleSymbol);
- if (!links.exportsChecked) {
- var exportEqualsSymbol = moduleSymbol.exports.get("export=");
- if (exportEqualsSymbol && hasExportedMembers(moduleSymbol)) {
- var declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration;
- if (!isTopLevelInExternalModuleAugmentation(declaration) && !ts.isInJSFile(declaration)) {
- error(declaration, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements);
+ else {
+ for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
+ var decl = declarations_5[_i];
+ addDiagnostic(decl, 0, ts.createDiagnosticForNode(decl, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(decl.name)));
}
}
- var exports_2 = getExportsOfModule(moduleSymbol);
- if (exports_2) {
- exports_2.forEach(function (_a, id) {
- var declarations = _a.declarations, flags = _a.flags;
- if (id === "__export") {
- return;
- }
- if (flags & (1920 | 64 | 384)) {
- return;
- }
- var exportedDeclarationsCount = ts.countWhere(declarations, isNotOverloadAndNotAccessor);
- if (flags & 524288 && exportedDeclarationsCount <= 2) {
- return;
- }
- if (exportedDeclarationsCount > 1) {
- for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) {
- var declaration = declarations_9[_i];
- if (isNotOverload(declaration)) {
- diagnostics.add(ts.createDiagnosticForNode(declaration, ts.Diagnostics.Cannot_redeclare_exported_variable_0, ts.unescapeLeadingUnderscores(id)));
- }
- }
- }
- });
- }
- links.exportsChecked = true;
- }
+ });
}
- function checkSourceElement(node) {
- if (node) {
- var saveCurrentNode = currentNode;
- currentNode = node;
- instantiationCount = 0;
- checkSourceElementWorker(node);
- currentNode = saveCurrentNode;
+ function bindingNameText(name) {
+ switch (name.kind) {
+ case 78:
+ return ts.idText(name);
+ case 197:
+ case 196:
+ return bindingNameText(ts.cast(ts.first(name.elements), ts.isBindingElement).name);
+ default:
+ return ts.Debug.assertNever(name);
}
}
- function checkSourceElementWorker(node) {
- if (ts.isInJSFile(node)) {
- ts.forEach(node.jsDoc, function (_a) {
- var tags = _a.tags;
- return ts.forEach(tags, checkSourceElement);
- });
+ function isImportedDeclaration(node) {
+ return node.kind === 262 || node.kind === 265 || node.kind === 263;
+ }
+ function importClauseFromImported(decl) {
+ return decl.kind === 262 ? decl : decl.kind === 263 ? decl.parent : decl.parent.parent;
+ }
+ function checkBlock(node) {
+ if (node.kind === 230) {
+ checkGrammarStatementInAmbientContext(node);
}
- var kind = node.kind;
- if (cancellationToken) {
- switch (kind) {
- case 249:
- case 245:
- case 246:
- case 244:
- cancellationToken.throwIfCancellationRequested();
- }
+ if (ts.isFunctionOrModuleBlock(node)) {
+ var saveFlowAnalysisDisabled = flowAnalysisDisabled;
+ ts.forEach(node.statements, checkSourceElement);
+ flowAnalysisDisabled = saveFlowAnalysisDisabled;
}
- if (kind >= 225 && kind <= 241 && node.flowNode && !isReachableFlowNode(node.flowNode)) {
- errorOrSuggestion(compilerOptions.allowUnreachableCode === false, node, ts.Diagnostics.Unreachable_code_detected);
+ else {
+ ts.forEach(node.statements, checkSourceElement);
}
- switch (kind) {
- case 155:
- return checkTypeParameter(node);
- case 156:
- return checkParameter(node);
- case 159:
- return checkPropertyDeclaration(node);
- case 158:
- return checkPropertySignature(node);
- case 170:
- case 171:
- case 165:
- case 166:
- case 167:
- return checkSignatureDeclaration(node);
- case 161:
- case 160:
- return checkMethodDeclaration(node);
- case 162:
- return checkConstructorDeclaration(node);
- case 163:
- case 164:
- return checkAccessorDeclaration(node);
- case 169:
- return checkTypeReferenceNode(node);
- case 168:
- return checkTypePredicate(node);
- case 172:
- return checkTypeQuery(node);
- case 173:
- return checkTypeLiteral(node);
- case 174:
- return checkArrayType(node);
- case 175:
- return checkTupleType(node);
- case 178:
- case 179:
- return checkUnionOrIntersectionType(node);
- case 182:
- case 176:
- case 177:
- return checkSourceElement(node.type);
- case 183:
- return checkThisType(node);
- case 184:
- return checkTypeOperator(node);
- case 180:
- return checkConditionalType(node);
- case 181:
- return checkInferType(node);
- case 188:
- return checkImportType(node);
- case 307:
- return checkJSDocAugmentsTag(node);
- case 308:
- return checkJSDocImplementsTag(node);
- case 322:
- case 315:
- case 316:
- return checkJSDocTypeAliasTag(node);
- case 321:
- return checkJSDocTemplateTag(node);
- case 320:
- return checkJSDocTypeTag(node);
- case 317:
- return checkJSDocParameterTag(node);
- case 323:
- return checkJSDocPropertyTag(node);
- case 300:
- checkJSDocFunctionType(node);
- case 298:
- case 297:
- case 295:
- case 296:
- case 304:
- checkJSDocTypeIsInJsFile(node);
- ts.forEachChild(node, checkSourceElement);
- return;
- case 301:
- checkJSDocVariadicType(node);
- return;
- case 294:
- return checkSourceElement(node.type);
- case 185:
- return checkIndexedAccessType(node);
- case 186:
- return checkMappedType(node);
- case 244:
- return checkFunctionDeclaration(node);
- case 223:
- case 250:
- return checkBlock(node);
- case 225:
- return checkVariableStatement(node);
- case 226:
- return checkExpressionStatement(node);
- case 227:
- return checkIfStatement(node);
- case 228:
- return checkDoStatement(node);
- case 229:
- return checkWhileStatement(node);
- case 230:
- return checkForStatement(node);
- case 231:
- return checkForInStatement(node);
- case 232:
- return checkForOfStatement(node);
- case 233:
- case 234:
- return checkBreakOrContinueStatement(node);
- case 235:
- return checkReturnStatement(node);
- case 236:
- return checkWithStatement(node);
- case 237:
- return checkSwitchStatement(node);
- case 238:
- return checkLabeledStatement(node);
- case 239:
- return checkThrowStatement(node);
- case 240:
- return checkTryStatement(node);
- case 242:
- return checkVariableDeclaration(node);
- case 191:
- return checkBindingElement(node);
- case 245:
- return checkClassDeclaration(node);
- case 246:
- return checkInterfaceDeclaration(node);
- case 247:
- return checkTypeAliasDeclaration(node);
- case 248:
- return checkEnumDeclaration(node);
- case 249:
- return checkModuleDeclaration(node);
- case 254:
- return checkImportDeclaration(node);
- case 253:
- return checkImportEqualsDeclaration(node);
- case 260:
- return checkExportDeclaration(node);
- case 259:
- return checkExportAssignment(node);
- case 224:
- case 241:
- checkGrammarStatementInAmbientContext(node);
- return;
- case 264:
- return checkMissingDeclaration(node);
+ if (node.locals) {
+ registerForUnusedIdentifiersCheck(node);
}
}
- function checkJSDocTypeIsInJsFile(node) {
- if (!ts.isInJSFile(node)) {
- grammarErrorOnNode(node, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
+ function checkCollisionWithArgumentsInGeneratedCode(node) {
+ if (languageVersion >= 2 || !ts.hasRestParameter(node) || node.flags & 8388608 || ts.nodeIsMissing(node.body)) {
+ return;
}
+ ts.forEach(node.parameters, function (p) {
+ if (p.name && !ts.isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.escapedName) {
+ errorSkippedOn("noEmit", p, ts.Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);
+ }
+ });
}
- function checkJSDocVariadicType(node) {
- checkJSDocTypeIsInJsFile(node);
- checkSourceElement(node.type);
- var parent = node.parent;
- if (ts.isParameter(parent) && ts.isJSDocFunctionType(parent.parent)) {
- if (ts.last(parent.parent.parameters) !== parent) {
- error(node, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
+ function needCollisionCheckForIdentifier(node, identifier, name) {
+ if (!(identifier && identifier.escapedText === name)) {
+ return false;
+ }
+ if (node.kind === 163 ||
+ node.kind === 162 ||
+ node.kind === 165 ||
+ node.kind === 164 ||
+ node.kind === 167 ||
+ node.kind === 168) {
+ return false;
+ }
+ if (node.flags & 8388608) {
+ return false;
+ }
+ var root = ts.getRootDeclaration(node);
+ if (root.kind === 160 && ts.nodeIsMissing(root.parent.body)) {
+ return false;
+ }
+ return true;
+ }
+ function checkIfThisIsCapturedInEnclosingScope(node) {
+ ts.findAncestor(node, function (current) {
+ if (getNodeCheckFlags(current) & 4) {
+ var isDeclaration_1 = node.kind !== 78;
+ if (isDeclaration_1) {
+ error(ts.getNameOfDeclaration(node), ts.Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference);
+ }
+ else {
+ error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference);
+ }
+ return true;
}
- return;
+ return false;
+ });
+ }
+ function checkIfNewTargetIsCapturedInEnclosingScope(node) {
+ ts.findAncestor(node, function (current) {
+ if (getNodeCheckFlags(current) & 8) {
+ var isDeclaration_2 = node.kind !== 78;
+ if (isDeclaration_2) {
+ error(ts.getNameOfDeclaration(node), ts.Diagnostics.Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference);
+ }
+ else {
+ error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference);
+ }
+ return true;
+ }
+ return false;
+ });
+ }
+ function checkWeakMapCollision(node) {
+ var enclosingBlockScope = ts.getEnclosingBlockScopeContainer(node);
+ if (getNodeCheckFlags(enclosingBlockScope) & 67108864) {
+ errorSkippedOn("noEmit", node, ts.Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, "WeakMap");
}
- if (!ts.isJSDocTypeExpression(parent)) {
- error(node, ts.Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature);
+ }
+ function checkCollisionWithRequireExportsInGeneratedCode(node, name) {
+ if (moduleKind >= ts.ModuleKind.ES2015) {
+ return;
}
- var paramTag = node.parent.parent;
- if (!ts.isJSDocParameterTag(paramTag)) {
- error(node, ts.Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature);
+ if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) {
return;
}
- var param = ts.getParameterSymbolFromJSDoc(paramTag);
- if (!param) {
+ if (ts.isModuleDeclaration(node) && ts.getModuleInstanceState(node) !== 1) {
return;
}
- var host = ts.getHostSignatureFromJSDoc(paramTag);
- if (!host || ts.last(host.parameters).symbol !== param) {
- error(node, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
+ var parent = getDeclarationContainer(node);
+ if (parent.kind === 297 && ts.isExternalOrCommonJsModule(parent)) {
+ errorSkippedOn("noEmit", name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name));
}
}
- function getTypeFromJSDocVariadicType(node) {
- var type = getTypeFromTypeNode(node.type);
- var parent = node.parent;
- var paramTag = node.parent.parent;
- if (ts.isJSDocTypeExpression(node.parent) && ts.isJSDocParameterTag(paramTag)) {
- var host_1 = ts.getHostSignatureFromJSDoc(paramTag);
- if (host_1) {
- var lastParamDeclaration = ts.lastOrUndefined(host_1.parameters);
- var symbol = ts.getParameterSymbolFromJSDoc(paramTag);
- if (!lastParamDeclaration ||
- symbol && lastParamDeclaration.symbol === symbol && ts.isRestParameter(lastParamDeclaration)) {
- return createArrayType(type);
- }
- }
+ function checkCollisionWithGlobalPromiseInGeneratedCode(node, name) {
+ if (languageVersion >= 4 || !needCollisionCheckForIdentifier(node, name, "Promise")) {
+ return;
}
- if (ts.isParameter(parent) && ts.isJSDocFunctionType(parent.parent)) {
- return createArrayType(type);
+ if (ts.isModuleDeclaration(node) && ts.getModuleInstanceState(node) !== 1) {
+ return;
}
- return addOptionality(type);
- }
- function checkNodeDeferred(node) {
- var enclosingFile = ts.getSourceFileOfNode(node);
- var links = getNodeLinks(enclosingFile);
- if (!(links.flags & 1)) {
- links.deferredNodes = links.deferredNodes || ts.createMap();
- var id = "" + getNodeId(node);
- links.deferredNodes.set(id, node);
+ var parent = getDeclarationContainer(node);
+ if (parent.kind === 297 && ts.isExternalOrCommonJsModule(parent) && parent.flags & 2048) {
+ errorSkippedOn("noEmit", name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions, ts.declarationNameToString(name), ts.declarationNameToString(name));
}
}
- function checkDeferredNodes(context) {
- var links = getNodeLinks(context);
- if (links.deferredNodes) {
- links.deferredNodes.forEach(checkDeferredNode);
+ function checkVarDeclaredNamesNotShadowed(node) {
+ if ((ts.getCombinedNodeFlags(node) & 3) !== 0 || ts.isParameterDeclaration(node)) {
+ return;
}
- }
- function checkDeferredNode(node) {
- var saveCurrentNode = currentNode;
- currentNode = node;
- instantiationCount = 0;
- switch (node.kind) {
- case 196:
- case 197:
- case 198:
- case 157:
- case 268:
- resolveUntypedCall(node);
- break;
- case 201:
- case 202:
- case 161:
- case 160:
- checkFunctionExpressionOrObjectLiteralMethodDeferred(node);
- break;
- case 163:
- case 164:
- checkAccessorDeclaration(node);
- break;
- case 214:
- checkClassExpressionDeferred(node);
- break;
- case 267:
- checkJsxSelfClosingElementDeferred(node);
- break;
- case 266:
- checkJsxElementDeferred(node);
- break;
+ if (node.kind === 249 && !node.initializer) {
+ return;
+ }
+ var symbol = getSymbolOfNode(node);
+ if (symbol.flags & 1) {
+ if (!ts.isIdentifier(node.name))
+ return ts.Debug.fail();
+ var localDeclarationSymbol = resolveName(node, node.name.escapedText, 3, undefined, undefined, false);
+ if (localDeclarationSymbol &&
+ localDeclarationSymbol !== symbol &&
+ localDeclarationSymbol.flags & 2) {
+ if (getDeclarationNodeFlagsFromSymbol(localDeclarationSymbol) & 3) {
+ var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 250);
+ var container = varDeclList.parent.kind === 232 && varDeclList.parent.parent
+ ? varDeclList.parent.parent
+ : undefined;
+ var namesShareScope = container &&
+ (container.kind === 230 && ts.isFunctionLike(container.parent) ||
+ container.kind === 257 ||
+ container.kind === 256 ||
+ container.kind === 297);
+ if (!namesShareScope) {
+ var name = symbolToString(localDeclarationSymbol);
+ error(node, ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name);
+ }
+ }
+ }
}
- currentNode = saveCurrentNode;
}
- function checkSourceFile(node) {
- ts.performance.mark("beforeCheck");
- checkSourceFileWorker(node);
- ts.performance.mark("afterCheck");
- ts.performance.measure("Check", "beforeCheck", "afterCheck");
+ function convertAutoToAny(type) {
+ return type === autoType ? anyType : type === autoArrayType ? anyArrayType : type;
}
- function unusedIsError(kind, isAmbient) {
- if (isAmbient) {
- return false;
+ function checkVariableLikeDeclaration(node) {
+ var _a;
+ checkDecorators(node);
+ if (!ts.isBindingElement(node)) {
+ checkSourceElement(node.type);
}
- switch (kind) {
- case 0:
- return !!compilerOptions.noUnusedLocals;
- case 1:
- return !!compilerOptions.noUnusedParameters;
- default:
- return ts.Debug.assertNever(kind);
+ if (!node.name) {
+ return;
}
- }
- function getPotentiallyUnusedIdentifiers(sourceFile) {
- return allPotentiallyUnusedIdentifiers.get(sourceFile.path) || ts.emptyArray;
- }
- function checkSourceFileWorker(node) {
- var links = getNodeLinks(node);
- if (!(links.flags & 1)) {
- if (ts.skipTypeChecking(node, compilerOptions, host)) {
- return;
+ if (node.name.kind === 158) {
+ checkComputedPropertyName(node.name);
+ if (node.initializer) {
+ checkExpressionCached(node.initializer);
}
- checkGrammarSourceFile(node);
- ts.clear(potentialThisCollisions);
- ts.clear(potentialNewTargetCollisions);
- ts.clear(potentialWeakMapCollisions);
- ts.forEach(node.statements, checkSourceElement);
- checkSourceElement(node.endOfFileToken);
- checkDeferredNodes(node);
- if (ts.isExternalOrCommonJsModule(node)) {
- registerForUnusedIdentifiersCheck(node);
+ }
+ if (node.kind === 198) {
+ if (node.parent.kind === 196 && languageVersion < 99) {
+ checkExternalEmitHelpers(node, 4);
}
- if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) {
- checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), function (containingNode, kind, diag) {
- if (!ts.containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 8388608))) {
- diagnostics.add(diag);
+ if (node.propertyName && node.propertyName.kind === 158) {
+ checkComputedPropertyName(node.propertyName);
+ }
+ var parent = node.parent.parent;
+ var parentType = getTypeForBindingElementParent(parent);
+ var name = node.propertyName || node.name;
+ if (parentType && !ts.isBindingPattern(name)) {
+ var exprType = getLiteralTypeFromPropertyName(name);
+ if (isTypeUsableAsPropertyName(exprType)) {
+ var nameText = getPropertyNameFromType(exprType);
+ var property = getPropertyOfType(parentType, nameText);
+ if (property) {
+ markPropertyAsReferenced(property, undefined, false);
+ checkPropertyAccessibility(parent, !!parent.initializer && parent.initializer.kind === 105, parentType, property);
}
- });
+ }
}
- if (compilerOptions.importsNotUsedAsValues === 2 &&
- !node.isDeclarationFile &&
- ts.isExternalModule(node)) {
- checkImportsForTypeOnlyConversion(node);
+ }
+ if (ts.isBindingPattern(node.name)) {
+ if (node.name.kind === 197 && languageVersion < 2 && compilerOptions.downlevelIteration) {
+ checkExternalEmitHelpers(node, 512);
}
- if (ts.isExternalOrCommonJsModule(node)) {
- checkExternalModuleExports(node);
+ ts.forEach(node.name.elements, checkSourceElement);
+ }
+ if (node.initializer && ts.isParameterDeclaration(node) && ts.nodeIsMissing(ts.getContainingFunction(node).body)) {
+ error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation);
+ return;
+ }
+ if (ts.isBindingPattern(node.name)) {
+ var needCheckInitializer = node.initializer && node.parent.parent.kind !== 238;
+ var needCheckWidenedType = node.name.elements.length === 0;
+ if (needCheckInitializer || needCheckWidenedType) {
+ var widenedType = getWidenedTypeForVariableLikeDeclaration(node);
+ if (needCheckInitializer) {
+ var initializerType = checkExpressionCached(node.initializer);
+ if (strictNullChecks && needCheckWidenedType) {
+ checkNonNullNonVoidType(initializerType, node);
+ }
+ else {
+ checkTypeAssignableToAndOptionallyElaborate(initializerType, getWidenedTypeForVariableLikeDeclaration(node), node, node.initializer);
+ }
+ }
+ if (needCheckWidenedType) {
+ if (ts.isArrayBindingPattern(node.name)) {
+ checkIteratedTypeOrElementType(65, widenedType, undefinedType, node);
+ }
+ else if (strictNullChecks) {
+ checkNonNullNonVoidType(widenedType, node);
+ }
+ }
}
- if (potentialThisCollisions.length) {
- ts.forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope);
- ts.clear(potentialThisCollisions);
+ return;
+ }
+ var symbol = getSymbolOfNode(node);
+ if (symbol.flags & 2097152 && ts.isRequireVariableDeclaration(node, true)) {
+ checkAliasSymbol(node);
+ return;
+ }
+ var type = convertAutoToAny(getTypeOfSymbol(symbol));
+ if (node === symbol.valueDeclaration) {
+ var initializer = ts.getEffectiveInitializer(node);
+ if (initializer) {
+ var isJSObjectLiteralInitializer = ts.isInJSFile(node) &&
+ ts.isObjectLiteralExpression(initializer) &&
+ (initializer.properties.length === 0 || ts.isPrototypeAccess(node.name)) &&
+ !!((_a = symbol.exports) === null || _a === void 0 ? void 0 : _a.size);
+ if (!isJSObjectLiteralInitializer && node.parent.parent.kind !== 238) {
+ checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(initializer), type, node, initializer, undefined);
+ }
}
- if (potentialNewTargetCollisions.length) {
- ts.forEach(potentialNewTargetCollisions, checkIfNewTargetIsCapturedInEnclosingScope);
- ts.clear(potentialNewTargetCollisions);
+ if (symbol.declarations.length > 1) {
+ if (ts.some(symbol.declarations, function (d) { return d !== node && ts.isVariableLike(d) && !areDeclarationFlagsIdentical(d, node); })) {
+ error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name));
+ }
}
- if (potentialWeakMapCollisions.length) {
- ts.forEach(potentialWeakMapCollisions, checkWeakMapCollision);
- ts.clear(potentialWeakMapCollisions);
+ }
+ else {
+ var declarationType = convertAutoToAny(getWidenedTypeForVariableLikeDeclaration(node));
+ if (type !== errorType && declarationType !== errorType &&
+ !isTypeIdenticalTo(type, declarationType) &&
+ !(symbol.flags & 67108864)) {
+ errorNextVariableOrPropertyDeclarationMustHaveSameType(symbol.valueDeclaration, type, node, declarationType);
+ }
+ if (node.initializer) {
+ checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(node.initializer), declarationType, node, node.initializer, undefined);
+ }
+ if (!areDeclarationFlagsIdentical(node, symbol.valueDeclaration)) {
+ error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name));
}
- links.flags |= 1;
}
- }
- function getDiagnostics(sourceFile, ct) {
- try {
- cancellationToken = ct;
- return getDiagnosticsWorker(sourceFile);
+ if (node.kind !== 163 && node.kind !== 162) {
+ checkExportsOnMergedDeclarations(node);
+ if (node.kind === 249 || node.kind === 198) {
+ checkVarDeclaredNamesNotShadowed(node);
+ }
+ checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+ checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+ if (languageVersion < 99 && needCollisionCheckForIdentifier(node, node.name, "WeakMap")) {
+ potentialWeakMapCollisions.push(node);
+ }
}
- finally {
- cancellationToken = undefined;
+ }
+ function errorNextVariableOrPropertyDeclarationMustHaveSameType(firstDeclaration, firstType, nextDeclaration, nextType) {
+ var nextDeclarationName = ts.getNameOfDeclaration(nextDeclaration);
+ var message = nextDeclaration.kind === 163 || nextDeclaration.kind === 162
+ ? ts.Diagnostics.Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2
+ : ts.Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2;
+ var declName = ts.declarationNameToString(nextDeclarationName);
+ var err = error(nextDeclarationName, message, declName, typeToString(firstType), typeToString(nextType));
+ if (firstDeclaration) {
+ ts.addRelatedInfo(err, ts.createDiagnosticForNode(firstDeclaration, ts.Diagnostics._0_was_also_declared_here, declName));
}
}
- function getDiagnosticsWorker(sourceFile) {
- throwIfNonDiagnosticsProducing();
- if (sourceFile) {
- var previousGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
- var previousGlobalDiagnosticsSize = previousGlobalDiagnostics.length;
- checkSourceFile(sourceFile);
- var semanticDiagnostics = diagnostics.getDiagnostics(sourceFile.fileName);
- var currentGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
- if (currentGlobalDiagnostics !== previousGlobalDiagnostics) {
- var deferredGlobalDiagnostics = ts.relativeComplement(previousGlobalDiagnostics, currentGlobalDiagnostics, ts.compareDiagnostics);
- return ts.concatenate(deferredGlobalDiagnostics, semanticDiagnostics);
- }
- else if (previousGlobalDiagnosticsSize === 0 && currentGlobalDiagnostics.length > 0) {
- return ts.concatenate(currentGlobalDiagnostics, semanticDiagnostics);
- }
- return semanticDiagnostics;
+ function areDeclarationFlagsIdentical(left, right) {
+ if ((left.kind === 160 && right.kind === 249) ||
+ (left.kind === 249 && right.kind === 160)) {
+ return true;
}
- ts.forEach(host.getSourceFiles(), checkSourceFile);
- return diagnostics.getDiagnostics();
+ if (ts.hasQuestionToken(left) !== ts.hasQuestionToken(right)) {
+ return false;
+ }
+ var interestingFlags = 8 |
+ 16 |
+ 256 |
+ 128 |
+ 64 |
+ 32;
+ return ts.getSelectedEffectiveModifierFlags(left, interestingFlags) === ts.getSelectedEffectiveModifierFlags(right, interestingFlags);
}
- function getGlobalDiagnostics() {
- throwIfNonDiagnosticsProducing();
- return diagnostics.getGlobalDiagnostics();
+ function checkVariableDeclaration(node) {
+ ts.tracing.push("check", "checkVariableDeclaration", { kind: node.kind, pos: node.pos, end: node.end });
+ checkGrammarVariableDeclaration(node);
+ checkVariableLikeDeclaration(node);
+ ts.tracing.pop();
}
- function throwIfNonDiagnosticsProducing() {
- if (!produceDiagnostics) {
- throw new Error("Trying to get diagnostics from a type checker that does not produce them.");
+ function checkBindingElement(node) {
+ checkGrammarBindingElement(node);
+ return checkVariableLikeDeclaration(node);
+ }
+ function checkVariableStatement(node) {
+ if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarVariableDeclarationList(node.declarationList))
+ checkGrammarForDisallowedLetOrConstStatement(node);
+ ts.forEach(node.declarationList.declarations, checkSourceElement);
+ }
+ function checkExpressionStatement(node) {
+ checkGrammarStatementInAmbientContext(node);
+ checkExpression(node.expression);
+ }
+ function checkIfStatement(node) {
+ checkGrammarStatementInAmbientContext(node);
+ var type = checkTruthinessExpression(node.expression);
+ checkTestingKnownTruthyCallableType(node.expression, node.thenStatement, type);
+ checkSourceElement(node.thenStatement);
+ if (node.thenStatement.kind === 231) {
+ error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
}
+ checkSourceElement(node.elseStatement);
}
- function getSymbolsInScope(location, meaning) {
- if (location.flags & 16777216) {
- return [];
+ function checkTestingKnownTruthyCallableType(condExpr, body, type) {
+ if (!strictNullChecks) {
+ return;
}
- var symbols = ts.createSymbolTable();
- var isStatic = false;
- populateSymbols();
- symbols.delete("this");
- return symbolsToArray(symbols);
- function populateSymbols() {
- while (location) {
- if (location.locals && !isGlobalSourceFile(location)) {
- copySymbols(location.locals, meaning);
- }
- switch (location.kind) {
- case 290:
- if (!ts.isExternalOrCommonJsModule(location))
- break;
- case 249:
- copySymbols(getSymbolOfNode(location).exports, meaning & 2623475);
- break;
- case 248:
- copySymbols(getSymbolOfNode(location).exports, meaning & 8);
- break;
- case 214:
- var className = location.name;
- if (className) {
- copySymbol(location.symbol, meaning);
+ var testedNode = ts.isIdentifier(condExpr)
+ ? condExpr
+ : ts.isPropertyAccessExpression(condExpr)
+ ? condExpr.name
+ : undefined;
+ if (!testedNode) {
+ return;
+ }
+ var possiblyFalsy = getFalsyFlags(type);
+ if (possiblyFalsy) {
+ return;
+ }
+ var callSignatures = getSignaturesOfType(type, 0);
+ if (callSignatures.length === 0) {
+ return;
+ }
+ var testedFunctionSymbol = getSymbolAtLocation(testedNode);
+ if (!testedFunctionSymbol) {
+ return;
+ }
+ var functionIsUsedInBody = ts.forEachChild(body, function check(childNode) {
+ if (ts.isIdentifier(childNode)) {
+ var childSymbol = getSymbolAtLocation(childNode);
+ if (childSymbol && childSymbol === testedFunctionSymbol) {
+ if (ts.isIdentifier(condExpr)) {
+ return true;
+ }
+ var testedExpression = testedNode.parent;
+ var childExpression = childNode.parent;
+ while (testedExpression && childExpression) {
+ if (ts.isIdentifier(testedExpression) && ts.isIdentifier(childExpression) ||
+ testedExpression.kind === 107 && childExpression.kind === 107) {
+ return getSymbolAtLocation(testedExpression) === getSymbolAtLocation(childExpression);
}
- case 245:
- case 246:
- if (!isStatic) {
- copySymbols(getMembersOfSymbol(getSymbolOfNode(location)), meaning & 788968);
+ if (ts.isPropertyAccessExpression(testedExpression) && ts.isPropertyAccessExpression(childExpression)) {
+ if (getSymbolAtLocation(testedExpression.name) !== getSymbolAtLocation(childExpression.name)) {
+ return false;
+ }
+ childExpression = childExpression.expression;
+ testedExpression = testedExpression.expression;
}
- break;
- case 201:
- var funcName = location.name;
- if (funcName) {
- copySymbol(location.symbol, meaning);
+ else {
+ return false;
}
- break;
- }
- if (ts.introducesArgumentsExoticObject(location)) {
- copySymbol(argumentsSymbol, meaning);
- }
- isStatic = ts.hasModifier(location, 32);
- location = location.parent;
- }
- copySymbols(globals, meaning);
- }
- function copySymbol(symbol, meaning) {
- if (ts.getCombinedLocalAndExportSymbolFlags(symbol) & meaning) {
- var id = symbol.escapedName;
- if (!symbols.has(id)) {
- symbols.set(id, symbol);
+ }
}
}
+ return ts.forEachChild(childNode, check);
+ });
+ if (!functionIsUsedInBody) {
+ error(condExpr, ts.Diagnostics.This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it_instead);
}
- function copySymbols(source, meaning) {
- if (meaning) {
- source.forEach(function (symbol) {
- copySymbol(symbol, meaning);
- });
- }
- }
- }
- function isTypeDeclarationName(name) {
- return name.kind === 75 &&
- isTypeDeclaration(name.parent) &&
- name.parent.name === name;
}
- function isTypeDeclaration(node) {
- switch (node.kind) {
- case 155:
- case 245:
- case 246:
- case 247:
- case 248:
- return true;
- case 255:
- return node.isTypeOnly;
- case 258:
- case 263:
- return node.parent.parent.isTypeOnly;
- default:
- return false;
- }
+ function checkDoStatement(node) {
+ checkGrammarStatementInAmbientContext(node);
+ checkSourceElement(node.statement);
+ checkTruthinessExpression(node.expression);
}
- function isTypeReferenceIdentifier(node) {
- while (node.parent.kind === 153) {
- node = node.parent;
- }
- return node.parent.kind === 169;
+ function checkWhileStatement(node) {
+ checkGrammarStatementInAmbientContext(node);
+ checkTruthinessExpression(node.expression);
+ checkSourceElement(node.statement);
}
- function isHeritageClauseElementIdentifier(node) {
- while (node.parent.kind === 194) {
- node = node.parent;
+ function checkTruthinessOfType(type, node) {
+ if (type.flags & 16384) {
+ error(node, ts.Diagnostics.An_expression_of_type_void_cannot_be_tested_for_truthiness);
}
- return node.parent.kind === 216;
+ return type;
}
- function forEachEnclosingClass(node, callback) {
- var result;
- while (true) {
- node = ts.getContainingClass(node);
- if (!node)
- break;
- if (result = callback(node))
- break;
- }
- return result;
+ function checkTruthinessExpression(node, checkMode) {
+ return checkTruthinessOfType(checkExpression(node, checkMode), node);
}
- function isNodeUsedDuringClassInitialization(node) {
- return !!ts.findAncestor(node, function (element) {
- if (ts.isConstructorDeclaration(element) && ts.nodeIsPresent(element.body) || ts.isPropertyDeclaration(element)) {
- return true;
- }
- else if (ts.isClassLike(element) || ts.isFunctionLikeDeclaration(element)) {
- return "quit";
+ function checkForStatement(node) {
+ if (!checkGrammarStatementInAmbientContext(node)) {
+ if (node.initializer && node.initializer.kind === 250) {
+ checkGrammarVariableDeclarationList(node.initializer);
}
- return false;
- });
- }
- function isNodeWithinClass(node, classDeclaration) {
- return !!forEachEnclosingClass(node, function (n) { return n === classDeclaration; });
- }
- function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) {
- while (nodeOnRightSide.parent.kind === 153) {
- nodeOnRightSide = nodeOnRightSide.parent;
- }
- if (nodeOnRightSide.parent.kind === 253) {
- return nodeOnRightSide.parent.moduleReference === nodeOnRightSide ? nodeOnRightSide.parent : undefined;
}
- if (nodeOnRightSide.parent.kind === 259) {
- return nodeOnRightSide.parent.expression === nodeOnRightSide ? nodeOnRightSide.parent : undefined;
+ if (node.initializer) {
+ if (node.initializer.kind === 250) {
+ ts.forEach(node.initializer.declarations, checkVariableDeclaration);
+ }
+ else {
+ checkExpression(node.initializer);
+ }
}
- return undefined;
- }
- function isInRightSideOfImportOrExportAssignment(node) {
- return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined;
- }
- function getSpecialPropertyAssignmentSymbolFromEntityName(entityName) {
- var specialPropertyAssignmentKind = ts.getAssignmentDeclarationKind(entityName.parent.parent);
- switch (specialPropertyAssignmentKind) {
- case 1:
- case 3:
- return getSymbolOfNode(entityName.parent);
- case 4:
- case 2:
- case 5:
- return getSymbolOfNode(entityName.parent.parent);
+ if (node.condition)
+ checkTruthinessExpression(node.condition);
+ if (node.incrementor)
+ checkExpression(node.incrementor);
+ checkSourceElement(node.statement);
+ if (node.locals) {
+ registerForUnusedIdentifiersCheck(node);
}
}
- function isImportTypeQualifierPart(node) {
- var parent = node.parent;
- while (ts.isQualifiedName(parent)) {
- node = parent;
- parent = parent.parent;
+ function checkForOfStatement(node) {
+ checkGrammarForInOrForOfStatement(node);
+ if (node.awaitModifier) {
+ var functionFlags = ts.getFunctionFlags(ts.getContainingFunction(node));
+ if ((functionFlags & (4 | 2)) === 2 && languageVersion < 99) {
+ checkExternalEmitHelpers(node, 32768);
+ }
}
- if (parent && parent.kind === 188 && parent.qualifier === node) {
- return parent;
+ else if (compilerOptions.downlevelIteration && languageVersion < 2) {
+ checkExternalEmitHelpers(node, 256);
}
- return undefined;
- }
- function getSymbolOfNameOrPropertyAccessExpression(name) {
- if (ts.isDeclarationName(name)) {
- return getSymbolOfNode(name.parent);
+ if (node.initializer.kind === 250) {
+ checkForInOrForOfVariableDeclaration(node);
}
- if (ts.isInJSFile(name) &&
- name.parent.kind === 194 &&
- name.parent === name.parent.parent.left) {
- if (!ts.isPrivateIdentifier(name)) {
- var specialPropertyAssignmentSymbol = getSpecialPropertyAssignmentSymbolFromEntityName(name);
- if (specialPropertyAssignmentSymbol) {
- return specialPropertyAssignmentSymbol;
- }
+ else {
+ var varExpr = node.initializer;
+ var iteratedType = checkRightHandSideOfForOf(node);
+ if (varExpr.kind === 199 || varExpr.kind === 200) {
+ checkDestructuringAssignment(varExpr, iteratedType || errorType);
}
- }
- if (name.parent.kind === 259 && ts.isEntityNameExpression(name)) {
- var success = resolveEntityName(name, 111551 | 788968 | 1920 | 2097152, true);
- if (success && success !== unknownSymbol) {
- return success;
+ else {
+ var leftType = checkExpression(varExpr);
+ checkReferenceExpression(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access);
+ if (iteratedType) {
+ checkTypeAssignableToAndOptionallyElaborate(iteratedType, leftType, varExpr, node.expression);
+ }
}
}
- else if (!ts.isPropertyAccessExpression(name) && !ts.isPrivateIdentifier(name) && isInRightSideOfImportOrExportAssignment(name)) {
- var importEqualsDeclaration = ts.getAncestor(name, 253);
- ts.Debug.assert(importEqualsDeclaration !== undefined);
- return getSymbolOfPartOfRightHandSideOfImportEquals(name, true);
+ checkSourceElement(node.statement);
+ if (node.locals) {
+ registerForUnusedIdentifiersCheck(node);
}
- if (!ts.isPropertyAccessExpression(name) && !ts.isPrivateIdentifier(name)) {
- var possibleImportNode = isImportTypeQualifierPart(name);
- if (possibleImportNode) {
- getTypeFromTypeNode(possibleImportNode);
- var sym = getNodeLinks(name).resolvedSymbol;
- return sym === unknownSymbol ? undefined : sym;
+ }
+ function checkForInStatement(node) {
+ checkGrammarForInOrForOfStatement(node);
+ var rightType = getNonNullableTypeIfNeeded(checkExpression(node.expression));
+ if (node.initializer.kind === 250) {
+ var variable = node.initializer.declarations[0];
+ if (variable && ts.isBindingPattern(variable.name)) {
+ error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
}
+ checkForInOrForOfVariableDeclaration(node);
}
- while (ts.isRightSideOfQualifiedNameOrPropertyAccess(name)) {
- name = name.parent;
- }
- if (isHeritageClauseElementIdentifier(name)) {
- var meaning = 0;
- if (name.parent.kind === 216) {
- meaning = 788968;
- if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(name.parent)) {
- meaning |= 111551;
- }
+ else {
+ var varExpr = node.initializer;
+ var leftType = checkExpression(varExpr);
+ if (varExpr.kind === 199 || varExpr.kind === 200) {
+ error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
}
- else {
- meaning = 1920;
+ else if (!isTypeAssignableTo(getIndexTypeOrString(rightType), leftType)) {
+ error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any);
}
- meaning |= 2097152;
- var entityNameSymbol = ts.isEntityNameExpression(name) ? resolveEntityName(name, meaning) : undefined;
- if (entityNameSymbol) {
- return entityNameSymbol;
+ else {
+ checkReferenceExpression(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access);
}
}
- if (name.parent.kind === 317) {
- return ts.getParameterSymbolFromJSDoc(name.parent);
+ if (rightType === neverType || !isTypeAssignableToKind(rightType, 67108864 | 58982400)) {
+ error(node.expression, ts.Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0, typeToString(rightType));
}
- if (name.parent.kind === 155 && name.parent.parent.kind === 321) {
- ts.Debug.assert(!ts.isInJSFile(name));
- var typeParameter = ts.getTypeParameterFromJsDoc(name.parent);
- return typeParameter && typeParameter.symbol;
+ checkSourceElement(node.statement);
+ if (node.locals) {
+ registerForUnusedIdentifiersCheck(node);
}
- if (ts.isExpressionNode(name)) {
- if (ts.nodeIsMissing(name)) {
- return undefined;
- }
- if (name.kind === 75) {
- if (ts.isJSXTagName(name) && isJsxIntrinsicIdentifier(name)) {
- var symbol = getIntrinsicTagSymbol(name.parent);
- return symbol === unknownSymbol ? undefined : symbol;
+ }
+ function checkForInOrForOfVariableDeclaration(iterationStatement) {
+ var variableDeclarationList = iterationStatement.initializer;
+ if (variableDeclarationList.declarations.length >= 1) {
+ var decl = variableDeclarationList.declarations[0];
+ checkVariableDeclaration(decl);
+ }
+ }
+ function checkRightHandSideOfForOf(statement) {
+ var use = statement.awaitModifier ? 15 : 13;
+ 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) {
+ var allowAsyncIterables = (use & 2) !== 0;
+ if (inputType === neverType) {
+ reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
+ return undefined;
+ }
+ var uplevelIteration = languageVersion >= 2;
+ var downlevelIteration = !uplevelIteration && compilerOptions.downlevelIteration;
+ var possibleOutOfBounds = compilerOptions.noUncheckedIndexedAccess && !!(use & 128);
+ if (uplevelIteration || downlevelIteration || allowAsyncIterables) {
+ var iterationTypes = getIterationTypesOfIterable(inputType, use, uplevelIteration ? errorNode : undefined);
+ if (checkAssignability) {
+ if (iterationTypes) {
+ var diagnostic = use & 8 ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 :
+ use & 32 ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 :
+ use & 64 ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 :
+ use & 16 ? ts.Diagnostics.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 :
+ undefined;
+ if (diagnostic) {
+ checkTypeAssignableTo(sentType, iterationTypes.nextType, errorNode, diagnostic);
+ }
}
- return resolveEntityName(name, 111551, false, true);
}
- else if (name.kind === 194 || name.kind === 153) {
- var links = getNodeLinks(name);
- if (links.resolvedSymbol) {
- return links.resolvedSymbol;
+ if (iterationTypes || uplevelIteration) {
+ return possibleOutOfBounds ? includeUndefinedInIndexSignature(iterationTypes && iterationTypes.yieldType) : (iterationTypes && iterationTypes.yieldType);
+ }
+ }
+ var arrayType = inputType;
+ var reportedError = false;
+ var hasStringConstituent = false;
+ if (use & 4) {
+ if (arrayType.flags & 1048576) {
+ var arrayTypes = inputType.types;
+ var filteredTypes = ts.filter(arrayTypes, function (t) { return !(t.flags & 402653316); });
+ if (filteredTypes !== arrayTypes) {
+ arrayType = getUnionType(filteredTypes, 2);
}
- if (name.kind === 194) {
- checkPropertyAccessExpression(name);
+ }
+ else if (arrayType.flags & 402653316) {
+ arrayType = neverType;
+ }
+ hasStringConstituent = arrayType !== inputType;
+ if (hasStringConstituent) {
+ if (languageVersion < 1) {
+ if (errorNode) {
+ error(errorNode, ts.Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher);
+ reportedError = true;
+ }
}
- else {
- checkQualifiedName(name);
+ if (arrayType.flags & 131072) {
+ return possibleOutOfBounds ? includeUndefinedInIndexSignature(stringType) : stringType;
}
- return links.resolvedSymbol;
}
}
- else if (isTypeReferenceIdentifier(name)) {
- var meaning = name.parent.kind === 169 ? 788968 : 1920;
- return resolveEntityName(name, meaning, false, true);
+ if (!isArrayLikeType(arrayType)) {
+ if (errorNode && !reportedError) {
+ var yieldType = getIterationTypeOfIterable(use, 0, inputType, undefined);
+ var _a = !(use & 4) || hasStringConstituent
+ ? downlevelIteration
+ ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true]
+ : yieldType
+ ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators, false]
+ : [ts.Diagnostics.Type_0_is_not_an_array_type, true]
+ : downlevelIteration
+ ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true]
+ : yieldType
+ ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators, false]
+ : [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type, true], defaultDiagnostic = _a[0], maybeMissingAwait = _a[1];
+ errorAndMaybeSuggestAwait(errorNode, maybeMissingAwait && !!getAwaitedTypeOfPromise(arrayType), defaultDiagnostic, typeToString(arrayType));
+ }
+ return hasStringConstituent ? possibleOutOfBounds ? includeUndefinedInIndexSignature(stringType) : stringType : undefined;
}
- if (name.parent.kind === 168) {
- return resolveEntityName(name, 1);
+ var arrayElementType = getIndexTypeOfType(arrayType, 1);
+ if (hasStringConstituent && arrayElementType) {
+ if (arrayElementType.flags & 402653316 && !compilerOptions.noUncheckedIndexedAccess) {
+ return stringType;
+ }
+ return getUnionType(possibleOutOfBounds ? [arrayElementType, stringType, undefinedType] : [arrayElementType, stringType], 2);
}
- return undefined;
+ return (use & 128) ? includeUndefinedInIndexSignature(arrayElementType) : arrayElementType;
}
- function getSymbolAtLocation(node, ignoreErrors) {
- if (node.kind === 290) {
- return ts.isExternalModule(node) ? getMergedSymbol(node.symbol) : undefined;
- }
- var parent = node.parent;
- var grandParent = parent.parent;
- if (node.flags & 16777216) {
+ function getIterationTypeOfIterable(use, typeKind, inputType, errorNode) {
+ if (isTypeAny(inputType)) {
return undefined;
}
- if (isDeclarationNameOrImportPropertyName(node)) {
- var parentSymbol = getSymbolOfNode(parent);
- return ts.isImportOrExportSpecifier(node.parent) && node.parent.propertyName === node
- ? getImmediateAliasedSymbol(parentSymbol)
- : parentSymbol;
- }
- else if (ts.isLiteralComputedPropertyDeclarationName(node)) {
- return getSymbolOfNode(parent.parent);
+ var iterationTypes = getIterationTypesOfIterable(inputType, use, errorNode);
+ return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(typeKind)];
+ }
+ function createIterationTypes(yieldType, returnType, nextType) {
+ if (yieldType === void 0) { yieldType = neverType; }
+ if (returnType === void 0) { returnType = neverType; }
+ if (nextType === void 0) { nextType = unknownType; }
+ if (yieldType.flags & 67359327 &&
+ returnType.flags & (1 | 131072 | 2 | 16384 | 32768) &&
+ nextType.flags & (1 | 131072 | 2 | 16384 | 32768)) {
+ var id = getTypeListId([yieldType, returnType, nextType]);
+ var iterationTypes = iterationTypesCache.get(id);
+ if (!iterationTypes) {
+ iterationTypes = { yieldType: yieldType, returnType: returnType, nextType: nextType };
+ iterationTypesCache.set(id, iterationTypes);
+ }
+ return iterationTypes;
}
- if (node.kind === 75) {
- if (isInRightSideOfImportOrExportAssignment(node)) {
- return getSymbolOfNameOrPropertyAccessExpression(node);
+ return { yieldType: yieldType, returnType: returnType, nextType: nextType };
+ }
+ function combineIterationTypes(array) {
+ var yieldTypes;
+ var returnTypes;
+ var nextTypes;
+ for (var _i = 0, array_10 = array; _i < array_10.length; _i++) {
+ var iterationTypes = array_10[_i];
+ if (iterationTypes === undefined || iterationTypes === noIterationTypes) {
+ continue;
}
- else if (parent.kind === 191 &&
- grandParent.kind === 189 &&
- node === parent.propertyName) {
- var typeOfPattern = getTypeOfNode(grandParent);
- var propertyDeclaration = getPropertyOfType(typeOfPattern, node.escapedText);
- if (propertyDeclaration) {
- return propertyDeclaration;
- }
+ if (iterationTypes === anyIterationTypes) {
+ return anyIterationTypes;
}
+ yieldTypes = ts.append(yieldTypes, iterationTypes.yieldType);
+ returnTypes = ts.append(returnTypes, iterationTypes.returnType);
+ nextTypes = ts.append(nextTypes, iterationTypes.nextType);
}
- switch (node.kind) {
- case 75:
- case 76:
- case 194:
- case 153:
- return getSymbolOfNameOrPropertyAccessExpression(node);
- case 104:
- var container = ts.getThisContainer(node, false);
- if (ts.isFunctionLike(container)) {
- var sig = getSignatureFromDeclaration(container);
- if (sig.thisParameter) {
- return sig.thisParameter;
- }
- }
- if (ts.isInExpressionContext(node)) {
- return checkExpression(node).symbol;
- }
- case 183:
- return getTypeFromThisTypeNode(node).symbol;
- case 102:
- return checkExpression(node).symbol;
- case 129:
- var constructorDeclaration = node.parent;
- if (constructorDeclaration && constructorDeclaration.kind === 162) {
- return constructorDeclaration.parent.symbol;
- }
- return undefined;
- case 10:
- case 14:
- if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) ||
- ((node.parent.kind === 254 || node.parent.kind === 260) && node.parent.moduleSpecifier === node) ||
- ((ts.isInJSFile(node) && ts.isRequireCall(node.parent, false)) || ts.isImportCall(node.parent)) ||
- (ts.isLiteralTypeNode(node.parent) && ts.isLiteralImportTypeNode(node.parent.parent) && node.parent.parent.argument === node.parent)) {
- return resolveExternalModuleName(node, node, ignoreErrors);
- }
- if (ts.isCallExpression(parent) && ts.isBindableObjectDefinePropertyCall(parent) && parent.arguments[1] === node) {
- return getSymbolOfNode(parent);
- }
- case 8:
- var objectType = ts.isElementAccessExpression(parent)
- ? parent.argumentExpression === node ? getTypeOfExpression(parent.expression) : undefined
- : ts.isLiteralTypeNode(parent) && ts.isIndexedAccessTypeNode(grandParent)
- ? getTypeFromTypeNode(grandParent.objectType)
- : undefined;
- return objectType && getPropertyOfType(objectType, ts.escapeLeadingUnderscores(node.text));
- case 84:
- case 94:
- case 38:
- case 80:
- return getSymbolOfNode(node.parent);
- case 188:
- return ts.isLiteralImportTypeNode(node) ? getSymbolAtLocation(node.argument.literal, ignoreErrors) : undefined;
- case 89:
- return ts.isExportAssignment(node.parent) ? ts.Debug.checkDefined(node.parent.symbol) : undefined;
- default:
- return undefined;
+ if (yieldTypes || returnTypes || nextTypes) {
+ return createIterationTypes(yieldTypes && getUnionType(yieldTypes), returnTypes && getUnionType(returnTypes), nextTypes && getIntersectionType(nextTypes));
}
+ return noIterationTypes;
}
- function getShorthandAssignmentValueSymbol(location) {
- if (location && location.kind === 282) {
- return resolveEntityName(location.name, 111551 | 2097152);
- }
- return undefined;
+ function getCachedIterationTypes(type, cacheKey) {
+ return type[cacheKey];
}
- function getExportSpecifierLocalTargetSymbol(node) {
- return node.parent.parent.moduleSpecifier ?
- getExternalModuleMember(node.parent.parent, node) :
- resolveEntityName(node.propertyName || node.name, 111551 | 788968 | 1920 | 2097152);
+ function setCachedIterationTypes(type, cacheKey, cachedTypes) {
+ return type[cacheKey] = cachedTypes;
}
- function getTypeOfNode(node) {
- if (node.flags & 16777216) {
- return errorType;
+ function getIterationTypesOfIterable(type, use, errorNode) {
+ if (isTypeAny(type)) {
+ return anyIterationTypes;
}
- var classDecl = ts.tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node);
- var classType = classDecl && getDeclaredTypeOfClassOrInterface(getSymbolOfNode(classDecl.class));
- if (ts.isPartOfTypeNode(node)) {
- var typeFromTypeNode = getTypeFromTypeNode(node);
- return classType ? getTypeWithThisArgument(typeFromTypeNode, classType.thisType) : typeFromTypeNode;
+ if (!(type.flags & 1048576)) {
+ var iterationTypes_1 = getIterationTypesOfIterableWorker(type, use, errorNode);
+ if (iterationTypes_1 === noIterationTypes) {
+ if (errorNode) {
+ reportTypeNotIterableError(errorNode, type, !!(use & 2));
+ }
+ return undefined;
+ }
+ return iterationTypes_1;
}
- if (ts.isExpressionNode(node)) {
- return getRegularTypeOfExpression(node);
+ var cacheKey = use & 2 ? "iterationTypesOfAsyncIterable" : "iterationTypesOfIterable";
+ var cachedTypes = getCachedIterationTypes(type, cacheKey);
+ if (cachedTypes)
+ return cachedTypes === noIterationTypes ? undefined : cachedTypes;
+ var allIterationTypes;
+ for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
+ var constituent = _a[_i];
+ var iterationTypes_2 = getIterationTypesOfIterableWorker(constituent, use, errorNode);
+ if (iterationTypes_2 === noIterationTypes) {
+ if (errorNode) {
+ reportTypeNotIterableError(errorNode, type, !!(use & 2));
+ }
+ setCachedIterationTypes(type, cacheKey, noIterationTypes);
+ return undefined;
+ }
+ else {
+ allIterationTypes = ts.append(allIterationTypes, iterationTypes_2);
+ }
}
- if (classType && !classDecl.isImplements) {
- var baseType = ts.firstOrUndefined(getBaseTypes(classType));
- return baseType ? getTypeWithThisArgument(baseType, classType.thisType) : errorType;
+ var iterationTypes = allIterationTypes ? combineIterationTypes(allIterationTypes) : noIterationTypes;
+ setCachedIterationTypes(type, cacheKey, iterationTypes);
+ return iterationTypes === noIterationTypes ? undefined : iterationTypes;
+ }
+ function getAsyncFromSyncIterationTypes(iterationTypes, errorNode) {
+ if (iterationTypes === noIterationTypes)
+ return noIterationTypes;
+ if (iterationTypes === anyIterationTypes)
+ return anyIterationTypes;
+ var yieldType = iterationTypes.yieldType, returnType = iterationTypes.returnType, nextType = iterationTypes.nextType;
+ return createIterationTypes(getAwaitedType(yieldType, errorNode) || anyType, getAwaitedType(returnType, errorNode) || anyType, nextType);
+ }
+ function getIterationTypesOfIterableWorker(type, use, errorNode) {
+ if (isTypeAny(type)) {
+ return anyIterationTypes;
}
- if (isTypeDeclaration(node)) {
- var symbol = getSymbolOfNode(node);
- return getDeclaredTypeOfSymbol(symbol);
+ if (use & 2) {
+ var iterationTypes = getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) ||
+ getIterationTypesOfIterableFast(type, asyncIterationTypesResolver);
+ if (iterationTypes) {
+ return iterationTypes;
+ }
}
- if (isTypeDeclarationName(node)) {
- var symbol = getSymbolAtLocation(node);
- return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
+ if (use & 1) {
+ var iterationTypes = getIterationTypesOfIterableCached(type, syncIterationTypesResolver) ||
+ getIterationTypesOfIterableFast(type, syncIterationTypesResolver);
+ if (iterationTypes) {
+ if (use & 2) {
+ if (iterationTypes !== noIterationTypes) {
+ return setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", getAsyncFromSyncIterationTypes(iterationTypes, errorNode));
+ }
+ }
+ else {
+ return iterationTypes;
+ }
+ }
}
- if (ts.isDeclaration(node)) {
- var symbol = getSymbolOfNode(node);
- return getTypeOfSymbol(symbol);
+ if (use & 2) {
+ var iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode);
+ if (iterationTypes !== noIterationTypes) {
+ return iterationTypes;
+ }
}
- if (isDeclarationNameOrImportPropertyName(node)) {
- var symbol = getSymbolAtLocation(node);
- if (symbol) {
- return getTypeOfSymbol(symbol);
+ if (use & 1) {
+ var iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode);
+ if (iterationTypes !== noIterationTypes) {
+ if (use & 2) {
+ return setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes
+ ? getAsyncFromSyncIterationTypes(iterationTypes, errorNode)
+ : noIterationTypes);
+ }
+ else {
+ return iterationTypes;
+ }
}
- return errorType;
}
- if (ts.isBindingPattern(node)) {
- return getTypeForVariableLikeDeclaration(node.parent, true) || errorType;
+ return noIterationTypes;
+ }
+ function getIterationTypesOfIterableCached(type, resolver) {
+ return getCachedIterationTypes(type, resolver.iterableCacheKey);
+ }
+ function getIterationTypesOfGlobalIterableType(globalType, resolver) {
+ var globalIterationTypes = getIterationTypesOfIterableCached(globalType, resolver) ||
+ getIterationTypesOfIterableSlow(globalType, resolver, undefined);
+ return globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
+ }
+ function getIterationTypesOfIterableFast(type, resolver) {
+ var globalType;
+ if (isReferenceToType(type, globalType = resolver.getGlobalIterableType(false)) ||
+ isReferenceToType(type, globalType = resolver.getGlobalIterableIteratorType(false))) {
+ var yieldType = getTypeArguments(type)[0];
+ var _a = getIterationTypesOfGlobalIterableType(globalType, resolver), returnType = _a.returnType, nextType = _a.nextType;
+ return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(yieldType, returnType, nextType));
}
- if (isInRightSideOfImportOrExportAssignment(node)) {
- var symbol = getSymbolAtLocation(node);
- if (symbol) {
- var declaredType = getDeclaredTypeOfSymbol(symbol);
- return declaredType !== errorType ? declaredType : getTypeOfSymbol(symbol);
- }
+ if (isReferenceToType(type, resolver.getGlobalGeneratorType(false))) {
+ var _b = getTypeArguments(type), yieldType = _b[0], returnType = _b[1], nextType = _b[2];
+ return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(yieldType, returnType, nextType));
}
- return errorType;
}
- function getTypeOfAssignmentPattern(expr) {
- ts.Debug.assert(expr.kind === 193 || expr.kind === 192);
- if (expr.parent.kind === 232) {
- var iteratedType = checkRightHandSideOfForOf(expr.parent);
- return checkDestructuringAssignment(expr, iteratedType || errorType);
- }
- if (expr.parent.kind === 209) {
- var iteratedType = getTypeOfExpression(expr.parent.right);
- return checkDestructuringAssignment(expr, iteratedType || errorType);
+ function getIterationTypesOfIterableSlow(type, resolver, errorNode) {
+ var _a;
+ var method = getPropertyOfType(type, ts.getPropertyNameForKnownSymbolName(resolver.iteratorSymbolName));
+ var methodType = method && !(method.flags & 16777216) ? getTypeOfSymbol(method) : undefined;
+ if (isTypeAny(methodType)) {
+ return setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes);
}
- if (expr.parent.kind === 281) {
- var node_4 = ts.cast(expr.parent.parent, ts.isObjectLiteralExpression);
- var typeOfParentObjectLiteral = getTypeOfAssignmentPattern(node_4) || errorType;
- var propertyIndex = ts.indexOfNode(node_4.properties, expr.parent);
- return checkObjectLiteralDestructuringPropertyAssignment(node_4, typeOfParentObjectLiteral, propertyIndex);
+ var signatures = methodType ? getSignaturesOfType(methodType, 0) : undefined;
+ if (!ts.some(signatures)) {
+ return setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes);
}
- var node = ts.cast(expr.parent, ts.isArrayLiteralExpression);
- var typeOfArrayLiteral = getTypeOfAssignmentPattern(node) || errorType;
- var elementType = checkIteratedTypeOrElementType(65, typeOfArrayLiteral, undefinedType, expr.parent) || errorType;
- return checkArrayLiteralDestructuringElementAssignment(node, typeOfArrayLiteral, node.elements.indexOf(expr), elementType);
+ var iteratorType = getIntersectionType(ts.map(signatures, getReturnTypeOfSignature));
+ var iterationTypes = (_a = getIterationTypesOfIterator(iteratorType, resolver, errorNode)) !== null && _a !== void 0 ? _a : noIterationTypes;
+ return setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes);
}
- function getPropertySymbolOfDestructuringAssignment(location) {
- var typeOfObjectLiteral = getTypeOfAssignmentPattern(ts.cast(location.parent.parent, ts.isAssignmentPattern));
- return typeOfObjectLiteral && getPropertyOfType(typeOfObjectLiteral, location.escapedText);
+ function reportTypeNotIterableError(errorNode, type, allowAsyncIterables) {
+ var message = allowAsyncIterables
+ ? ts.Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator
+ : ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator;
+ errorAndMaybeSuggestAwait(errorNode, !!getAwaitedTypeOfPromise(type), message, typeToString(type));
}
- function getRegularTypeOfExpression(expr) {
- if (ts.isRightSideOfQualifiedNameOrPropertyAccess(expr)) {
- expr = expr.parent;
+ function getIterationTypesOfIterator(type, resolver, errorNode) {
+ if (isTypeAny(type)) {
+ return anyIterationTypes;
}
- return getRegularTypeOfLiteralType(getTypeOfExpression(expr));
+ var iterationTypes = getIterationTypesOfIteratorCached(type, resolver) ||
+ getIterationTypesOfIteratorFast(type, resolver) ||
+ getIterationTypesOfIteratorSlow(type, resolver, errorNode);
+ return iterationTypes === noIterationTypes ? undefined : iterationTypes;
}
- function getParentTypeOfClassElement(node) {
- var classSymbol = getSymbolOfNode(node.parent);
- return ts.hasModifier(node, 32)
- ? getTypeOfSymbol(classSymbol)
- : getDeclaredTypeOfSymbol(classSymbol);
+ function getIterationTypesOfIteratorCached(type, resolver) {
+ return getCachedIterationTypes(type, resolver.iteratorCacheKey);
}
- function getClassElementPropertyKeyType(element) {
- var name = element.name;
- switch (name.kind) {
- case 75:
- return getLiteralType(ts.idText(name));
- case 8:
- case 10:
- return getLiteralType(name.text);
- case 154:
- var nameType = checkComputedPropertyName(name);
- return isTypeAssignableToKind(nameType, 12288) ? nameType : stringType;
- default:
- return ts.Debug.fail("Unsupported property name.");
+ function getIterationTypesOfIteratorFast(type, resolver) {
+ var globalType = resolver.getGlobalIterableIteratorType(false);
+ if (isReferenceToType(type, globalType)) {
+ var yieldType = getTypeArguments(type)[0];
+ var globalIterationTypes = getIterationTypesOfIteratorCached(globalType, resolver) ||
+ getIterationTypesOfIteratorSlow(globalType, resolver, undefined);
+ var _a = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes, returnType = _a.returnType, nextType = _a.nextType;
+ return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
}
- }
- function getAugmentedPropertiesOfType(type) {
- type = getApparentType(type);
- var propsByName = ts.createSymbolTable(getPropertiesOfType(type));
- var functionType = getSignaturesOfType(type, 0).length ? globalCallableFunctionType :
- getSignaturesOfType(type, 1).length ? globalNewableFunctionType :
- undefined;
- if (functionType) {
- ts.forEach(getPropertiesOfType(functionType), function (p) {
- if (!propsByName.has(p.escapedName)) {
- propsByName.set(p.escapedName, p);
- }
- });
+ if (isReferenceToType(type, resolver.getGlobalIteratorType(false)) ||
+ isReferenceToType(type, resolver.getGlobalGeneratorType(false))) {
+ var _b = getTypeArguments(type), yieldType = _b[0], returnType = _b[1], nextType = _b[2];
+ return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
}
- return getNamedMembers(propsByName);
}
- function typeHasCallOrConstructSignatures(type) {
- return ts.typeHasCallOrConstructSignatures(type, checker);
+ function isIteratorResult(type, kind) {
+ var doneType = getTypeOfPropertyOfType(type, "done") || falseType;
+ return isTypeAssignableTo(kind === 0 ? falseType : trueType, doneType);
}
- function getRootSymbols(symbol) {
- var roots = getImmediateRootSymbols(symbol);
- return roots ? ts.flatMap(roots, getRootSymbols) : [symbol];
+ function isYieldIteratorResult(type) {
+ return isIteratorResult(type, 0);
}
- function getImmediateRootSymbols(symbol) {
- if (ts.getCheckFlags(symbol) & 6) {
- return ts.mapDefined(getSymbolLinks(symbol).containingType.types, function (type) { return getPropertyOfType(type, symbol.escapedName); });
- }
- else if (symbol.flags & 33554432) {
- var _a = symbol, leftSpread = _a.leftSpread, rightSpread = _a.rightSpread, syntheticOrigin = _a.syntheticOrigin;
- return leftSpread ? [leftSpread, rightSpread]
- : syntheticOrigin ? [syntheticOrigin]
- : ts.singleElementArray(tryGetAliasTarget(symbol));
- }
- return undefined;
+ function isReturnIteratorResult(type) {
+ return isIteratorResult(type, 1);
}
- function tryGetAliasTarget(symbol) {
- var target;
- var next = symbol;
- while (next = getSymbolLinks(next).target) {
- target = next;
+ function getIterationTypesOfIteratorResult(type) {
+ if (isTypeAny(type)) {
+ return anyIterationTypes;
}
- return target;
- }
- function isArgumentsLocalBinding(nodeIn) {
- if (!ts.isGeneratedIdentifier(nodeIn)) {
- var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier);
- if (node) {
- var isPropertyName_1 = node.parent.kind === 194 && node.parent.name === node;
- return !isPropertyName_1 && getReferencedValueSymbol(node) === argumentsSymbol;
- }
+ var cachedTypes = getCachedIterationTypes(type, "iterationTypesOfIteratorResult");
+ if (cachedTypes) {
+ return cachedTypes;
}
- return false;
- }
- function moduleExportsSomeValue(moduleReferenceExpression) {
- var moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression);
- if (!moduleSymbol || ts.isShorthandAmbientModuleSymbol(moduleSymbol)) {
- return true;
+ if (isReferenceToType(type, getGlobalIteratorYieldResultType(false))) {
+ var yieldType_1 = getTypeArguments(type)[0];
+ return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType_1, undefined, undefined));
}
- var hasExportAssignment = hasExportAssignmentSymbol(moduleSymbol);
- moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
- var symbolLinks = getSymbolLinks(moduleSymbol);
- if (symbolLinks.exportsSomeValue === undefined) {
- symbolLinks.exportsSomeValue = hasExportAssignment
- ? !!(moduleSymbol.flags & 111551)
- : ts.forEachEntry(getExportsOfModule(moduleSymbol), isValue);
+ if (isReferenceToType(type, getGlobalIteratorReturnResultType(false))) {
+ var returnType_1 = getTypeArguments(type)[0];
+ return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(undefined, returnType_1, undefined));
}
- return symbolLinks.exportsSomeValue;
- function isValue(s) {
- s = resolveSymbol(s);
- return s && !!(s.flags & 111551);
+ var yieldIteratorResult = filterType(type, isYieldIteratorResult);
+ var yieldType = yieldIteratorResult !== neverType ? getTypeOfPropertyOfType(yieldIteratorResult, "value") : undefined;
+ var returnIteratorResult = filterType(type, isReturnIteratorResult);
+ var returnType = returnIteratorResult !== neverType ? getTypeOfPropertyOfType(returnIteratorResult, "value") : undefined;
+ if (!yieldType && !returnType) {
+ return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", noIterationTypes);
}
+ return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType, returnType || voidType, undefined));
}
- function isNameOfModuleOrEnumDeclaration(node) {
- return ts.isModuleOrEnumDeclaration(node.parent) && node === node.parent.name;
- }
- function getReferencedExportContainer(nodeIn, prefixLocals) {
- var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier);
- if (node) {
- var symbol = getReferencedValueSymbol(node, isNameOfModuleOrEnumDeclaration(node));
- if (symbol) {
- if (symbol.flags & 1048576) {
- var exportSymbol = getMergedSymbol(symbol.exportSymbol);
- if (!prefixLocals && exportSymbol.flags & 944 && !(exportSymbol.flags & 3)) {
- return undefined;
- }
- symbol = exportSymbol;
- }
- var parentSymbol_1 = getParentOfSymbol(symbol);
- if (parentSymbol_1) {
- if (parentSymbol_1.flags & 512 && parentSymbol_1.valueDeclaration.kind === 290) {
- var symbolFile = parentSymbol_1.valueDeclaration;
- var referenceFile = ts.getSourceFileOfNode(node);
- var symbolIsUmdExport = symbolFile !== referenceFile;
- return symbolIsUmdExport ? undefined : symbolFile;
- }
- return ts.findAncestor(node.parent, function (n) { return ts.isModuleOrEnumDeclaration(n) && getSymbolOfNode(n) === parentSymbol_1; });
- }
+ function getIterationTypesOfMethod(type, resolver, methodName, errorNode) {
+ var _a, _b, _c, _d;
+ var method = getPropertyOfType(type, methodName);
+ if (!method && methodName !== "next") {
+ return undefined;
+ }
+ var methodType = method && !(methodName === "next" && (method.flags & 16777216))
+ ? methodName === "next" ? getTypeOfSymbol(method) : getTypeWithFacts(getTypeOfSymbol(method), 2097152)
+ : undefined;
+ if (isTypeAny(methodType)) {
+ return methodName === "next" ? anyIterationTypes : anyIterationTypesExceptNext;
+ }
+ var methodSignatures = methodType ? getSignaturesOfType(methodType, 0) : ts.emptyArray;
+ if (methodSignatures.length === 0) {
+ if (errorNode) {
+ var diagnostic = methodName === "next"
+ ? resolver.mustHaveANextMethodDiagnostic
+ : resolver.mustBeAMethodDiagnostic;
+ error(errorNode, diagnostic, methodName);
}
+ return methodName === "next" ? anyIterationTypes : undefined;
}
- }
- function getReferencedImportDeclaration(nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier);
- if (node) {
- var symbol = getReferencedValueSymbol(node);
- if (isNonLocalAlias(symbol, 111551) && !getTypeOnlyAliasDeclaration(symbol)) {
- return getDeclarationOfAliasSymbol(symbol);
+ if ((methodType === null || methodType === void 0 ? void 0 : methodType.symbol) && methodSignatures.length === 1) {
+ var globalGeneratorType = resolver.getGlobalGeneratorType(false);
+ var globalIteratorType = resolver.getGlobalIteratorType(false);
+ var isGeneratorMethod = ((_b = (_a = globalGeneratorType.symbol) === null || _a === void 0 ? void 0 : _a.members) === null || _b === void 0 ? void 0 : _b.get(methodName)) === methodType.symbol;
+ var isIteratorMethod = !isGeneratorMethod && ((_d = (_c = globalIteratorType.symbol) === null || _c === void 0 ? void 0 : _c.members) === null || _d === void 0 ? void 0 : _d.get(methodName)) === methodType.symbol;
+ if (isGeneratorMethod || isIteratorMethod) {
+ var globalType = isGeneratorMethod ? globalGeneratorType : globalIteratorType;
+ var mapper = methodType.mapper;
+ return createIterationTypes(getMappedType(globalType.typeParameters[0], mapper), getMappedType(globalType.typeParameters[1], mapper), methodName === "next" ? getMappedType(globalType.typeParameters[2], mapper) : undefined);
}
}
- return undefined;
- }
- function isSymbolOfDestructuredElementOfCatchBinding(symbol) {
- return ts.isBindingElement(symbol.valueDeclaration)
- && ts.walkUpBindingElementsAndPatterns(symbol.valueDeclaration).parent.kind === 280;
- }
- function isSymbolOfDeclarationWithCollidingName(symbol) {
- if (symbol.flags & 418 && !ts.isSourceFile(symbol.valueDeclaration)) {
- var links = getSymbolLinks(symbol);
- if (links.isDeclarationWithCollidingName === undefined) {
- var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration);
- if (ts.isStatementWithLocals(container) || isSymbolOfDestructuredElementOfCatchBinding(symbol)) {
- var nodeLinks_1 = getNodeLinks(symbol.valueDeclaration);
- if (resolveName(container.parent, symbol.escapedName, 111551, undefined, undefined, false)) {
- links.isDeclarationWithCollidingName = true;
- }
- else if (nodeLinks_1.flags & 262144) {
- var isDeclaredInLoop = nodeLinks_1.flags & 524288;
- var inLoopInitializer = ts.isIterationStatement(container, false);
- var inLoopBodyBlock = container.kind === 223 && ts.isIterationStatement(container.parent, false);
- links.isDeclarationWithCollidingName = !ts.isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || (!inLoopInitializer && !inLoopBodyBlock));
- }
- else {
- links.isDeclarationWithCollidingName = false;
- }
- }
+ var methodParameterTypes;
+ var methodReturnTypes;
+ for (var _i = 0, methodSignatures_1 = methodSignatures; _i < methodSignatures_1.length; _i++) {
+ var signature = methodSignatures_1[_i];
+ if (methodName !== "throw" && ts.some(signature.parameters)) {
+ methodParameterTypes = ts.append(methodParameterTypes, getTypeAtPosition(signature, 0));
}
- return links.isDeclarationWithCollidingName;
+ methodReturnTypes = ts.append(methodReturnTypes, getReturnTypeOfSignature(signature));
}
- return false;
- }
- function getReferencedDeclarationWithCollidingName(nodeIn) {
- if (!ts.isGeneratedIdentifier(nodeIn)) {
- var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier);
- if (node) {
- var symbol = getReferencedValueSymbol(node);
- if (symbol && isSymbolOfDeclarationWithCollidingName(symbol)) {
- return symbol.valueDeclaration;
- }
+ var returnTypes;
+ var nextType;
+ if (methodName !== "throw") {
+ var methodParameterType = methodParameterTypes ? getUnionType(methodParameterTypes) : unknownType;
+ if (methodName === "next") {
+ nextType = methodParameterType;
+ }
+ else if (methodName === "return") {
+ var resolvedMethodParameterType = resolver.resolveIterationType(methodParameterType, errorNode) || anyType;
+ returnTypes = ts.append(returnTypes, resolvedMethodParameterType);
}
}
- return undefined;
- }
- function isDeclarationWithCollidingName(nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isDeclaration);
- if (node) {
- var symbol = getSymbolOfNode(node);
- if (symbol) {
- return isSymbolOfDeclarationWithCollidingName(symbol);
+ var yieldType;
+ var methodReturnType = methodReturnTypes ? getIntersectionType(methodReturnTypes) : neverType;
+ var resolvedMethodReturnType = resolver.resolveIterationType(methodReturnType, errorNode) || anyType;
+ var iterationTypes = getIterationTypesOfIteratorResult(resolvedMethodReturnType);
+ if (iterationTypes === noIterationTypes) {
+ if (errorNode) {
+ error(errorNode, resolver.mustHaveAValueDiagnostic, methodName);
}
+ yieldType = anyType;
+ returnTypes = ts.append(returnTypes, anyType);
}
- return false;
- }
- function isValueAliasDeclaration(node) {
- switch (node.kind) {
- case 253:
- return isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol);
- case 255:
- case 256:
- case 258:
- case 263:
- var symbol = getSymbolOfNode(node) || unknownSymbol;
- return isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol);
- case 260:
- var exportClause = node.exportClause;
- return !!exportClause && (ts.isNamespaceExport(exportClause) ||
- ts.some(exportClause.elements, isValueAliasDeclaration));
- case 259:
- return node.expression && node.expression.kind === 75 ?
- isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol) :
- true;
+ else {
+ yieldType = iterationTypes.yieldType;
+ returnTypes = ts.append(returnTypes, iterationTypes.returnType);
}
- return false;
+ return createIterationTypes(yieldType, getUnionType(returnTypes), nextType);
}
- function isTopLevelValueImportEqualsWithEntityName(nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isImportEqualsDeclaration);
- if (node === undefined || node.parent.kind !== 290 || !ts.isInternalModuleImportEqualsDeclaration(node)) {
- return false;
- }
- var isValue = isAliasResolvedToValue(getSymbolOfNode(node));
- return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference);
+ function getIterationTypesOfIteratorSlow(type, resolver, errorNode) {
+ var iterationTypes = combineIterationTypes([
+ getIterationTypesOfMethod(type, resolver, "next", errorNode),
+ getIterationTypesOfMethod(type, resolver, "return", errorNode),
+ getIterationTypesOfMethod(type, resolver, "throw", errorNode),
+ ]);
+ return setCachedIterationTypes(type, resolver.iteratorCacheKey, iterationTypes);
}
- function isAliasResolvedToValue(symbol) {
- var target = resolveAlias(symbol);
- if (target === unknownSymbol) {
- return true;
+ function getIterationTypeOfGeneratorFunctionReturnType(kind, returnType, isAsyncGenerator) {
+ if (isTypeAny(returnType)) {
+ return undefined;
}
- return !!(target.flags & 111551) &&
- (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target));
- }
- function isConstEnumOrConstEnumOnlyModule(s) {
- return isConstEnumSymbol(s) || !!s.constEnumOnlyModule;
+ var iterationTypes = getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsyncGenerator);
+ return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(kind)];
}
- function isReferencedAliasDeclaration(node, checkChildren) {
- if (isAliasSymbolDeclaration(node)) {
- var symbol = getSymbolOfNode(node);
- if (symbol && getSymbolLinks(symbol).referenced) {
- return true;
- }
- var target = getSymbolLinks(symbol).target;
- if (target && ts.getModifierFlags(node) & 1 &&
- target.flags & 111551 &&
- (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target))) {
- return true;
- }
- }
- if (checkChildren) {
- return !!ts.forEachChild(node, function (node) { return isReferencedAliasDeclaration(node, checkChildren); });
+ function getIterationTypesOfGeneratorFunctionReturnType(type, isAsyncGenerator) {
+ if (isTypeAny(type)) {
+ return anyIterationTypes;
}
- return false;
+ var use = isAsyncGenerator ? 2 : 1;
+ var resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
+ return getIterationTypesOfIterable(type, use, undefined) ||
+ getIterationTypesOfIterator(type, resolver, undefined);
}
- function isImplementationOfOverload(node) {
- if (ts.nodeIsPresent(node.body)) {
- if (ts.isGetAccessor(node) || ts.isSetAccessor(node))
- return false;
- var symbol = getSymbolOfNode(node);
- var signaturesOfSymbol = getSignaturesOfSymbol(symbol);
- return signaturesOfSymbol.length > 1 ||
- (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node);
- }
- return false;
+ function checkBreakOrContinueStatement(node) {
+ if (!checkGrammarStatementInAmbientContext(node))
+ checkGrammarBreakOrContinueStatement(node);
}
- function isRequiredInitializedParameter(parameter) {
- return !!strictNullChecks &&
- !isOptionalParameter(parameter) &&
- !ts.isJSDocParameterTag(parameter) &&
- !!parameter.initializer &&
- !ts.hasModifier(parameter, 92);
+ function unwrapReturnType(returnType, functionFlags) {
+ var _a, _b;
+ var isGenerator = !!(functionFlags & 1);
+ var isAsync = !!(functionFlags & 2);
+ return isGenerator ? (_a = getIterationTypeOfGeneratorFunctionReturnType(1, returnType, isAsync)) !== null && _a !== void 0 ? _a : errorType :
+ isAsync ? (_b = getAwaitedType(returnType)) !== null && _b !== void 0 ? _b : errorType :
+ returnType;
}
- function isOptionalUninitializedParameterProperty(parameter) {
- return strictNullChecks &&
- isOptionalParameter(parameter) &&
- !parameter.initializer &&
- ts.hasModifier(parameter, 92);
+ function isUnwrappedReturnTypeVoidOrAny(func, returnType) {
+ var unwrappedReturnType = unwrapReturnType(returnType, ts.getFunctionFlags(func));
+ return !!unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, 16384 | 3);
}
- function isExpandoFunctionDeclaration(node) {
- var declaration = ts.getParseTreeNode(node, ts.isFunctionDeclaration);
- if (!declaration) {
- return false;
+ function checkReturnStatement(node) {
+ var _a;
+ if (checkGrammarStatementInAmbientContext(node)) {
+ return;
}
- var symbol = getSymbolOfNode(declaration);
- if (!symbol || !(symbol.flags & 16)) {
- return false;
+ var func = ts.getContainingFunction(node);
+ if (!func) {
+ grammarErrorOnFirstToken(node, ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);
+ return;
}
- return !!ts.forEachEntry(getExportsOfSymbol(symbol), function (p) { return p.flags & 111551 && p.valueDeclaration && ts.isPropertyAccessExpression(p.valueDeclaration); });
- }
- function getPropertiesOfContainerFunction(node) {
- var declaration = ts.getParseTreeNode(node, ts.isFunctionDeclaration);
- if (!declaration) {
- return ts.emptyArray;
+ var signature = getSignatureFromDeclaration(func);
+ var returnType = getReturnTypeOfSignature(signature);
+ var functionFlags = ts.getFunctionFlags(func);
+ if (strictNullChecks || node.expression || returnType.flags & 131072) {
+ var exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
+ if (func.kind === 168) {
+ if (node.expression) {
+ error(node, ts.Diagnostics.Setters_cannot_return_a_value);
+ }
+ }
+ else if (func.kind === 166) {
+ if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
+ error(node, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
+ }
+ }
+ else if (getReturnTypeFromAnnotation(func)) {
+ var unwrappedReturnType = (_a = unwrapReturnType(returnType, functionFlags)) !== null && _a !== void 0 ? _a : returnType;
+ var unwrappedExprType = functionFlags & 2
+ ? checkAwaitedType(exprType, node, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)
+ : exprType;
+ if (unwrappedReturnType) {
+ checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
+ }
+ }
}
- var symbol = getSymbolOfNode(declaration);
- return symbol && getPropertiesOfType(getTypeOfSymbol(symbol)) || ts.emptyArray;
- }
- function getNodeCheckFlags(node) {
- return getNodeLinks(node).flags || 0;
- }
- function getEnumMemberValue(node) {
- computeEnumMemberValues(node.parent);
- return getNodeLinks(node).enumMemberValue;
- }
- function canHaveConstantValue(node) {
- switch (node.kind) {
- case 284:
- case 194:
- case 195:
- return true;
+ else if (func.kind !== 166 && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(func, returnType)) {
+ error(node, ts.Diagnostics.Not_all_code_paths_return_a_value);
}
- return false;
}
- function getConstantValue(node) {
- if (node.kind === 284) {
- return getEnumMemberValue(node);
- }
- var symbol = getNodeLinks(node).resolvedSymbol;
- if (symbol && (symbol.flags & 8)) {
- var member = symbol.valueDeclaration;
- if (ts.isEnumConst(member.parent)) {
- return getEnumMemberValue(member);
+ function checkWithStatement(node) {
+ if (!checkGrammarStatementInAmbientContext(node)) {
+ if (node.flags & 32768) {
+ grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_an_async_function_block);
}
}
- return undefined;
- }
- function isFunctionType(type) {
- return !!(type.flags & 524288) && getSignaturesOfType(type, 0).length > 0;
- }
- function getTypeReferenceSerializationKind(typeNameIn, location) {
- var typeName = ts.getParseTreeNode(typeNameIn, ts.isEntityName);
- if (!typeName)
- return ts.TypeReferenceSerializationKind.Unknown;
- if (location) {
- location = ts.getParseTreeNode(location);
- if (!location)
- return ts.TypeReferenceSerializationKind.Unknown;
+ checkExpression(node.expression);
+ var sourceFile = ts.getSourceFileOfNode(node);
+ if (!hasParseDiagnostics(sourceFile)) {
+ var start = ts.getSpanOfTokenAtPosition(sourceFile, node.pos).start;
+ var end = node.statement.pos;
+ grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any);
}
- var valueSymbol = resolveEntityName(typeName, 111551, true, false, location);
- var typeSymbol = resolveEntityName(typeName, 788968, true, false, location);
- if (valueSymbol && valueSymbol === typeSymbol) {
- var globalPromiseSymbol = getGlobalPromiseConstructorSymbol(false);
- if (globalPromiseSymbol && valueSymbol === globalPromiseSymbol) {
- return ts.TypeReferenceSerializationKind.Promise;
+ }
+ function checkSwitchStatement(node) {
+ checkGrammarStatementInAmbientContext(node);
+ var firstDefaultClause;
+ var hasDuplicateDefaultClause = false;
+ var expressionType = checkExpression(node.expression);
+ var expressionIsLiteral = isLiteralType(expressionType);
+ ts.forEach(node.caseBlock.clauses, function (clause) {
+ if (clause.kind === 285 && !hasDuplicateDefaultClause) {
+ if (firstDefaultClause === undefined) {
+ firstDefaultClause = clause;
+ }
+ else {
+ grammarErrorOnNode(clause, ts.Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement);
+ hasDuplicateDefaultClause = true;
+ }
}
- var constructorType = getTypeOfSymbol(valueSymbol);
- if (constructorType && isConstructorType(constructorType)) {
- return ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue;
+ if (produceDiagnostics && clause.kind === 284) {
+ var caseType = checkExpression(clause.expression);
+ var caseIsLiteral = isLiteralType(caseType);
+ var comparedExpressionType = expressionType;
+ if (!caseIsLiteral || !expressionIsLiteral) {
+ caseType = caseIsLiteral ? getBaseTypeOfLiteralType(caseType) : caseType;
+ comparedExpressionType = getBaseTypeOfLiteralType(expressionType);
+ }
+ if (!isTypeEqualityComparableTo(comparedExpressionType, caseType)) {
+ checkTypeComparableTo(caseType, comparedExpressionType, clause.expression, undefined);
+ }
+ }
+ ts.forEach(clause.statements, checkSourceElement);
+ if (compilerOptions.noFallthroughCasesInSwitch && clause.fallthroughFlowNode && isReachableFlowNode(clause.fallthroughFlowNode)) {
+ error(clause, ts.Diagnostics.Fallthrough_case_in_switch);
}
+ });
+ if (node.caseBlock.locals) {
+ registerForUnusedIdentifiersCheck(node.caseBlock);
}
- if (!typeSymbol) {
- return ts.TypeReferenceSerializationKind.Unknown;
- }
- var type = getDeclaredTypeOfSymbol(typeSymbol);
- if (type === errorType) {
- return ts.TypeReferenceSerializationKind.Unknown;
- }
- else if (type.flags & 3) {
- return ts.TypeReferenceSerializationKind.ObjectType;
- }
- else if (isTypeAssignableToKind(type, 16384 | 98304 | 131072)) {
- return ts.TypeReferenceSerializationKind.VoidNullableOrNeverType;
- }
- else if (isTypeAssignableToKind(type, 528)) {
- return ts.TypeReferenceSerializationKind.BooleanType;
+ }
+ function checkLabeledStatement(node) {
+ if (!checkGrammarStatementInAmbientContext(node)) {
+ ts.findAncestor(node.parent, function (current) {
+ if (ts.isFunctionLike(current)) {
+ return "quit";
+ }
+ if (current.kind === 245 && current.label.escapedText === node.label.escapedText) {
+ grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNode(node.label));
+ return true;
+ }
+ return false;
+ });
}
- else if (isTypeAssignableToKind(type, 296)) {
- return ts.TypeReferenceSerializationKind.NumberLikeType;
+ checkSourceElement(node.statement);
+ }
+ function checkThrowStatement(node) {
+ if (!checkGrammarStatementInAmbientContext(node)) {
+ if (ts.isIdentifier(node.expression) && !node.expression.escapedText) {
+ grammarErrorAfterFirstToken(node, ts.Diagnostics.Line_break_not_permitted_here);
+ }
}
- else if (isTypeAssignableToKind(type, 2112)) {
- return ts.TypeReferenceSerializationKind.BigIntLikeType;
+ if (node.expression) {
+ checkExpression(node.expression);
}
- else if (isTypeAssignableToKind(type, 132)) {
- return ts.TypeReferenceSerializationKind.StringLikeType;
+ }
+ function checkTryStatement(node) {
+ checkGrammarStatementInAmbientContext(node);
+ checkBlock(node.tryBlock);
+ var catchClause = node.catchClause;
+ if (catchClause) {
+ if (catchClause.variableDeclaration) {
+ var declaration = catchClause.variableDeclaration;
+ if (declaration.type) {
+ var type = getTypeForVariableLikeDeclaration(declaration, false);
+ if (type && !(type.flags & 3)) {
+ grammarErrorOnFirstToken(declaration.type, ts.Diagnostics.Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified);
+ }
+ }
+ else if (declaration.initializer) {
+ grammarErrorOnFirstToken(declaration.initializer, ts.Diagnostics.Catch_clause_variable_cannot_have_an_initializer);
+ }
+ else {
+ var blockLocals_1 = catchClause.block.locals;
+ if (blockLocals_1) {
+ ts.forEachKey(catchClause.locals, function (caughtName) {
+ var blockLocal = blockLocals_1.get(caughtName);
+ if (blockLocal && (blockLocal.flags & 2) !== 0) {
+ grammarErrorOnNode(blockLocal.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName);
+ }
+ });
+ }
+ }
+ }
+ checkBlock(catchClause.block);
}
- else if (isTupleType(type)) {
- return ts.TypeReferenceSerializationKind.ArrayLikeType;
+ if (node.finallyBlock) {
+ checkBlock(node.finallyBlock);
}
- else if (isTypeAssignableToKind(type, 12288)) {
- return ts.TypeReferenceSerializationKind.ESSymbolType;
+ }
+ function checkIndexConstraints(type) {
+ var declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, 1);
+ var declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, 0);
+ var stringIndexType = getIndexTypeOfType(type, 0);
+ var numberIndexType = getIndexTypeOfType(type, 1);
+ if (stringIndexType || numberIndexType) {
+ ts.forEach(getPropertiesOfObjectType(type), function (prop) {
+ var propType = getTypeOfSymbol(prop);
+ checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0);
+ checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1);
+ });
+ var classDeclaration = type.symbol.valueDeclaration;
+ if (ts.getObjectFlags(type) & 1 && ts.isClassLike(classDeclaration)) {
+ for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) {
+ var member = _a[_i];
+ if (!ts.hasSyntacticModifier(member, 32) && hasNonBindableDynamicName(member)) {
+ var symbol = getSymbolOfNode(member);
+ var propType = getTypeOfSymbol(symbol);
+ checkIndexConstraintForProperty(symbol, propType, type, declaredStringIndexer, stringIndexType, 0);
+ checkIndexConstraintForProperty(symbol, propType, type, declaredNumberIndexer, numberIndexType, 1);
+ }
+ }
+ }
}
- else if (isFunctionType(type)) {
- return ts.TypeReferenceSerializationKind.TypeWithCallSignature;
+ var errorNode;
+ if (stringIndexType && numberIndexType) {
+ errorNode = declaredNumberIndexer || declaredStringIndexer;
+ if (!errorNode && (ts.getObjectFlags(type) & 2)) {
+ var someBaseTypeHasBothIndexers = ts.forEach(getBaseTypes(type), function (base) { return getIndexTypeOfType(base, 0) && getIndexTypeOfType(base, 1); });
+ errorNode = someBaseTypeHasBothIndexers ? undefined : type.symbol.declarations[0];
+ }
}
- else if (isArrayType(type)) {
- return ts.TypeReferenceSerializationKind.ArrayLikeType;
+ if (errorNode && !isTypeAssignableTo(numberIndexType, stringIndexType)) {
+ error(errorNode, ts.Diagnostics.Numeric_index_type_0_is_not_assignable_to_string_index_type_1, typeToString(numberIndexType), typeToString(stringIndexType));
}
- else {
- return ts.TypeReferenceSerializationKind.ObjectType;
+ function checkIndexConstraintForProperty(prop, propertyType, containingType, indexDeclaration, indexType, indexKind) {
+ if (!indexType || ts.isKnownSymbol(prop)) {
+ return;
+ }
+ var propDeclaration = prop.valueDeclaration;
+ var name = propDeclaration && ts.getNameOfDeclaration(propDeclaration);
+ if (name && ts.isPrivateIdentifier(name)) {
+ return;
+ }
+ if (indexKind === 1 && !(name ? isNumericName(name) : isNumericLiteralName(prop.escapedName))) {
+ return;
+ }
+ var errorNode;
+ if (propDeclaration && name &&
+ (propDeclaration.kind === 216 ||
+ name.kind === 158 ||
+ prop.parent === containingType.symbol)) {
+ errorNode = propDeclaration;
+ }
+ else if (indexDeclaration) {
+ errorNode = indexDeclaration;
+ }
+ else if (ts.getObjectFlags(containingType) & 2) {
+ var someBaseClassHasBothPropertyAndIndexer = ts.forEach(getBaseTypes(containingType), function (base) { return getPropertyOfObjectType(base, prop.escapedName) && getIndexTypeOfType(base, indexKind); });
+ errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : containingType.symbol.declarations[0];
+ }
+ if (errorNode && !isTypeAssignableTo(propertyType, indexType)) {
+ var errorMessage = indexKind === 0
+ ? ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_string_index_type_2
+ : ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2;
+ error(errorNode, errorMessage, symbolToString(prop), typeToString(propertyType), typeToString(indexType));
+ }
}
}
- function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker, addUndefined) {
- var declaration = ts.getParseTreeNode(declarationIn, ts.isVariableLikeOrAccessor);
- if (!declaration) {
- return ts.createToken(125);
- }
- var symbol = getSymbolOfNode(declaration);
- var type = symbol && !(symbol.flags & (2048 | 131072))
- ? getWidenedLiteralType(getTypeOfSymbol(symbol))
- : errorType;
- if (type.flags & 8192 &&
- type.symbol === symbol) {
- flags |= 1048576;
- }
- if (addUndefined) {
- type = getOptionalType(type);
+ function checkTypeNameIsReserved(name, message) {
+ switch (name.escapedText) {
+ case "any":
+ case "unknown":
+ case "number":
+ case "bigint":
+ case "boolean":
+ case "string":
+ case "symbol":
+ case "void":
+ case "object":
+ error(name, message, name.escapedText);
}
- return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024, tracker);
}
- function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
- var signatureDeclaration = ts.getParseTreeNode(signatureDeclarationIn, ts.isFunctionLike);
- if (!signatureDeclaration) {
- return ts.createToken(125);
+ function checkClassNameCollisionWithObject(name) {
+ if (languageVersion === 1 && name.escapedText === "Object"
+ && moduleKind < ts.ModuleKind.ES2015) {
+ error(name, ts.Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ts.ModuleKind[moduleKind]);
}
- var signature = getSignatureFromDeclaration(signatureDeclaration);
- return nodeBuilder.typeToTypeNode(getReturnTypeOfSignature(signature), enclosingDeclaration, flags | 1024, tracker);
}
- function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
- var expr = ts.getParseTreeNode(exprIn, ts.isExpression);
- if (!expr) {
- return ts.createToken(125);
+ function checkTypeParameters(typeParameterDeclarations) {
+ if (typeParameterDeclarations) {
+ var seenDefault = false;
+ for (var i = 0; i < typeParameterDeclarations.length; i++) {
+ var node = typeParameterDeclarations[i];
+ checkTypeParameter(node);
+ if (produceDiagnostics) {
+ if (node.default) {
+ seenDefault = true;
+ checkTypeParametersNotReferenced(node.default, typeParameterDeclarations, i);
+ }
+ else if (seenDefault) {
+ error(node, ts.Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters);
+ }
+ for (var j = 0; j < i; j++) {
+ if (typeParameterDeclarations[j].symbol === node.symbol) {
+ error(node.name, ts.Diagnostics.Duplicate_identifier_0, ts.declarationNameToString(node.name));
+ }
+ }
+ }
+ }
}
- var type = getWidenedType(getRegularTypeOfExpression(expr));
- return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024, tracker);
- }
- function hasGlobalName(name) {
- return globals.has(ts.escapeLeadingUnderscores(name));
}
- function getReferencedValueSymbol(reference, startInDeclarationContainer) {
- var resolvedSymbol = getNodeLinks(reference).resolvedSymbol;
- if (resolvedSymbol) {
- return resolvedSymbol;
- }
- var location = reference;
- if (startInDeclarationContainer) {
- var parent = reference.parent;
- if (ts.isDeclaration(parent) && reference === parent.name) {
- location = getDeclarationContainer(parent);
+ function checkTypeParametersNotReferenced(root, typeParameters, index) {
+ visit(root);
+ function visit(node) {
+ if (node.kind === 173) {
+ var type = getTypeFromTypeReference(node);
+ if (type.flags & 262144) {
+ for (var i = index; i < typeParameters.length; i++) {
+ if (type.symbol === getSymbolOfNode(typeParameters[i])) {
+ error(node, ts.Diagnostics.Type_parameter_defaults_can_only_reference_previously_declared_type_parameters);
+ }
+ }
+ }
}
+ ts.forEachChild(node, visit);
}
- return resolveName(location, reference.escapedText, 111551 | 1048576 | 2097152, undefined, undefined, true);
}
- function getReferencedValueDeclaration(referenceIn) {
- if (!ts.isGeneratedIdentifier(referenceIn)) {
- var reference = ts.getParseTreeNode(referenceIn, ts.isIdentifier);
- if (reference) {
- var symbol = getReferencedValueSymbol(reference);
- if (symbol) {
- return getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
+ function checkTypeParameterListsIdentical(symbol) {
+ if (symbol.declarations.length === 1) {
+ return;
+ }
+ var links = getSymbolLinks(symbol);
+ if (!links.typeParametersChecked) {
+ links.typeParametersChecked = true;
+ var declarations = getClassOrInterfaceDeclarationsOfSymbol(symbol);
+ if (declarations.length <= 1) {
+ return;
+ }
+ var type = getDeclaredTypeOfSymbol(symbol);
+ if (!areTypeParametersIdentical(declarations, type.localTypeParameters)) {
+ var name = symbolToString(symbol);
+ for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
+ var declaration = declarations_6[_i];
+ error(declaration.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_type_parameters, name);
}
}
}
- return undefined;
}
- function isLiteralConstDeclaration(node) {
- if (ts.isDeclarationReadonly(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) {
- return isFreshLiteralType(getTypeOfSymbol(getSymbolOfNode(node)));
+ function areTypeParametersIdentical(declarations, targetParameters) {
+ var maxTypeArgumentCount = ts.length(targetParameters);
+ var minTypeArgumentCount = getMinTypeArgumentCount(targetParameters);
+ for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
+ var declaration = declarations_7[_i];
+ var sourceParameters = ts.getEffectiveTypeParameterDeclarations(declaration);
+ var numTypeParameters = sourceParameters.length;
+ if (numTypeParameters < minTypeArgumentCount || numTypeParameters > maxTypeArgumentCount) {
+ return false;
+ }
+ for (var i = 0; i < numTypeParameters; i++) {
+ var source = sourceParameters[i];
+ var target = targetParameters[i];
+ if (source.name.escapedText !== target.symbol.escapedName) {
+ return false;
+ }
+ var constraint = ts.getEffectiveConstraintOfTypeParameter(source);
+ var sourceConstraint = constraint && getTypeFromTypeNode(constraint);
+ var targetConstraint = getConstraintOfTypeParameter(target);
+ if (sourceConstraint && targetConstraint && !isTypeIdenticalTo(sourceConstraint, targetConstraint)) {
+ return false;
+ }
+ var sourceDefault = source.default && getTypeFromTypeNode(source.default);
+ var targetDefault = getDefaultFromTypeParameter(target);
+ if (sourceDefault && targetDefault && !isTypeIdenticalTo(sourceDefault, targetDefault)) {
+ return false;
+ }
+ }
}
- return false;
+ return true;
}
- function literalTypeToNode(type, enclosing, tracker) {
- var enumResult = type.flags & 1024 ? nodeBuilder.symbolToExpression(type.symbol, 111551, enclosing, undefined, tracker)
- : type === trueType ? ts.createTrue() : type === falseType && ts.createFalse();
- return enumResult || ts.createLiteral(type.value);
+ function checkClassExpression(node) {
+ checkClassLikeDeclaration(node);
+ checkNodeDeferred(node);
+ return getTypeOfSymbol(getSymbolOfNode(node));
}
- function createLiteralConstValue(node, tracker) {
- var type = getTypeOfSymbol(getSymbolOfNode(node));
- return literalTypeToNode(type, node, tracker);
+ function checkClassExpressionDeferred(node) {
+ ts.forEach(node.members, checkSourceElement);
+ registerForUnusedIdentifiersCheck(node);
}
- function getJsxFactoryEntity(location) {
- return location ? (getJsxNamespace(location), (ts.getSourceFileOfNode(location).localJsxFactory || _jsxFactoryEntity)) : _jsxFactoryEntity;
+ function checkClassDeclaration(node) {
+ if (!node.name && !ts.hasSyntacticModifier(node, 512)) {
+ grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
+ }
+ checkClassLikeDeclaration(node);
+ ts.forEach(node.members, checkSourceElement);
+ registerForUnusedIdentifiersCheck(node);
}
- function createResolver() {
- var resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives();
- var fileToDirective;
- if (resolvedTypeReferenceDirectives) {
- fileToDirective = ts.createMap();
- resolvedTypeReferenceDirectives.forEach(function (resolvedDirective, key) {
- if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
- return;
+ function checkClassLikeDeclaration(node) {
+ checkGrammarClassLikeDeclaration(node);
+ checkDecorators(node);
+ if (node.name) {
+ checkTypeNameIsReserved(node.name, ts.Diagnostics.Class_name_cannot_be_0);
+ checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+ checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+ if (!(node.flags & 8388608)) {
+ checkClassNameCollisionWithObject(node.name);
+ }
+ }
+ checkTypeParameters(ts.getEffectiveTypeParameterDeclarations(node));
+ checkExportsOnMergedDeclarations(node);
+ var symbol = getSymbolOfNode(node);
+ var type = getDeclaredTypeOfSymbol(symbol);
+ var typeWithThis = getTypeWithThisArgument(type);
+ var staticType = getTypeOfSymbol(symbol);
+ checkTypeParameterListsIdentical(symbol);
+ checkFunctionOrConstructorSymbol(symbol);
+ checkClassForDuplicateDeclarations(node);
+ if (!(node.flags & 8388608)) {
+ checkClassForStaticPropertyNameConflicts(node);
+ }
+ var baseTypeNode = ts.getEffectiveBaseTypeNode(node);
+ if (baseTypeNode) {
+ ts.forEach(baseTypeNode.typeArguments, checkSourceElement);
+ if (languageVersion < 2) {
+ checkExternalEmitHelpers(baseTypeNode.parent, 1);
+ }
+ var extendsNode = ts.getClassExtendsHeritageElement(node);
+ if (extendsNode && extendsNode !== baseTypeNode) {
+ checkExpression(extendsNode.expression);
+ }
+ var baseTypes = getBaseTypes(type);
+ if (baseTypes.length && produceDiagnostics) {
+ var baseType_1 = baseTypes[0];
+ var baseConstructorType = getBaseConstructorTypeOfClass(type);
+ var staticBaseType = getApparentType(baseConstructorType);
+ checkBaseTypeAccessibility(staticBaseType, baseTypeNode);
+ checkSourceElement(baseTypeNode.expression);
+ if (ts.some(baseTypeNode.typeArguments)) {
+ ts.forEach(baseTypeNode.typeArguments, checkSourceElement);
+ for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); _i < _a.length; _i++) {
+ var constructor = _a[_i];
+ if (!checkTypeArgumentConstraints(baseTypeNode, constructor.typeParameters)) {
+ break;
+ }
+ }
}
- var file = host.getSourceFile(resolvedDirective.resolvedFileName);
- if (file) {
- addReferencedFilesToTypeDirective(file, key);
+ var baseWithThis = getTypeWithThisArgument(baseType_1, type.thisType);
+ if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) {
+ issueMemberSpecificError(node, typeWithThis, baseWithThis, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1);
}
- });
+ else {
+ checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
+ }
+ if (baseConstructorType.flags & 8650752 && !isMixinConstructorType(staticType)) {
+ error(node.name || node, ts.Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any);
+ }
+ if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32) && !(baseConstructorType.flags & 8650752)) {
+ var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode);
+ if (ts.forEach(constructors, function (sig) { return !isJSConstructor(sig.declaration) && !isTypeIdenticalTo(getReturnTypeOfSignature(sig), baseType_1); })) {
+ error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type);
+ }
+ }
+ checkKindsOfPropertyMemberOverrides(type, baseType_1);
+ }
}
- return {
- getReferencedExportContainer: getReferencedExportContainer,
- getReferencedImportDeclaration: getReferencedImportDeclaration,
- getReferencedDeclarationWithCollidingName: getReferencedDeclarationWithCollidingName,
- isDeclarationWithCollidingName: isDeclarationWithCollidingName,
- isValueAliasDeclaration: function (node) {
- node = ts.getParseTreeNode(node);
- return node ? isValueAliasDeclaration(node) : true;
- },
- hasGlobalName: hasGlobalName,
- isReferencedAliasDeclaration: function (node, checkChildren) {
- node = ts.getParseTreeNode(node);
- return node ? isReferencedAliasDeclaration(node, checkChildren) : true;
- },
- getNodeCheckFlags: function (node) {
- node = ts.getParseTreeNode(node);
- return node ? getNodeCheckFlags(node) : 0;
- },
- isTopLevelValueImportEqualsWithEntityName: isTopLevelValueImportEqualsWithEntityName,
- isDeclarationVisible: isDeclarationVisible,
- isImplementationOfOverload: isImplementationOfOverload,
- isRequiredInitializedParameter: isRequiredInitializedParameter,
- isOptionalUninitializedParameterProperty: isOptionalUninitializedParameterProperty,
- isExpandoFunctionDeclaration: isExpandoFunctionDeclaration,
- getPropertiesOfContainerFunction: getPropertiesOfContainerFunction,
- createTypeOfDeclaration: createTypeOfDeclaration,
- createReturnTypeOfSignatureDeclaration: createReturnTypeOfSignatureDeclaration,
- createTypeOfExpression: createTypeOfExpression,
- createLiteralConstValue: createLiteralConstValue,
- isSymbolAccessible: isSymbolAccessible,
- isEntityNameVisible: isEntityNameVisible,
- getConstantValue: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, canHaveConstantValue);
- return node ? getConstantValue(node) : undefined;
- },
- collectLinkedAliases: collectLinkedAliases,
- getReferencedValueDeclaration: getReferencedValueDeclaration,
- getTypeReferenceSerializationKind: getTypeReferenceSerializationKind,
- isOptionalParameter: isOptionalParameter,
- moduleExportsSomeValue: moduleExportsSomeValue,
- isArgumentsLocalBinding: isArgumentsLocalBinding,
- getExternalModuleFileFromDeclaration: getExternalModuleFileFromDeclaration,
- getTypeReferenceDirectivesForEntityName: getTypeReferenceDirectivesForEntityName,
- getTypeReferenceDirectivesForSymbol: getTypeReferenceDirectivesForSymbol,
- isLiteralConstDeclaration: isLiteralConstDeclaration,
- isLateBound: function (nodeIn) {
- var node = ts.getParseTreeNode(nodeIn, ts.isDeclaration);
- var symbol = node && getSymbolOfNode(node);
- return !!(symbol && ts.getCheckFlags(symbol) & 4096);
- },
- getJsxFactoryEntity: getJsxFactoryEntity,
- getAllAccessorDeclarations: function (accessor) {
- accessor = ts.getParseTreeNode(accessor, ts.isGetOrSetAccessorDeclaration);
- var otherKind = accessor.kind === 164 ? 163 : 164;
- var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(accessor), otherKind);
- var firstAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? otherAccessor : accessor;
- var secondAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? accessor : otherAccessor;
- var setAccessor = accessor.kind === 164 ? accessor : otherAccessor;
- var getAccessor = accessor.kind === 163 ? accessor : otherAccessor;
- return {
- firstAccessor: firstAccessor,
- secondAccessor: secondAccessor,
- setAccessor: setAccessor,
- getAccessor: getAccessor
- };
- },
- getSymbolOfExternalModuleSpecifier: function (moduleName) { return resolveExternalModuleNameWorker(moduleName, moduleName, undefined); },
- isBindingCapturedByNode: function (node, decl) {
- var parseNode = ts.getParseTreeNode(node);
- var parseDecl = ts.getParseTreeNode(decl);
- return !!parseNode && !!parseDecl && (ts.isVariableDeclaration(parseDecl) || ts.isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
- },
- getDeclarationStatementsForSourceFile: function (node, flags, tracker, bundled) {
- var n = ts.getParseTreeNode(node);
- ts.Debug.assert(n && n.kind === 290, "Non-sourcefile node passed into getDeclarationsForSourceFile");
- var sym = getSymbolOfNode(node);
- if (!sym) {
- return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker, bundled);
+ var implementedTypeNodes = ts.getEffectiveImplementsTypeNodes(node);
+ if (implementedTypeNodes) {
+ for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
+ var typeRefNode = implementedTypeNodes_1[_b];
+ if (!ts.isEntityNameExpression(typeRefNode.expression)) {
+ error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
}
- return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker, bundled);
- },
- isImportRequiredByAugmentation: isImportRequiredByAugmentation,
- };
- function isImportRequiredByAugmentation(node) {
- var file = ts.getSourceFileOfNode(node);
- if (!file.symbol)
- return false;
- var importTarget = getExternalModuleFileFromDeclaration(node);
- if (!importTarget)
- return false;
- if (importTarget === file)
- return false;
- var exports = getExportsOfModule(file.symbol);
- for (var _i = 0, _a = ts.arrayFrom(exports.values()); _i < _a.length; _i++) {
- var s = _a[_i];
- if (s.mergeId) {
- var merged = getMergedSymbol(s);
- for (var _b = 0, _c = merged.declarations; _b < _c.length; _b++) {
- var d = _c[_b];
- var declFile = ts.getSourceFileOfNode(d);
- if (declFile === importTarget) {
- return true;
+ checkTypeReferenceNode(typeRefNode);
+ if (produceDiagnostics) {
+ var t = getReducedType(getTypeFromTypeNode(typeRefNode));
+ if (t !== errorType) {
+ if (isValidBaseType(t)) {
+ var genericDiag = t.symbol && t.symbol.flags & 32 ?
+ ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass :
+ ts.Diagnostics.Class_0_incorrectly_implements_interface_1;
+ var baseWithThis = getTypeWithThisArgument(t, type.thisType);
+ if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) {
+ issueMemberSpecificError(node, typeWithThis, baseWithThis, genericDiag);
+ }
+ }
+ else {
+ error(typeRefNode, ts.Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members);
}
}
}
}
- return false;
}
- function isInHeritageClause(node) {
- return node.parent && node.parent.kind === 216 && node.parent.parent && node.parent.parent.kind === 279;
+ if (produceDiagnostics) {
+ checkIndexConstraints(type);
+ checkTypeForDuplicateIndexSignatures(node);
+ checkPropertyInitialization(node);
+ }
+ }
+ function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
+ var issuedMemberError = false;
+ var _loop_23 = function (member) {
+ if (ts.hasStaticModifier(member)) {
+ return "continue";
+ }
+ var declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
+ if (declaredProp) {
+ var prop = getPropertyOfType(typeWithThis, declaredProp.escapedName);
+ var baseProp = getPropertyOfType(baseWithThis, declaredProp.escapedName);
+ if (prop && baseProp) {
+ var rootChain = function () { return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2, symbolToString(declaredProp), typeToString(typeWithThis), typeToString(baseWithThis)); };
+ if (!checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(baseProp), member.name || member, undefined, rootChain)) {
+ issuedMemberError = true;
+ }
+ }
+ }
+ };
+ for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+ var member = _a[_i];
+ _loop_23(member);
+ }
+ if (!issuedMemberError) {
+ checkTypeAssignableTo(typeWithThis, baseWithThis, node.name || node, broadDiag);
}
- function getTypeReferenceDirectivesForEntityName(node) {
- if (!fileToDirective) {
- return undefined;
- }
- var meaning = 788968 | 1920;
- if ((node.kind === 75 && isInTypeQuery(node)) || (node.kind === 194 && !isInHeritageClause(node))) {
- meaning = 111551 | 1048576;
+ }
+ function checkBaseTypeAccessibility(type, node) {
+ var signatures = getSignaturesOfType(type, 1);
+ if (signatures.length) {
+ var declaration = signatures[0].declaration;
+ if (declaration && ts.hasEffectiveModifier(declaration, 8)) {
+ var typeClassDeclaration = ts.getClassLikeDeclarationOfSymbol(type.symbol);
+ if (!isNodeWithinClass(node, typeClassDeclaration)) {
+ error(node, ts.Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, getFullyQualifiedName(type.symbol));
+ }
}
- var symbol = resolveEntityName(node, meaning, true);
- return symbol && symbol !== unknownSymbol ? getTypeReferenceDirectivesForSymbol(symbol, meaning) : undefined;
}
- function getTypeReferenceDirectivesForSymbol(symbol, meaning) {
- if (!fileToDirective) {
- return undefined;
+ }
+ function getTargetSymbol(s) {
+ return ts.getCheckFlags(s) & 1 ? s.target : s;
+ }
+ function getClassOrInterfaceDeclarationsOfSymbol(symbol) {
+ return ts.filter(symbol.declarations, function (d) {
+ return d.kind === 252 || d.kind === 253;
+ });
+ }
+ function checkKindsOfPropertyMemberOverrides(type, baseType) {
+ var baseProperties = getPropertiesOfType(baseType);
+ basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
+ var baseProperty = baseProperties_1[_i];
+ var base = getTargetSymbol(baseProperty);
+ if (base.flags & 4194304) {
+ continue;
}
- if (!isSymbolFromTypeDeclarationFile(symbol)) {
- return undefined;
+ var baseSymbol = getPropertyOfObjectType(type, base.escapedName);
+ if (!baseSymbol) {
+ continue;
}
- var typeReferenceDirectives;
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var decl = _a[_i];
- if (decl.symbol && decl.symbol.flags & meaning) {
- var file = ts.getSourceFileOfNode(decl);
- var typeReferenceDirective = fileToDirective.get(file.path);
- if (typeReferenceDirective) {
- (typeReferenceDirectives || (typeReferenceDirectives = [])).push(typeReferenceDirective);
+ var derived = getTargetSymbol(baseSymbol);
+ var baseDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(base);
+ ts.Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration.");
+ if (derived === base) {
+ var derivedClassDecl = ts.getClassLikeDeclarationOfSymbol(type.symbol);
+ if (baseDeclarationFlags & 128 && (!derivedClassDecl || !ts.hasSyntacticModifier(derivedClassDecl, 128))) {
+ for (var _a = 0, _b = getBaseTypes(type); _a < _b.length; _a++) {
+ var otherBaseType = _b[_a];
+ if (otherBaseType === baseType)
+ continue;
+ var baseSymbol_1 = getPropertyOfObjectType(otherBaseType, base.escapedName);
+ var derivedElsewhere = baseSymbol_1 && getTargetSymbol(baseSymbol_1);
+ if (derivedElsewhere && derivedElsewhere !== base) {
+ continue basePropertyCheck;
+ }
+ }
+ if (derivedClassDecl.kind === 221) {
+ error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, symbolToString(baseProperty), typeToString(baseType));
}
else {
- return undefined;
+ error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, typeToString(type), symbolToString(baseProperty), typeToString(baseType));
}
}
}
- return typeReferenceDirectives;
- }
- function isSymbolFromTypeDeclarationFile(symbol) {
- if (!symbol.declarations) {
- return false;
- }
- var current = symbol;
- while (true) {
- var parent = getParentOfSymbol(current);
- if (parent) {
- current = parent;
+ else {
+ var derivedDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(derived);
+ if (baseDeclarationFlags & 8 || derivedDeclarationFlags & 8) {
+ continue;
}
- else {
- break;
+ var errorMessage = void 0;
+ var basePropertyFlags = base.flags & 98308;
+ var derivedPropertyFlags = derived.flags & 98308;
+ if (basePropertyFlags && derivedPropertyFlags) {
+ if (baseDeclarationFlags & 128 && !(base.valueDeclaration && ts.isPropertyDeclaration(base.valueDeclaration) && base.valueDeclaration.initializer)
+ || base.valueDeclaration && base.valueDeclaration.parent.kind === 253
+ || derived.valueDeclaration && ts.isBinaryExpression(derived.valueDeclaration)) {
+ continue;
+ }
+ var overriddenInstanceProperty = basePropertyFlags !== 4 && derivedPropertyFlags === 4;
+ var overriddenInstanceAccessor = basePropertyFlags === 4 && derivedPropertyFlags !== 4;
+ if (overriddenInstanceProperty || overriddenInstanceAccessor) {
+ var errorMessage_1 = overriddenInstanceProperty ?
+ ts.Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property :
+ ts.Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor;
+ error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_1, symbolToString(base), typeToString(baseType), typeToString(type));
+ }
+ else if (compilerOptions.useDefineForClassFields) {
+ var uninitialized = ts.find(derived.declarations, function (d) { return d.kind === 163 && !d.initializer; });
+ if (uninitialized
+ && !(derived.flags & 33554432)
+ && !(baseDeclarationFlags & 128)
+ && !(derivedDeclarationFlags & 128)
+ && !derived.declarations.some(function (d) { return !!(d.flags & 8388608); })) {
+ var constructor = findConstructorDeclaration(ts.getClassLikeDeclarationOfSymbol(type.symbol));
+ var propName = uninitialized.name;
+ if (uninitialized.exclamationToken
+ || !constructor
+ || !ts.isIdentifier(propName)
+ || !strictNullChecks
+ || !isPropertyInitializedInConstructor(propName, type, constructor)) {
+ var errorMessage_2 = ts.Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration;
+ error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_2, symbolToString(base), typeToString(baseType));
+ }
+ }
+ }
+ continue;
}
- }
- if (current.valueDeclaration && current.valueDeclaration.kind === 290 && current.flags & 512) {
- return false;
- }
- for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
- var decl = _a[_i];
- var file = ts.getSourceFileOfNode(decl);
- if (fileToDirective.has(file.path)) {
- return true;
+ else if (isPrototypeProperty(base)) {
+ if (isPrototypeProperty(derived) || derived.flags & 4) {
+ continue;
+ }
+ else {
+ ts.Debug.assert(!!(derived.flags & 98304));
+ errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
+ }
+ }
+ else if (base.flags & 98304) {
+ errorMessage = ts.Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
+ }
+ else {
+ errorMessage = ts.Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
}
+ error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type));
}
- return false;
}
- function addReferencedFilesToTypeDirective(file, key) {
- if (fileToDirective.has(file.path))
- return;
- fileToDirective.set(file.path, key);
- for (var _i = 0, _a = file.referencedFiles; _i < _a.length; _i++) {
- var fileName = _a[_i].fileName;
- var resolvedFile = ts.resolveTripleslashReference(fileName, file.originalFileName);
- var referencedFile = host.getSourceFile(resolvedFile);
- if (referencedFile) {
- addReferencedFilesToTypeDirective(referencedFile, key);
+ }
+ function getNonInterhitedProperties(type, baseTypes, properties) {
+ if (!ts.length(baseTypes)) {
+ return properties;
+ }
+ var seen = new ts.Map();
+ ts.forEach(properties, function (p) { seen.set(p.escapedName, p); });
+ for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {
+ var base = baseTypes_2[_i];
+ var properties_5 = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
+ for (var _a = 0, properties_4 = properties_5; _a < properties_4.length; _a++) {
+ var prop = properties_4[_a];
+ var existing = seen.get(prop.escapedName);
+ if (existing && !isPropertyIdenticalTo(existing, prop)) {
+ seen.delete(prop.escapedName);
}
}
}
+ return ts.arrayFrom(seen.values());
}
- function getExternalModuleFileFromDeclaration(declaration) {
- var specifier = declaration.kind === 249 ? ts.tryCast(declaration.name, ts.isStringLiteral) : ts.getExternalModuleName(declaration);
- var moduleSymbol = resolveExternalModuleNameWorker(specifier, specifier, undefined);
- if (!moduleSymbol) {
- return undefined;
+ function checkInheritedPropertiesAreIdentical(type, typeNode) {
+ var baseTypes = getBaseTypes(type);
+ if (baseTypes.length < 2) {
+ return true;
+ }
+ var seen = new ts.Map();
+ ts.forEach(resolveDeclaredMembers(type).declaredProperties, function (p) { seen.set(p.escapedName, { prop: p, containingType: type }); });
+ var ok = true;
+ for (var _i = 0, baseTypes_3 = baseTypes; _i < baseTypes_3.length; _i++) {
+ var base = baseTypes_3[_i];
+ var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
+ for (var _a = 0, properties_6 = properties; _a < properties_6.length; _a++) {
+ var prop = properties_6[_a];
+ var existing = seen.get(prop.escapedName);
+ if (!existing) {
+ seen.set(prop.escapedName, { prop: prop, containingType: base });
+ }
+ else {
+ var isInheritedProperty = existing.containingType !== type;
+ if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) {
+ ok = false;
+ var typeName1 = typeToString(existing.containingType);
+ var typeName2 = typeToString(base);
+ var errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical, symbolToString(prop), typeName1, typeName2);
+ errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2);
+ diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(typeNode, errorInfo));
+ }
+ }
+ }
}
- return ts.getDeclarationOfKind(moduleSymbol, 290);
+ return ok;
}
- function initializeTypeChecker() {
- for (var _i = 0, _a = host.getSourceFiles(); _i < _a.length; _i++) {
- var file = _a[_i];
- ts.bindSourceFile(file, compilerOptions);
+ function checkPropertyInitialization(node) {
+ if (!strictNullChecks || !strictPropertyInitialization || node.flags & 8388608) {
+ return;
}
- amalgamatedDuplicates = ts.createMap();
- var augmentations;
- for (var _b = 0, _c = host.getSourceFiles(); _b < _c.length; _b++) {
- var file = _c[_b];
- if (file.redirectInfo) {
+ var constructor = findConstructorDeclaration(node);
+ for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+ var member = _a[_i];
+ if (ts.getEffectiveModifierFlags(member) & 2) {
continue;
}
- if (!ts.isExternalOrCommonJsModule(file)) {
- var fileGlobalThisSymbol = file.locals.get("globalThis");
- if (fileGlobalThisSymbol) {
- for (var _d = 0, _e = fileGlobalThisSymbol.declarations; _d < _e.length; _d++) {
- var declaration = _e[_d];
- diagnostics.add(ts.createDiagnosticForNode(declaration, ts.Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0, "globalThis"));
+ if (isInstancePropertyWithoutInitializer(member)) {
+ var propName = member.name;
+ if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName)) {
+ var type = getTypeOfSymbol(getSymbolOfNode(member));
+ if (!(type.flags & 3 || getFalsyFlags(type) & 32768)) {
+ if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) {
+ error(member.name, ts.Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor, ts.declarationNameToString(propName));
+ }
}
}
- mergeSymbolTable(globals, file.locals);
}
- if (file.jsGlobalAugmentations) {
- mergeSymbolTable(globals, file.jsGlobalAugmentations);
+ }
+ }
+ function isInstancePropertyWithoutInitializer(node) {
+ return node.kind === 163 &&
+ !ts.hasSyntacticModifier(node, 32 | 128) &&
+ !node.exclamationToken &&
+ !node.initializer;
+ }
+ function isPropertyInitializedInConstructor(propName, propType, constructor) {
+ var reference = ts.factory.createPropertyAccessExpression(ts.factory.createThis(), propName);
+ ts.setParent(reference.expression, reference);
+ ts.setParent(reference, constructor);
+ reference.flowNode = constructor.returnFlowNode;
+ var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
+ return !(getFalsyFlags(flowType) & 32768);
+ }
+ function checkInterfaceDeclaration(node) {
+ if (!checkGrammarDecoratorsAndModifiers(node))
+ checkGrammarInterfaceDeclaration(node);
+ checkTypeParameters(node.typeParameters);
+ if (produceDiagnostics) {
+ checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0);
+ checkExportsOnMergedDeclarations(node);
+ var symbol = getSymbolOfNode(node);
+ checkTypeParameterListsIdentical(symbol);
+ var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 253);
+ if (node === firstInterfaceDecl) {
+ var type = getDeclaredTypeOfSymbol(symbol);
+ var typeWithThis = getTypeWithThisArgument(type);
+ if (checkInheritedPropertiesAreIdentical(type, node.name)) {
+ for (var _i = 0, _a = getBaseTypes(type); _i < _a.length; _i++) {
+ var baseType = _a[_i];
+ checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name, ts.Diagnostics.Interface_0_incorrectly_extends_interface_1);
+ }
+ checkIndexConstraints(type);
+ }
}
- if (file.patternAmbientModules && file.patternAmbientModules.length) {
- patternAmbientModules = ts.concatenate(patternAmbientModules, file.patternAmbientModules);
+ checkObjectTypeForDuplicateDeclarations(node);
+ }
+ ts.forEach(ts.getInterfaceBaseTypeNodes(node), function (heritageElement) {
+ if (!ts.isEntityNameExpression(heritageElement.expression)) {
+ error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
}
- if (file.moduleAugmentations.length) {
- (augmentations || (augmentations = [])).push(file.moduleAugmentations);
+ checkTypeReferenceNode(heritageElement);
+ });
+ ts.forEach(node.members, checkSourceElement);
+ if (produceDiagnostics) {
+ checkTypeForDuplicateIndexSignatures(node);
+ registerForUnusedIdentifiersCheck(node);
+ }
+ }
+ function checkTypeAliasDeclaration(node) {
+ checkGrammarDecoratorsAndModifiers(node);
+ checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0);
+ checkExportsOnMergedDeclarations(node);
+ checkTypeParameters(node.typeParameters);
+ if (node.type.kind === 136) {
+ if (!intrinsicTypeKinds.has(node.name.escapedText) || ts.length(node.typeParameters) !== 1) {
+ error(node.type, ts.Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types);
}
- if (file.symbol && file.symbol.globalExports) {
- var source = file.symbol.globalExports;
- source.forEach(function (sourceSymbol, id) {
- if (!globals.has(id)) {
- globals.set(id, sourceSymbol);
- }
- });
+ }
+ else {
+ checkSourceElement(node.type);
+ registerForUnusedIdentifiersCheck(node);
+ }
+ }
+ function computeEnumMemberValues(node) {
+ var nodeLinks = getNodeLinks(node);
+ if (!(nodeLinks.flags & 16384)) {
+ nodeLinks.flags |= 16384;
+ var autoValue = 0;
+ for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+ var member = _a[_i];
+ var value = computeMemberValue(member, autoValue);
+ getNodeLinks(member).enumMemberValue = value;
+ autoValue = typeof value === "number" ? value + 1 : undefined;
}
}
- if (augmentations) {
- for (var _f = 0, augmentations_1 = augmentations; _f < augmentations_1.length; _f++) {
- var list = augmentations_1[_f];
- for (var _g = 0, list_1 = list; _g < list_1.length; _g++) {
- var augmentation = list_1[_g];
- if (!ts.isGlobalScopeAugmentation(augmentation.parent))
- continue;
- mergeModuleAugmentation(augmentation);
- }
+ }
+ function computeMemberValue(member, autoValue) {
+ if (ts.isComputedNonLiteralName(member.name)) {
+ error(member.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums);
+ }
+ else {
+ var text = ts.getTextOfPropertyName(member.name);
+ if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
+ error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name);
}
}
- addToSymbolTable(globals, builtinGlobals, ts.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, 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(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ if (member.initializer) {
+ return computeConstantValue(member);
}
- globalReadonlyArrayType = getGlobalTypeOrUndefined("ReadonlyArray", 1) || globalArrayType;
- anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;
- globalThisType = getGlobalTypeOrUndefined("ThisType", 1);
- if (augmentations) {
- for (var _h = 0, augmentations_2 = augmentations; _h < augmentations_2.length; _h++) {
- var list = augmentations_2[_h];
- for (var _j = 0, list_2 = list; _j < list_2.length; _j++) {
- var augmentation = list_2[_j];
- if (ts.isGlobalScopeAugmentation(augmentation.parent))
- continue;
- mergeModuleAugmentation(augmentation);
- }
+ if (member.parent.flags & 8388608 && !ts.isEnumConst(member.parent) && getEnumKind(getSymbolOfNode(member.parent)) === 0) {
+ return undefined;
+ }
+ if (autoValue !== undefined) {
+ return autoValue;
+ }
+ error(member.name, ts.Diagnostics.Enum_member_must_have_initializer);
+ return undefined;
+ }
+ function computeConstantValue(member) {
+ var enumKind = getEnumKind(getSymbolOfNode(member.parent));
+ var isConstEnum = ts.isEnumConst(member.parent);
+ var initializer = member.initializer;
+ var value = enumKind === 1 && !isLiteralEnumMember(member) ? undefined : evaluate(initializer);
+ if (value !== undefined) {
+ if (isConstEnum && typeof value === "number" && !isFinite(value)) {
+ error(initializer, isNaN(value) ?
+ ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN :
+ ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value);
}
}
- amalgamatedDuplicates.forEach(function (_a) {
- var firstFile = _a.firstFile, secondFile = _a.secondFile, conflictingSymbols = _a.conflictingSymbols;
- if (conflictingSymbols.size < 8) {
- conflictingSymbols.forEach(function (_a, symbolName) {
- var isBlockScoped = _a.isBlockScoped, firstFileLocations = _a.firstFileLocations, secondFileLocations = _a.secondFileLocations;
- var message = isBlockScoped ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 : ts.Diagnostics.Duplicate_identifier_0;
- for (var _i = 0, firstFileLocations_1 = firstFileLocations; _i < firstFileLocations_1.length; _i++) {
- var node = firstFileLocations_1[_i];
- addDuplicateDeclarationError(node, message, symbolName, secondFileLocations);
+ else if (enumKind === 1) {
+ error(initializer, ts.Diagnostics.Computed_values_are_not_permitted_in_an_enum_with_string_valued_members);
+ return 0;
+ }
+ else if (isConstEnum) {
+ error(initializer, ts.Diagnostics.const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values);
+ }
+ else if (member.parent.flags & 8388608) {
+ error(initializer, ts.Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);
+ }
+ else {
+ var source = checkExpression(initializer);
+ if (!isTypeAssignableToKind(source, 296)) {
+ error(initializer, ts.Diagnostics.Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhaustiveness_checks_consider_using_an_object_literal_instead, typeToString(source));
+ }
+ else {
+ checkTypeAssignableTo(source, getDeclaredTypeOfSymbol(getSymbolOfNode(member.parent)), initializer, undefined);
+ }
+ }
+ return value;
+ function evaluate(expr) {
+ switch (expr.kind) {
+ case 214:
+ var value_2 = evaluate(expr.operand);
+ if (typeof value_2 === "number") {
+ switch (expr.operator) {
+ case 39: return value_2;
+ case 40: return -value_2;
+ case 54: return ~value_2;
+ }
}
- for (var _b = 0, secondFileLocations_1 = secondFileLocations; _b < secondFileLocations_1.length; _b++) {
- var node = secondFileLocations_1[_b];
- addDuplicateDeclarationError(node, message, symbolName, firstFileLocations);
+ break;
+ case 216:
+ var left = evaluate(expr.left);
+ var right = evaluate(expr.right);
+ if (typeof left === "number" && typeof right === "number") {
+ switch (expr.operatorToken.kind) {
+ case 51: return left | right;
+ case 50: return left & right;
+ case 48: return left >> right;
+ case 49: return left >>> right;
+ case 47: return left << right;
+ case 52: return left ^ right;
+ case 41: return left * right;
+ case 43: return left / right;
+ case 39: return left + right;
+ case 40: return left - right;
+ case 44: return left % right;
+ case 42: return Math.pow(left, right);
+ }
+ }
+ else if (typeof left === "string" && typeof right === "string" && expr.operatorToken.kind === 39) {
+ return left + right;
+ }
+ break;
+ case 10:
+ case 14:
+ return expr.text;
+ case 8:
+ checkGrammarNumericLiteral(expr);
+ return +expr.text;
+ case 207:
+ return evaluate(expr.expression);
+ case 78:
+ var identifier = expr;
+ if (isInfinityOrNaNString(identifier.escapedText)) {
+ return +(identifier.escapedText);
+ }
+ return ts.nodeIsMissing(expr) ? 0 : evaluateEnumMember(expr, getSymbolOfNode(member.parent), identifier.escapedText);
+ case 202:
+ case 201:
+ var ex = expr;
+ if (isConstantMemberAccess(ex)) {
+ var type = getTypeOfExpression(ex.expression);
+ if (type.symbol && type.symbol.flags & 384) {
+ var name = void 0;
+ if (ex.kind === 201) {
+ name = ex.name.escapedText;
+ }
+ else {
+ name = ts.escapeLeadingUnderscores(ts.cast(ex.argumentExpression, ts.isLiteralExpression).text);
+ }
+ return evaluateEnumMember(expr, type.symbol, name);
+ }
+ }
+ break;
+ }
+ return undefined;
+ }
+ function evaluateEnumMember(expr, enumSymbol, name) {
+ var memberSymbol = enumSymbol.exports.get(name);
+ if (memberSymbol) {
+ var declaration = memberSymbol.valueDeclaration;
+ if (declaration !== member) {
+ if (isBlockScopedNameDeclaredBeforeUse(declaration, member)) {
+ return getEnumMemberValue(declaration);
+ }
+ error(expr, ts.Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
+ return 0;
+ }
+ else {
+ error(expr, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(memberSymbol));
+ }
+ }
+ return undefined;
+ }
+ }
+ function isConstantMemberAccess(node) {
+ return node.kind === 78 ||
+ node.kind === 201 && isConstantMemberAccess(node.expression) ||
+ node.kind === 202 && isConstantMemberAccess(node.expression) &&
+ ts.isStringLiteralLike(node.argumentExpression);
+ }
+ function checkEnumDeclaration(node) {
+ if (!produceDiagnostics) {
+ return;
+ }
+ checkGrammarDecoratorsAndModifiers(node);
+ checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0);
+ checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+ checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+ checkExportsOnMergedDeclarations(node);
+ node.members.forEach(checkEnumMember);
+ computeEnumMemberValues(node);
+ var enumSymbol = getSymbolOfNode(node);
+ var firstDeclaration = ts.getDeclarationOfKind(enumSymbol, node.kind);
+ if (node === firstDeclaration) {
+ if (enumSymbol.declarations.length > 1) {
+ var enumIsConst_1 = ts.isEnumConst(node);
+ ts.forEach(enumSymbol.declarations, function (decl) {
+ if (ts.isEnumDeclaration(decl) && ts.isEnumConst(decl) !== enumIsConst_1) {
+ error(ts.getNameOfDeclaration(decl), ts.Diagnostics.Enum_declarations_must_all_be_const_or_non_const);
}
});
}
- else {
- var list = ts.arrayFrom(conflictingSymbols.keys()).join(", ");
- diagnostics.add(ts.addRelatedInfo(ts.createDiagnosticForNode(firstFile, ts.Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list), ts.createDiagnosticForNode(secondFile, ts.Diagnostics.Conflicts_are_in_this_file)));
- diagnostics.add(ts.addRelatedInfo(ts.createDiagnosticForNode(secondFile, ts.Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list), ts.createDiagnosticForNode(firstFile, ts.Diagnostics.Conflicts_are_in_this_file)));
- }
- });
- amalgamatedDuplicates = undefined;
- }
- function checkExternalEmitHelpers(location, helpers) {
- if ((requestedExternalEmitHelpers & helpers) !== helpers && compilerOptions.importHelpers) {
- var sourceFile = ts.getSourceFileOfNode(location);
- if (ts.isEffectiveExternalModule(sourceFile, compilerOptions) && !(location.flags & 8388608)) {
- var helpersModule = resolveHelpersModule(sourceFile, location);
- if (helpersModule !== unknownSymbol) {
- var uncheckedHelpers = helpers & ~requestedExternalEmitHelpers;
- for (var helper = 1; helper <= 1048576; helper <<= 1) {
- if (uncheckedHelpers & helper) {
- var name = getHelperName(helper);
- var symbol = getSymbol(helpersModule.exports, ts.escapeLeadingUnderscores(name), 111551);
- if (!symbol) {
- error(location, ts.Diagnostics.This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0, ts.externalHelpersModuleNameText, name);
- }
- }
+ var seenEnumMissingInitialInitializer_1 = false;
+ ts.forEach(enumSymbol.declarations, function (declaration) {
+ if (declaration.kind !== 255) {
+ return false;
+ }
+ var enumDeclaration = declaration;
+ if (!enumDeclaration.members.length) {
+ return false;
+ }
+ var firstEnumMember = enumDeclaration.members[0];
+ if (!firstEnumMember.initializer) {
+ if (seenEnumMissingInitialInitializer_1) {
+ error(firstEnumMember.name, ts.Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element);
+ }
+ else {
+ seenEnumMissingInitialInitializer_1 = true;
}
}
- requestedExternalEmitHelpers |= helpers;
- }
+ });
}
}
- function getHelperName(helper) {
- switch (helper) {
- case 1: return "__extends";
- case 2: return "__assign";
- case 4: return "__rest";
- case 8: return "__decorate";
- case 16: return "__metadata";
- case 32: return "__param";
- case 64: return "__awaiter";
- case 128: return "__generator";
- case 256: return "__values";
- case 512: return "__read";
- case 1024: return "__spread";
- case 2048: return "__spreadArrays";
- case 4096: return "__await";
- case 8192: return "__asyncGenerator";
- case 16384: return "__asyncDelegator";
- case 32768: return "__asyncValues";
- case 65536: return "__exportStar";
- case 131072: return "__makeTemplateObject";
- case 262144: return "__classPrivateFieldGet";
- case 524288: return "__classPrivateFieldSet";
- case 1048576: return "__createBinding";
- default: return ts.Debug.fail("Unrecognized helper");
+ function checkEnumMember(node) {
+ if (ts.isPrivateIdentifier(node.name)) {
+ error(node, ts.Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier);
}
}
- function resolveHelpersModule(node, errorNode) {
- if (!externalHelpersModule) {
- externalHelpersModule = resolveExternalModule(node, ts.externalHelpersModuleNameText, ts.Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found, errorNode) || unknownSymbol;
+ function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
+ var declarations = symbol.declarations;
+ for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
+ var declaration = declarations_8[_i];
+ if ((declaration.kind === 252 ||
+ (declaration.kind === 251 && ts.nodeIsPresent(declaration.body))) &&
+ !(declaration.flags & 8388608)) {
+ return declaration;
+ }
}
- return externalHelpersModule;
- }
- function checkGrammarDecoratorsAndModifiers(node) {
- return checkGrammarDecorators(node) || checkGrammarModifiers(node);
+ return undefined;
}
- function checkGrammarDecorators(node) {
- if (!node.decorators) {
- return false;
+ function inSameLexicalScope(node1, node2) {
+ var container1 = ts.getEnclosingBlockScopeContainer(node1);
+ var container2 = ts.getEnclosingBlockScopeContainer(node2);
+ if (isGlobalSourceFile(container1)) {
+ return isGlobalSourceFile(container2);
}
- if (!ts.nodeCanBeDecorated(node, node.parent, node.parent.parent)) {
- if (node.kind === 161 && !ts.nodeIsPresent(node.body)) {
- return grammarErrorOnFirstToken(node, ts.Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload);
- }
- else {
- return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_not_valid_here);
- }
+ else if (isGlobalSourceFile(container2)) {
+ return false;
}
- else if (node.kind === 163 || node.kind === 164) {
- var accessors = ts.getAllAccessorDeclarations(node.parent.members, node);
- if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) {
- return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
- }
+ else {
+ return container1 === container2;
}
- return false;
}
- function checkGrammarModifiers(node) {
- var quickResult = reportObviousModifierErrors(node);
- if (quickResult !== undefined) {
- return quickResult;
- }
- var lastStatic, lastDeclare, lastAsync, lastReadonly;
- var flags = 0;
- for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
- var modifier = _a[_i];
- if (modifier.kind !== 138) {
- if (node.kind === 158 || node.kind === 160) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_type_member, ts.tokenToString(modifier.kind));
- }
- if (node.kind === 167) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_an_index_signature, ts.tokenToString(modifier.kind));
+ function checkModuleDeclaration(node) {
+ if (produceDiagnostics) {
+ var isGlobalAugmentation = ts.isGlobalScopeAugmentation(node);
+ var inAmbientContext = node.flags & 8388608;
+ if (isGlobalAugmentation && !inAmbientContext) {
+ error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context);
+ }
+ var isAmbientExternalModule = ts.isAmbientModule(node);
+ var contextErrorMessage = isAmbientExternalModule
+ ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file
+ : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module;
+ if (checkGrammarModuleElementContext(node, contextErrorMessage)) {
+ return;
+ }
+ if (!checkGrammarDecoratorsAndModifiers(node)) {
+ if (!inAmbientContext && node.name.kind === 10) {
+ grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names);
}
}
- switch (modifier.kind) {
- case 81:
- if (node.kind !== 248) {
- return grammarErrorOnNode(node, ts.Diagnostics.A_class_member_cannot_have_the_0_keyword, ts.tokenToString(81));
- }
- break;
- case 119:
- case 118:
- case 117:
- var text = visibilityToString(ts.modifierToFlag(modifier.kind));
- if (flags & 28) {
- return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen);
- }
- else if (flags & 32) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
- }
- else if (flags & 64) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly");
- }
- else if (flags & 256) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
+ if (ts.isIdentifier(node.name)) {
+ checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+ checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+ }
+ checkExportsOnMergedDeclarations(node);
+ var symbol = getSymbolOfNode(node);
+ if (symbol.flags & 512
+ && !inAmbientContext
+ && symbol.declarations.length > 1
+ && isInstantiatedModule(node, !!compilerOptions.preserveConstEnums || !!compilerOptions.isolatedModules)) {
+ var firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
+ if (firstNonAmbientClassOrFunc) {
+ if (ts.getSourceFileOfNode(node) !== ts.getSourceFileOfNode(firstNonAmbientClassOrFunc)) {
+ error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged);
}
- else if (node.parent.kind === 250 || node.parent.kind === 290) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, text);
+ else if (node.pos < firstNonAmbientClassOrFunc.pos) {
+ error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged);
}
- else if (flags & 128) {
- if (modifier.kind === 117) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
- }
- else {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract");
+ }
+ var mergedClass = ts.getDeclarationOfKind(symbol, 252);
+ if (mergedClass &&
+ inSameLexicalScope(node, mergedClass)) {
+ getNodeLinks(node).flags |= 32768;
+ }
+ }
+ if (isAmbientExternalModule) {
+ if (ts.isExternalModuleAugmentation(node)) {
+ var checkBody = isGlobalAugmentation || (getSymbolOfNode(node).flags & 33554432);
+ if (checkBody && node.body) {
+ for (var _i = 0, _a = node.body.statements; _i < _a.length; _i++) {
+ var statement = _a[_i];
+ checkModuleAugmentationElement(statement, isGlobalAugmentation);
}
}
- else if (ts.isPrivateIdentifierPropertyDeclaration(node)) {
- return grammarErrorOnNode(modifier, ts.Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier);
- }
- flags |= ts.modifierToFlag(modifier.kind);
- break;
- case 120:
- if (flags & 32) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static");
- }
- else if (flags & 64) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "readonly");
- }
- else if (flags & 256) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
- }
- else if (node.parent.kind === 250 || node.parent.kind === 290) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static");
- }
- else if (node.kind === 156) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
- }
- else if (flags & 128) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
- }
- else if (ts.isPrivateIdentifierPropertyDeclaration(node)) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "static");
- }
- flags |= 32;
- lastStatic = modifier;
- break;
- case 138:
- if (flags & 64) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "readonly");
- }
- else if (node.kind !== 159 && node.kind !== 158 && node.kind !== 167 && node.kind !== 156) {
- return grammarErrorOnNode(modifier, ts.Diagnostics.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature);
- }
- flags |= 64;
- lastReadonly = modifier;
- break;
- case 89:
- if (flags & 1) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export");
- }
- else if (flags & 2) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
- }
- else if (flags & 128) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
- }
- else if (flags & 256) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
- }
- else if (ts.isClassLike(node.parent)) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export");
- }
- else if (node.kind === 156) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
- }
- flags |= 1;
- break;
- case 84:
- var container = node.parent.kind === 290 ? node.parent : node.parent.parent;
- if (container.kind === 249 && !ts.isAmbientModule(container)) {
- return grammarErrorOnNode(modifier, ts.Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module);
- }
- flags |= 512;
- break;
- case 130:
- if (flags & 2) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare");
- }
- else if (flags & 256) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
- }
- else if (ts.isClassLike(node.parent) && !ts.isPropertyDeclaration(node)) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare");
- }
- else if (node.kind === 156) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare");
- }
- else if ((node.parent.flags & 8388608) && node.parent.kind === 250) {
- return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
+ }
+ else if (isGlobalSourceFile(node.parent)) {
+ if (isGlobalAugmentation) {
+ error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
}
- else if (ts.isPrivateIdentifierPropertyDeclaration(node)) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "declare");
+ else if (ts.isExternalModuleNameRelative(ts.getTextOfIdentifierOrLiteral(node.name))) {
+ error(node.name, ts.Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name);
}
- flags |= 2;
- lastDeclare = modifier;
- break;
- case 122:
- if (flags & 128) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract");
+ }
+ else {
+ if (isGlobalAugmentation) {
+ error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
}
- if (node.kind !== 245) {
- if (node.kind !== 161 &&
- node.kind !== 159 &&
- node.kind !== 163 &&
- node.kind !== 164) {
- return grammarErrorOnNode(modifier, ts.Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration);
- }
- if (!(node.parent.kind === 245 && ts.hasModifier(node.parent, 128))) {
- return grammarErrorOnNode(modifier, ts.Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
- }
- if (flags & 32) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
- }
- if (flags & 8) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
- }
+ else {
+ error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces);
}
- if (ts.isNamedDeclaration(node) && node.name.kind === 76) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "abstract");
+ }
+ }
+ }
+ if (node.body) {
+ checkSourceElement(node.body);
+ if (!ts.isGlobalScopeAugmentation(node)) {
+ registerForUnusedIdentifiersCheck(node);
+ }
+ }
+ }
+ function checkModuleAugmentationElement(node, isGlobalAugmentation) {
+ switch (node.kind) {
+ case 232:
+ for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ checkModuleAugmentationElement(decl, isGlobalAugmentation);
+ }
+ break;
+ case 266:
+ case 267:
+ grammarErrorOnFirstToken(node, ts.Diagnostics.Exports_and_export_assignments_are_not_permitted_in_module_augmentations);
+ break;
+ case 260:
+ case 261:
+ grammarErrorOnFirstToken(node, ts.Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module);
+ break;
+ case 198:
+ case 249:
+ var name = node.name;
+ if (ts.isBindingPattern(name)) {
+ for (var _b = 0, _c = name.elements; _b < _c.length; _b++) {
+ var el = _c[_b];
+ checkModuleAugmentationElement(el, isGlobalAugmentation);
}
- flags |= 128;
break;
- case 126:
- if (flags & 256) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async");
- }
- else if (flags & 2 || node.parent.flags & 8388608) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
+ }
+ case 252:
+ case 255:
+ case 251:
+ case 253:
+ case 256:
+ case 254:
+ if (isGlobalAugmentation) {
+ return;
+ }
+ var symbol = getSymbolOfNode(node);
+ if (symbol) {
+ var reportError = !(symbol.flags & 33554432);
+ if (!reportError) {
+ reportError = !!symbol.parent && ts.isExternalModuleAugmentation(symbol.parent.declarations[0]);
}
- else if (node.kind === 156) {
- return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
+ }
+ break;
+ }
+ }
+ function getFirstNonModuleExportsIdentifier(node) {
+ switch (node.kind) {
+ case 78:
+ return node;
+ case 157:
+ do {
+ node = node.left;
+ } while (node.kind !== 78);
+ return node;
+ case 201:
+ do {
+ if (ts.isModuleExportsAccessExpression(node.expression) && !ts.isPrivateIdentifier(node.name)) {
+ return node.name;
}
- flags |= 256;
- lastAsync = modifier;
- break;
- }
+ node = node.expression;
+ } while (node.kind !== 78);
+ return node;
}
- if (node.kind === 162) {
- if (flags & 32) {
- return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
+ }
+ function checkExternalImportOrExportDeclaration(node) {
+ var moduleName = ts.getExternalModuleName(node);
+ if (!moduleName || ts.nodeIsMissing(moduleName)) {
+ return false;
+ }
+ if (!ts.isStringLiteral(moduleName)) {
+ error(moduleName, ts.Diagnostics.String_literal_expected);
+ return false;
+ }
+ var inAmbientExternalModule = node.parent.kind === 257 && ts.isAmbientModule(node.parent.parent);
+ if (node.parent.kind !== 297 && !inAmbientExternalModule) {
+ error(moduleName, node.kind === 267 ?
+ ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace :
+ ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module);
+ return false;
+ }
+ if (inAmbientExternalModule && ts.isExternalModuleNameRelative(moduleName.text)) {
+ if (!isTopLevelInExternalModuleAugmentation(node)) {
+ error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name);
+ return false;
}
- if (flags & 128) {
- return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "abstract");
+ }
+ return true;
+ }
+ function checkAliasSymbol(node) {
+ var symbol = getSymbolOfNode(node);
+ var target = resolveAlias(symbol);
+ if (target !== unknownSymbol) {
+ symbol = getMergedSymbol(symbol.exportSymbol || symbol);
+ var excludedMeanings = (symbol.flags & (111551 | 1048576) ? 111551 : 0) |
+ (symbol.flags & 788968 ? 788968 : 0) |
+ (symbol.flags & 1920 ? 1920 : 0);
+ if (target.flags & excludedMeanings) {
+ var message = node.kind === 270 ?
+ ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 :
+ ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
+ error(node, message, symbolToString(symbol));
}
- else if (flags & 256) {
- return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
+ if (compilerOptions.isolatedModules
+ && node.kind === 270
+ && !node.parent.parent.isTypeOnly
+ && !(target.flags & 111551)
+ && !(node.flags & 8388608)) {
+ error(node, ts.Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type);
}
- else if (flags & 64) {
- return grammarErrorOnNode(lastReadonly, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "readonly");
+ if (ts.isImportSpecifier(node) && ts.every(target.declarations, function (d) { return !!(ts.getCombinedNodeFlags(d) & 134217728); })) {
+ errorOrSuggestion(false, node.name, ts.Diagnostics._0_is_deprecated, symbol.escapedName);
}
- return false;
}
- else if ((node.kind === 254 || node.kind === 253) && flags & 2) {
- return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
+ }
+ function checkImportBinding(node) {
+ checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+ checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
+ checkAliasSymbol(node);
+ if (node.kind === 265 &&
+ ts.idText(node.propertyName || node.name) === "default" &&
+ compilerOptions.esModuleInterop &&
+ moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015) {
+ checkExternalEmitHelpers(node, 262144);
}
- else if (node.kind === 156 && (flags & 92) && ts.isBindingPattern(node.name)) {
- return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern);
+ }
+ function checkImportDeclaration(node) {
+ if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+ return;
}
- else if (node.kind === 156 && (flags & 92) && node.dotDotDotToken) {
- return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter);
+ if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasEffectiveModifiers(node)) {
+ grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers);
}
- if (flags & 256) {
- return checkGrammarAsyncModifier(node, lastAsync);
+ if (checkExternalImportOrExportDeclaration(node)) {
+ var importClause = node.importClause;
+ if (importClause && !checkGrammarImportClause(importClause)) {
+ if (importClause.name) {
+ checkImportBinding(importClause);
+ }
+ if (importClause.namedBindings) {
+ if (importClause.namedBindings.kind === 263) {
+ checkImportBinding(importClause.namedBindings);
+ if (moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015 && compilerOptions.esModuleInterop) {
+ checkExternalEmitHelpers(node, 131072);
+ }
+ }
+ else {
+ var moduleExisted = resolveExternalModuleName(node, node.moduleSpecifier);
+ if (moduleExisted) {
+ ts.forEach(importClause.namedBindings.elements, checkImportBinding);
+ }
+ }
+ }
+ }
}
- return false;
- }
- function reportObviousModifierErrors(node) {
- return !node.modifiers
- ? false
- : shouldReportBadModifier(node)
- ? grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here)
- : undefined;
}
- function shouldReportBadModifier(node) {
- switch (node.kind) {
- case 163:
- case 164:
- case 162:
- case 159:
- case 158:
- case 161:
- case 160:
- case 167:
- case 249:
- case 254:
- case 253:
- case 260:
- case 259:
- case 201:
- case 202:
- case 156:
- return false;
- default:
- if (node.parent.kind === 250 || node.parent.kind === 290) {
- return false;
+ function checkImportEqualsDeclaration(node) {
+ if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+ return;
+ }
+ checkGrammarDecoratorsAndModifiers(node);
+ if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
+ checkImportBinding(node);
+ if (ts.hasSyntacticModifier(node, 1)) {
+ markExportAsReferenced(node);
+ }
+ if (node.moduleReference.kind !== 272) {
+ var target = resolveAlias(getSymbolOfNode(node));
+ if (target !== unknownSymbol) {
+ if (target.flags & 111551) {
+ var moduleName = ts.getFirstIdentifier(node.moduleReference);
+ if (!(resolveEntityName(moduleName, 111551 | 1920).flags & 1920)) {
+ error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName));
+ }
+ }
+ if (target.flags & 788968) {
+ checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0);
+ }
}
- switch (node.kind) {
- case 244:
- return nodeHasAnyModifiersExcept(node, 126);
- case 245:
- return nodeHasAnyModifiersExcept(node, 122);
- case 246:
- case 225:
- case 247:
- return true;
- case 248:
- return nodeHasAnyModifiersExcept(node, 81);
- default:
- ts.Debug.fail();
- return false;
+ }
+ else {
+ if (moduleKind >= ts.ModuleKind.ES2015 && !(node.flags & 8388608)) {
+ grammarErrorOnNode(node, ts.Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
}
+ }
}
}
- function nodeHasAnyModifiersExcept(node, allowedModifier) {
- return node.modifiers.length > 1 || node.modifiers[0].kind !== allowedModifier;
- }
- function checkGrammarAsyncModifier(node, asyncModifier) {
- switch (node.kind) {
- case 161:
- case 244:
- case 201:
- case 202:
- return false;
+ function checkExportDeclaration(node) {
+ if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) {
+ return;
}
- return grammarErrorOnNode(asyncModifier, ts.Diagnostics._0_modifier_cannot_be_used_here, "async");
- }
- function checkGrammarForDisallowedTrailingComma(list, diag) {
- if (diag === void 0) { diag = ts.Diagnostics.Trailing_comma_not_allowed; }
- if (list && list.hasTrailingComma) {
- return grammarErrorAtPos(list[0], list.end - ",".length, ",".length, diag);
+ if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasEffectiveModifiers(node)) {
+ grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers);
}
- return false;
- }
- function checkGrammarTypeParameterList(typeParameters, file) {
- if (typeParameters && typeParameters.length === 0) {
- var start = typeParameters.pos - "<".length;
- var end = ts.skipTrivia(file.text, typeParameters.end) + ">".length;
- return grammarErrorAtPos(file, start, end - start, ts.Diagnostics.Type_parameter_list_cannot_be_empty);
+ if (node.moduleSpecifier && node.exportClause && ts.isNamedExports(node.exportClause) && ts.length(node.exportClause.elements) && languageVersion === 0) {
+ checkExternalEmitHelpers(node, 4194304);
}
- return false;
- }
- function checkGrammarParameterList(parameters) {
- var seenOptionalParameter = false;
- var parameterCount = parameters.length;
- for (var i = 0; i < parameterCount; i++) {
- var parameter = parameters[i];
- if (parameter.dotDotDotToken) {
- if (i !== (parameterCount - 1)) {
- return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
- }
- if (!(parameter.flags & 8388608)) {
- checkGrammarForDisallowedTrailingComma(parameters, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
+ checkGrammarExportDeclaration(node);
+ if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
+ if (node.exportClause && !ts.isNamespaceExport(node.exportClause)) {
+ ts.forEach(node.exportClause.elements, checkExportSpecifier);
+ var inAmbientExternalModule = node.parent.kind === 257 && ts.isAmbientModule(node.parent.parent);
+ var inAmbientNamespaceDeclaration = !inAmbientExternalModule && node.parent.kind === 257 &&
+ !node.moduleSpecifier && node.flags & 8388608;
+ if (node.parent.kind !== 297 && !inAmbientExternalModule && !inAmbientNamespaceDeclaration) {
+ error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace);
}
- if (parameter.questionToken) {
- return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_rest_parameter_cannot_be_optional);
+ }
+ else {
+ var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
+ if (moduleSymbol && hasExportAssignmentSymbol(moduleSymbol)) {
+ error(node.moduleSpecifier, ts.Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol));
}
- if (parameter.initializer) {
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer);
+ else if (node.exportClause) {
+ checkAliasSymbol(node.exportClause);
}
- }
- else if (parameter.questionToken) {
- seenOptionalParameter = true;
- if (parameter.initializer) {
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.Parameter_cannot_have_question_mark_and_initializer);
+ if (moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015) {
+ if (node.exportClause) {
+ if (compilerOptions.esModuleInterop) {
+ checkExternalEmitHelpers(node, 131072);
+ }
+ }
+ else {
+ checkExternalEmitHelpers(node, 65536);
+ }
}
}
- else if (seenOptionalParameter && !parameter.initializer) {
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter);
- }
}
}
- function getNonSimpleParameters(parameters) {
- return ts.filter(parameters, function (parameter) { return !!parameter.initializer || ts.isBindingPattern(parameter.name) || ts.isRestParameter(parameter); });
+ function checkGrammarExportDeclaration(node) {
+ var _a;
+ var isTypeOnlyExportStar = node.isTypeOnly && ((_a = node.exportClause) === null || _a === void 0 ? void 0 : _a.kind) !== 268;
+ if (isTypeOnlyExportStar) {
+ grammarErrorOnNode(node, ts.Diagnostics.Only_named_exports_may_use_export_type);
+ }
+ return !isTypeOnlyExportStar;
}
- function checkGrammarForUseStrictSimpleParameterList(node) {
- if (languageVersion >= 3) {
- var useStrictDirective_1 = node.body && ts.isBlock(node.body) && ts.findUseStrictPrologue(node.body.statements);
- if (useStrictDirective_1) {
- var nonSimpleParameters = getNonSimpleParameters(node.parameters);
- if (ts.length(nonSimpleParameters)) {
- ts.forEach(nonSimpleParameters, function (parameter) {
- ts.addRelatedInfo(error(parameter, ts.Diagnostics.This_parameter_is_not_allowed_with_use_strict_directive), ts.createDiagnosticForNode(useStrictDirective_1, ts.Diagnostics.use_strict_directive_used_here));
- });
- var diagnostics_1 = nonSimpleParameters.map(function (parameter, index) { return (index === 0 ? ts.createDiagnosticForNode(parameter, ts.Diagnostics.Non_simple_parameter_declared_here) : ts.createDiagnosticForNode(parameter, ts.Diagnostics.and_here)); });
- ts.addRelatedInfo.apply(void 0, __spreadArrays([error(useStrictDirective_1, ts.Diagnostics.use_strict_directive_cannot_be_used_with_non_simple_parameter_list)], diagnostics_1));
- return true;
- }
- }
+ function checkGrammarModuleElementContext(node, errorMessage) {
+ var isInAppropriateContext = node.parent.kind === 297 || node.parent.kind === 257 || node.parent.kind === 256;
+ if (!isInAppropriateContext) {
+ grammarErrorOnFirstToken(node, errorMessage);
}
- return false;
+ return !isInAppropriateContext;
}
- function checkGrammarFunctionLikeDeclaration(node) {
- var file = ts.getSourceFileOfNode(node);
- return checkGrammarDecoratorsAndModifiers(node) || checkGrammarTypeParameterList(node.typeParameters, file) ||
- checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file) ||
- (ts.isFunctionLikeDeclaration(node) && checkGrammarForUseStrictSimpleParameterList(node));
+ function importClauseContainsReferencedImport(importClause) {
+ return ts.forEachImportClauseDeclaration(importClause, function (declaration) {
+ return !!getSymbolOfNode(declaration).isReferenced;
+ });
}
- function checkGrammarClassLikeDeclaration(node) {
- var file = ts.getSourceFileOfNode(node);
- return checkGrammarClassDeclarationHeritageClauses(node) || checkGrammarTypeParameterList(node.typeParameters, file);
+ function importClauseContainsConstEnumUsedAsValue(importClause) {
+ return ts.forEachImportClauseDeclaration(importClause, function (declaration) {
+ return !!getSymbolLinks(getSymbolOfNode(declaration)).constEnumReferenced;
+ });
}
- function checkGrammarArrowFunction(node, file) {
- if (!ts.isArrowFunction(node)) {
- return false;
+ function checkImportsForTypeOnlyConversion(sourceFile) {
+ for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) {
+ var statement = _a[_i];
+ if (ts.isImportDeclaration(statement) &&
+ statement.importClause &&
+ !statement.importClause.isTypeOnly &&
+ importClauseContainsReferencedImport(statement.importClause) &&
+ !isReferencedAliasDeclaration(statement.importClause, true) &&
+ !importClauseContainsConstEnumUsedAsValue(statement.importClause)) {
+ error(statement, ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error);
+ }
}
- var equalsGreaterThanToken = node.equalsGreaterThanToken;
- var startLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.pos).line;
- var endLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.end).line;
- return startLine !== endLine && grammarErrorOnNode(equalsGreaterThanToken, ts.Diagnostics.Line_terminator_not_permitted_before_arrow);
}
- function checkGrammarIndexSignatureParameters(node) {
- var parameter = node.parameters[0];
- if (node.parameters.length !== 1) {
- if (parameter) {
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter);
+ function checkExportSpecifier(node) {
+ checkAliasSymbol(node);
+ if (ts.getEmitDeclarations(compilerOptions)) {
+ collectLinkedAliases(node.propertyName || node.name, true);
+ }
+ if (!node.parent.parent.moduleSpecifier) {
+ var exportedName = node.propertyName || node.name;
+ var symbol = resolveName(exportedName, exportedName.escapedText, 111551 | 788968 | 1920 | 2097152, undefined, undefined, true);
+ if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
+ error(exportedName, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, ts.idText(exportedName));
}
else {
- return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter);
+ markExportAsReferenced(node);
+ var target = symbol && (symbol.flags & 2097152 ? resolveAlias(symbol) : symbol);
+ if (!target || target === unknownSymbol || target.flags & 111551) {
+ checkExpressionCached(node.propertyName || node.name);
+ }
}
}
- checkGrammarForDisallowedTrailingComma(node.parameters, ts.Diagnostics.An_index_signature_cannot_have_a_trailing_comma);
- if (parameter.dotDotDotToken) {
- return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
- }
- if (ts.hasModifiers(parameter)) {
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
+ else {
+ if (compilerOptions.esModuleInterop &&
+ moduleKind !== ts.ModuleKind.System &&
+ moduleKind < ts.ModuleKind.ES2015 &&
+ ts.idText(node.propertyName || node.name) === "default") {
+ checkExternalEmitHelpers(node, 262144);
+ }
}
- if (parameter.questionToken) {
- return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark);
+ }
+ function checkExportAssignment(node) {
+ if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_assignment_can_only_be_used_in_a_module)) {
+ return;
}
- if (parameter.initializer) {
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_initializer);
+ var container = node.parent.kind === 297 ? node.parent : node.parent.parent;
+ if (container.kind === 256 && !ts.isAmbientModule(container)) {
+ if (node.isExportEquals) {
+ error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace);
+ }
+ else {
+ error(node, ts.Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module);
+ }
+ return;
}
- if (!parameter.type) {
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation);
+ if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasEffectiveModifiers(node)) {
+ grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers);
}
- if (parameter.type.kind !== 143 && parameter.type.kind !== 140) {
- var type = getTypeFromTypeNode(parameter.type);
- if (type.flags & 4 || type.flags & 8) {
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_cannot_be_a_type_alias_Consider_writing_0_Colon_1_Colon_2_instead, ts.getTextOfNode(parameter.name), typeToString(type), typeToString(node.type ? getTypeFromTypeNode(node.type) : anyType));
+ if (node.expression.kind === 78) {
+ var id = node.expression;
+ var sym = resolveEntityName(id, 67108863, true, true, node);
+ if (sym) {
+ markAliasReferenced(sym, id);
+ var target = sym.flags & 2097152 ? resolveAlias(sym) : sym;
+ if (target === unknownSymbol || target.flags & 111551) {
+ checkExpressionCached(node.expression);
+ }
}
- if (type.flags & 1048576 && allTypesAssignableToKind(type, 384, true)) {
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_cannot_be_a_union_type_Consider_using_a_mapped_object_type_instead);
+ else {
+ checkExpressionCached(node.expression);
+ }
+ if (ts.getEmitDeclarations(compilerOptions)) {
+ collectLinkedAliases(node.expression, true);
}
- return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_either_string_or_number);
}
- if (!node.type) {
- return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_a_type_annotation);
+ else {
+ checkExpressionCached(node.expression);
}
- return false;
- }
- function checkGrammarIndexSignature(node) {
- return checkGrammarDecoratorsAndModifiers(node) || checkGrammarIndexSignatureParameters(node);
- }
- function checkGrammarForAtLeastOneTypeArgument(node, typeArguments) {
- if (typeArguments && typeArguments.length === 0) {
- var sourceFile = ts.getSourceFileOfNode(node);
- var start = typeArguments.pos - "<".length;
- var end = ts.skipTrivia(sourceFile.text, typeArguments.end) + ">".length;
- return grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Type_argument_list_cannot_be_empty);
+ checkExternalModuleExports(container);
+ if ((node.flags & 8388608) && !ts.isEntityNameExpression(node.expression)) {
+ grammarErrorOnNode(node.expression, ts.Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context);
}
- return false;
- }
- function checkGrammarTypeArguments(node, typeArguments) {
- return checkGrammarForDisallowedTrailingComma(typeArguments) ||
- checkGrammarForAtLeastOneTypeArgument(node, typeArguments);
- }
- function checkGrammarTaggedTemplateChain(node) {
- if (node.questionDotToken || node.flags & 32) {
- return grammarErrorOnNode(node.template, ts.Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain);
+ if (node.isExportEquals && !(node.flags & 8388608)) {
+ if (moduleKind >= ts.ModuleKind.ES2015) {
+ grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead);
+ }
+ else if (moduleKind === ts.ModuleKind.System) {
+ grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system);
+ }
}
- return false;
}
- function checkGrammarForOmittedArgument(args) {
- if (args) {
- for (var _i = 0, args_4 = args; _i < args_4.length; _i++) {
- var arg = args_4[_i];
- if (arg.kind === 215) {
- return grammarErrorAtPos(arg, arg.pos, 0, ts.Diagnostics.Argument_expression_expected);
+ function hasExportedMembers(moduleSymbol) {
+ return ts.forEachEntry(moduleSymbol.exports, function (_, id) { return id !== "export="; });
+ }
+ function checkExternalModuleExports(node) {
+ var moduleSymbol = getSymbolOfNode(node);
+ var links = getSymbolLinks(moduleSymbol);
+ if (!links.exportsChecked) {
+ var exportEqualsSymbol = moduleSymbol.exports.get("export=");
+ if (exportEqualsSymbol && hasExportedMembers(moduleSymbol)) {
+ var declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration;
+ if (!isTopLevelInExternalModuleAugmentation(declaration) && !ts.isInJSFile(declaration)) {
+ error(declaration, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements);
}
}
+ var exports_2 = getExportsOfModule(moduleSymbol);
+ if (exports_2) {
+ exports_2.forEach(function (_a, id) {
+ var declarations = _a.declarations, flags = _a.flags;
+ if (id === "__export") {
+ return;
+ }
+ if (flags & (1920 | 64 | 384)) {
+ return;
+ }
+ var exportedDeclarationsCount = ts.countWhere(declarations, isNotOverloadAndNotAccessor);
+ if (flags & 524288 && exportedDeclarationsCount <= 2) {
+ return;
+ }
+ if (exportedDeclarationsCount > 1) {
+ for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) {
+ var declaration = declarations_9[_i];
+ if (isNotOverload(declaration)) {
+ diagnostics.add(ts.createDiagnosticForNode(declaration, ts.Diagnostics.Cannot_redeclare_exported_variable_0, ts.unescapeLeadingUnderscores(id)));
+ }
+ }
+ }
+ });
+ }
+ links.exportsChecked = true;
}
- return false;
}
- function checkGrammarArguments(args) {
- return checkGrammarForOmittedArgument(args);
+ function checkSourceElement(node) {
+ if (node) {
+ var saveCurrentNode = currentNode;
+ currentNode = node;
+ instantiationCount = 0;
+ checkSourceElementWorker(node);
+ currentNode = saveCurrentNode;
+ }
}
- function checkGrammarHeritageClause(node) {
- var types = node.types;
- if (checkGrammarForDisallowedTrailingComma(types)) {
- return true;
+ function checkSourceElementWorker(node) {
+ if (ts.isInJSFile(node)) {
+ ts.forEach(node.jsDoc, function (_a) {
+ var tags = _a.tags;
+ return ts.forEach(tags, checkSourceElement);
+ });
}
- if (types && types.length === 0) {
- var listType = ts.tokenToString(node.token);
- return grammarErrorAtPos(node, types.pos, 0, ts.Diagnostics._0_list_cannot_be_empty, listType);
+ var kind = node.kind;
+ if (cancellationToken) {
+ switch (kind) {
+ case 256:
+ case 252:
+ case 253:
+ case 251:
+ cancellationToken.throwIfCancellationRequested();
+ }
+ }
+ if (kind >= 232 && kind <= 248 && node.flowNode && !isReachableFlowNode(node.flowNode)) {
+ errorOrSuggestion(compilerOptions.allowUnreachableCode === false, node, ts.Diagnostics.Unreachable_code_detected);
+ }
+ switch (kind) {
+ case 159:
+ return checkTypeParameter(node);
+ case 160:
+ return checkParameter(node);
+ case 163:
+ return checkPropertyDeclaration(node);
+ case 162:
+ return checkPropertySignature(node);
+ case 174:
+ case 175:
+ case 169:
+ case 170:
+ case 171:
+ return checkSignatureDeclaration(node);
+ case 165:
+ case 164:
+ return checkMethodDeclaration(node);
+ case 166:
+ return checkConstructorDeclaration(node);
+ case 167:
+ case 168:
+ return checkAccessorDeclaration(node);
+ case 173:
+ return checkTypeReferenceNode(node);
+ case 172:
+ return checkTypePredicate(node);
+ case 176:
+ return checkTypeQuery(node);
+ case 177:
+ return checkTypeLiteral(node);
+ case 178:
+ return checkArrayType(node);
+ case 179:
+ return checkTupleType(node);
+ case 182:
+ case 183:
+ return checkUnionOrIntersectionType(node);
+ case 186:
+ case 180:
+ case 181:
+ return checkSourceElement(node.type);
+ case 187:
+ return checkThisType(node);
+ case 188:
+ return checkTypeOperator(node);
+ case 184:
+ return checkConditionalType(node);
+ case 185:
+ return checkInferType(node);
+ case 193:
+ return checkTemplateLiteralType(node);
+ case 195:
+ return checkImportType(node);
+ case 192:
+ return checkNamedTupleMember(node);
+ case 315:
+ return checkJSDocAugmentsTag(node);
+ case 316:
+ return checkJSDocImplementsTag(node);
+ case 331:
+ case 324:
+ case 325:
+ return checkJSDocTypeAliasTag(node);
+ case 330:
+ return checkJSDocTemplateTag(node);
+ case 329:
+ return checkJSDocTypeTag(node);
+ case 326:
+ return checkJSDocParameterTag(node);
+ case 333:
+ return checkJSDocPropertyTag(node);
+ case 308:
+ checkJSDocFunctionType(node);
+ case 306:
+ case 305:
+ case 303:
+ case 304:
+ case 312:
+ checkJSDocTypeIsInJsFile(node);
+ ts.forEachChild(node, checkSourceElement);
+ return;
+ case 309:
+ checkJSDocVariadicType(node);
+ return;
+ case 301:
+ return checkSourceElement(node.type);
+ case 189:
+ return checkIndexedAccessType(node);
+ case 190:
+ return checkMappedType(node);
+ case 251:
+ return checkFunctionDeclaration(node);
+ case 230:
+ case 257:
+ return checkBlock(node);
+ case 232:
+ return checkVariableStatement(node);
+ case 233:
+ return checkExpressionStatement(node);
+ case 234:
+ return checkIfStatement(node);
+ case 235:
+ return checkDoStatement(node);
+ case 236:
+ return checkWhileStatement(node);
+ case 237:
+ return checkForStatement(node);
+ case 238:
+ return checkForInStatement(node);
+ case 239:
+ return checkForOfStatement(node);
+ case 240:
+ case 241:
+ return checkBreakOrContinueStatement(node);
+ case 242:
+ return checkReturnStatement(node);
+ case 243:
+ return checkWithStatement(node);
+ case 244:
+ return checkSwitchStatement(node);
+ case 245:
+ return checkLabeledStatement(node);
+ case 246:
+ return checkThrowStatement(node);
+ case 247:
+ return checkTryStatement(node);
+ case 249:
+ return checkVariableDeclaration(node);
+ case 198:
+ return checkBindingElement(node);
+ case 252:
+ return checkClassDeclaration(node);
+ case 253:
+ return checkInterfaceDeclaration(node);
+ case 254:
+ return checkTypeAliasDeclaration(node);
+ case 255:
+ return checkEnumDeclaration(node);
+ case 256:
+ return checkModuleDeclaration(node);
+ case 261:
+ return checkImportDeclaration(node);
+ case 260:
+ return checkImportEqualsDeclaration(node);
+ case 267:
+ return checkExportDeclaration(node);
+ case 266:
+ return checkExportAssignment(node);
+ case 231:
+ case 248:
+ checkGrammarStatementInAmbientContext(node);
+ return;
+ case 271:
+ return checkMissingDeclaration(node);
}
- return ts.some(types, checkGrammarExpressionWithTypeArguments);
}
- function checkGrammarExpressionWithTypeArguments(node) {
- return checkGrammarTypeArguments(node, node.typeArguments);
+ function checkJSDocTypeIsInJsFile(node) {
+ if (!ts.isInJSFile(node)) {
+ grammarErrorOnNode(node, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
+ }
}
- function checkGrammarClassDeclarationHeritageClauses(node) {
- var seenExtendsClause = false;
- var seenImplementsClause = false;
- if (!checkGrammarDecoratorsAndModifiers(node) && node.heritageClauses) {
- for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
- var heritageClause = _a[_i];
- if (heritageClause.token === 90) {
- if (seenExtendsClause) {
- return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen);
- }
- if (seenImplementsClause) {
- return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_must_precede_implements_clause);
- }
- if (heritageClause.types.length > 1) {
- return grammarErrorOnFirstToken(heritageClause.types[1], ts.Diagnostics.Classes_can_only_extend_a_single_class);
- }
- seenExtendsClause = true;
- }
- else {
- ts.Debug.assert(heritageClause.token === 113);
- if (seenImplementsClause) {
- return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen);
- }
- seenImplementsClause = true;
- }
- checkGrammarHeritageClause(heritageClause);
+ function checkJSDocVariadicType(node) {
+ checkJSDocTypeIsInJsFile(node);
+ checkSourceElement(node.type);
+ var parent = node.parent;
+ if (ts.isParameter(parent) && ts.isJSDocFunctionType(parent.parent)) {
+ if (ts.last(parent.parent.parameters) !== parent) {
+ error(node, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
}
+ return;
+ }
+ if (!ts.isJSDocTypeExpression(parent)) {
+ error(node, ts.Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature);
+ }
+ var paramTag = node.parent.parent;
+ if (!ts.isJSDocParameterTag(paramTag)) {
+ error(node, ts.Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature);
+ return;
+ }
+ var param = ts.getParameterSymbolFromJSDoc(paramTag);
+ if (!param) {
+ return;
+ }
+ var host = ts.getHostSignatureFromJSDoc(paramTag);
+ if (!host || ts.last(host.parameters).symbol !== param) {
+ error(node, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
}
}
- function checkGrammarInterfaceDeclaration(node) {
- var seenExtendsClause = false;
- if (node.heritageClauses) {
- for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
- var heritageClause = _a[_i];
- if (heritageClause.token === 90) {
- if (seenExtendsClause) {
- return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen);
- }
- seenExtendsClause = true;
- }
- else {
- ts.Debug.assert(heritageClause.token === 113);
- return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause);
+ function getTypeFromJSDocVariadicType(node) {
+ var type = getTypeFromTypeNode(node.type);
+ var parent = node.parent;
+ var paramTag = node.parent.parent;
+ if (ts.isJSDocTypeExpression(node.parent) && ts.isJSDocParameterTag(paramTag)) {
+ var host_1 = ts.getHostSignatureFromJSDoc(paramTag);
+ if (host_1) {
+ var lastParamDeclaration = ts.lastOrUndefined(host_1.parameters);
+ var symbol = ts.getParameterSymbolFromJSDoc(paramTag);
+ if (!lastParamDeclaration ||
+ symbol && lastParamDeclaration.symbol === symbol && ts.isRestParameter(lastParamDeclaration)) {
+ return createArrayType(type);
}
- checkGrammarHeritageClause(heritageClause);
}
}
- return false;
+ if (ts.isParameter(parent) && ts.isJSDocFunctionType(parent.parent)) {
+ return createArrayType(type);
+ }
+ return addOptionality(type);
}
- function checkGrammarComputedPropertyName(node) {
- if (node.kind !== 154) {
- return false;
+ function checkNodeDeferred(node) {
+ var enclosingFile = ts.getSourceFileOfNode(node);
+ var links = getNodeLinks(enclosingFile);
+ if (!(links.flags & 1)) {
+ links.deferredNodes = links.deferredNodes || new ts.Map();
+ var id = getNodeId(node);
+ links.deferredNodes.set(id, node);
}
- var computedPropertyName = node;
- if (computedPropertyName.expression.kind === 209 && computedPropertyName.expression.operatorToken.kind === 27) {
- return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
+ }
+ function checkDeferredNodes(context) {
+ var links = getNodeLinks(context);
+ if (links.deferredNodes) {
+ links.deferredNodes.forEach(checkDeferredNode);
}
- return false;
}
- function checkGrammarForGenerator(node) {
- if (node.asteriskToken) {
- ts.Debug.assert(node.kind === 244 ||
- node.kind === 201 ||
- node.kind === 161);
- if (node.flags & 8388608) {
- return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context);
- }
- if (!node.body) {
- return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator);
- }
+ function checkDeferredNode(node) {
+ var saveCurrentNode = currentNode;
+ currentNode = node;
+ instantiationCount = 0;
+ switch (node.kind) {
+ case 203:
+ case 204:
+ case 205:
+ case 161:
+ case 275:
+ resolveUntypedCall(node);
+ break;
+ case 208:
+ case 209:
+ case 165:
+ case 164:
+ checkFunctionExpressionOrObjectLiteralMethodDeferred(node);
+ break;
+ case 167:
+ case 168:
+ checkAccessorDeclaration(node);
+ break;
+ case 221:
+ checkClassExpressionDeferred(node);
+ break;
+ case 274:
+ checkJsxSelfClosingElementDeferred(node);
+ break;
+ case 273:
+ checkJsxElementDeferred(node);
+ break;
}
+ currentNode = saveCurrentNode;
}
- function checkGrammarForInvalidQuestionMark(questionToken, message) {
- return !!questionToken && grammarErrorOnNode(questionToken, message);
+ function checkSourceFile(node) {
+ var tracingData = ["check", "checkSourceFile", { path: node.path }];
+ ts.tracing.begin.apply(ts.tracing, tracingData);
+ ts.performance.mark("beforeCheck");
+ checkSourceFileWorker(node);
+ ts.performance.mark("afterCheck");
+ ts.performance.measure("Check", "beforeCheck", "afterCheck");
+ ts.tracing.end.apply(ts.tracing, tracingData);
}
- function checkGrammarForInvalidExclamationToken(exclamationToken, message) {
- return !!exclamationToken && grammarErrorOnNode(exclamationToken, message);
+ function unusedIsError(kind, isAmbient) {
+ if (isAmbient) {
+ return false;
+ }
+ switch (kind) {
+ case 0:
+ return !!compilerOptions.noUnusedLocals;
+ case 1:
+ return !!compilerOptions.noUnusedParameters;
+ default:
+ return ts.Debug.assertNever(kind);
+ }
}
- function checkGrammarObjectLiteralExpression(node, inDestructuring) {
- var seen = ts.createUnderscoreEscapedMap();
- for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
- var prop = _a[_i];
- if (prop.kind === 283) {
- if (inDestructuring) {
- var expression = ts.skipParentheses(prop.expression);
- if (ts.isArrayLiteralExpression(expression) || ts.isObjectLiteralExpression(expression)) {
- return grammarErrorOnNode(prop.expression, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern);
- }
- }
- continue;
+ function getPotentiallyUnusedIdentifiers(sourceFile) {
+ return allPotentiallyUnusedIdentifiers.get(sourceFile.path) || ts.emptyArray;
+ }
+ function checkSourceFileWorker(node) {
+ var links = getNodeLinks(node);
+ if (!(links.flags & 1)) {
+ if (ts.skipTypeChecking(node, compilerOptions, host)) {
+ return;
}
- var name = prop.name;
- if (name.kind === 154) {
- checkGrammarComputedPropertyName(name);
+ checkGrammarSourceFile(node);
+ ts.clear(potentialThisCollisions);
+ ts.clear(potentialNewTargetCollisions);
+ ts.clear(potentialWeakMapCollisions);
+ ts.forEach(node.statements, checkSourceElement);
+ checkSourceElement(node.endOfFileToken);
+ checkDeferredNodes(node);
+ if (ts.isExternalOrCommonJsModule(node)) {
+ registerForUnusedIdentifiersCheck(node);
+ }
+ if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) {
+ checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), function (containingNode, kind, diag) {
+ if (!ts.containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 8388608))) {
+ diagnostics.add(diag);
+ }
+ });
}
- if (prop.kind === 282 && !inDestructuring && prop.objectAssignmentInitializer) {
- return grammarErrorOnNode(prop.equalsToken, ts.Diagnostics.can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment);
+ if (compilerOptions.importsNotUsedAsValues === 2 &&
+ !node.isDeclarationFile &&
+ ts.isExternalModule(node)) {
+ checkImportsForTypeOnlyConversion(node);
}
- if (name.kind === 76) {
- return grammarErrorOnNode(name, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+ if (ts.isExternalOrCommonJsModule(node)) {
+ checkExternalModuleExports(node);
}
- if (prop.modifiers) {
- for (var _b = 0, _c = prop.modifiers; _b < _c.length; _b++) {
- var mod = _c[_b];
- if (mod.kind !== 126 || prop.kind !== 161) {
- grammarErrorOnNode(mod, ts.Diagnostics._0_modifier_cannot_be_used_here, ts.getTextOfNode(mod));
- }
- }
+ if (potentialThisCollisions.length) {
+ ts.forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope);
+ ts.clear(potentialThisCollisions);
}
- var currentKind = void 0;
- switch (prop.kind) {
- case 282:
- checkGrammarForInvalidExclamationToken(prop.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context);
- case 281:
- checkGrammarForInvalidQuestionMark(prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional);
- if (name.kind === 8) {
- checkGrammarNumericLiteral(name);
- }
- currentKind = 4;
- break;
- case 161:
- currentKind = 8;
- break;
- case 163:
- currentKind = 1;
- break;
- case 164:
- currentKind = 2;
- break;
- default:
- throw ts.Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind);
+ if (potentialNewTargetCollisions.length) {
+ ts.forEach(potentialNewTargetCollisions, checkIfNewTargetIsCapturedInEnclosingScope);
+ ts.clear(potentialNewTargetCollisions);
}
- if (!inDestructuring) {
- var effectiveName = ts.getPropertyNameForPropertyNameNode(name);
- if (effectiveName === undefined) {
- continue;
- }
- var existingKind = seen.get(effectiveName);
- if (!existingKind) {
- seen.set(effectiveName, currentKind);
- }
- else {
- if ((currentKind & 12) && (existingKind & 12)) {
- grammarErrorOnNode(name, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(name));
- }
- else if ((currentKind & 3) && (existingKind & 3)) {
- if (existingKind !== 3 && currentKind !== existingKind) {
- seen.set(effectiveName, currentKind | existingKind);
- }
- else {
- return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name);
- }
- }
- else {
- return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name);
- }
- }
+ if (potentialWeakMapCollisions.length) {
+ ts.forEach(potentialWeakMapCollisions, checkWeakMapCollision);
+ ts.clear(potentialWeakMapCollisions);
}
+ links.flags |= 1;
}
}
- function checkGrammarJsxElement(node) {
- checkGrammarTypeArguments(node, node.typeArguments);
- var seen = ts.createUnderscoreEscapedMap();
- for (var _i = 0, _a = node.attributes.properties; _i < _a.length; _i++) {
- var attr = _a[_i];
- if (attr.kind === 275) {
- continue;
- }
- var name = attr.name, initializer = attr.initializer;
- if (!seen.get(name.escapedText)) {
- seen.set(name.escapedText, true);
- }
- else {
- return grammarErrorOnNode(name, ts.Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name);
+ function getDiagnostics(sourceFile, ct) {
+ try {
+ cancellationToken = ct;
+ return getDiagnosticsWorker(sourceFile);
+ }
+ finally {
+ cancellationToken = undefined;
+ }
+ }
+ function getDiagnosticsWorker(sourceFile) {
+ throwIfNonDiagnosticsProducing();
+ if (sourceFile) {
+ var previousGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
+ var previousGlobalDiagnosticsSize = previousGlobalDiagnostics.length;
+ checkSourceFile(sourceFile);
+ var semanticDiagnostics = diagnostics.getDiagnostics(sourceFile.fileName);
+ var currentGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
+ if (currentGlobalDiagnostics !== previousGlobalDiagnostics) {
+ var deferredGlobalDiagnostics = ts.relativeComplement(previousGlobalDiagnostics, currentGlobalDiagnostics, ts.compareDiagnostics);
+ return ts.concatenate(deferredGlobalDiagnostics, semanticDiagnostics);
}
- if (initializer && initializer.kind === 276 && !initializer.expression) {
- return grammarErrorOnNode(initializer, ts.Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression);
+ else if (previousGlobalDiagnosticsSize === 0 && currentGlobalDiagnostics.length > 0) {
+ return ts.concatenate(currentGlobalDiagnostics, semanticDiagnostics);
}
+ return semanticDiagnostics;
}
+ ts.forEach(host.getSourceFiles(), checkSourceFile);
+ return diagnostics.getDiagnostics();
}
- function checkGrammarJsxExpression(node) {
- if (node.expression && ts.isCommaSequence(node.expression)) {
- return grammarErrorOnNode(node.expression, ts.Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array);
- }
+ function getGlobalDiagnostics() {
+ throwIfNonDiagnosticsProducing();
+ return diagnostics.getGlobalDiagnostics();
}
- function checkGrammarForInOrForOfStatement(forInOrOfStatement) {
- if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) {
- return true;
+ function throwIfNonDiagnosticsProducing() {
+ if (!produceDiagnostics) {
+ throw new Error("Trying to get diagnostics from a type checker that does not produce them.");
}
- if (forInOrOfStatement.kind === 232 && forInOrOfStatement.awaitModifier) {
- if ((forInOrOfStatement.flags & 32768) === 0) {
- var sourceFile = ts.getSourceFileOfNode(forInOrOfStatement);
- if (!hasParseDiagnostics(sourceFile)) {
- var diagnostic = ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator);
- var func = ts.getContainingFunction(forInOrOfStatement);
- if (func && func.kind !== 162) {
- ts.Debug.assert((ts.getFunctionFlags(func) & 2) === 0, "Enclosing function should never be an async function.");
- var relatedInfo = ts.createDiagnosticForNode(func, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async);
- ts.addRelatedInfo(diagnostic, relatedInfo);
- }
- diagnostics.add(diagnostic);
- return true;
- }
- return false;
- }
+ }
+ function getSymbolsInScope(location, meaning) {
+ if (location.flags & 16777216) {
+ return [];
}
- if (forInOrOfStatement.initializer.kind === 243) {
- var variableList = forInOrOfStatement.initializer;
- if (!checkGrammarVariableDeclarationList(variableList)) {
- var declarations = variableList.declarations;
- if (!declarations.length) {
- return false;
- }
- if (declarations.length > 1) {
- var diagnostic = forInOrOfStatement.kind === 231
- ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement
- : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement;
- return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic);
+ var symbols = ts.createSymbolTable();
+ var isStatic = false;
+ populateSymbols();
+ symbols.delete("this");
+ return symbolsToArray(symbols);
+ function populateSymbols() {
+ while (location) {
+ if (location.locals && !isGlobalSourceFile(location)) {
+ copySymbols(location.locals, meaning);
}
- var firstDeclaration = declarations[0];
- if (firstDeclaration.initializer) {
- var diagnostic = forInOrOfStatement.kind === 231
- ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer
- : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer;
- return grammarErrorOnNode(firstDeclaration.name, diagnostic);
+ switch (location.kind) {
+ case 297:
+ if (!ts.isExternalOrCommonJsModule(location))
+ break;
+ case 256:
+ copySymbols(getSymbolOfNode(location).exports, meaning & 2623475);
+ break;
+ case 255:
+ copySymbols(getSymbolOfNode(location).exports, meaning & 8);
+ break;
+ case 221:
+ var className = location.name;
+ if (className) {
+ copySymbol(location.symbol, meaning);
+ }
+ case 252:
+ case 253:
+ if (!isStatic) {
+ copySymbols(getMembersOfSymbol(getSymbolOfNode(location)), meaning & 788968);
+ }
+ break;
+ case 208:
+ var funcName = location.name;
+ if (funcName) {
+ copySymbol(location.symbol, meaning);
+ }
+ break;
}
- if (firstDeclaration.type) {
- var diagnostic = forInOrOfStatement.kind === 231
- ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation
- : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation;
- return grammarErrorOnNode(firstDeclaration, diagnostic);
+ if (ts.introducesArgumentsExoticObject(location)) {
+ copySymbol(argumentsSymbol, meaning);
}
+ isStatic = ts.hasSyntacticModifier(location, 32);
+ location = location.parent;
}
+ copySymbols(globals, meaning);
}
- return false;
- }
- function checkGrammarAccessor(accessor) {
- if (!(accessor.flags & 8388608)) {
- if (languageVersion < 1) {
- return grammarErrorOnNode(accessor.name, ts.Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
- }
- if (accessor.body === undefined && !ts.hasModifier(accessor, 128)) {
- return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, ts.Diagnostics._0_expected, "{");
+ function copySymbol(symbol, meaning) {
+ if (ts.getCombinedLocalAndExportSymbolFlags(symbol) & meaning) {
+ var id = symbol.escapedName;
+ if (!symbols.has(id)) {
+ symbols.set(id, symbol);
+ }
}
}
- if (accessor.body && ts.hasModifier(accessor, 128)) {
- return grammarErrorOnNode(accessor, ts.Diagnostics.An_abstract_accessor_cannot_have_an_implementation);
- }
- if (accessor.typeParameters) {
- return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters);
- }
- if (!doesAccessorHaveCorrectParameterCount(accessor)) {
- return grammarErrorOnNode(accessor.name, accessor.kind === 163 ?
- ts.Diagnostics.A_get_accessor_cannot_have_parameters :
- ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter);
- }
- if (accessor.kind === 164) {
- if (accessor.type) {
- return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation);
- }
- var parameter = ts.Debug.checkDefined(ts.getSetAccessorValueParameter(accessor), "Return value does not match parameter count assertion.");
- if (parameter.dotDotDotToken) {
- return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter);
- }
- if (parameter.questionToken) {
- return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_set_accessor_cannot_have_an_optional_parameter);
- }
- if (parameter.initializer) {
- return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer);
+ function copySymbols(source, meaning) {
+ if (meaning) {
+ source.forEach(function (symbol) {
+ copySymbol(symbol, meaning);
+ });
}
}
- return false;
}
- function doesAccessorHaveCorrectParameterCount(accessor) {
- return getAccessorThisParameter(accessor) || accessor.parameters.length === (accessor.kind === 163 ? 0 : 1);
+ function isTypeDeclarationName(name) {
+ return name.kind === 78 &&
+ isTypeDeclaration(name.parent) &&
+ ts.getNameOfDeclaration(name.parent) === name;
}
- function getAccessorThisParameter(accessor) {
- if (accessor.parameters.length === (accessor.kind === 163 ? 1 : 2)) {
- return ts.getThisParameter(accessor);
+ function isTypeDeclaration(node) {
+ switch (node.kind) {
+ case 159:
+ case 252:
+ case 253:
+ case 254:
+ case 255:
+ case 331:
+ case 324:
+ case 325:
+ return true;
+ case 262:
+ return node.isTypeOnly;
+ case 265:
+ case 270:
+ return node.parent.parent.isTypeOnly;
+ default:
+ return false;
}
}
- function checkGrammarTypeOperatorNode(node) {
- if (node.operator === 147) {
- if (node.type.kind !== 144) {
- return grammarErrorOnNode(node.type, ts.Diagnostics._0_expected, ts.tokenToString(144));
- }
- var parent = ts.walkUpParenthesizedTypes(node.parent);
- switch (parent.kind) {
- case 242:
- var decl = parent;
- if (decl.name.kind !== 75) {
- return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name);
- }
- if (!ts.isVariableDeclarationInVariableStatement(decl)) {
- return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement);
- }
- if (!(decl.parent.flags & 2)) {
- return grammarErrorOnNode(parent.name, ts.Diagnostics.A_variable_whose_type_is_a_unique_symbol_type_must_be_const);
- }
- break;
- case 159:
- if (!ts.hasModifier(parent, 32) ||
- !ts.hasModifier(parent, 64)) {
- return grammarErrorOnNode(parent.name, ts.Diagnostics.A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly);
- }
- break;
- case 158:
- if (!ts.hasModifier(parent, 64)) {
- return grammarErrorOnNode(parent.name, ts.Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly);
- }
- break;
- default:
- return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_are_not_allowed_here);
- }
+ function isTypeReferenceIdentifier(node) {
+ while (node.parent.kind === 157) {
+ node = node.parent;
}
- else if (node.operator === 138) {
- if (node.type.kind !== 174 && node.type.kind !== 175) {
- return grammarErrorOnFirstToken(node, ts.Diagnostics.readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types, ts.tokenToString(144));
- }
+ return node.parent.kind === 173;
+ }
+ function isHeritageClauseElementIdentifier(node) {
+ while (node.parent.kind === 201) {
+ node = node.parent;
}
+ return node.parent.kind === 223;
}
- function checkGrammarForInvalidDynamicName(node, message) {
- if (isNonBindableDynamicName(node)) {
- return grammarErrorOnNode(node, message);
+ function isJSDocEntryNameReference(node) {
+ while (node.parent.kind === 157) {
+ node = node.parent;
+ }
+ while (node.parent.kind === 201) {
+ node = node.parent;
}
+ return node.parent.kind === 302;
}
- function checkGrammarMethod(node) {
- if (checkGrammarFunctionLikeDeclaration(node)) {
- return true;
+ function forEachEnclosingClass(node, callback) {
+ var result;
+ while (true) {
+ node = ts.getContainingClass(node);
+ if (!node)
+ break;
+ if (result = callback(node))
+ break;
}
- if (node.kind === 161) {
- if (node.parent.kind === 193) {
- if (node.modifiers && !(node.modifiers.length === 1 && ts.first(node.modifiers).kind === 126)) {
- return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here);
- }
- else if (checkGrammarForInvalidQuestionMark(node.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional)) {
- return true;
- }
- else if (checkGrammarForInvalidExclamationToken(node.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context)) {
- return true;
- }
- else if (node.body === undefined) {
- return grammarErrorAtPos(node, node.end - 1, ";".length, ts.Diagnostics._0_expected, "{");
- }
- }
- if (checkGrammarForGenerator(node)) {
+ return result;
+ }
+ function isNodeUsedDuringClassInitialization(node) {
+ return !!ts.findAncestor(node, function (element) {
+ if (ts.isConstructorDeclaration(element) && ts.nodeIsPresent(element.body) || ts.isPropertyDeclaration(element)) {
return true;
}
- }
- if (ts.isClassLike(node.parent)) {
- if (node.flags & 8388608) {
- return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
- }
- else if (node.kind === 161 && !node.body) {
- return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
+ else if (ts.isClassLike(element) || ts.isFunctionLikeDeclaration(element)) {
+ return "quit";
}
+ return false;
+ });
+ }
+ function isNodeWithinClass(node, classDeclaration) {
+ return !!forEachEnclosingClass(node, function (n) { return n === classDeclaration; });
+ }
+ function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) {
+ while (nodeOnRightSide.parent.kind === 157) {
+ nodeOnRightSide = nodeOnRightSide.parent;
}
- else if (node.parent.kind === 246) {
- return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
+ if (nodeOnRightSide.parent.kind === 260) {
+ return nodeOnRightSide.parent.moduleReference === nodeOnRightSide ? nodeOnRightSide.parent : undefined;
}
- else if (node.parent.kind === 173) {
- return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
+ if (nodeOnRightSide.parent.kind === 266) {
+ return nodeOnRightSide.parent.expression === nodeOnRightSide ? nodeOnRightSide.parent : undefined;
}
+ return undefined;
}
- function checkGrammarBreakOrContinueStatement(node) {
- var current = node;
- while (current) {
- if (ts.isFunctionLike(current)) {
- return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary);
- }
- switch (current.kind) {
- case 238:
- if (node.label && current.label.escapedText === node.label.escapedText) {
- var isMisplacedContinueLabel = node.kind === 233
- && !ts.isIterationStatement(current.statement, true);
- if (isMisplacedContinueLabel) {
- return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement);
- }
- return false;
- }
- break;
- case 237:
- if (node.kind === 234 && !node.label) {
- return false;
- }
- break;
- default:
- if (ts.isIterationStatement(current, false) && !node.label) {
- return false;
- }
- break;
- }
- current = current.parent;
+ function isInRightSideOfImportOrExportAssignment(node) {
+ return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined;
+ }
+ function getSpecialPropertyAssignmentSymbolFromEntityName(entityName) {
+ var specialPropertyAssignmentKind = ts.getAssignmentDeclarationKind(entityName.parent.parent);
+ switch (specialPropertyAssignmentKind) {
+ case 1:
+ case 3:
+ return getSymbolOfNode(entityName.parent);
+ case 4:
+ case 2:
+ case 5:
+ return getSymbolOfNode(entityName.parent.parent);
}
- if (node.label) {
- var message = node.kind === 234
- ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement
- : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement;
- return grammarErrorOnNode(node, message);
+ }
+ function isImportTypeQualifierPart(node) {
+ var parent = node.parent;
+ while (ts.isQualifiedName(parent)) {
+ node = parent;
+ parent = parent.parent;
}
- else {
- var message = node.kind === 234
- ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement
- : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement;
- return grammarErrorOnNode(node, message);
+ if (parent && parent.kind === 195 && parent.qualifier === node) {
+ return parent;
}
+ return undefined;
}
- function checkGrammarBindingElement(node) {
- if (node.dotDotDotToken) {
- var elements = node.parent.elements;
- if (node !== ts.last(elements)) {
- return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
+ function getSymbolOfNameOrPropertyAccessExpression(name) {
+ if (ts.isDeclarationName(name)) {
+ return getSymbolOfNode(name.parent);
+ }
+ if (ts.isInJSFile(name) &&
+ name.parent.kind === 201 &&
+ name.parent === name.parent.parent.left) {
+ if (!ts.isPrivateIdentifier(name)) {
+ var specialPropertyAssignmentSymbol = getSpecialPropertyAssignmentSymbolFromEntityName(name);
+ if (specialPropertyAssignmentSymbol) {
+ return specialPropertyAssignmentSymbol;
+ }
}
- checkGrammarForDisallowedTrailingComma(elements, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
- if (node.propertyName) {
- return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_have_a_property_name);
+ }
+ if (name.parent.kind === 266 && ts.isEntityNameExpression(name)) {
+ var success = resolveEntityName(name, 111551 | 788968 | 1920 | 2097152, true);
+ if (success && success !== unknownSymbol) {
+ return success;
}
- if (node.initializer) {
- return grammarErrorAtPos(node, node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer);
+ }
+ else if (!ts.isPropertyAccessExpression(name) && !ts.isPrivateIdentifier(name) && isInRightSideOfImportOrExportAssignment(name)) {
+ var importEqualsDeclaration = ts.getAncestor(name, 260);
+ ts.Debug.assert(importEqualsDeclaration !== undefined);
+ return getSymbolOfPartOfRightHandSideOfImportEquals(name, true);
+ }
+ if (!ts.isPropertyAccessExpression(name) && !ts.isPrivateIdentifier(name)) {
+ var possibleImportNode = isImportTypeQualifierPart(name);
+ if (possibleImportNode) {
+ getTypeFromTypeNode(possibleImportNode);
+ var sym = getNodeLinks(name).resolvedSymbol;
+ return sym === unknownSymbol ? undefined : sym;
}
}
- }
- function isStringOrNumberLiteralExpression(expr) {
- return ts.isStringOrNumericLiteralLike(expr) ||
- expr.kind === 207 && expr.operator === 40 &&
- expr.operand.kind === 8;
- }
- function isBigIntLiteralExpression(expr) {
- return expr.kind === 9 ||
- expr.kind === 207 && expr.operator === 40 &&
- expr.operand.kind === 9;
- }
- function isSimpleLiteralEnumReference(expr) {
- if ((ts.isPropertyAccessExpression(expr) || (ts.isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression))) &&
- ts.isEntityNameExpression(expr.expression)) {
- return !!(checkExpressionCached(expr).flags & 1024);
+ while (ts.isRightSideOfQualifiedNameOrPropertyAccess(name)) {
+ name = name.parent;
}
- }
- function checkAmbientInitializer(node) {
- var initializer = node.initializer;
- if (initializer) {
- var isInvalidInitializer = !(isStringOrNumberLiteralExpression(initializer) ||
- isSimpleLiteralEnumReference(initializer) ||
- initializer.kind === 106 || initializer.kind === 91 ||
- isBigIntLiteralExpression(initializer));
- var isConstOrReadonly = ts.isDeclarationReadonly(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node);
- if (isConstOrReadonly && !node.type) {
- if (isInvalidInitializer) {
- return grammarErrorOnNode(initializer, ts.Diagnostics.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference);
+ if (isHeritageClauseElementIdentifier(name)) {
+ var meaning = 0;
+ if (name.parent.kind === 223) {
+ meaning = 788968;
+ if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(name.parent)) {
+ meaning |= 111551;
}
}
else {
- return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
+ meaning = 1920;
}
- if (!isConstOrReadonly || isInvalidInitializer) {
- return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
+ meaning |= 2097152;
+ var entityNameSymbol = ts.isEntityNameExpression(name) ? resolveEntityName(name, meaning) : undefined;
+ if (entityNameSymbol) {
+ return entityNameSymbol;
}
}
- }
- function checkGrammarVariableDeclaration(node) {
- if (node.parent.parent.kind !== 231 && node.parent.parent.kind !== 232) {
- if (node.flags & 8388608) {
- checkAmbientInitializer(node);
+ if (name.parent.kind === 326) {
+ return ts.getParameterSymbolFromJSDoc(name.parent);
+ }
+ if (name.parent.kind === 159 && name.parent.parent.kind === 330) {
+ ts.Debug.assert(!ts.isInJSFile(name));
+ var typeParameter = ts.getTypeParameterFromJsDoc(name.parent);
+ return typeParameter && typeParameter.symbol;
+ }
+ if (ts.isExpressionNode(name)) {
+ if (ts.nodeIsMissing(name)) {
+ return undefined;
}
- else if (!node.initializer) {
- if (ts.isBindingPattern(node.name) && !ts.isBindingPattern(node.parent)) {
- return grammarErrorOnNode(node, ts.Diagnostics.A_destructuring_declaration_must_have_an_initializer);
+ if (name.kind === 78) {
+ if (ts.isJSXTagName(name) && isJsxIntrinsicIdentifier(name)) {
+ var symbol = getIntrinsicTagSymbol(name.parent);
+ return symbol === unknownSymbol ? undefined : symbol;
}
- if (ts.isVarConst(node)) {
- return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_must_be_initialized);
+ return resolveEntityName(name, 111551, false, true);
+ }
+ else if (name.kind === 201 || name.kind === 157) {
+ var links = getNodeLinks(name);
+ if (links.resolvedSymbol) {
+ return links.resolvedSymbol;
+ }
+ if (name.kind === 201) {
+ checkPropertyAccessExpression(name);
}
+ else {
+ checkQualifiedName(name);
+ }
+ return links.resolvedSymbol;
}
}
- if (node.exclamationToken && (node.parent.parent.kind !== 225 || !node.type || node.initializer || node.flags & 8388608)) {
- return grammarErrorOnNode(node.exclamationToken, ts.Diagnostics.Definite_assignment_assertions_can_only_be_used_along_with_a_type_annotation);
- }
- var moduleKind = ts.getEmitModuleKind(compilerOptions);
- if (moduleKind < ts.ModuleKind.ES2015 && moduleKind !== ts.ModuleKind.System && !compilerOptions.noEmit &&
- !(node.parent.parent.flags & 8388608) && ts.hasModifier(node.parent.parent, 1)) {
- checkESModuleMarker(node.name);
+ else if (isTypeReferenceIdentifier(name)) {
+ var meaning = name.parent.kind === 173 ? 788968 : 1920;
+ return resolveEntityName(name, meaning, false, true);
}
- var checkLetConstNames = (ts.isLet(node) || ts.isVarConst(node));
- return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name);
- }
- function checkESModuleMarker(name) {
- if (name.kind === 75) {
- if (ts.idText(name) === "__esModule") {
- return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules);
- }
+ else if (isJSDocEntryNameReference(name)) {
+ var meaning = 788968 | 1920 | 111551;
+ return resolveEntityName(name, meaning, false, true, ts.getHostSignatureFromJSDoc(name));
}
- else {
- var elements = name.elements;
- for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
- var element = elements_1[_i];
- if (!ts.isOmittedExpression(element)) {
- return checkESModuleMarker(element.name);
- }
- }
+ if (name.parent.kind === 172) {
+ return resolveEntityName(name, 1);
}
- return false;
+ return undefined;
}
- function checkGrammarNameInLetOrConstDeclarations(name) {
- if (name.kind === 75) {
- if (name.originalKeywordKind === 115) {
- return grammarErrorOnNode(name, ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations);
- }
- }
- else {
- var elements = name.elements;
- for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
- var element = elements_2[_i];
- if (!ts.isOmittedExpression(element)) {
- checkGrammarNameInLetOrConstDeclarations(element.name);
- }
- }
+ function getSymbolAtLocation(node, ignoreErrors) {
+ if (node.kind === 297) {
+ return ts.isExternalModule(node) ? getMergedSymbol(node.symbol) : undefined;
}
- return false;
- }
- function checkGrammarVariableDeclarationList(declarationList) {
- var declarations = declarationList.declarations;
- if (checkGrammarForDisallowedTrailingComma(declarationList.declarations)) {
- return true;
+ var parent = node.parent;
+ var grandParent = parent.parent;
+ if (node.flags & 16777216) {
+ return undefined;
}
- if (!declarationList.declarations.length) {
- return grammarErrorAtPos(declarationList, declarations.pos, declarations.end - declarations.pos, ts.Diagnostics.Variable_declaration_list_cannot_be_empty);
+ if (isDeclarationNameOrImportPropertyName(node)) {
+ var parentSymbol = getSymbolOfNode(parent);
+ return ts.isImportOrExportSpecifier(node.parent) && node.parent.propertyName === node
+ ? getImmediateAliasedSymbol(parentSymbol)
+ : parentSymbol;
}
- return false;
- }
- function allowLetAndConstDeclarations(parent) {
- switch (parent.kind) {
- case 227:
- case 228:
- case 229:
- case 236:
- case 230:
- case 231:
- case 232:
- return false;
- case 238:
- return allowLetAndConstDeclarations(parent.parent);
+ else if (ts.isLiteralComputedPropertyDeclarationName(node)) {
+ return getSymbolOfNode(parent.parent);
}
- return true;
- }
- function checkGrammarForDisallowedLetOrConstStatement(node) {
- if (!allowLetAndConstDeclarations(node.parent)) {
- if (ts.isLet(node.declarationList)) {
- return grammarErrorOnNode(node, ts.Diagnostics.let_declarations_can_only_be_declared_inside_a_block);
+ if (node.kind === 78) {
+ if (isInRightSideOfImportOrExportAssignment(node)) {
+ return getSymbolOfNameOrPropertyAccessExpression(node);
}
- else if (ts.isVarConst(node.declarationList)) {
- return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_can_only_be_declared_inside_a_block);
+ else if (parent.kind === 198 &&
+ grandParent.kind === 196 &&
+ node === parent.propertyName) {
+ var typeOfPattern = getTypeOfNode(grandParent);
+ var propertyDeclaration = getPropertyOfType(typeOfPattern, node.escapedText);
+ if (propertyDeclaration) {
+ return propertyDeclaration;
+ }
}
}
- }
- function checkGrammarMetaProperty(node) {
- var escapedText = node.name.escapedText;
- switch (node.keywordToken) {
- case 99:
- if (escapedText !== "target") {
- return grammarErrorOnNode(node.name, ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, ts.tokenToString(node.keywordToken), "target");
+ switch (node.kind) {
+ case 78:
+ case 79:
+ case 201:
+ case 157:
+ return getSymbolOfNameOrPropertyAccessExpression(node);
+ case 107:
+ var container = ts.getThisContainer(node, false);
+ if (ts.isFunctionLike(container)) {
+ var sig = getSignatureFromDeclaration(container);
+ if (sig.thisParameter) {
+ return sig.thisParameter;
+ }
}
- break;
- case 96:
- if (escapedText !== "meta") {
- return grammarErrorOnNode(node.name, ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, ts.tokenToString(node.keywordToken), "meta");
+ if (ts.isInExpressionContext(node)) {
+ return checkExpression(node).symbol;
}
- break;
+ case 187:
+ return getTypeFromThisTypeNode(node).symbol;
+ case 105:
+ return checkExpression(node).symbol;
+ case 132:
+ var constructorDeclaration = node.parent;
+ if (constructorDeclaration && constructorDeclaration.kind === 166) {
+ return constructorDeclaration.parent.symbol;
+ }
+ return undefined;
+ case 10:
+ case 14:
+ if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) ||
+ ((node.parent.kind === 261 || node.parent.kind === 267) && node.parent.moduleSpecifier === node) ||
+ ((ts.isInJSFile(node) && ts.isRequireCall(node.parent, false)) || ts.isImportCall(node.parent)) ||
+ (ts.isLiteralTypeNode(node.parent) && ts.isLiteralImportTypeNode(node.parent.parent) && node.parent.parent.argument === node.parent)) {
+ return resolveExternalModuleName(node, node, ignoreErrors);
+ }
+ if (ts.isCallExpression(parent) && ts.isBindableObjectDefinePropertyCall(parent) && parent.arguments[1] === node) {
+ return getSymbolOfNode(parent);
+ }
+ case 8:
+ var objectType = ts.isElementAccessExpression(parent)
+ ? parent.argumentExpression === node ? getTypeOfExpression(parent.expression) : undefined
+ : ts.isLiteralTypeNode(parent) && ts.isIndexedAccessTypeNode(grandParent)
+ ? getTypeFromTypeNode(grandParent.objectType)
+ : undefined;
+ return objectType && getPropertyOfType(objectType, ts.escapeLeadingUnderscores(node.text));
+ case 87:
+ case 97:
+ case 38:
+ case 83:
+ return getSymbolOfNode(node.parent);
+ case 195:
+ return ts.isLiteralImportTypeNode(node) ? getSymbolAtLocation(node.argument.literal, ignoreErrors) : undefined;
+ case 92:
+ return ts.isExportAssignment(node.parent) ? ts.Debug.checkDefined(node.parent.symbol) : undefined;
+ default:
+ return undefined;
}
}
- function hasParseDiagnostics(sourceFile) {
- return sourceFile.parseDiagnostics.length > 0;
- }
- function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
- var sourceFile = ts.getSourceFileOfNode(node);
- if (!hasParseDiagnostics(sourceFile)) {
- var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
- diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2));
- return true;
+ function getShorthandAssignmentValueSymbol(location) {
+ if (location && location.kind === 289) {
+ return resolveEntityName(location.name, 111551 | 2097152);
}
- return false;
+ return undefined;
}
- function grammarErrorAtPos(nodeForSourceFile, start, length, message, arg0, arg1, arg2) {
- var sourceFile = ts.getSourceFileOfNode(nodeForSourceFile);
- if (!hasParseDiagnostics(sourceFile)) {
- diagnostics.add(ts.createFileDiagnostic(sourceFile, start, length, message, arg0, arg1, arg2));
- return true;
+ function getExportSpecifierLocalTargetSymbol(node) {
+ if (ts.isExportSpecifier(node)) {
+ return node.parent.parent.moduleSpecifier ?
+ getExternalModuleMember(node.parent.parent, node) :
+ resolveEntityName(node.propertyName || node.name, 111551 | 788968 | 1920 | 2097152);
}
- return false;
- }
- function grammarErrorOnNode(node, message, arg0, arg1, arg2) {
- var sourceFile = ts.getSourceFileOfNode(node);
- if (!hasParseDiagnostics(sourceFile)) {
- diagnostics.add(ts.createDiagnosticForNode(node, message, arg0, arg1, arg2));
- return true;
+ else {
+ return resolveEntityName(node, 111551 | 788968 | 1920 | 2097152);
}
- return false;
}
- function checkGrammarConstructorTypeParameters(node) {
- var jsdocTypeParameters = ts.isInJSFile(node) ? ts.getJSDocTypeParameterDeclarations(node) : undefined;
- var range = node.typeParameters || jsdocTypeParameters && ts.firstOrUndefined(jsdocTypeParameters);
- if (range) {
- var pos = range.pos === range.end ? range.pos : ts.skipTrivia(ts.getSourceFileOfNode(node).text, range.pos);
- return grammarErrorAtPos(node, pos, range.end - pos, ts.Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);
+ function getTypeOfNode(node) {
+ if (ts.isSourceFile(node) && !ts.isExternalModule(node)) {
+ return errorType;
}
- }
- function checkGrammarConstructorTypeAnnotation(node) {
- var type = ts.getEffectiveReturnTypeNode(node);
- if (type) {
- return grammarErrorOnNode(type, ts.Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration);
+ if (node.flags & 16777216) {
+ return errorType;
}
- }
- function checkGrammarProperty(node) {
- if (ts.isClassLike(node.parent)) {
- if (ts.isStringLiteral(node.name) && node.name.text === "constructor") {
- return grammarErrorOnNode(node.name, ts.Diagnostics.Classes_may_not_have_a_field_named_constructor);
- }
- if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) {
- return true;
- }
- if (languageVersion < 2 && ts.isPrivateIdentifier(node.name)) {
- return grammarErrorOnNode(node.name, ts.Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
- }
+ var classDecl = ts.tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node);
+ var classType = classDecl && getDeclaredTypeOfClassOrInterface(getSymbolOfNode(classDecl.class));
+ if (ts.isPartOfTypeNode(node)) {
+ var typeFromTypeNode = getTypeFromTypeNode(node);
+ return classType ? getTypeWithThisArgument(typeFromTypeNode, classType.thisType) : typeFromTypeNode;
}
- else if (node.parent.kind === 246) {
- if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) {
- return true;
- }
- if (node.initializer) {
- return grammarErrorOnNode(node.initializer, ts.Diagnostics.An_interface_property_cannot_have_an_initializer);
- }
+ if (ts.isExpressionNode(node)) {
+ return getRegularTypeOfExpression(node);
}
- else if (node.parent.kind === 173) {
- if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) {
- return true;
- }
- if (node.initializer) {
- return grammarErrorOnNode(node.initializer, ts.Diagnostics.A_type_literal_property_cannot_have_an_initializer);
- }
+ if (classType && !classDecl.isImplements) {
+ var baseType = ts.firstOrUndefined(getBaseTypes(classType));
+ return baseType ? getTypeWithThisArgument(baseType, classType.thisType) : errorType;
}
- if (node.flags & 8388608) {
- checkAmbientInitializer(node);
+ if (isTypeDeclaration(node)) {
+ var symbol = getSymbolOfNode(node);
+ return getDeclaredTypeOfSymbol(symbol);
}
- if (ts.isPropertyDeclaration(node) && node.exclamationToken && (!ts.isClassLike(node.parent) || !node.type || node.initializer ||
- node.flags & 8388608 || ts.hasModifier(node, 32 | 128))) {
- return grammarErrorOnNode(node.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context);
+ if (isTypeDeclarationName(node)) {
+ var symbol = getSymbolAtLocation(node);
+ return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
}
- }
- function checkGrammarTopLevelElementForRequiredDeclareModifier(node) {
- if (node.kind === 246 ||
- node.kind === 247 ||
- node.kind === 254 ||
- node.kind === 253 ||
- node.kind === 260 ||
- node.kind === 259 ||
- node.kind === 252 ||
- ts.hasModifier(node, 2 | 1 | 512)) {
- return false;
+ if (ts.isDeclaration(node)) {
+ var symbol = getSymbolOfNode(node);
+ return getTypeOfSymbol(symbol);
}
- return grammarErrorOnFirstToken(node, ts.Diagnostics.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier);
- }
- function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) {
- for (var _i = 0, _a = file.statements; _i < _a.length; _i++) {
- var decl = _a[_i];
- if (ts.isDeclaration(decl) || decl.kind === 225) {
- if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) {
- return true;
- }
+ if (isDeclarationNameOrImportPropertyName(node)) {
+ var symbol = getSymbolAtLocation(node);
+ if (symbol) {
+ return getTypeOfSymbol(symbol);
}
+ return errorType;
}
- return false;
- }
- function checkGrammarSourceFile(node) {
- return !!(node.flags & 8388608) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node);
- }
- function checkGrammarStatementInAmbientContext(node) {
- if (node.flags & 8388608) {
- var links = getNodeLinks(node);
- if (!links.hasReportedStatementInAmbientContext && (ts.isFunctionLike(node.parent) || ts.isAccessor(node.parent))) {
- return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts);
- }
- if (node.parent.kind === 223 || node.parent.kind === 250 || node.parent.kind === 290) {
- var links_2 = getNodeLinks(node.parent);
- if (!links_2.hasReportedStatementInAmbientContext) {
- return links_2.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts);
- }
- }
- else {
- }
+ if (ts.isBindingPattern(node)) {
+ return getTypeForVariableLikeDeclaration(node.parent, true) || errorType;
}
- return false;
- }
- function checkGrammarNumericLiteral(node) {
- if (node.numericLiteralFlags & 32) {
- var diagnosticMessage = void 0;
- if (languageVersion >= 1) {
- diagnosticMessage = ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0;
- }
- else if (ts.isChildOfNodeWithKind(node, 187)) {
- diagnosticMessage = ts.Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0;
- }
- else if (ts.isChildOfNodeWithKind(node, 284)) {
- diagnosticMessage = ts.Diagnostics.Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0;
- }
- if (diagnosticMessage) {
- var withMinus = ts.isPrefixUnaryExpression(node.parent) && node.parent.operator === 40;
- var literal = (withMinus ? "-" : "") + "0o" + node.text;
- return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal);
+ if (isInRightSideOfImportOrExportAssignment(node)) {
+ var symbol = getSymbolAtLocation(node);
+ if (symbol) {
+ var declaredType = getDeclaredTypeOfSymbol(symbol);
+ return declaredType !== errorType ? declaredType : getTypeOfSymbol(symbol);
}
}
- checkNumericLiteralValueSize(node);
- return false;
+ return errorType;
}
- function checkNumericLiteralValueSize(node) {
- if (node.numericLiteralFlags & 16 || node.text.length <= 15 || node.text.indexOf(".") !== -1) {
- return;
+ function getTypeOfAssignmentPattern(expr) {
+ ts.Debug.assert(expr.kind === 200 || expr.kind === 199);
+ if (expr.parent.kind === 239) {
+ var iteratedType = checkRightHandSideOfForOf(expr.parent);
+ return checkDestructuringAssignment(expr, iteratedType || errorType);
}
- var apparentValue = +ts.getTextOfNode(node);
- if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) {
- return;
+ if (expr.parent.kind === 216) {
+ var iteratedType = getTypeOfExpression(expr.parent.right);
+ return checkDestructuringAssignment(expr, iteratedType || errorType);
}
- addErrorOrSuggestion(false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
+ if (expr.parent.kind === 288) {
+ var node_2 = ts.cast(expr.parent.parent, ts.isObjectLiteralExpression);
+ var typeOfParentObjectLiteral = getTypeOfAssignmentPattern(node_2) || errorType;
+ var propertyIndex = ts.indexOfNode(node_2.properties, expr.parent);
+ return checkObjectLiteralDestructuringPropertyAssignment(node_2, typeOfParentObjectLiteral, propertyIndex);
+ }
+ var node = ts.cast(expr.parent, ts.isArrayLiteralExpression);
+ var typeOfArrayLiteral = getTypeOfAssignmentPattern(node) || errorType;
+ var elementType = checkIteratedTypeOrElementType(65, typeOfArrayLiteral, undefinedType, expr.parent) || errorType;
+ return checkArrayLiteralDestructuringElementAssignment(node, typeOfArrayLiteral, node.elements.indexOf(expr), elementType);
}
- function checkGrammarBigIntLiteral(node) {
- var literalType = ts.isLiteralTypeNode(node.parent) ||
- ts.isPrefixUnaryExpression(node.parent) && ts.isLiteralTypeNode(node.parent.parent);
- if (!literalType) {
- if (languageVersion < 7) {
- if (grammarErrorOnNode(node, ts.Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020)) {
- return true;
- }
- }
+ function getPropertySymbolOfDestructuringAssignment(location) {
+ var typeOfObjectLiteral = getTypeOfAssignmentPattern(ts.cast(location.parent.parent, ts.isAssignmentPattern));
+ return typeOfObjectLiteral && getPropertyOfType(typeOfObjectLiteral, location.escapedText);
+ }
+ function getRegularTypeOfExpression(expr) {
+ if (ts.isRightSideOfQualifiedNameOrPropertyAccess(expr)) {
+ expr = expr.parent;
}
- return false;
+ return getRegularTypeOfLiteralType(getTypeOfExpression(expr));
}
- function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) {
- var sourceFile = ts.getSourceFileOfNode(node);
- if (!hasParseDiagnostics(sourceFile)) {
- var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
- diagnostics.add(ts.createFileDiagnostic(sourceFile, ts.textSpanEnd(span), 0, message, arg0, arg1, arg2));
- return true;
+ function getParentTypeOfClassElement(node) {
+ var classSymbol = getSymbolOfNode(node.parent);
+ return ts.hasSyntacticModifier(node, 32)
+ ? getTypeOfSymbol(classSymbol)
+ : getDeclaredTypeOfSymbol(classSymbol);
+ }
+ function getClassElementPropertyKeyType(element) {
+ var name = element.name;
+ switch (name.kind) {
+ case 78:
+ return getLiteralType(ts.idText(name));
+ case 8:
+ case 10:
+ return getLiteralType(name.text);
+ case 158:
+ var nameType = checkComputedPropertyName(name);
+ return isTypeAssignableToKind(nameType, 12288) ? nameType : stringType;
+ default:
+ return ts.Debug.fail("Unsupported property name.");
}
- return false;
}
- function getAmbientModules() {
- if (!ambientModulesCache) {
- ambientModulesCache = [];
- globals.forEach(function (global, sym) {
- if (ambientModuleSymbolRegex.test(sym)) {
- ambientModulesCache.push(global);
+ function getAugmentedPropertiesOfType(type) {
+ type = getApparentType(type);
+ var propsByName = ts.createSymbolTable(getPropertiesOfType(type));
+ var functionType = getSignaturesOfType(type, 0).length ? globalCallableFunctionType :
+ getSignaturesOfType(type, 1).length ? globalNewableFunctionType :
+ undefined;
+ if (functionType) {
+ ts.forEach(getPropertiesOfType(functionType), function (p) {
+ if (!propsByName.has(p.escapedName)) {
+ propsByName.set(p.escapedName, p);
}
});
}
- return ambientModulesCache;
+ return getNamedMembers(propsByName);
+ }
+ function typeHasCallOrConstructSignatures(type) {
+ return ts.typeHasCallOrConstructSignatures(type, checker);
+ }
+ function getRootSymbols(symbol) {
+ var roots = getImmediateRootSymbols(symbol);
+ return roots ? ts.flatMap(roots, getRootSymbols) : [symbol];
+ }
+ function getImmediateRootSymbols(symbol) {
+ if (ts.getCheckFlags(symbol) & 6) {
+ return ts.mapDefined(getSymbolLinks(symbol).containingType.types, function (type) { return getPropertyOfType(type, symbol.escapedName); });
+ }
+ else if (symbol.flags & 33554432) {
+ var _a = symbol, leftSpread = _a.leftSpread, rightSpread = _a.rightSpread, syntheticOrigin = _a.syntheticOrigin;
+ return leftSpread ? [leftSpread, rightSpread]
+ : syntheticOrigin ? [syntheticOrigin]
+ : ts.singleElementArray(tryGetAliasTarget(symbol));
+ }
+ return undefined;
}
- function checkGrammarImportClause(node) {
- if (node.isTypeOnly && node.name && node.namedBindings) {
- return grammarErrorOnNode(node, ts.Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both);
+ function tryGetAliasTarget(symbol) {
+ var target;
+ var next = symbol;
+ while (next = getSymbolLinks(next).target) {
+ target = next;
}
- return false;
+ return target;
}
- function checkGrammarImportCallExpression(node) {
- if (moduleKind === ts.ModuleKind.ES2015) {
- return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system_or_umd);
- }
- if (node.typeArguments) {
- return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
+ function isArgumentsLocalBinding(nodeIn) {
+ if (ts.isGeneratedIdentifier(nodeIn))
+ return false;
+ var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier);
+ if (!node)
+ return false;
+ var parent = node.parent;
+ if (!parent)
+ return false;
+ var isPropertyName = ((ts.isPropertyAccessExpression(parent)
+ || ts.isPropertyAssignment(parent))
+ && parent.name === node);
+ return !isPropertyName && getReferencedValueSymbol(node) === argumentsSymbol;
+ }
+ function moduleExportsSomeValue(moduleReferenceExpression) {
+ var moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression);
+ if (!moduleSymbol || ts.isShorthandAmbientModuleSymbol(moduleSymbol)) {
+ return true;
}
- var nodeArguments = node.arguments;
- if (nodeArguments.length !== 1) {
- return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_must_have_one_specifier_as_an_argument);
+ var hasExportAssignment = hasExportAssignmentSymbol(moduleSymbol);
+ moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
+ var symbolLinks = getSymbolLinks(moduleSymbol);
+ if (symbolLinks.exportsSomeValue === undefined) {
+ symbolLinks.exportsSomeValue = hasExportAssignment
+ ? !!(moduleSymbol.flags & 111551)
+ : ts.forEachEntry(getExportsOfModule(moduleSymbol), isValue);
}
- checkGrammarForDisallowedTrailingComma(nodeArguments);
- if (ts.isSpreadElement(nodeArguments[0])) {
- return grammarErrorOnNode(nodeArguments[0], ts.Diagnostics.Specifier_of_dynamic_import_cannot_be_spread_element);
+ return symbolLinks.exportsSomeValue;
+ function isValue(s) {
+ s = resolveSymbol(s);
+ return s && !!(s.flags & 111551);
}
- return false;
}
- function findMatchingTypeReferenceOrTypeAliasReference(source, unionTarget) {
- var sourceObjectFlags = ts.getObjectFlags(source);
- if (sourceObjectFlags & (4 | 16) && unionTarget.flags & 1048576) {
- return ts.find(unionTarget.types, function (target) {
- if (target.flags & 524288) {
- var overlapObjFlags = sourceObjectFlags & ts.getObjectFlags(target);
- if (overlapObjFlags & 4) {
- return source.target === target.target;
+ function isNameOfModuleOrEnumDeclaration(node) {
+ return ts.isModuleOrEnumDeclaration(node.parent) && node === node.parent.name;
+ }
+ function getReferencedExportContainer(nodeIn, prefixLocals) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier);
+ if (node) {
+ var symbol = getReferencedValueSymbol(node, isNameOfModuleOrEnumDeclaration(node));
+ if (symbol) {
+ if (symbol.flags & 1048576) {
+ var exportSymbol = getMergedSymbol(symbol.exportSymbol);
+ if (!prefixLocals && exportSymbol.flags & 944 && !(exportSymbol.flags & 3)) {
+ return undefined;
}
- if (overlapObjFlags & 16) {
- return !!source.aliasSymbol && source.aliasSymbol === target.aliasSymbol;
+ symbol = exportSymbol;
+ }
+ var parentSymbol_1 = getParentOfSymbol(symbol);
+ if (parentSymbol_1) {
+ if (parentSymbol_1.flags & 512 && parentSymbol_1.valueDeclaration.kind === 297) {
+ var symbolFile = parentSymbol_1.valueDeclaration;
+ var referenceFile = ts.getSourceFileOfNode(node);
+ var symbolIsUmdExport = symbolFile !== referenceFile;
+ return symbolIsUmdExport ? undefined : symbolFile;
}
+ return ts.findAncestor(node.parent, function (n) { return ts.isModuleOrEnumDeclaration(n) && getSymbolOfNode(n) === parentSymbol_1; });
}
- return false;
- });
+ }
}
}
- function findBestTypeForObjectLiteral(source, unionTarget) {
- if (ts.getObjectFlags(source) & 128 && forEachType(unionTarget, isArrayLikeType)) {
- return ts.find(unionTarget.types, function (t) { return !isArrayLikeType(t); });
+ function getReferencedImportDeclaration(nodeIn) {
+ if (nodeIn.generatedImportReference) {
+ return nodeIn.generatedImportReference;
}
- }
- function findBestTypeForInvokable(source, unionTarget) {
- var signatureKind = 0;
- var hasSignatures = getSignaturesOfType(source, signatureKind).length > 0 ||
- (signatureKind = 1, getSignaturesOfType(source, signatureKind).length > 0);
- if (hasSignatures) {
- return ts.find(unionTarget.types, function (t) { return getSignaturesOfType(t, signatureKind).length > 0; });
+ var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier);
+ if (node) {
+ var symbol = getReferencedValueSymbol(node);
+ if (isNonLocalAlias(symbol, 111551) && !getTypeOnlyAliasDeclaration(symbol)) {
+ return getDeclarationOfAliasSymbol(symbol);
+ }
}
+ return undefined;
}
- function findMostOverlappyType(source, unionTarget) {
- var bestMatch;
- var matchingCount = 0;
- for (var _i = 0, _a = unionTarget.types; _i < _a.length; _i++) {
- var target = _a[_i];
- var overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
- if (overlap.flags & 4194304) {
- bestMatch = target;
- matchingCount = Infinity;
- }
- else if (overlap.flags & 1048576) {
- var len = ts.length(ts.filter(overlap.types, isUnitType));
- if (len >= matchingCount) {
- bestMatch = target;
- matchingCount = len;
+ function isSymbolOfDestructuredElementOfCatchBinding(symbol) {
+ return ts.isBindingElement(symbol.valueDeclaration)
+ && ts.walkUpBindingElementsAndPatterns(symbol.valueDeclaration).parent.kind === 287;
+ }
+ function isSymbolOfDeclarationWithCollidingName(symbol) {
+ if (symbol.flags & 418 && !ts.isSourceFile(symbol.valueDeclaration)) {
+ var links = getSymbolLinks(symbol);
+ if (links.isDeclarationWithCollidingName === undefined) {
+ var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration);
+ if (ts.isStatementWithLocals(container) || isSymbolOfDestructuredElementOfCatchBinding(symbol)) {
+ var nodeLinks_1 = getNodeLinks(symbol.valueDeclaration);
+ if (resolveName(container.parent, symbol.escapedName, 111551, undefined, undefined, false)) {
+ links.isDeclarationWithCollidingName = true;
+ }
+ else if (nodeLinks_1.flags & 262144) {
+ var isDeclaredInLoop = nodeLinks_1.flags & 524288;
+ var inLoopInitializer = ts.isIterationStatement(container, false);
+ var inLoopBodyBlock = container.kind === 230 && ts.isIterationStatement(container.parent, false);
+ links.isDeclarationWithCollidingName = !ts.isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || (!inLoopInitializer && !inLoopBodyBlock));
+ }
+ else {
+ links.isDeclarationWithCollidingName = false;
+ }
}
}
- else if (isUnitType(overlap) && 1 >= matchingCount) {
- bestMatch = target;
- matchingCount = 1;
- }
+ return links.isDeclarationWithCollidingName;
}
- return bestMatch;
+ return false;
}
- function filterPrimitivesIfContainsNonPrimitive(type) {
- if (maybeTypeOfKind(type, 67108864)) {
- var result = filterType(type, function (t) { return !(t.flags & 131068); });
- if (!(result.flags & 131072)) {
- return result;
+ function getReferencedDeclarationWithCollidingName(nodeIn) {
+ if (!ts.isGeneratedIdentifier(nodeIn)) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier);
+ if (node) {
+ var symbol = getReferencedValueSymbol(node);
+ if (symbol && isSymbolOfDeclarationWithCollidingName(symbol)) {
+ return symbol.valueDeclaration;
+ }
}
}
- return type;
+ return undefined;
}
- function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) {
- if (target.flags & 1048576 && source.flags & (2097152 | 524288)) {
- var sourceProperties = getPropertiesOfType(source);
- if (sourceProperties) {
- var sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
- if (sourcePropertiesFiltered) {
- return discriminateTypeByDiscriminableItems(target, ts.map(sourcePropertiesFiltered, function (p) { return [function () { return getTypeOfSymbol(p); }, p.escapedName]; }), isRelatedTo, undefined, skipPartial);
- }
+ function isDeclarationWithCollidingName(nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isDeclaration);
+ if (node) {
+ var symbol = getSymbolOfNode(node);
+ if (symbol) {
+ return isSymbolOfDeclarationWithCollidingName(symbol);
}
}
- return undefined;
+ return false;
}
- }
- ts.createTypeChecker = createTypeChecker;
- function isNotAccessor(declaration) {
- return !ts.isAccessor(declaration);
- }
- function isNotOverload(declaration) {
- return (declaration.kind !== 244 && declaration.kind !== 161) ||
- !!declaration.body;
- }
- function isDeclarationNameOrImportPropertyName(name) {
- switch (name.parent.kind) {
- case 258:
- case 263:
- return ts.isIdentifier(name);
- default:
- return ts.isDeclarationName(name);
+ function isValueAliasDeclaration(node) {
+ switch (node.kind) {
+ case 260:
+ return isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol);
+ case 262:
+ case 263:
+ case 265:
+ case 270:
+ var symbol = getSymbolOfNode(node) || unknownSymbol;
+ return isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol);
+ case 267:
+ var exportClause = node.exportClause;
+ return !!exportClause && (ts.isNamespaceExport(exportClause) ||
+ ts.some(exportClause.elements, isValueAliasDeclaration));
+ case 266:
+ return node.expression && node.expression.kind === 78 ?
+ isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol) :
+ true;
+ }
+ return false;
}
- }
- function isSomeImportDeclaration(decl) {
- switch (decl.kind) {
- case 255:
- case 253:
- case 256:
- case 258:
- return true;
- case 75:
- return decl.parent.kind === 258;
- default:
+ function isTopLevelValueImportEqualsWithEntityName(nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isImportEqualsDeclaration);
+ if (node === undefined || node.parent.kind !== 297 || !ts.isInternalModuleImportEqualsDeclaration(node)) {
return false;
- }
- }
- var JsxNames;
- (function (JsxNames) {
- JsxNames.JSX = "JSX";
- JsxNames.IntrinsicElements = "IntrinsicElements";
- JsxNames.ElementClass = "ElementClass";
- JsxNames.ElementAttributesPropertyNameContainer = "ElementAttributesProperty";
- JsxNames.ElementChildrenAttributeNameContainer = "ElementChildrenAttribute";
- JsxNames.Element = "Element";
- JsxNames.IntrinsicAttributes = "IntrinsicAttributes";
- JsxNames.IntrinsicClassAttributes = "IntrinsicClassAttributes";
- JsxNames.LibraryManagedAttributes = "LibraryManagedAttributes";
- })(JsxNames || (JsxNames = {}));
- function getIterationTypesKeyFromIterationTypeKind(typeKind) {
- switch (typeKind) {
- case 0: return "yieldType";
- case 1: return "returnType";
- case 2: return "nextType";
- }
- }
- function signatureHasRestParameter(s) {
- return !!(s.flags & 1);
- }
- ts.signatureHasRestParameter = signatureHasRestParameter;
- function signatureHasLiteralTypes(s) {
- return !!(s.flags & 2);
- }
- ts.signatureHasLiteralTypes = signatureHasLiteralTypes;
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- function createSynthesizedNode(kind) {
- var node = ts.createNode(kind, -1, -1);
- node.flags |= 8;
- return node;
- }
- function updateNode(updated, original) {
- if (updated !== original) {
- setOriginalNode(updated, original);
- setTextRange(updated, original);
- ts.aggregateTransformFlags(updated);
- }
- return updated;
- }
- ts.updateNode = updateNode;
- function createNodeArray(elements, hasTrailingComma) {
- if (!elements || elements === ts.emptyArray) {
- elements = [];
- }
- else if (ts.isNodeArray(elements)) {
- return elements;
- }
- var array = elements;
- array.pos = -1;
- array.end = -1;
- array.hasTrailingComma = hasTrailingComma;
- return array;
- }
- ts.createNodeArray = createNodeArray;
- function getSynthesizedClone(node) {
- if (node === undefined) {
- return node;
- }
- var clone = createSynthesizedNode(node.kind);
- clone.flags |= node.flags;
- setOriginalNode(clone, node);
- for (var key in node) {
- if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {
- continue;
}
- clone[key] = node[key];
- }
- return clone;
- }
- ts.getSynthesizedClone = getSynthesizedClone;
- function createLiteral(value, isSingleQuote) {
- if (typeof value === "number") {
- return createNumericLiteral(value + "");
- }
- if (typeof value === "object" && "base10Value" in value) {
- return createBigIntLiteral(ts.pseudoBigIntToString(value) + "n");
- }
- if (typeof value === "boolean") {
- return value ? createTrue() : createFalse();
- }
- if (ts.isString(value)) {
- var res = createStringLiteral(value);
- if (isSingleQuote)
- res.singleQuote = true;
- return res;
- }
- return createLiteralFromNode(value);
- }
- ts.createLiteral = createLiteral;
- function createNumericLiteral(value, numericLiteralFlags) {
- if (numericLiteralFlags === void 0) { numericLiteralFlags = 0; }
- var node = createSynthesizedNode(8);
- node.text = value;
- node.numericLiteralFlags = numericLiteralFlags;
- return node;
- }
- ts.createNumericLiteral = createNumericLiteral;
- function createBigIntLiteral(value) {
- var node = createSynthesizedNode(9);
- node.text = value;
- return node;
- }
- ts.createBigIntLiteral = createBigIntLiteral;
- function createStringLiteral(text) {
- var node = createSynthesizedNode(10);
- node.text = text;
- return node;
- }
- ts.createStringLiteral = createStringLiteral;
- function createRegularExpressionLiteral(text) {
- var node = createSynthesizedNode(13);
- node.text = text;
- return node;
- }
- ts.createRegularExpressionLiteral = createRegularExpressionLiteral;
- function createLiteralFromNode(sourceNode) {
- var node = createStringLiteral(ts.getTextOfIdentifierOrLiteral(sourceNode));
- node.textSourceNode = sourceNode;
- return node;
- }
- function createIdentifier(text, typeArguments) {
- var node = createSynthesizedNode(75);
- node.escapedText = ts.escapeLeadingUnderscores(text);
- node.originalKeywordKind = text ? ts.stringToToken(text) : 0;
- node.autoGenerateFlags = 0;
- node.autoGenerateId = 0;
- if (typeArguments) {
- node.typeArguments = createNodeArray(typeArguments);
- }
- return node;
- }
- ts.createIdentifier = createIdentifier;
- function updateIdentifier(node, typeArguments) {
- return node.typeArguments !== typeArguments
- ? updateNode(createIdentifier(ts.idText(node), typeArguments), node)
- : node;
- }
- ts.updateIdentifier = updateIdentifier;
- var nextAutoGenerateId = 0;
- function createTempVariable(recordTempVariable, reservedInNestedScopes) {
- var name = createIdentifier("");
- name.autoGenerateFlags = 1;
- name.autoGenerateId = nextAutoGenerateId;
- nextAutoGenerateId++;
- if (recordTempVariable) {
- recordTempVariable(name);
- }
- if (reservedInNestedScopes) {
- name.autoGenerateFlags |= 8;
- }
- return name;
- }
- ts.createTempVariable = createTempVariable;
- function createLoopVariable() {
- var name = createIdentifier("");
- name.autoGenerateFlags = 2;
- name.autoGenerateId = nextAutoGenerateId;
- nextAutoGenerateId++;
- return name;
- }
- ts.createLoopVariable = createLoopVariable;
- function createUniqueName(text) {
- var name = createIdentifier(text);
- name.autoGenerateFlags = 3;
- name.autoGenerateId = nextAutoGenerateId;
- nextAutoGenerateId++;
- return name;
- }
- ts.createUniqueName = createUniqueName;
- function createOptimisticUniqueName(text) {
- var name = createIdentifier(text);
- name.autoGenerateFlags = 3 | 16;
- name.autoGenerateId = nextAutoGenerateId;
- nextAutoGenerateId++;
- return name;
- }
- ts.createOptimisticUniqueName = createOptimisticUniqueName;
- function createFileLevelUniqueName(text) {
- var name = createOptimisticUniqueName(text);
- name.autoGenerateFlags |= 32;
- return name;
- }
- ts.createFileLevelUniqueName = createFileLevelUniqueName;
- function getGeneratedNameForNode(node, flags) {
- var name = createIdentifier(node && ts.isIdentifier(node) ? ts.idText(node) : "");
- name.autoGenerateFlags = 4 | flags;
- name.autoGenerateId = nextAutoGenerateId;
- name.original = node;
- nextAutoGenerateId++;
- return name;
- }
- ts.getGeneratedNameForNode = getGeneratedNameForNode;
- function createPrivateIdentifier(text) {
- if (text[0] !== "#") {
- ts.Debug.fail("First character of private identifier must be #: " + text);
- }
- var node = createSynthesizedNode(76);
- node.escapedText = ts.escapeLeadingUnderscores(text);
- return node;
- }
- ts.createPrivateIdentifier = createPrivateIdentifier;
- function createToken(token) {
- return createSynthesizedNode(token);
- }
- ts.createToken = createToken;
- function createSuper() {
- return createSynthesizedNode(102);
- }
- ts.createSuper = createSuper;
- function createThis() {
- return createSynthesizedNode(104);
- }
- ts.createThis = createThis;
- function createNull() {
- return createSynthesizedNode(100);
- }
- ts.createNull = createNull;
- function createTrue() {
- return createSynthesizedNode(106);
- }
- ts.createTrue = createTrue;
- function createFalse() {
- return createSynthesizedNode(91);
- }
- ts.createFalse = createFalse;
- function createModifier(kind) {
- return createToken(kind);
- }
- ts.createModifier = createModifier;
- function createModifiersFromModifierFlags(flags) {
- var result = [];
- if (flags & 1) {
- result.push(createModifier(89));
- }
- if (flags & 2) {
- result.push(createModifier(130));
- }
- if (flags & 512) {
- result.push(createModifier(84));
- }
- if (flags & 2048) {
- result.push(createModifier(81));
- }
- if (flags & 4) {
- result.push(createModifier(119));
- }
- if (flags & 8) {
- result.push(createModifier(117));
- }
- if (flags & 16) {
- result.push(createModifier(118));
- }
- if (flags & 128) {
- result.push(createModifier(122));
- }
- if (flags & 32) {
- result.push(createModifier(120));
- }
- if (flags & 64) {
- result.push(createModifier(138));
- }
- if (flags & 256) {
- result.push(createModifier(126));
- }
- return result;
- }
- ts.createModifiersFromModifierFlags = createModifiersFromModifierFlags;
- function createQualifiedName(left, right) {
- var node = createSynthesizedNode(153);
- node.left = left;
- node.right = asName(right);
- return node;
- }
- ts.createQualifiedName = createQualifiedName;
- function updateQualifiedName(node, left, right) {
- return node.left !== left
- || node.right !== right
- ? updateNode(createQualifiedName(left, right), node)
- : node;
- }
- ts.updateQualifiedName = updateQualifiedName;
- function parenthesizeForComputedName(expression) {
- return ts.isCommaSequence(expression)
- ? createParen(expression)
- : expression;
- }
- function createComputedPropertyName(expression) {
- var node = createSynthesizedNode(154);
- node.expression = parenthesizeForComputedName(expression);
- return node;
- }
- ts.createComputedPropertyName = createComputedPropertyName;
- function updateComputedPropertyName(node, expression) {
- return node.expression !== expression
- ? updateNode(createComputedPropertyName(expression), node)
- : node;
- }
- ts.updateComputedPropertyName = updateComputedPropertyName;
- function createTypeParameterDeclaration(name, constraint, defaultType) {
- var node = createSynthesizedNode(155);
- node.name = asName(name);
- node.constraint = constraint;
- node.default = defaultType;
- return node;
- }
- ts.createTypeParameterDeclaration = createTypeParameterDeclaration;
- function updateTypeParameterDeclaration(node, name, constraint, defaultType) {
- return node.name !== name
- || node.constraint !== constraint
- || node.default !== defaultType
- ? updateNode(createTypeParameterDeclaration(name, constraint, defaultType), node)
- : node;
- }
- ts.updateTypeParameterDeclaration = updateTypeParameterDeclaration;
- function createParameter(decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) {
- var node = createSynthesizedNode(156);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.dotDotDotToken = dotDotDotToken;
- node.name = asName(name);
- node.questionToken = questionToken;
- node.type = type;
- node.initializer = initializer ? ts.parenthesizeExpressionForList(initializer) : undefined;
- return node;
- }
- ts.createParameter = createParameter;
- function updateParameter(node, decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.dotDotDotToken !== dotDotDotToken
- || node.name !== name
- || node.questionToken !== questionToken
- || node.type !== type
- || node.initializer !== initializer
- ? updateNode(createParameter(decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer), node)
- : node;
- }
- ts.updateParameter = updateParameter;
- function createDecorator(expression) {
- var node = createSynthesizedNode(157);
- node.expression = ts.parenthesizeForAccess(expression);
- return node;
- }
- ts.createDecorator = createDecorator;
- function updateDecorator(node, expression) {
- return node.expression !== expression
- ? updateNode(createDecorator(expression), node)
- : node;
- }
- ts.updateDecorator = updateDecorator;
- function createPropertySignature(modifiers, name, questionToken, type, initializer) {
- var node = createSynthesizedNode(158);
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.questionToken = questionToken;
- node.type = type;
- node.initializer = initializer;
- return node;
- }
- ts.createPropertySignature = createPropertySignature;
- function updatePropertySignature(node, modifiers, name, questionToken, type, initializer) {
- return node.modifiers !== modifiers
- || node.name !== name
- || node.questionToken !== questionToken
- || node.type !== type
- || node.initializer !== initializer
- ? updateNode(createPropertySignature(modifiers, name, questionToken, type, initializer), node)
- : node;
- }
- ts.updatePropertySignature = updatePropertySignature;
- function createProperty(decorators, modifiers, name, questionOrExclamationToken, type, initializer) {
- var node = createSynthesizedNode(159);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.questionToken = questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === 57 ? questionOrExclamationToken : undefined;
- node.exclamationToken = questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === 53 ? questionOrExclamationToken : undefined;
- node.type = type;
- node.initializer = initializer;
- return node;
- }
- ts.createProperty = createProperty;
- function updateProperty(node, decorators, modifiers, name, questionOrExclamationToken, type, initializer) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.name !== name
- || node.questionToken !== (questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === 57 ? questionOrExclamationToken : undefined)
- || node.exclamationToken !== (questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === 53 ? questionOrExclamationToken : undefined)
- || node.type !== type
- || node.initializer !== initializer
- ? updateNode(createProperty(decorators, modifiers, name, questionOrExclamationToken, type, initializer), node)
- : node;
- }
- ts.updateProperty = updateProperty;
- function createMethodSignature(typeParameters, parameters, type, name, questionToken) {
- var node = createSignatureDeclaration(160, typeParameters, parameters, type);
- node.name = asName(name);
- node.questionToken = questionToken;
- return node;
- }
- ts.createMethodSignature = createMethodSignature;
- function updateMethodSignature(node, typeParameters, parameters, type, name, questionToken) {
- return node.typeParameters !== typeParameters
- || node.parameters !== parameters
- || node.type !== type
- || node.name !== name
- || node.questionToken !== questionToken
- ? updateNode(createMethodSignature(typeParameters, parameters, type, name, questionToken), node)
- : node;
- }
- ts.updateMethodSignature = updateMethodSignature;
- function createMethod(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
- var node = createSynthesizedNode(161);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.asteriskToken = asteriskToken;
- node.name = asName(name);
- node.questionToken = questionToken;
- node.typeParameters = asNodeArray(typeParameters);
- node.parameters = createNodeArray(parameters);
- node.type = type;
- node.body = body;
- return node;
- }
- ts.createMethod = createMethod;
- function createMethodCall(object, methodName, argumentsList) {
- return createCall(createPropertyAccess(object, asName(methodName)), undefined, argumentsList);
- }
- function createGlobalMethodCall(globalObjectName, methodName, argumentsList) {
- return createMethodCall(createIdentifier(globalObjectName), methodName, argumentsList);
- }
- function createObjectDefinePropertyCall(target, propertyName, attributes) {
- return createGlobalMethodCall("Object", "defineProperty", [target, asExpression(propertyName), attributes]);
- }
- ts.createObjectDefinePropertyCall = createObjectDefinePropertyCall;
- function tryAddPropertyAssignment(properties, propertyName, expression) {
- if (expression) {
- properties.push(createPropertyAssignment(propertyName, expression));
- return true;
- }
- return false;
- }
- function createPropertyDescriptor(attributes, singleLine) {
- var properties = [];
- tryAddPropertyAssignment(properties, "enumerable", asExpression(attributes.enumerable));
- tryAddPropertyAssignment(properties, "configurable", asExpression(attributes.configurable));
- var isData = tryAddPropertyAssignment(properties, "writable", asExpression(attributes.writable));
- isData = tryAddPropertyAssignment(properties, "value", attributes.value) || isData;
- var isAccessor = tryAddPropertyAssignment(properties, "get", attributes.get);
- isAccessor = tryAddPropertyAssignment(properties, "set", attributes.set) || isAccessor;
- ts.Debug.assert(!(isData && isAccessor), "A PropertyDescriptor may not be both an accessor descriptor and a data descriptor.");
- return createObjectLiteral(properties, !singleLine);
- }
- ts.createPropertyDescriptor = createPropertyDescriptor;
- function updateMethod(node, decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.asteriskToken !== asteriskToken
- || node.name !== name
- || node.questionToken !== questionToken
- || node.typeParameters !== typeParameters
- || node.parameters !== parameters
- || node.type !== type
- || node.body !== body
- ? updateNode(createMethod(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body), node)
- : node;
- }
- ts.updateMethod = updateMethod;
- function createConstructor(decorators, modifiers, parameters, body) {
- var node = createSynthesizedNode(162);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.typeParameters = undefined;
- node.parameters = createNodeArray(parameters);
- node.type = undefined;
- node.body = body;
- return node;
- }
- ts.createConstructor = createConstructor;
- function updateConstructor(node, decorators, modifiers, parameters, body) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.parameters !== parameters
- || node.body !== body
- ? updateNode(createConstructor(decorators, modifiers, parameters, body), node)
- : node;
- }
- ts.updateConstructor = updateConstructor;
- function createGetAccessor(decorators, modifiers, name, parameters, type, body) {
- var node = createSynthesizedNode(163);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.typeParameters = undefined;
- node.parameters = createNodeArray(parameters);
- node.type = type;
- node.body = body;
- return node;
- }
- ts.createGetAccessor = createGetAccessor;
- function updateGetAccessor(node, decorators, modifiers, name, parameters, type, body) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.name !== name
- || node.parameters !== parameters
- || node.type !== type
- || node.body !== body
- ? updateNode(createGetAccessor(decorators, modifiers, name, parameters, type, body), node)
- : node;
- }
- ts.updateGetAccessor = updateGetAccessor;
- function createSetAccessor(decorators, modifiers, name, parameters, body) {
- var node = createSynthesizedNode(164);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.typeParameters = undefined;
- node.parameters = createNodeArray(parameters);
- node.body = body;
- return node;
- }
- ts.createSetAccessor = createSetAccessor;
- function updateSetAccessor(node, decorators, modifiers, name, parameters, body) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.name !== name
- || node.parameters !== parameters
- || node.body !== body
- ? updateNode(createSetAccessor(decorators, modifiers, name, parameters, body), node)
- : node;
- }
- ts.updateSetAccessor = updateSetAccessor;
- function createCallSignature(typeParameters, parameters, type) {
- return createSignatureDeclaration(165, typeParameters, parameters, type);
- }
- ts.createCallSignature = createCallSignature;
- function updateCallSignature(node, typeParameters, parameters, type) {
- return updateSignatureDeclaration(node, typeParameters, parameters, type);
- }
- ts.updateCallSignature = updateCallSignature;
- function createConstructSignature(typeParameters, parameters, type) {
- return createSignatureDeclaration(166, typeParameters, parameters, type);
- }
- ts.createConstructSignature = createConstructSignature;
- function updateConstructSignature(node, typeParameters, parameters, type) {
- return updateSignatureDeclaration(node, typeParameters, parameters, type);
- }
- ts.updateConstructSignature = updateConstructSignature;
- function createIndexSignature(decorators, modifiers, parameters, type) {
- var node = createSynthesizedNode(167);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.parameters = createNodeArray(parameters);
- node.type = type;
- return node;
- }
- ts.createIndexSignature = createIndexSignature;
- function updateIndexSignature(node, decorators, modifiers, parameters, type) {
- return node.parameters !== parameters
- || node.type !== type
- || node.decorators !== decorators
- || node.modifiers !== modifiers
- ? updateNode(createIndexSignature(decorators, modifiers, parameters, type), node)
- : node;
- }
- ts.updateIndexSignature = updateIndexSignature;
- function createSignatureDeclaration(kind, typeParameters, parameters, type, typeArguments) {
- var node = createSynthesizedNode(kind);
- node.typeParameters = asNodeArray(typeParameters);
- node.parameters = asNodeArray(parameters);
- node.type = type;
- node.typeArguments = asNodeArray(typeArguments);
- return node;
- }
- ts.createSignatureDeclaration = createSignatureDeclaration;
- function updateSignatureDeclaration(node, typeParameters, parameters, type) {
- return node.typeParameters !== typeParameters
- || node.parameters !== parameters
- || node.type !== type
- ? updateNode(createSignatureDeclaration(node.kind, typeParameters, parameters, type), node)
- : node;
- }
- function createKeywordTypeNode(kind) {
- return createSynthesizedNode(kind);
- }
- ts.createKeywordTypeNode = createKeywordTypeNode;
- function createTypePredicateNode(parameterName, type) {
- return createTypePredicateNodeWithModifier(undefined, parameterName, type);
- }
- ts.createTypePredicateNode = createTypePredicateNode;
- function createTypePredicateNodeWithModifier(assertsModifier, parameterName, type) {
- var node = createSynthesizedNode(168);
- node.assertsModifier = assertsModifier;
- node.parameterName = asName(parameterName);
- node.type = type;
- return node;
- }
- ts.createTypePredicateNodeWithModifier = createTypePredicateNodeWithModifier;
- function updateTypePredicateNode(node, parameterName, type) {
- return updateTypePredicateNodeWithModifier(node, node.assertsModifier, parameterName, type);
- }
- ts.updateTypePredicateNode = updateTypePredicateNode;
- function updateTypePredicateNodeWithModifier(node, assertsModifier, parameterName, type) {
- return node.assertsModifier !== assertsModifier
- || node.parameterName !== parameterName
- || node.type !== type
- ? updateNode(createTypePredicateNodeWithModifier(assertsModifier, parameterName, type), node)
- : node;
- }
- ts.updateTypePredicateNodeWithModifier = updateTypePredicateNodeWithModifier;
- function createTypeReferenceNode(typeName, typeArguments) {
- var node = createSynthesizedNode(169);
- node.typeName = asName(typeName);
- node.typeArguments = typeArguments && ts.parenthesizeTypeParameters(typeArguments);
- return node;
- }
- ts.createTypeReferenceNode = createTypeReferenceNode;
- function updateTypeReferenceNode(node, typeName, typeArguments) {
- return node.typeName !== typeName
- || node.typeArguments !== typeArguments
- ? updateNode(createTypeReferenceNode(typeName, typeArguments), node)
- : node;
- }
- ts.updateTypeReferenceNode = updateTypeReferenceNode;
- function createFunctionTypeNode(typeParameters, parameters, type) {
- return createSignatureDeclaration(170, typeParameters, parameters, type);
- }
- ts.createFunctionTypeNode = createFunctionTypeNode;
- function updateFunctionTypeNode(node, typeParameters, parameters, type) {
- return updateSignatureDeclaration(node, typeParameters, parameters, type);
- }
- ts.updateFunctionTypeNode = updateFunctionTypeNode;
- function createConstructorTypeNode(typeParameters, parameters, type) {
- return createSignatureDeclaration(171, typeParameters, parameters, type);
- }
- ts.createConstructorTypeNode = createConstructorTypeNode;
- function updateConstructorTypeNode(node, typeParameters, parameters, type) {
- return updateSignatureDeclaration(node, typeParameters, parameters, type);
- }
- ts.updateConstructorTypeNode = updateConstructorTypeNode;
- function createTypeQueryNode(exprName) {
- var node = createSynthesizedNode(172);
- node.exprName = exprName;
- return node;
- }
- ts.createTypeQueryNode = createTypeQueryNode;
- function updateTypeQueryNode(node, exprName) {
- return node.exprName !== exprName
- ? updateNode(createTypeQueryNode(exprName), node)
- : node;
- }
- ts.updateTypeQueryNode = updateTypeQueryNode;
- function createTypeLiteralNode(members) {
- var node = createSynthesizedNode(173);
- node.members = createNodeArray(members);
- return node;
- }
- ts.createTypeLiteralNode = createTypeLiteralNode;
- function updateTypeLiteralNode(node, members) {
- return node.members !== members
- ? updateNode(createTypeLiteralNode(members), node)
- : node;
- }
- ts.updateTypeLiteralNode = updateTypeLiteralNode;
- function createArrayTypeNode(elementType) {
- var node = createSynthesizedNode(174);
- node.elementType = ts.parenthesizeArrayTypeMember(elementType);
- return node;
- }
- ts.createArrayTypeNode = createArrayTypeNode;
- function updateArrayTypeNode(node, elementType) {
- return node.elementType !== elementType
- ? updateNode(createArrayTypeNode(elementType), node)
- : node;
- }
- ts.updateArrayTypeNode = updateArrayTypeNode;
- function createTupleTypeNode(elementTypes) {
- var node = createSynthesizedNode(175);
- node.elementTypes = createNodeArray(elementTypes);
- return node;
- }
- ts.createTupleTypeNode = createTupleTypeNode;
- function updateTupleTypeNode(node, elementTypes) {
- return node.elementTypes !== elementTypes
- ? updateNode(createTupleTypeNode(elementTypes), node)
- : node;
- }
- ts.updateTupleTypeNode = updateTupleTypeNode;
- function createOptionalTypeNode(type) {
- var node = createSynthesizedNode(176);
- node.type = ts.parenthesizeArrayTypeMember(type);
- return node;
- }
- ts.createOptionalTypeNode = createOptionalTypeNode;
- function updateOptionalTypeNode(node, type) {
- return node.type !== type
- ? updateNode(createOptionalTypeNode(type), node)
- : node;
- }
- ts.updateOptionalTypeNode = updateOptionalTypeNode;
- function createRestTypeNode(type) {
- var node = createSynthesizedNode(177);
- node.type = type;
- return node;
- }
- ts.createRestTypeNode = createRestTypeNode;
- function updateRestTypeNode(node, type) {
- return node.type !== type
- ? updateNode(createRestTypeNode(type), node)
- : node;
- }
- ts.updateRestTypeNode = updateRestTypeNode;
- function createUnionTypeNode(types) {
- return createUnionOrIntersectionTypeNode(178, types);
- }
- ts.createUnionTypeNode = createUnionTypeNode;
- function updateUnionTypeNode(node, types) {
- return updateUnionOrIntersectionTypeNode(node, types);
- }
- ts.updateUnionTypeNode = updateUnionTypeNode;
- function createIntersectionTypeNode(types) {
- return createUnionOrIntersectionTypeNode(179, types);
- }
- ts.createIntersectionTypeNode = createIntersectionTypeNode;
- function updateIntersectionTypeNode(node, types) {
- return updateUnionOrIntersectionTypeNode(node, types);
- }
- ts.updateIntersectionTypeNode = updateIntersectionTypeNode;
- function createUnionOrIntersectionTypeNode(kind, types) {
- var node = createSynthesizedNode(kind);
- node.types = ts.parenthesizeElementTypeMembers(types);
- return node;
- }
- ts.createUnionOrIntersectionTypeNode = createUnionOrIntersectionTypeNode;
- function updateUnionOrIntersectionTypeNode(node, types) {
- return node.types !== types
- ? updateNode(createUnionOrIntersectionTypeNode(node.kind, types), node)
- : node;
- }
- function createConditionalTypeNode(checkType, extendsType, trueType, falseType) {
- var node = createSynthesizedNode(180);
- node.checkType = ts.parenthesizeConditionalTypeMember(checkType);
- node.extendsType = ts.parenthesizeConditionalTypeMember(extendsType);
- node.trueType = trueType;
- node.falseType = falseType;
- return node;
- }
- ts.createConditionalTypeNode = createConditionalTypeNode;
- function updateConditionalTypeNode(node, checkType, extendsType, trueType, falseType) {
- return node.checkType !== checkType
- || node.extendsType !== extendsType
- || node.trueType !== trueType
- || node.falseType !== falseType
- ? updateNode(createConditionalTypeNode(checkType, extendsType, trueType, falseType), node)
- : node;
- }
- ts.updateConditionalTypeNode = updateConditionalTypeNode;
- function createInferTypeNode(typeParameter) {
- var node = createSynthesizedNode(181);
- node.typeParameter = typeParameter;
- return node;
- }
- ts.createInferTypeNode = createInferTypeNode;
- function updateInferTypeNode(node, typeParameter) {
- return node.typeParameter !== typeParameter
- ? updateNode(createInferTypeNode(typeParameter), node)
- : node;
- }
- ts.updateInferTypeNode = updateInferTypeNode;
- function createImportTypeNode(argument, qualifier, typeArguments, isTypeOf) {
- var node = createSynthesizedNode(188);
- node.argument = argument;
- node.qualifier = qualifier;
- node.typeArguments = ts.parenthesizeTypeParameters(typeArguments);
- node.isTypeOf = isTypeOf;
- return node;
- }
- ts.createImportTypeNode = createImportTypeNode;
- function updateImportTypeNode(node, argument, qualifier, typeArguments, isTypeOf) {
- return node.argument !== argument
- || node.qualifier !== qualifier
- || node.typeArguments !== typeArguments
- || node.isTypeOf !== isTypeOf
- ? updateNode(createImportTypeNode(argument, qualifier, typeArguments, isTypeOf), node)
- : node;
- }
- ts.updateImportTypeNode = updateImportTypeNode;
- function createParenthesizedType(type) {
- var node = createSynthesizedNode(182);
- node.type = type;
- return node;
- }
- ts.createParenthesizedType = createParenthesizedType;
- function updateParenthesizedType(node, type) {
- return node.type !== type
- ? updateNode(createParenthesizedType(type), node)
- : node;
- }
- ts.updateParenthesizedType = updateParenthesizedType;
- function createThisTypeNode() {
- return createSynthesizedNode(183);
- }
- ts.createThisTypeNode = createThisTypeNode;
- function createTypeOperatorNode(operatorOrType, type) {
- var node = createSynthesizedNode(184);
- node.operator = typeof operatorOrType === "number" ? operatorOrType : 134;
- node.type = ts.parenthesizeElementTypeMember(typeof operatorOrType === "number" ? type : operatorOrType);
- return node;
- }
- ts.createTypeOperatorNode = createTypeOperatorNode;
- function updateTypeOperatorNode(node, type) {
- return node.type !== type ? updateNode(createTypeOperatorNode(node.operator, type), node) : node;
- }
- ts.updateTypeOperatorNode = updateTypeOperatorNode;
- function createIndexedAccessTypeNode(objectType, indexType) {
- var node = createSynthesizedNode(185);
- node.objectType = ts.parenthesizeElementTypeMember(objectType);
- node.indexType = indexType;
- return node;
- }
- ts.createIndexedAccessTypeNode = createIndexedAccessTypeNode;
- function updateIndexedAccessTypeNode(node, objectType, indexType) {
- return node.objectType !== objectType
- || node.indexType !== indexType
- ? updateNode(createIndexedAccessTypeNode(objectType, indexType), node)
- : node;
- }
- ts.updateIndexedAccessTypeNode = updateIndexedAccessTypeNode;
- function createMappedTypeNode(readonlyToken, typeParameter, questionToken, type) {
- var node = createSynthesizedNode(186);
- node.readonlyToken = readonlyToken;
- node.typeParameter = typeParameter;
- node.questionToken = questionToken;
- node.type = type;
- return node;
- }
- ts.createMappedTypeNode = createMappedTypeNode;
- function updateMappedTypeNode(node, readonlyToken, typeParameter, questionToken, type) {
- return node.readonlyToken !== readonlyToken
- || node.typeParameter !== typeParameter
- || node.questionToken !== questionToken
- || node.type !== type
- ? updateNode(createMappedTypeNode(readonlyToken, typeParameter, questionToken, type), node)
- : node;
- }
- ts.updateMappedTypeNode = updateMappedTypeNode;
- function createLiteralTypeNode(literal) {
- var node = createSynthesizedNode(187);
- node.literal = literal;
- return node;
- }
- ts.createLiteralTypeNode = createLiteralTypeNode;
- function updateLiteralTypeNode(node, literal) {
- return node.literal !== literal
- ? updateNode(createLiteralTypeNode(literal), node)
- : node;
- }
- ts.updateLiteralTypeNode = updateLiteralTypeNode;
- function createObjectBindingPattern(elements) {
- var node = createSynthesizedNode(189);
- node.elements = createNodeArray(elements);
- return node;
- }
- ts.createObjectBindingPattern = createObjectBindingPattern;
- function updateObjectBindingPattern(node, elements) {
- return node.elements !== elements
- ? updateNode(createObjectBindingPattern(elements), node)
- : node;
- }
- ts.updateObjectBindingPattern = updateObjectBindingPattern;
- function createArrayBindingPattern(elements) {
- var node = createSynthesizedNode(190);
- node.elements = createNodeArray(elements);
- return node;
- }
- ts.createArrayBindingPattern = createArrayBindingPattern;
- function updateArrayBindingPattern(node, elements) {
- return node.elements !== elements
- ? updateNode(createArrayBindingPattern(elements), node)
- : node;
- }
- ts.updateArrayBindingPattern = updateArrayBindingPattern;
- function createBindingElement(dotDotDotToken, propertyName, name, initializer) {
- var node = createSynthesizedNode(191);
- node.dotDotDotToken = dotDotDotToken;
- node.propertyName = asName(propertyName);
- node.name = asName(name);
- node.initializer = initializer;
- return node;
- }
- ts.createBindingElement = createBindingElement;
- function updateBindingElement(node, dotDotDotToken, propertyName, name, initializer) {
- return node.propertyName !== propertyName
- || node.dotDotDotToken !== dotDotDotToken
- || node.name !== name
- || node.initializer !== initializer
- ? updateNode(createBindingElement(dotDotDotToken, propertyName, name, initializer), node)
- : node;
- }
- ts.updateBindingElement = updateBindingElement;
- function createArrayLiteral(elements, multiLine) {
- var node = createSynthesizedNode(192);
- node.elements = ts.parenthesizeListElements(createNodeArray(elements));
- if (multiLine)
- node.multiLine = true;
- return node;
- }
- ts.createArrayLiteral = createArrayLiteral;
- function updateArrayLiteral(node, elements) {
- return node.elements !== elements
- ? updateNode(createArrayLiteral(elements, node.multiLine), node)
- : node;
- }
- ts.updateArrayLiteral = updateArrayLiteral;
- function createObjectLiteral(properties, multiLine) {
- var node = createSynthesizedNode(193);
- node.properties = createNodeArray(properties);
- if (multiLine)
- node.multiLine = true;
- return node;
- }
- ts.createObjectLiteral = createObjectLiteral;
- function updateObjectLiteral(node, properties) {
- return node.properties !== properties
- ? updateNode(createObjectLiteral(properties, node.multiLine), node)
- : node;
- }
- ts.updateObjectLiteral = updateObjectLiteral;
- function createPropertyAccess(expression, name) {
- var node = createSynthesizedNode(194);
- node.expression = ts.parenthesizeForAccess(expression);
- node.name = asName(name);
- setEmitFlags(node, 131072);
- return node;
- }
- ts.createPropertyAccess = createPropertyAccess;
- function updatePropertyAccess(node, expression, name) {
- if (ts.isPropertyAccessChain(node)) {
- return updatePropertyAccessChain(node, expression, node.questionDotToken, ts.cast(name, ts.isIdentifier));
+ var isValue = isAliasResolvedToValue(getSymbolOfNode(node));
+ return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference);
}
- return node.expression !== expression
- || node.name !== name
- ? updateNode(setEmitFlags(createPropertyAccess(expression, name), ts.getEmitFlags(node)), node)
- : node;
- }
- ts.updatePropertyAccess = updatePropertyAccess;
- function createPropertyAccessChain(expression, questionDotToken, name) {
- var node = createSynthesizedNode(194);
- node.flags |= 32;
- node.expression = ts.parenthesizeForAccess(expression);
- node.questionDotToken = questionDotToken;
- node.name = asName(name);
- setEmitFlags(node, 131072);
- return node;
- }
- ts.createPropertyAccessChain = createPropertyAccessChain;
- function updatePropertyAccessChain(node, expression, questionDotToken, name) {
- ts.Debug.assert(!!(node.flags & 32), "Cannot update a PropertyAccessExpression using updatePropertyAccessChain. Use updatePropertyAccess instead.");
- return node.expression !== expression
- || node.questionDotToken !== questionDotToken
- || node.name !== name
- ? updateNode(setEmitFlags(createPropertyAccessChain(expression, questionDotToken, name), ts.getEmitFlags(node)), node)
- : node;
- }
- ts.updatePropertyAccessChain = updatePropertyAccessChain;
- function createElementAccess(expression, index) {
- var node = createSynthesizedNode(195);
- node.expression = ts.parenthesizeForAccess(expression);
- node.argumentExpression = asExpression(index);
- return node;
- }
- ts.createElementAccess = createElementAccess;
- function updateElementAccess(node, expression, argumentExpression) {
- if (ts.isOptionalChain(node)) {
- return updateElementAccessChain(node, expression, node.questionDotToken, argumentExpression);
+ function isAliasResolvedToValue(symbol) {
+ var target = resolveAlias(symbol);
+ if (target === unknownSymbol) {
+ return true;
+ }
+ return !!(target.flags & 111551) &&
+ (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target));
}
- return node.expression !== expression
- || node.argumentExpression !== argumentExpression
- ? updateNode(createElementAccess(expression, argumentExpression), node)
- : node;
- }
- ts.updateElementAccess = updateElementAccess;
- function createElementAccessChain(expression, questionDotToken, index) {
- var node = createSynthesizedNode(195);
- node.flags |= 32;
- node.expression = ts.parenthesizeForAccess(expression);
- node.questionDotToken = questionDotToken;
- node.argumentExpression = asExpression(index);
- return node;
- }
- ts.createElementAccessChain = createElementAccessChain;
- function updateElementAccessChain(node, expression, questionDotToken, argumentExpression) {
- ts.Debug.assert(!!(node.flags & 32), "Cannot update an ElementAccessExpression using updateElementAccessChain. Use updateElementAccess instead.");
- return node.expression !== expression
- || node.questionDotToken !== questionDotToken
- || node.argumentExpression !== argumentExpression
- ? updateNode(createElementAccessChain(expression, questionDotToken, argumentExpression), node)
- : node;
- }
- ts.updateElementAccessChain = updateElementAccessChain;
- function createCall(expression, typeArguments, argumentsArray) {
- var node = createSynthesizedNode(196);
- node.expression = ts.parenthesizeForAccess(expression);
- node.typeArguments = asNodeArray(typeArguments);
- node.arguments = ts.parenthesizeListElements(createNodeArray(argumentsArray));
- return node;
- }
- ts.createCall = createCall;
- function updateCall(node, expression, typeArguments, argumentsArray) {
- if (ts.isOptionalChain(node)) {
- return updateCallChain(node, expression, node.questionDotToken, typeArguments, argumentsArray);
+ function isConstEnumOrConstEnumOnlyModule(s) {
+ return isConstEnumSymbol(s) || !!s.constEnumOnlyModule;
}
- return node.expression !== expression
- || node.typeArguments !== typeArguments
- || node.arguments !== argumentsArray
- ? updateNode(createCall(expression, typeArguments, argumentsArray), node)
- : node;
- }
- ts.updateCall = updateCall;
- function createCallChain(expression, questionDotToken, typeArguments, argumentsArray) {
- var node = createSynthesizedNode(196);
- node.flags |= 32;
- node.expression = ts.parenthesizeForAccess(expression);
- node.questionDotToken = questionDotToken;
- node.typeArguments = asNodeArray(typeArguments);
- node.arguments = ts.parenthesizeListElements(createNodeArray(argumentsArray));
- return node;
- }
- ts.createCallChain = createCallChain;
- function updateCallChain(node, expression, questionDotToken, typeArguments, argumentsArray) {
- ts.Debug.assert(!!(node.flags & 32), "Cannot update a CallExpression using updateCallChain. Use updateCall instead.");
- return node.expression !== expression
- || node.questionDotToken !== questionDotToken
- || node.typeArguments !== typeArguments
- || node.arguments !== argumentsArray
- ? updateNode(createCallChain(expression, questionDotToken, typeArguments, argumentsArray), node)
- : node;
- }
- ts.updateCallChain = updateCallChain;
- function createNew(expression, typeArguments, argumentsArray) {
- var node = createSynthesizedNode(197);
- node.expression = ts.parenthesizeForNew(expression);
- node.typeArguments = asNodeArray(typeArguments);
- node.arguments = argumentsArray ? ts.parenthesizeListElements(createNodeArray(argumentsArray)) : undefined;
- return node;
- }
- ts.createNew = createNew;
- function updateNew(node, expression, typeArguments, argumentsArray) {
- return node.expression !== expression
- || node.typeArguments !== typeArguments
- || node.arguments !== argumentsArray
- ? updateNode(createNew(expression, typeArguments, argumentsArray), node)
- : node;
- }
- ts.updateNew = updateNew;
- function createTaggedTemplate(tag, typeArgumentsOrTemplate, template) {
- var node = createSynthesizedNode(198);
- node.tag = ts.parenthesizeForAccess(tag);
- if (template) {
- node.typeArguments = asNodeArray(typeArgumentsOrTemplate);
- node.template = template;
+ function isReferencedAliasDeclaration(node, checkChildren) {
+ if (isAliasSymbolDeclaration(node)) {
+ var symbol = getSymbolOfNode(node);
+ if (symbol && getSymbolLinks(symbol).referenced) {
+ return true;
+ }
+ var target = getSymbolLinks(symbol).target;
+ if (target && ts.getEffectiveModifierFlags(node) & 1 &&
+ target.flags & 111551 &&
+ (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target))) {
+ return true;
+ }
+ }
+ if (checkChildren) {
+ return !!ts.forEachChild(node, function (node) { return isReferencedAliasDeclaration(node, checkChildren); });
+ }
+ return false;
}
- else {
- node.typeArguments = undefined;
- node.template = typeArgumentsOrTemplate;
+ function isImplementationOfOverload(node) {
+ if (ts.nodeIsPresent(node.body)) {
+ if (ts.isGetAccessor(node) || ts.isSetAccessor(node))
+ return false;
+ var symbol = getSymbolOfNode(node);
+ var signaturesOfSymbol = getSignaturesOfSymbol(symbol);
+ return signaturesOfSymbol.length > 1 ||
+ (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node);
+ }
+ return false;
}
- return node;
- }
- ts.createTaggedTemplate = createTaggedTemplate;
- function updateTaggedTemplate(node, tag, typeArgumentsOrTemplate, template) {
- return node.tag !== tag
- || (template
- ? node.typeArguments !== typeArgumentsOrTemplate || node.template !== template
- : node.typeArguments !== undefined || node.template !== typeArgumentsOrTemplate)
- ? updateNode(createTaggedTemplate(tag, typeArgumentsOrTemplate, template), node)
- : node;
- }
- ts.updateTaggedTemplate = updateTaggedTemplate;
- function createTypeAssertion(type, expression) {
- var node = createSynthesizedNode(199);
- node.type = type;
- node.expression = ts.parenthesizePrefixOperand(expression);
- return node;
- }
- ts.createTypeAssertion = createTypeAssertion;
- function updateTypeAssertion(node, type, expression) {
- return node.type !== type
- || node.expression !== expression
- ? updateNode(createTypeAssertion(type, expression), node)
- : node;
- }
- ts.updateTypeAssertion = updateTypeAssertion;
- function createParen(expression) {
- var node = createSynthesizedNode(200);
- node.expression = expression;
- return node;
- }
- ts.createParen = createParen;
- function updateParen(node, expression) {
- return node.expression !== expression
- ? updateNode(createParen(expression), node)
- : node;
- }
- ts.updateParen = updateParen;
- function createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
- var node = createSynthesizedNode(201);
- node.modifiers = asNodeArray(modifiers);
- node.asteriskToken = asteriskToken;
- node.name = asName(name);
- node.typeParameters = asNodeArray(typeParameters);
- node.parameters = createNodeArray(parameters);
- node.type = type;
- node.body = body;
- return node;
- }
- ts.createFunctionExpression = createFunctionExpression;
- 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
- ? updateNode(createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body), node)
- : node;
- }
- ts.updateFunctionExpression = updateFunctionExpression;
- function createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) {
- var node = createSynthesizedNode(202);
- node.modifiers = asNodeArray(modifiers);
- node.typeParameters = asNodeArray(typeParameters);
- node.parameters = createNodeArray(parameters);
- node.type = type;
- node.equalsGreaterThanToken = equalsGreaterThanToken || createToken(38);
- node.body = ts.parenthesizeConciseBody(body);
- return node;
- }
- ts.createArrowFunction = createArrowFunction;
- 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
- ? updateNode(createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body), node)
- : node;
- }
- ts.updateArrowFunction = updateArrowFunction;
- function createDelete(expression) {
- var node = createSynthesizedNode(203);
- node.expression = ts.parenthesizePrefixOperand(expression);
- return node;
- }
- ts.createDelete = createDelete;
- function updateDelete(node, expression) {
- return node.expression !== expression
- ? updateNode(createDelete(expression), node)
- : node;
- }
- ts.updateDelete = updateDelete;
- function createTypeOf(expression) {
- var node = createSynthesizedNode(204);
- node.expression = ts.parenthesizePrefixOperand(expression);
- return node;
- }
- ts.createTypeOf = createTypeOf;
- function updateTypeOf(node, expression) {
- return node.expression !== expression
- ? updateNode(createTypeOf(expression), node)
- : node;
- }
- ts.updateTypeOf = updateTypeOf;
- function createVoid(expression) {
- var node = createSynthesizedNode(205);
- node.expression = ts.parenthesizePrefixOperand(expression);
- return node;
- }
- ts.createVoid = createVoid;
- function updateVoid(node, expression) {
- return node.expression !== expression
- ? updateNode(createVoid(expression), node)
- : node;
- }
- ts.updateVoid = updateVoid;
- function createAwait(expression) {
- var node = createSynthesizedNode(206);
- node.expression = ts.parenthesizePrefixOperand(expression);
- return node;
- }
- ts.createAwait = createAwait;
- function updateAwait(node, expression) {
- return node.expression !== expression
- ? updateNode(createAwait(expression), node)
- : node;
- }
- ts.updateAwait = updateAwait;
- function createPrefix(operator, operand) {
- var node = createSynthesizedNode(207);
- node.operator = operator;
- node.operand = ts.parenthesizePrefixOperand(operand);
- return node;
- }
- ts.createPrefix = createPrefix;
- function updatePrefix(node, operand) {
- return node.operand !== operand
- ? updateNode(createPrefix(node.operator, operand), node)
- : node;
- }
- ts.updatePrefix = updatePrefix;
- function createPostfix(operand, operator) {
- var node = createSynthesizedNode(208);
- node.operand = ts.parenthesizePostfixOperand(operand);
- node.operator = operator;
- return node;
- }
- ts.createPostfix = createPostfix;
- function updatePostfix(node, operand) {
- return node.operand !== operand
- ? updateNode(createPostfix(operand, node.operator), node)
- : node;
- }
- ts.updatePostfix = updatePostfix;
- function createBinary(left, operator, right) {
- var node = createSynthesizedNode(209);
- var operatorToken = asToken(operator);
- var operatorKind = operatorToken.kind;
- node.left = ts.parenthesizeBinaryOperand(operatorKind, left, true, undefined);
- node.operatorToken = operatorToken;
- node.right = ts.parenthesizeBinaryOperand(operatorKind, right, false, node.left);
- return node;
- }
- ts.createBinary = createBinary;
- function updateBinary(node, left, right, operator) {
- return node.left !== left
- || node.right !== right
- ? updateNode(createBinary(left, operator || node.operatorToken, right), node)
- : node;
- }
- ts.updateBinary = updateBinary;
- function createConditional(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) {
- var node = createSynthesizedNode(210);
- node.condition = ts.parenthesizeForConditionalHead(condition);
- node.questionToken = whenFalse ? questionTokenOrWhenTrue : createToken(57);
- node.whenTrue = ts.parenthesizeSubexpressionOfConditionalExpression(whenFalse ? whenTrueOrWhenFalse : questionTokenOrWhenTrue);
- node.colonToken = whenFalse ? colonToken : createToken(58);
- node.whenFalse = ts.parenthesizeSubexpressionOfConditionalExpression(whenFalse ? whenFalse : whenTrueOrWhenFalse);
- return node;
- }
- ts.createConditional = createConditional;
- function updateConditional(node, condition, questionToken, whenTrue, colonToken, whenFalse) {
- return node.condition !== condition
- || node.questionToken !== questionToken
- || node.whenTrue !== whenTrue
- || node.colonToken !== colonToken
- || node.whenFalse !== whenFalse
- ? updateNode(createConditional(condition, questionToken, whenTrue, colonToken, whenFalse), node)
- : node;
- }
- ts.updateConditional = updateConditional;
- function createTemplateExpression(head, templateSpans) {
- var node = createSynthesizedNode(211);
- node.head = head;
- node.templateSpans = createNodeArray(templateSpans);
- return node;
- }
- ts.createTemplateExpression = createTemplateExpression;
- function updateTemplateExpression(node, head, templateSpans) {
- return node.head !== head
- || node.templateSpans !== templateSpans
- ? updateNode(createTemplateExpression(head, templateSpans), node)
- : node;
- }
- ts.updateTemplateExpression = updateTemplateExpression;
- var rawTextScanner;
- var invalidValueSentinel = {};
- function getCookedText(kind, rawText) {
- if (!rawTextScanner) {
- rawTextScanner = ts.createScanner(99, false, 0);
+ function isRequiredInitializedParameter(parameter) {
+ return !!strictNullChecks &&
+ !isOptionalParameter(parameter) &&
+ !ts.isJSDocParameterTag(parameter) &&
+ !!parameter.initializer &&
+ !ts.hasSyntacticModifier(parameter, 92);
}
- switch (kind) {
- case 14:
- rawTextScanner.setText("`" + rawText + "`");
- break;
- case 15:
- rawTextScanner.setText("`" + rawText + "${");
- break;
- case 16:
- rawTextScanner.setText("}" + rawText + "${");
- break;
- case 17:
- rawTextScanner.setText("}" + rawText + "`");
- break;
+ function isOptionalUninitializedParameterProperty(parameter) {
+ return strictNullChecks &&
+ isOptionalParameter(parameter) &&
+ !parameter.initializer &&
+ ts.hasSyntacticModifier(parameter, 92);
}
- var token = rawTextScanner.scan();
- if (token === 23) {
- token = rawTextScanner.reScanTemplateToken(false);
+ function isOptionalUninitializedParameter(parameter) {
+ return !!strictNullChecks &&
+ isOptionalParameter(parameter) &&
+ !parameter.initializer;
}
- if (rawTextScanner.isUnterminated()) {
- rawTextScanner.setText(undefined);
- return invalidValueSentinel;
+ function isExpandoFunctionDeclaration(node) {
+ var declaration = ts.getParseTreeNode(node, ts.isFunctionDeclaration);
+ if (!declaration) {
+ return false;
+ }
+ var symbol = getSymbolOfNode(declaration);
+ if (!symbol || !(symbol.flags & 16)) {
+ return false;
+ }
+ return !!ts.forEachEntry(getExportsOfSymbol(symbol), function (p) { return p.flags & 111551 && p.valueDeclaration && ts.isPropertyAccessExpression(p.valueDeclaration); });
}
- var tokenValue;
- switch (token) {
- case 14:
- case 15:
- case 16:
- case 17:
- tokenValue = rawTextScanner.getTokenValue();
- break;
+ function getPropertiesOfContainerFunction(node) {
+ var declaration = ts.getParseTreeNode(node, ts.isFunctionDeclaration);
+ if (!declaration) {
+ return ts.emptyArray;
+ }
+ var symbol = getSymbolOfNode(declaration);
+ return symbol && getPropertiesOfType(getTypeOfSymbol(symbol)) || ts.emptyArray;
}
- if (rawTextScanner.scan() !== 1) {
- rawTextScanner.setText(undefined);
- return invalidValueSentinel;
+ function getNodeCheckFlags(node) {
+ return getNodeLinks(node).flags || 0;
}
- rawTextScanner.setText(undefined);
- return tokenValue;
- }
- function createTemplateLiteralLikeNode(kind, text, rawText) {
- var node = createSynthesizedNode(kind);
- node.text = text;
- if (rawText === undefined || text === rawText) {
- node.rawText = rawText;
+ function getEnumMemberValue(node) {
+ computeEnumMemberValues(node.parent);
+ return getNodeLinks(node).enumMemberValue;
}
- else {
- var cooked = getCookedText(kind, rawText);
- if (typeof cooked === "object") {
- return ts.Debug.fail("Invalid raw text");
+ function canHaveConstantValue(node) {
+ switch (node.kind) {
+ case 291:
+ case 201:
+ case 202:
+ return true;
}
- ts.Debug.assert(text === cooked, "Expected argument 'text' to be the normalized (i.e. 'cooked') version of argument 'rawText'.");
- node.rawText = rawText;
+ return false;
}
- return node;
- }
- function createTemplateHead(text, rawText) {
- var node = createTemplateLiteralLikeNode(15, text, rawText);
- node.text = text;
- return node;
- }
- ts.createTemplateHead = createTemplateHead;
- function createTemplateMiddle(text, rawText) {
- var node = createTemplateLiteralLikeNode(16, text, rawText);
- node.text = text;
- return node;
- }
- ts.createTemplateMiddle = createTemplateMiddle;
- function createTemplateTail(text, rawText) {
- var node = createTemplateLiteralLikeNode(17, text, rawText);
- node.text = text;
- return node;
- }
- ts.createTemplateTail = createTemplateTail;
- function createNoSubstitutionTemplateLiteral(text, rawText) {
- var node = createTemplateLiteralLikeNode(14, text, rawText);
- return node;
- }
- ts.createNoSubstitutionTemplateLiteral = createNoSubstitutionTemplateLiteral;
- function createYield(asteriskTokenOrExpression, expression) {
- var asteriskToken = asteriskTokenOrExpression && asteriskTokenOrExpression.kind === 41 ? asteriskTokenOrExpression : undefined;
- expression = asteriskTokenOrExpression && asteriskTokenOrExpression.kind !== 41 ? asteriskTokenOrExpression : expression;
- var node = createSynthesizedNode(212);
- node.asteriskToken = asteriskToken;
- node.expression = expression && ts.parenthesizeExpressionForList(expression);
- return node;
- }
- ts.createYield = createYield;
- function updateYield(node, asteriskToken, expression) {
- return node.expression !== expression
- || node.asteriskToken !== asteriskToken
- ? updateNode(createYield(asteriskToken, expression), node)
- : node;
- }
- ts.updateYield = updateYield;
- function createSpread(expression) {
- var node = createSynthesizedNode(213);
- node.expression = ts.parenthesizeExpressionForList(expression);
- return node;
- }
- ts.createSpread = createSpread;
- function updateSpread(node, expression) {
- return node.expression !== expression
- ? updateNode(createSpread(expression), node)
- : node;
- }
- ts.updateSpread = updateSpread;
- function createClassExpression(modifiers, name, typeParameters, heritageClauses, members) {
- var node = createSynthesizedNode(214);
- node.decorators = undefined;
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.typeParameters = asNodeArray(typeParameters);
- node.heritageClauses = asNodeArray(heritageClauses);
- node.members = createNodeArray(members);
- return node;
- }
- ts.createClassExpression = createClassExpression;
- function updateClassExpression(node, modifiers, name, typeParameters, heritageClauses, members) {
- return node.modifiers !== modifiers
- || node.name !== name
- || node.typeParameters !== typeParameters
- || node.heritageClauses !== heritageClauses
- || node.members !== members
- ? updateNode(createClassExpression(modifiers, name, typeParameters, heritageClauses, members), node)
- : node;
- }
- ts.updateClassExpression = updateClassExpression;
- function createOmittedExpression() {
- return createSynthesizedNode(215);
- }
- ts.createOmittedExpression = createOmittedExpression;
- function createExpressionWithTypeArguments(typeArguments, expression) {
- var node = createSynthesizedNode(216);
- node.expression = ts.parenthesizeForAccess(expression);
- node.typeArguments = asNodeArray(typeArguments);
- return node;
- }
- ts.createExpressionWithTypeArguments = createExpressionWithTypeArguments;
- function updateExpressionWithTypeArguments(node, typeArguments, expression) {
- return node.typeArguments !== typeArguments
- || node.expression !== expression
- ? updateNode(createExpressionWithTypeArguments(typeArguments, expression), node)
- : node;
- }
- ts.updateExpressionWithTypeArguments = updateExpressionWithTypeArguments;
- function createAsExpression(expression, type) {
- var node = createSynthesizedNode(217);
- node.expression = expression;
- node.type = type;
- return node;
- }
- ts.createAsExpression = createAsExpression;
- function updateAsExpression(node, expression, type) {
- return node.expression !== expression
- || node.type !== type
- ? updateNode(createAsExpression(expression, type), node)
- : node;
- }
- ts.updateAsExpression = updateAsExpression;
- function createNonNullExpression(expression) {
- var node = createSynthesizedNode(218);
- node.expression = ts.parenthesizeForAccess(expression);
- return node;
- }
- ts.createNonNullExpression = createNonNullExpression;
- function updateNonNullExpression(node, expression) {
- if (ts.isNonNullChain(node)) {
- return updateNonNullChain(node, expression);
+ function getConstantValue(node) {
+ if (node.kind === 291) {
+ return getEnumMemberValue(node);
+ }
+ var symbol = getNodeLinks(node).resolvedSymbol;
+ if (symbol && (symbol.flags & 8)) {
+ var member = symbol.valueDeclaration;
+ if (ts.isEnumConst(member.parent)) {
+ return getEnumMemberValue(member);
+ }
+ }
+ return undefined;
}
- return node.expression !== expression
- ? updateNode(createNonNullExpression(expression), node)
- : node;
- }
- ts.updateNonNullExpression = updateNonNullExpression;
- function createNonNullChain(expression) {
- var node = createSynthesizedNode(218);
- node.flags |= 32;
- node.expression = ts.parenthesizeForAccess(expression);
- return node;
- }
- ts.createNonNullChain = createNonNullChain;
- function updateNonNullChain(node, expression) {
- ts.Debug.assert(!!(node.flags & 32), "Cannot update a NonNullExpression using updateNonNullChain. Use updateNonNullExpression instead.");
- return node.expression !== expression
- ? updateNode(createNonNullChain(expression), node)
- : node;
- }
- ts.updateNonNullChain = updateNonNullChain;
- function createMetaProperty(keywordToken, name) {
- var node = createSynthesizedNode(219);
- node.keywordToken = keywordToken;
- node.name = name;
- return node;
- }
- ts.createMetaProperty = createMetaProperty;
- function updateMetaProperty(node, name) {
- return node.name !== name
- ? updateNode(createMetaProperty(node.keywordToken, name), node)
- : node;
- }
- ts.updateMetaProperty = updateMetaProperty;
- function createTemplateSpan(expression, literal) {
- var node = createSynthesizedNode(221);
- node.expression = expression;
- node.literal = literal;
- return node;
- }
- ts.createTemplateSpan = createTemplateSpan;
- function updateTemplateSpan(node, expression, literal) {
- return node.expression !== expression
- || node.literal !== literal
- ? updateNode(createTemplateSpan(expression, literal), node)
- : node;
- }
- ts.updateTemplateSpan = updateTemplateSpan;
- function createSemicolonClassElement() {
- return createSynthesizedNode(222);
- }
- ts.createSemicolonClassElement = createSemicolonClassElement;
- function createBlock(statements, multiLine) {
- var block = createSynthesizedNode(223);
- block.statements = createNodeArray(statements);
- if (multiLine)
- block.multiLine = multiLine;
- return block;
- }
- ts.createBlock = createBlock;
- function updateBlock(node, statements) {
- return node.statements !== statements
- ? updateNode(createBlock(statements, node.multiLine), node)
- : node;
- }
- ts.updateBlock = updateBlock;
- function createVariableStatement(modifiers, declarationList) {
- var node = createSynthesizedNode(225);
- node.decorators = undefined;
- node.modifiers = asNodeArray(modifiers);
- node.declarationList = ts.isArray(declarationList) ? createVariableDeclarationList(declarationList) : declarationList;
- return node;
- }
- ts.createVariableStatement = createVariableStatement;
- function updateVariableStatement(node, modifiers, declarationList) {
- return node.modifiers !== modifiers
- || node.declarationList !== declarationList
- ? updateNode(createVariableStatement(modifiers, declarationList), node)
- : node;
- }
- ts.updateVariableStatement = updateVariableStatement;
- function createEmptyStatement() {
- return createSynthesizedNode(224);
- }
- ts.createEmptyStatement = createEmptyStatement;
- function createExpressionStatement(expression) {
- var node = createSynthesizedNode(226);
- node.expression = ts.parenthesizeExpressionForExpressionStatement(expression);
- return node;
- }
- ts.createExpressionStatement = createExpressionStatement;
- function updateExpressionStatement(node, expression) {
- return node.expression !== expression
- ? updateNode(createExpressionStatement(expression), node)
- : node;
- }
- ts.updateExpressionStatement = updateExpressionStatement;
- ts.createStatement = createExpressionStatement;
- ts.updateStatement = updateExpressionStatement;
- function createIf(expression, thenStatement, elseStatement) {
- var node = createSynthesizedNode(227);
- node.expression = expression;
- node.thenStatement = asEmbeddedStatement(thenStatement);
- node.elseStatement = asEmbeddedStatement(elseStatement);
- return node;
- }
- ts.createIf = createIf;
- function updateIf(node, expression, thenStatement, elseStatement) {
- return node.expression !== expression
- || node.thenStatement !== thenStatement
- || node.elseStatement !== elseStatement
- ? updateNode(createIf(expression, thenStatement, elseStatement), node)
- : node;
- }
- ts.updateIf = updateIf;
- function createDo(statement, expression) {
- var node = createSynthesizedNode(228);
- node.statement = asEmbeddedStatement(statement);
- node.expression = expression;
- return node;
- }
- ts.createDo = createDo;
- function updateDo(node, statement, expression) {
- return node.statement !== statement
- || node.expression !== expression
- ? updateNode(createDo(statement, expression), node)
- : node;
- }
- ts.updateDo = updateDo;
- function createWhile(expression, statement) {
- var node = createSynthesizedNode(229);
- node.expression = expression;
- node.statement = asEmbeddedStatement(statement);
- return node;
- }
- ts.createWhile = createWhile;
- function updateWhile(node, expression, statement) {
- return node.expression !== expression
- || node.statement !== statement
- ? updateNode(createWhile(expression, statement), node)
- : node;
- }
- ts.updateWhile = updateWhile;
- function createFor(initializer, condition, incrementor, statement) {
- var node = createSynthesizedNode(230);
- node.initializer = initializer;
- node.condition = condition;
- node.incrementor = incrementor;
- node.statement = asEmbeddedStatement(statement);
- return node;
- }
- ts.createFor = createFor;
- function updateFor(node, initializer, condition, incrementor, statement) {
- return node.initializer !== initializer
- || node.condition !== condition
- || node.incrementor !== incrementor
- || node.statement !== statement
- ? updateNode(createFor(initializer, condition, incrementor, statement), node)
- : node;
- }
- ts.updateFor = updateFor;
- function createForIn(initializer, expression, statement) {
- var node = createSynthesizedNode(231);
- node.initializer = initializer;
- node.expression = expression;
- node.statement = asEmbeddedStatement(statement);
- return node;
- }
- ts.createForIn = createForIn;
- function updateForIn(node, initializer, expression, statement) {
- return node.initializer !== initializer
- || node.expression !== expression
- || node.statement !== statement
- ? updateNode(createForIn(initializer, expression, statement), node)
- : node;
- }
- ts.updateForIn = updateForIn;
- function createForOf(awaitModifier, initializer, expression, statement) {
- var node = createSynthesizedNode(232);
- node.awaitModifier = awaitModifier;
- node.initializer = initializer;
- node.expression = ts.isCommaSequence(expression) ? createParen(expression) : expression;
- node.statement = asEmbeddedStatement(statement);
- return node;
- }
- ts.createForOf = createForOf;
- function updateForOf(node, awaitModifier, initializer, expression, statement) {
- return node.awaitModifier !== awaitModifier
- || node.initializer !== initializer
- || node.expression !== expression
- || node.statement !== statement
- ? updateNode(createForOf(awaitModifier, initializer, expression, statement), node)
- : node;
- }
- ts.updateForOf = updateForOf;
- function createContinue(label) {
- var node = createSynthesizedNode(233);
- node.label = asName(label);
- return node;
- }
- ts.createContinue = createContinue;
- function updateContinue(node, label) {
- return node.label !== label
- ? updateNode(createContinue(label), node)
- : node;
- }
- ts.updateContinue = updateContinue;
- function createBreak(label) {
- var node = createSynthesizedNode(234);
- node.label = asName(label);
- return node;
- }
- ts.createBreak = createBreak;
- function updateBreak(node, label) {
- return node.label !== label
- ? updateNode(createBreak(label), node)
- : node;
- }
- ts.updateBreak = updateBreak;
- function createReturn(expression) {
- var node = createSynthesizedNode(235);
- node.expression = expression;
- return node;
- }
- ts.createReturn = createReturn;
- function updateReturn(node, expression) {
- return node.expression !== expression
- ? updateNode(createReturn(expression), node)
- : node;
- }
- ts.updateReturn = updateReturn;
- function createWith(expression, statement) {
- var node = createSynthesizedNode(236);
- node.expression = expression;
- node.statement = asEmbeddedStatement(statement);
- return node;
- }
- ts.createWith = createWith;
- function updateWith(node, expression, statement) {
- return node.expression !== expression
- || node.statement !== statement
- ? updateNode(createWith(expression, statement), node)
- : node;
- }
- ts.updateWith = updateWith;
- function createSwitch(expression, caseBlock) {
- var node = createSynthesizedNode(237);
- node.expression = ts.parenthesizeExpressionForList(expression);
- node.caseBlock = caseBlock;
- return node;
- }
- ts.createSwitch = createSwitch;
- function updateSwitch(node, expression, caseBlock) {
- return node.expression !== expression
- || node.caseBlock !== caseBlock
- ? updateNode(createSwitch(expression, caseBlock), node)
- : node;
- }
- ts.updateSwitch = updateSwitch;
- function createLabel(label, statement) {
- var node = createSynthesizedNode(238);
- node.label = asName(label);
- node.statement = asEmbeddedStatement(statement);
- return node;
- }
- ts.createLabel = createLabel;
- function updateLabel(node, label, statement) {
- return node.label !== label
- || node.statement !== statement
- ? updateNode(createLabel(label, statement), node)
- : node;
- }
- ts.updateLabel = updateLabel;
- function createThrow(expression) {
- var node = createSynthesizedNode(239);
- node.expression = expression;
- return node;
- }
- ts.createThrow = createThrow;
- function updateThrow(node, expression) {
- return node.expression !== expression
- ? updateNode(createThrow(expression), node)
- : node;
- }
- ts.updateThrow = updateThrow;
- function createTry(tryBlock, catchClause, finallyBlock) {
- var node = createSynthesizedNode(240);
- node.tryBlock = tryBlock;
- node.catchClause = catchClause;
- node.finallyBlock = finallyBlock;
- return node;
- }
- ts.createTry = createTry;
- function updateTry(node, tryBlock, catchClause, finallyBlock) {
- return node.tryBlock !== tryBlock
- || node.catchClause !== catchClause
- || node.finallyBlock !== finallyBlock
- ? updateNode(createTry(tryBlock, catchClause, finallyBlock), node)
- : node;
- }
- ts.updateTry = updateTry;
- function createDebuggerStatement() {
- return createSynthesizedNode(241);
- }
- ts.createDebuggerStatement = createDebuggerStatement;
- function createVariableDeclaration(name, type, initializer) {
- var node = createSynthesizedNode(242);
- node.name = asName(name);
- node.type = type;
- node.initializer = initializer !== undefined ? ts.parenthesizeExpressionForList(initializer) : undefined;
- return node;
- }
- ts.createVariableDeclaration = createVariableDeclaration;
- function updateVariableDeclaration(node, name, type, initializer) {
- return node.name !== name
- || node.type !== type
- || node.initializer !== initializer
- ? updateNode(createVariableDeclaration(name, type, initializer), node)
- : node;
- }
- ts.updateVariableDeclaration = updateVariableDeclaration;
- function createTypeScriptVariableDeclaration(name, exclaimationToken, type, initializer) {
- var node = createSynthesizedNode(242);
- node.name = asName(name);
- node.type = type;
- node.initializer = initializer !== undefined ? ts.parenthesizeExpressionForList(initializer) : undefined;
- node.exclamationToken = exclaimationToken;
- return node;
- }
- ts.createTypeScriptVariableDeclaration = createTypeScriptVariableDeclaration;
- function updateTypeScriptVariableDeclaration(node, name, exclaimationToken, type, initializer) {
- return node.name !== name
- || node.type !== type
- || node.initializer !== initializer
- || node.exclamationToken !== exclaimationToken
- ? updateNode(createTypeScriptVariableDeclaration(name, exclaimationToken, type, initializer), node)
- : node;
- }
- ts.updateTypeScriptVariableDeclaration = updateTypeScriptVariableDeclaration;
- function createVariableDeclarationList(declarations, flags) {
- if (flags === void 0) { flags = 0; }
- var node = createSynthesizedNode(243);
- node.flags |= flags & 3;
- node.declarations = createNodeArray(declarations);
- return node;
- }
- ts.createVariableDeclarationList = createVariableDeclarationList;
- function updateVariableDeclarationList(node, declarations) {
- return node.declarations !== declarations
- ? updateNode(createVariableDeclarationList(declarations, node.flags), node)
- : node;
- }
- ts.updateVariableDeclarationList = updateVariableDeclarationList;
- function createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
- var node = createSynthesizedNode(244);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.asteriskToken = asteriskToken;
- node.name = asName(name);
- node.typeParameters = asNodeArray(typeParameters);
- node.parameters = createNodeArray(parameters);
- node.type = type;
- node.body = body;
- return node;
- }
- ts.createFunctionDeclaration = createFunctionDeclaration;
- function updateFunctionDeclaration(node, decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.asteriskToken !== asteriskToken
- || node.name !== name
- || node.typeParameters !== typeParameters
- || node.parameters !== parameters
- || node.type !== type
- || node.body !== body
- ? updateNode(createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body), node)
- : node;
- }
- ts.updateFunctionDeclaration = updateFunctionDeclaration;
- function updateFunctionLikeBody(declaration, body) {
- switch (declaration.kind) {
- case 244:
- return createFunctionDeclaration(declaration.decorators, declaration.modifiers, declaration.asteriskToken, declaration.name, declaration.typeParameters, declaration.parameters, declaration.type, body);
- case 161:
- return createMethod(declaration.decorators, declaration.modifiers, declaration.asteriskToken, declaration.name, declaration.questionToken, declaration.typeParameters, declaration.parameters, declaration.type, body);
- case 163:
- return createGetAccessor(declaration.decorators, declaration.modifiers, declaration.name, declaration.parameters, declaration.type, body);
- case 164:
- return createSetAccessor(declaration.decorators, declaration.modifiers, declaration.name, declaration.parameters, body);
- case 162:
- return createConstructor(declaration.decorators, declaration.modifiers, declaration.parameters, body);
- case 201:
- return createFunctionExpression(declaration.modifiers, declaration.asteriskToken, declaration.name, declaration.typeParameters, declaration.parameters, declaration.type, body);
- case 202:
- return createArrowFunction(declaration.modifiers, declaration.typeParameters, declaration.parameters, declaration.type, declaration.equalsGreaterThanToken, body);
- }
- }
- ts.updateFunctionLikeBody = updateFunctionLikeBody;
- function createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members) {
- var node = createSynthesizedNode(245);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.typeParameters = asNodeArray(typeParameters);
- node.heritageClauses = asNodeArray(heritageClauses);
- node.members = createNodeArray(members);
- return node;
- }
- ts.createClassDeclaration = createClassDeclaration;
- function updateClassDeclaration(node, decorators, modifiers, name, typeParameters, heritageClauses, members) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.name !== name
- || node.typeParameters !== typeParameters
- || node.heritageClauses !== heritageClauses
- || node.members !== members
- ? updateNode(createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members), node)
- : node;
- }
- ts.updateClassDeclaration = updateClassDeclaration;
- function createInterfaceDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members) {
- var node = createSynthesizedNode(246);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.typeParameters = asNodeArray(typeParameters);
- node.heritageClauses = asNodeArray(heritageClauses);
- node.members = createNodeArray(members);
- return node;
- }
- ts.createInterfaceDeclaration = createInterfaceDeclaration;
- function updateInterfaceDeclaration(node, decorators, modifiers, name, typeParameters, heritageClauses, members) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.name !== name
- || node.typeParameters !== typeParameters
- || node.heritageClauses !== heritageClauses
- || node.members !== members
- ? updateNode(createInterfaceDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members), node)
- : node;
- }
- ts.updateInterfaceDeclaration = updateInterfaceDeclaration;
- function createTypeAliasDeclaration(decorators, modifiers, name, typeParameters, type) {
- var node = createSynthesizedNode(247);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.typeParameters = asNodeArray(typeParameters);
- node.type = type;
- return node;
- }
- ts.createTypeAliasDeclaration = createTypeAliasDeclaration;
- function updateTypeAliasDeclaration(node, decorators, modifiers, name, typeParameters, type) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.name !== name
- || node.typeParameters !== typeParameters
- || node.type !== type
- ? updateNode(createTypeAliasDeclaration(decorators, modifiers, name, typeParameters, type), node)
- : node;
- }
- ts.updateTypeAliasDeclaration = updateTypeAliasDeclaration;
- function createEnumDeclaration(decorators, modifiers, name, members) {
- var node = createSynthesizedNode(248);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.members = createNodeArray(members);
- return node;
- }
- ts.createEnumDeclaration = createEnumDeclaration;
- function updateEnumDeclaration(node, decorators, modifiers, name, members) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.name !== name
- || node.members !== members
- ? updateNode(createEnumDeclaration(decorators, modifiers, name, members), node)
- : node;
- }
- ts.updateEnumDeclaration = updateEnumDeclaration;
- function createModuleDeclaration(decorators, modifiers, name, body, flags) {
- if (flags === void 0) { flags = 0; }
- var node = createSynthesizedNode(249);
- node.flags |= flags & (16 | 4 | 1024);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.name = name;
- node.body = body;
- return node;
- }
- ts.createModuleDeclaration = createModuleDeclaration;
- function updateModuleDeclaration(node, decorators, modifiers, name, body) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.name !== name
- || node.body !== body
- ? updateNode(createModuleDeclaration(decorators, modifiers, name, body, node.flags), node)
- : node;
- }
- ts.updateModuleDeclaration = updateModuleDeclaration;
- function createModuleBlock(statements) {
- var node = createSynthesizedNode(250);
- node.statements = createNodeArray(statements);
- return node;
- }
- ts.createModuleBlock = createModuleBlock;
- function updateModuleBlock(node, statements) {
- return node.statements !== statements
- ? updateNode(createModuleBlock(statements), node)
- : node;
- }
- ts.updateModuleBlock = updateModuleBlock;
- function createCaseBlock(clauses) {
- var node = createSynthesizedNode(251);
- node.clauses = createNodeArray(clauses);
- return node;
- }
- ts.createCaseBlock = createCaseBlock;
- function updateCaseBlock(node, clauses) {
- return node.clauses !== clauses
- ? updateNode(createCaseBlock(clauses), node)
- : node;
- }
- ts.updateCaseBlock = updateCaseBlock;
- function createNamespaceExportDeclaration(name) {
- var node = createSynthesizedNode(252);
- node.name = asName(name);
- return node;
- }
- ts.createNamespaceExportDeclaration = createNamespaceExportDeclaration;
- function updateNamespaceExportDeclaration(node, name) {
- return node.name !== name
- ? updateNode(createNamespaceExportDeclaration(name), node)
- : node;
- }
- ts.updateNamespaceExportDeclaration = updateNamespaceExportDeclaration;
- function createImportEqualsDeclaration(decorators, modifiers, name, moduleReference) {
- var node = createSynthesizedNode(253);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.name = asName(name);
- node.moduleReference = moduleReference;
- return node;
- }
- ts.createImportEqualsDeclaration = createImportEqualsDeclaration;
- function updateImportEqualsDeclaration(node, decorators, modifiers, name, moduleReference) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.name !== name
- || node.moduleReference !== moduleReference
- ? updateNode(createImportEqualsDeclaration(decorators, modifiers, name, moduleReference), node)
- : node;
- }
- ts.updateImportEqualsDeclaration = updateImportEqualsDeclaration;
- function createImportDeclaration(decorators, modifiers, importClause, moduleSpecifier) {
- var node = createSynthesizedNode(254);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.importClause = importClause;
- node.moduleSpecifier = moduleSpecifier;
- return node;
- }
- ts.createImportDeclaration = createImportDeclaration;
- function updateImportDeclaration(node, decorators, modifiers, importClause, moduleSpecifier) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.importClause !== importClause
- || node.moduleSpecifier !== moduleSpecifier
- ? updateNode(createImportDeclaration(decorators, modifiers, importClause, moduleSpecifier), node)
- : node;
- }
- ts.updateImportDeclaration = updateImportDeclaration;
- function createImportClause(name, namedBindings, isTypeOnly) {
- if (isTypeOnly === void 0) { isTypeOnly = false; }
- var node = createSynthesizedNode(255);
- node.name = name;
- node.namedBindings = namedBindings;
- node.isTypeOnly = isTypeOnly;
- return node;
- }
- ts.createImportClause = createImportClause;
- function updateImportClause(node, name, namedBindings, isTypeOnly) {
- return node.name !== name
- || node.namedBindings !== namedBindings
- || node.isTypeOnly !== isTypeOnly
- ? updateNode(createImportClause(name, namedBindings, isTypeOnly), node)
- : node;
- }
- ts.updateImportClause = updateImportClause;
- function createNamespaceImport(name) {
- var node = createSynthesizedNode(256);
- node.name = name;
- return node;
- }
- ts.createNamespaceImport = createNamespaceImport;
- function createNamespaceExport(name) {
- var node = createSynthesizedNode(262);
- node.name = name;
- return node;
- }
- ts.createNamespaceExport = createNamespaceExport;
- function updateNamespaceImport(node, name) {
- return node.name !== name
- ? updateNode(createNamespaceImport(name), node)
- : node;
- }
- ts.updateNamespaceImport = updateNamespaceImport;
- function updateNamespaceExport(node, name) {
- return node.name !== name
- ? updateNode(createNamespaceExport(name), node)
- : node;
- }
- ts.updateNamespaceExport = updateNamespaceExport;
- function createNamedImports(elements) {
- var node = createSynthesizedNode(257);
- node.elements = createNodeArray(elements);
- return node;
- }
- ts.createNamedImports = createNamedImports;
- function updateNamedImports(node, elements) {
- return node.elements !== elements
- ? updateNode(createNamedImports(elements), node)
- : node;
- }
- ts.updateNamedImports = updateNamedImports;
- function createImportSpecifier(propertyName, name) {
- var node = createSynthesizedNode(258);
- node.propertyName = propertyName;
- node.name = name;
- return node;
- }
- ts.createImportSpecifier = createImportSpecifier;
- function updateImportSpecifier(node, propertyName, name) {
- return node.propertyName !== propertyName
- || node.name !== name
- ? updateNode(createImportSpecifier(propertyName, name), node)
- : node;
- }
- ts.updateImportSpecifier = updateImportSpecifier;
- function createExportAssignment(decorators, modifiers, isExportEquals, expression) {
- var node = createSynthesizedNode(259);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.isExportEquals = isExportEquals;
- node.expression = isExportEquals ? ts.parenthesizeBinaryOperand(62, expression, false, undefined) : ts.parenthesizeDefaultExpression(expression);
- return node;
- }
- ts.createExportAssignment = createExportAssignment;
- function updateExportAssignment(node, decorators, modifiers, expression) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.expression !== expression
- ? updateNode(createExportAssignment(decorators, modifiers, node.isExportEquals, expression), node)
- : node;
- }
- ts.updateExportAssignment = updateExportAssignment;
- function createExportDeclaration(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) {
- if (isTypeOnly === void 0) { isTypeOnly = false; }
- var node = createSynthesizedNode(260);
- node.decorators = asNodeArray(decorators);
- node.modifiers = asNodeArray(modifiers);
- node.isTypeOnly = isTypeOnly;
- node.exportClause = exportClause;
- node.moduleSpecifier = moduleSpecifier;
- return node;
- }
- ts.createExportDeclaration = createExportDeclaration;
- function updateExportDeclaration(node, decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) {
- return node.decorators !== decorators
- || node.modifiers !== modifiers
- || node.isTypeOnly !== isTypeOnly
- || node.exportClause !== exportClause
- || node.moduleSpecifier !== moduleSpecifier
- ? updateNode(createExportDeclaration(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly), node)
- : node;
- }
- ts.updateExportDeclaration = updateExportDeclaration;
- function createEmptyExports() {
- return createExportDeclaration(undefined, undefined, createNamedExports([]), undefined);
- }
- ts.createEmptyExports = createEmptyExports;
- function createNamedExports(elements) {
- var node = createSynthesizedNode(261);
- node.elements = createNodeArray(elements);
- return node;
- }
- ts.createNamedExports = createNamedExports;
- function updateNamedExports(node, elements) {
- return node.elements !== elements
- ? updateNode(createNamedExports(elements), node)
- : node;
- }
- ts.updateNamedExports = updateNamedExports;
- function createExportSpecifier(propertyName, name) {
- var node = createSynthesizedNode(263);
- node.propertyName = asName(propertyName);
- node.name = asName(name);
- return node;
- }
- ts.createExportSpecifier = createExportSpecifier;
- function updateExportSpecifier(node, propertyName, name) {
- return node.propertyName !== propertyName
- || node.name !== name
- ? updateNode(createExportSpecifier(propertyName, name), node)
- : node;
- }
- ts.updateExportSpecifier = updateExportSpecifier;
- function createExternalModuleReference(expression) {
- var node = createSynthesizedNode(265);
- node.expression = expression;
- return node;
- }
- ts.createExternalModuleReference = createExternalModuleReference;
- function updateExternalModuleReference(node, expression) {
- return node.expression !== expression
- ? updateNode(createExternalModuleReference(expression), node)
- : node;
- }
- ts.updateExternalModuleReference = updateExternalModuleReference;
- function createJSDocTypeExpression(type) {
- var node = createSynthesizedNode(294);
- node.type = type;
- return node;
- }
- ts.createJSDocTypeExpression = createJSDocTypeExpression;
- function createJSDocTypeTag(typeExpression, comment) {
- var tag = createJSDocTag(320, "type");
- tag.typeExpression = typeExpression;
- tag.comment = comment;
- return tag;
- }
- ts.createJSDocTypeTag = createJSDocTypeTag;
- function createJSDocReturnTag(typeExpression, comment) {
- var tag = createJSDocTag(318, "returns");
- tag.typeExpression = typeExpression;
- tag.comment = comment;
- return tag;
- }
- ts.createJSDocReturnTag = createJSDocReturnTag;
- function createJSDocThisTag(typeExpression) {
- var tag = createJSDocTag(319, "this");
- tag.typeExpression = typeExpression;
- return tag;
- }
- ts.createJSDocThisTag = createJSDocThisTag;
- function createJSDocParamTag(name, isBracketed, typeExpression, comment) {
- var tag = createJSDocTag(317, "param");
- tag.typeExpression = typeExpression;
- tag.name = name;
- tag.isBracketed = isBracketed;
- tag.comment = comment;
- return tag;
- }
- ts.createJSDocParamTag = createJSDocParamTag;
- function createJSDocClassTag() {
- return createJSDocTag(310, "class");
- }
- ts.createJSDocClassTag = createJSDocClassTag;
- function createJSDocComment(comment, tags) {
- var node = createSynthesizedNode(303);
- node.comment = comment;
- node.tags = tags;
- return node;
- }
- ts.createJSDocComment = createJSDocComment;
- function createJSDocTag(kind, tagName) {
- var node = createSynthesizedNode(kind);
- node.tagName = createIdentifier(tagName);
- return node;
- }
- function createJsxElement(openingElement, children, closingElement) {
- var node = createSynthesizedNode(266);
- node.openingElement = openingElement;
- node.children = createNodeArray(children);
- node.closingElement = closingElement;
- return node;
- }
- ts.createJsxElement = createJsxElement;
- function updateJsxElement(node, openingElement, children, closingElement) {
- return node.openingElement !== openingElement
- || node.children !== children
- || node.closingElement !== closingElement
- ? updateNode(createJsxElement(openingElement, children, closingElement), node)
- : node;
- }
- ts.updateJsxElement = updateJsxElement;
- function createJsxSelfClosingElement(tagName, typeArguments, attributes) {
- var node = createSynthesizedNode(267);
- node.tagName = tagName;
- node.typeArguments = asNodeArray(typeArguments);
- node.attributes = attributes;
- return node;
- }
- ts.createJsxSelfClosingElement = createJsxSelfClosingElement;
- function updateJsxSelfClosingElement(node, tagName, typeArguments, attributes) {
- return node.tagName !== tagName
- || node.typeArguments !== typeArguments
- || node.attributes !== attributes
- ? updateNode(createJsxSelfClosingElement(tagName, typeArguments, attributes), node)
- : node;
- }
- ts.updateJsxSelfClosingElement = updateJsxSelfClosingElement;
- function createJsxOpeningElement(tagName, typeArguments, attributes) {
- var node = createSynthesizedNode(268);
- node.tagName = tagName;
- node.typeArguments = asNodeArray(typeArguments);
- node.attributes = attributes;
- return node;
- }
- ts.createJsxOpeningElement = createJsxOpeningElement;
- function updateJsxOpeningElement(node, tagName, typeArguments, attributes) {
- return node.tagName !== tagName
- || node.typeArguments !== typeArguments
- || node.attributes !== attributes
- ? updateNode(createJsxOpeningElement(tagName, typeArguments, attributes), node)
- : node;
- }
- ts.updateJsxOpeningElement = updateJsxOpeningElement;
- function createJsxClosingElement(tagName) {
- var node = createSynthesizedNode(269);
- node.tagName = tagName;
- return node;
- }
- ts.createJsxClosingElement = createJsxClosingElement;
- function updateJsxClosingElement(node, tagName) {
- return node.tagName !== tagName
- ? updateNode(createJsxClosingElement(tagName), node)
- : node;
- }
- ts.updateJsxClosingElement = updateJsxClosingElement;
- function createJsxFragment(openingFragment, children, closingFragment) {
- var node = createSynthesizedNode(270);
- node.openingFragment = openingFragment;
- node.children = createNodeArray(children);
- node.closingFragment = closingFragment;
- return node;
- }
- ts.createJsxFragment = createJsxFragment;
- function createJsxText(text, containsOnlyTriviaWhiteSpaces) {
- var node = createSynthesizedNode(11);
- node.text = text;
- node.containsOnlyTriviaWhiteSpaces = !!containsOnlyTriviaWhiteSpaces;
- return node;
- }
- ts.createJsxText = createJsxText;
- function updateJsxText(node, text, containsOnlyTriviaWhiteSpaces) {
- return node.text !== text
- || node.containsOnlyTriviaWhiteSpaces !== containsOnlyTriviaWhiteSpaces
- ? updateNode(createJsxText(text, containsOnlyTriviaWhiteSpaces), node)
- : node;
- }
- ts.updateJsxText = updateJsxText;
- function createJsxOpeningFragment() {
- return createSynthesizedNode(271);
- }
- ts.createJsxOpeningFragment = createJsxOpeningFragment;
- function createJsxJsxClosingFragment() {
- return createSynthesizedNode(272);
- }
- ts.createJsxJsxClosingFragment = createJsxJsxClosingFragment;
- function updateJsxFragment(node, openingFragment, children, closingFragment) {
- return node.openingFragment !== openingFragment
- || node.children !== children
- || node.closingFragment !== closingFragment
- ? updateNode(createJsxFragment(openingFragment, children, closingFragment), node)
- : node;
- }
- ts.updateJsxFragment = updateJsxFragment;
- function createJsxAttribute(name, initializer) {
- var node = createSynthesizedNode(273);
- node.name = name;
- node.initializer = initializer;
- return node;
- }
- ts.createJsxAttribute = createJsxAttribute;
- function updateJsxAttribute(node, name, initializer) {
- return node.name !== name
- || node.initializer !== initializer
- ? updateNode(createJsxAttribute(name, initializer), node)
- : node;
- }
- ts.updateJsxAttribute = updateJsxAttribute;
- function createJsxAttributes(properties) {
- var node = createSynthesizedNode(274);
- node.properties = createNodeArray(properties);
- return node;
- }
- ts.createJsxAttributes = createJsxAttributes;
- function updateJsxAttributes(node, properties) {
- return node.properties !== properties
- ? updateNode(createJsxAttributes(properties), node)
- : node;
- }
- ts.updateJsxAttributes = updateJsxAttributes;
- function createJsxSpreadAttribute(expression) {
- var node = createSynthesizedNode(275);
- node.expression = expression;
- return node;
- }
- ts.createJsxSpreadAttribute = createJsxSpreadAttribute;
- function updateJsxSpreadAttribute(node, expression) {
- return node.expression !== expression
- ? updateNode(createJsxSpreadAttribute(expression), node)
- : node;
- }
- ts.updateJsxSpreadAttribute = updateJsxSpreadAttribute;
- function createJsxExpression(dotDotDotToken, expression) {
- var node = createSynthesizedNode(276);
- node.dotDotDotToken = dotDotDotToken;
- node.expression = expression;
- return node;
- }
- ts.createJsxExpression = createJsxExpression;
- function updateJsxExpression(node, expression) {
- return node.expression !== expression
- ? updateNode(createJsxExpression(node.dotDotDotToken, expression), node)
- : node;
- }
- ts.updateJsxExpression = updateJsxExpression;
- function createCaseClause(expression, statements) {
- var node = createSynthesizedNode(277);
- node.expression = ts.parenthesizeExpressionForList(expression);
- node.statements = createNodeArray(statements);
- return node;
- }
- ts.createCaseClause = createCaseClause;
- function updateCaseClause(node, expression, statements) {
- return node.expression !== expression
- || node.statements !== statements
- ? updateNode(createCaseClause(expression, statements), node)
- : node;
- }
- ts.updateCaseClause = updateCaseClause;
- function createDefaultClause(statements) {
- var node = createSynthesizedNode(278);
- node.statements = createNodeArray(statements);
- return node;
- }
- ts.createDefaultClause = createDefaultClause;
- function updateDefaultClause(node, statements) {
- return node.statements !== statements
- ? updateNode(createDefaultClause(statements), node)
- : node;
- }
- ts.updateDefaultClause = updateDefaultClause;
- function createHeritageClause(token, types) {
- var node = createSynthesizedNode(279);
- node.token = token;
- node.types = createNodeArray(types);
- return node;
- }
- ts.createHeritageClause = createHeritageClause;
- function updateHeritageClause(node, types) {
- return node.types !== types
- ? updateNode(createHeritageClause(node.token, types), node)
- : node;
- }
- ts.updateHeritageClause = updateHeritageClause;
- function createCatchClause(variableDeclaration, block) {
- var node = createSynthesizedNode(280);
- node.variableDeclaration = ts.isString(variableDeclaration) ? createVariableDeclaration(variableDeclaration) : variableDeclaration;
- node.block = block;
- return node;
- }
- ts.createCatchClause = createCatchClause;
- function updateCatchClause(node, variableDeclaration, block) {
- return node.variableDeclaration !== variableDeclaration
- || node.block !== block
- ? updateNode(createCatchClause(variableDeclaration, block), node)
- : node;
- }
- ts.updateCatchClause = updateCatchClause;
- function createPropertyAssignment(name, initializer) {
- var node = createSynthesizedNode(281);
- node.name = asName(name);
- node.questionToken = undefined;
- node.initializer = ts.parenthesizeExpressionForList(initializer);
- return node;
- }
- ts.createPropertyAssignment = createPropertyAssignment;
- function updatePropertyAssignment(node, name, initializer) {
- return node.name !== name
- || node.initializer !== initializer
- ? updateNode(createPropertyAssignment(name, initializer), node)
- : node;
- }
- ts.updatePropertyAssignment = updatePropertyAssignment;
- function createShorthandPropertyAssignment(name, objectAssignmentInitializer) {
- var node = createSynthesizedNode(282);
- node.name = asName(name);
- node.objectAssignmentInitializer = objectAssignmentInitializer !== undefined ? ts.parenthesizeExpressionForList(objectAssignmentInitializer) : undefined;
- return node;
- }
- ts.createShorthandPropertyAssignment = createShorthandPropertyAssignment;
- function updateShorthandPropertyAssignment(node, name, objectAssignmentInitializer) {
- return node.name !== name
- || node.objectAssignmentInitializer !== objectAssignmentInitializer
- ? updateNode(createShorthandPropertyAssignment(name, objectAssignmentInitializer), node)
- : node;
- }
- ts.updateShorthandPropertyAssignment = updateShorthandPropertyAssignment;
- function createSpreadAssignment(expression) {
- var node = createSynthesizedNode(283);
- node.expression = ts.parenthesizeExpressionForList(expression);
- return node;
- }
- ts.createSpreadAssignment = createSpreadAssignment;
- function updateSpreadAssignment(node, expression) {
- return node.expression !== expression
- ? updateNode(createSpreadAssignment(expression), node)
- : node;
- }
- ts.updateSpreadAssignment = updateSpreadAssignment;
- function createEnumMember(name, initializer) {
- var node = createSynthesizedNode(284);
- node.name = asName(name);
- node.initializer = initializer && ts.parenthesizeExpressionForList(initializer);
- return node;
- }
- ts.createEnumMember = createEnumMember;
- function updateEnumMember(node, name, initializer) {
- return node.name !== name
- || node.initializer !== initializer
- ? updateNode(createEnumMember(name, initializer), node)
- : node;
- }
- ts.updateEnumMember = updateEnumMember;
- function updateSourceFileNode(node, statements, isDeclarationFile, referencedFiles, typeReferences, hasNoDefaultLib, libReferences) {
- if (node.statements !== statements ||
- (isDeclarationFile !== undefined && node.isDeclarationFile !== isDeclarationFile) ||
- (referencedFiles !== undefined && node.referencedFiles !== referencedFiles) ||
- (typeReferences !== undefined && node.typeReferenceDirectives !== typeReferences) ||
- (libReferences !== undefined && node.libReferenceDirectives !== libReferences) ||
- (hasNoDefaultLib !== undefined && node.hasNoDefaultLib !== hasNoDefaultLib)) {
- var updated = createSynthesizedNode(290);
- updated.flags |= node.flags;
- updated.statements = createNodeArray(statements);
- updated.endOfFileToken = node.endOfFileToken;
- updated.fileName = node.fileName;
- updated.path = node.path;
- updated.text = node.text;
- updated.isDeclarationFile = isDeclarationFile === undefined ? node.isDeclarationFile : isDeclarationFile;
- updated.referencedFiles = referencedFiles === undefined ? node.referencedFiles : referencedFiles;
- updated.typeReferenceDirectives = typeReferences === undefined ? node.typeReferenceDirectives : typeReferences;
- updated.hasNoDefaultLib = hasNoDefaultLib === undefined ? node.hasNoDefaultLib : hasNoDefaultLib;
- updated.libReferenceDirectives = libReferences === undefined ? node.libReferenceDirectives : libReferences;
- if (node.amdDependencies !== undefined)
- updated.amdDependencies = node.amdDependencies;
- if (node.moduleName !== undefined)
- updated.moduleName = node.moduleName;
- if (node.languageVariant !== undefined)
- updated.languageVariant = node.languageVariant;
- if (node.renamedDependencies !== undefined)
- updated.renamedDependencies = node.renamedDependencies;
- if (node.languageVersion !== undefined)
- updated.languageVersion = node.languageVersion;
- if (node.scriptKind !== undefined)
- updated.scriptKind = node.scriptKind;
- if (node.externalModuleIndicator !== undefined)
- updated.externalModuleIndicator = node.externalModuleIndicator;
- if (node.commonJsModuleIndicator !== undefined)
- updated.commonJsModuleIndicator = node.commonJsModuleIndicator;
- if (node.identifiers !== undefined)
- updated.identifiers = node.identifiers;
- if (node.nodeCount !== undefined)
- updated.nodeCount = node.nodeCount;
- if (node.identifierCount !== undefined)
- updated.identifierCount = node.identifierCount;
- if (node.symbolCount !== undefined)
- updated.symbolCount = node.symbolCount;
- if (node.parseDiagnostics !== undefined)
- updated.parseDiagnostics = node.parseDiagnostics;
- if (node.bindDiagnostics !== undefined)
- updated.bindDiagnostics = node.bindDiagnostics;
- if (node.bindSuggestionDiagnostics !== undefined)
- updated.bindSuggestionDiagnostics = node.bindSuggestionDiagnostics;
- if (node.lineMap !== undefined)
- updated.lineMap = node.lineMap;
- if (node.classifiableNames !== undefined)
- updated.classifiableNames = node.classifiableNames;
- if (node.resolvedModules !== undefined)
- updated.resolvedModules = node.resolvedModules;
- if (node.resolvedTypeReferenceDirectiveNames !== undefined)
- updated.resolvedTypeReferenceDirectiveNames = node.resolvedTypeReferenceDirectiveNames;
- if (node.imports !== undefined)
- updated.imports = node.imports;
- if (node.moduleAugmentations !== undefined)
- updated.moduleAugmentations = node.moduleAugmentations;
- if (node.pragmas !== undefined)
- updated.pragmas = node.pragmas;
- if (node.localJsxFactory !== undefined)
- updated.localJsxFactory = node.localJsxFactory;
- if (node.localJsxNamespace !== undefined)
- updated.localJsxNamespace = node.localJsxNamespace;
- return updateNode(updated, node);
+ function isFunctionType(type) {
+ return !!(type.flags & 524288) && getSignaturesOfType(type, 0).length > 0;
+ }
+ function getTypeReferenceSerializationKind(typeNameIn, location) {
+ var _a;
+ var typeName = ts.getParseTreeNode(typeNameIn, ts.isEntityName);
+ if (!typeName)
+ return ts.TypeReferenceSerializationKind.Unknown;
+ if (location) {
+ location = ts.getParseTreeNode(location);
+ if (!location)
+ return ts.TypeReferenceSerializationKind.Unknown;
+ }
+ var valueSymbol = resolveEntityName(typeName, 111551, true, true, location);
+ var isTypeOnly = ((_a = valueSymbol === null || valueSymbol === void 0 ? void 0 : valueSymbol.declarations) === null || _a === void 0 ? void 0 : _a.every(ts.isTypeOnlyImportOrExportDeclaration)) || false;
+ var resolvedSymbol = valueSymbol && valueSymbol.flags & 2097152 ? resolveAlias(valueSymbol) : valueSymbol;
+ var typeSymbol = resolveEntityName(typeName, 788968, true, false, location);
+ if (resolvedSymbol && resolvedSymbol === typeSymbol) {
+ var globalPromiseSymbol = getGlobalPromiseConstructorSymbol(false);
+ if (globalPromiseSymbol && resolvedSymbol === globalPromiseSymbol) {
+ return ts.TypeReferenceSerializationKind.Promise;
+ }
+ var constructorType = getTypeOfSymbol(resolvedSymbol);
+ if (constructorType && isConstructorType(constructorType)) {
+ return isTypeOnly ? ts.TypeReferenceSerializationKind.TypeWithCallSignature : ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue;
+ }
+ }
+ if (!typeSymbol) {
+ return isTypeOnly ? ts.TypeReferenceSerializationKind.ObjectType : ts.TypeReferenceSerializationKind.Unknown;
+ }
+ var type = getDeclaredTypeOfSymbol(typeSymbol);
+ if (type === errorType) {
+ return isTypeOnly ? ts.TypeReferenceSerializationKind.ObjectType : ts.TypeReferenceSerializationKind.Unknown;
+ }
+ else if (type.flags & 3) {
+ return ts.TypeReferenceSerializationKind.ObjectType;
+ }
+ else if (isTypeAssignableToKind(type, 16384 | 98304 | 131072)) {
+ return ts.TypeReferenceSerializationKind.VoidNullableOrNeverType;
+ }
+ else if (isTypeAssignableToKind(type, 528)) {
+ return ts.TypeReferenceSerializationKind.BooleanType;
+ }
+ else if (isTypeAssignableToKind(type, 296)) {
+ return ts.TypeReferenceSerializationKind.NumberLikeType;
+ }
+ else if (isTypeAssignableToKind(type, 2112)) {
+ return ts.TypeReferenceSerializationKind.BigIntLikeType;
+ }
+ else if (isTypeAssignableToKind(type, 402653316)) {
+ return ts.TypeReferenceSerializationKind.StringLikeType;
+ }
+ else if (isTupleType(type)) {
+ return ts.TypeReferenceSerializationKind.ArrayLikeType;
+ }
+ else if (isTypeAssignableToKind(type, 12288)) {
+ return ts.TypeReferenceSerializationKind.ESSymbolType;
+ }
+ else if (isFunctionType(type)) {
+ return ts.TypeReferenceSerializationKind.TypeWithCallSignature;
+ }
+ else if (isArrayType(type)) {
+ return ts.TypeReferenceSerializationKind.ArrayLikeType;
+ }
+ else {
+ return ts.TypeReferenceSerializationKind.ObjectType;
+ }
}
- return node;
- }
- ts.updateSourceFileNode = updateSourceFileNode;
- function getMutableClone(node) {
- var clone = getSynthesizedClone(node);
- clone.pos = node.pos;
- clone.end = node.end;
- clone.parent = node.parent;
- return clone;
- }
- ts.getMutableClone = getMutableClone;
- function createNotEmittedStatement(original) {
- var node = createSynthesizedNode(325);
- node.original = original;
- setTextRange(node, original);
- return node;
- }
- ts.createNotEmittedStatement = createNotEmittedStatement;
- function createEndOfDeclarationMarker(original) {
- var node = createSynthesizedNode(329);
- node.emitNode = {};
- node.original = original;
- return node;
- }
- ts.createEndOfDeclarationMarker = createEndOfDeclarationMarker;
- function createMergeDeclarationMarker(original) {
- var node = createSynthesizedNode(328);
- node.emitNode = {};
- node.original = original;
- return node;
- }
- ts.createMergeDeclarationMarker = createMergeDeclarationMarker;
- function createPartiallyEmittedExpression(expression, original) {
- var node = createSynthesizedNode(326);
- node.expression = expression;
- node.original = original;
- setTextRange(node, original);
- return node;
- }
- ts.createPartiallyEmittedExpression = createPartiallyEmittedExpression;
- function updatePartiallyEmittedExpression(node, expression) {
- if (node.expression !== expression) {
- return updateNode(createPartiallyEmittedExpression(expression, node.original), node);
+ function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker, addUndefined) {
+ var declaration = ts.getParseTreeNode(declarationIn, ts.isVariableLikeOrAccessor);
+ if (!declaration) {
+ return ts.factory.createToken(128);
+ }
+ var symbol = getSymbolOfNode(declaration);
+ var type = symbol && !(symbol.flags & (2048 | 131072))
+ ? getWidenedLiteralType(getTypeOfSymbol(symbol))
+ : errorType;
+ if (type.flags & 8192 &&
+ type.symbol === symbol) {
+ flags |= 1048576;
+ }
+ if (addUndefined) {
+ type = getOptionalType(type);
+ }
+ return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024, tracker);
}
- return node;
- }
- ts.updatePartiallyEmittedExpression = updatePartiallyEmittedExpression;
- function flattenCommaElements(node) {
- if (ts.nodeIsSynthesized(node) && !ts.isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) {
- if (node.kind === 327) {
- return node.elements;
+ function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
+ var signatureDeclaration = ts.getParseTreeNode(signatureDeclarationIn, ts.isFunctionLike);
+ if (!signatureDeclaration) {
+ return ts.factory.createToken(128);
}
- if (ts.isBinaryExpression(node) && node.operatorToken.kind === 27) {
- return [node.left, node.right];
+ var signature = getSignatureFromDeclaration(signatureDeclaration);
+ return nodeBuilder.typeToTypeNode(getReturnTypeOfSignature(signature), enclosingDeclaration, flags | 1024, tracker);
+ }
+ function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
+ var expr = ts.getParseTreeNode(exprIn, ts.isExpression);
+ if (!expr) {
+ return ts.factory.createToken(128);
}
+ var type = getWidenedType(getRegularTypeOfExpression(expr));
+ return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024, tracker);
}
- return node;
- }
- function createCommaList(elements) {
- var node = createSynthesizedNode(327);
- node.elements = createNodeArray(ts.sameFlatMap(elements, flattenCommaElements));
- return node;
- }
- ts.createCommaList = createCommaList;
- function updateCommaList(node, elements) {
- return node.elements !== elements
- ? updateNode(createCommaList(elements), node)
- : node;
- }
- ts.updateCommaList = updateCommaList;
- function createSyntheticReferenceExpression(expression, thisArg) {
- var node = createSynthesizedNode(330);
- node.expression = expression;
- node.thisArg = thisArg;
- return node;
- }
- ts.createSyntheticReferenceExpression = createSyntheticReferenceExpression;
- function updateSyntheticReferenceExpression(node, expression, thisArg) {
- return node.expression !== expression
- || node.thisArg !== thisArg
- ? updateNode(createSyntheticReferenceExpression(expression, thisArg), node)
- : node;
- }
- ts.updateSyntheticReferenceExpression = updateSyntheticReferenceExpression;
- function createBundle(sourceFiles, prepends) {
- if (prepends === void 0) { prepends = ts.emptyArray; }
- var node = ts.createNode(291);
- node.prepends = prepends;
- node.sourceFiles = sourceFiles;
- return node;
- }
- ts.createBundle = createBundle;
- var allUnscopedEmitHelpers;
- function getAllUnscopedEmitHelpers() {
- return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = ts.arrayToMap([
- ts.valuesHelper,
- ts.readHelper,
- ts.spreadHelper,
- ts.spreadArraysHelper,
- ts.restHelper,
- ts.decorateHelper,
- ts.metadataHelper,
- ts.paramHelper,
- ts.awaiterHelper,
- ts.assignHelper,
- ts.awaitHelper,
- ts.asyncGeneratorHelper,
- ts.asyncDelegator,
- ts.asyncValues,
- ts.extendsHelper,
- ts.templateObjectHelper,
- ts.generatorHelper,
- ts.importStarHelper,
- ts.importDefaultHelper,
- ts.classPrivateFieldGetHelper,
- ts.classPrivateFieldSetHelper,
- ts.createBindingHelper,
- ts.setModuleDefaultHelper
- ], function (helper) { return helper.name; }));
- }
- function createUnparsedSource() {
- var node = ts.createNode(292);
- node.prologues = ts.emptyArray;
- node.referencedFiles = ts.emptyArray;
- node.libReferenceDirectives = ts.emptyArray;
- node.getLineAndCharacterOfPosition = function (pos) { return ts.getLineAndCharacterOfPosition(node, pos); };
- return node;
- }
- function createUnparsedSourceFile(textOrInputFiles, mapPathOrType, mapTextOrStripInternal) {
- var node = createUnparsedSource();
- var stripInternal;
- var bundleFileInfo;
- if (!ts.isString(textOrInputFiles)) {
- ts.Debug.assert(mapPathOrType === "js" || mapPathOrType === "dts");
- node.fileName = (mapPathOrType === "js" ? textOrInputFiles.javascriptPath : textOrInputFiles.declarationPath) || "";
- node.sourceMapPath = mapPathOrType === "js" ? textOrInputFiles.javascriptMapPath : textOrInputFiles.declarationMapPath;
- Object.defineProperties(node, {
- text: { get: function () { return mapPathOrType === "js" ? textOrInputFiles.javascriptText : textOrInputFiles.declarationText; } },
- sourceMapText: { get: function () { return mapPathOrType === "js" ? textOrInputFiles.javascriptMapText : textOrInputFiles.declarationMapText; } },
- });
- if (textOrInputFiles.buildInfo && textOrInputFiles.buildInfo.bundle) {
- node.oldFileOfCurrentEmit = textOrInputFiles.oldFileOfCurrentEmit;
- ts.Debug.assert(mapTextOrStripInternal === undefined || typeof mapTextOrStripInternal === "boolean");
- stripInternal = mapTextOrStripInternal;
- bundleFileInfo = mapPathOrType === "js" ? textOrInputFiles.buildInfo.bundle.js : textOrInputFiles.buildInfo.bundle.dts;
- if (node.oldFileOfCurrentEmit) {
- parseOldFileOfCurrentEmit(node, ts.Debug.checkDefined(bundleFileInfo));
- return node;
+ function hasGlobalName(name) {
+ return globals.has(ts.escapeLeadingUnderscores(name));
+ }
+ function getReferencedValueSymbol(reference, startInDeclarationContainer) {
+ var resolvedSymbol = getNodeLinks(reference).resolvedSymbol;
+ if (resolvedSymbol) {
+ return resolvedSymbol;
+ }
+ var location = reference;
+ if (startInDeclarationContainer) {
+ var parent = reference.parent;
+ if (ts.isDeclaration(parent) && reference === parent.name) {
+ location = getDeclarationContainer(parent);
}
}
+ return resolveName(location, reference.escapedText, 111551 | 1048576 | 2097152, undefined, undefined, true);
}
- else {
- node.fileName = "";
- node.text = textOrInputFiles;
- node.sourceMapPath = mapPathOrType;
- node.sourceMapText = mapTextOrStripInternal;
+ function getReferencedValueDeclaration(referenceIn) {
+ if (!ts.isGeneratedIdentifier(referenceIn)) {
+ var reference = ts.getParseTreeNode(referenceIn, ts.isIdentifier);
+ if (reference) {
+ var symbol = getReferencedValueSymbol(reference);
+ if (symbol) {
+ return getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
+ }
+ }
+ }
+ return undefined;
}
- ts.Debug.assert(!node.oldFileOfCurrentEmit);
- parseUnparsedSourceFile(node, bundleFileInfo, stripInternal);
- return node;
- }
- ts.createUnparsedSourceFile = createUnparsedSourceFile;
- function parseUnparsedSourceFile(node, bundleFileInfo, stripInternal) {
- var prologues;
- var helpers;
- var referencedFiles;
- var typeReferenceDirectives;
- var libReferenceDirectives;
- var texts;
- for (var _i = 0, _a = bundleFileInfo ? bundleFileInfo.sections : ts.emptyArray; _i < _a.length; _i++) {
- var section = _a[_i];
- switch (section.kind) {
- case "prologue":
- (prologues || (prologues = [])).push(createUnparsedNode(section, node));
- break;
- case "emitHelpers":
- (helpers || (helpers = [])).push(getAllUnscopedEmitHelpers().get(section.data));
- break;
- case "no-default-lib":
- node.hasNoDefaultLib = true;
- break;
- case "reference":
- (referencedFiles || (referencedFiles = [])).push({ pos: -1, end: -1, fileName: section.data });
- break;
- case "type":
- (typeReferenceDirectives || (typeReferenceDirectives = [])).push(section.data);
- break;
- case "lib":
- (libReferenceDirectives || (libReferenceDirectives = [])).push({ pos: -1, end: -1, fileName: section.data });
- break;
- case "prepend":
- var prependNode = createUnparsedNode(section, node);
- var prependTexts = void 0;
- for (var _b = 0, _c = section.texts; _b < _c.length; _b++) {
- var text = _c[_b];
- if (!stripInternal || text.kind !== "internal") {
- (prependTexts || (prependTexts = [])).push(createUnparsedNode(text, node));
+ function isLiteralConstDeclaration(node) {
+ if (ts.isDeclarationReadonly(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) {
+ return isFreshLiteralType(getTypeOfSymbol(getSymbolOfNode(node)));
+ }
+ return false;
+ }
+ function literalTypeToNode(type, enclosing, tracker) {
+ var enumResult = type.flags & 1024 ? nodeBuilder.symbolToExpression(type.symbol, 111551, enclosing, undefined, tracker)
+ : type === trueType ? ts.factory.createTrue() : type === falseType && ts.factory.createFalse();
+ if (enumResult)
+ return enumResult;
+ var literalValue = type.value;
+ return typeof literalValue === "object" ? ts.factory.createBigIntLiteral(literalValue) :
+ typeof literalValue === "number" ? ts.factory.createNumericLiteral(literalValue) :
+ ts.factory.createStringLiteral(literalValue);
+ }
+ function createLiteralConstValue(node, tracker) {
+ var type = getTypeOfSymbol(getSymbolOfNode(node));
+ return literalTypeToNode(type, node, tracker);
+ }
+ function getJsxFactoryEntity(location) {
+ return location ? (getJsxNamespace(location), (ts.getSourceFileOfNode(location).localJsxFactory || _jsxFactoryEntity)) : _jsxFactoryEntity;
+ }
+ function getJsxFragmentFactoryEntity(location) {
+ if (location) {
+ var file = ts.getSourceFileOfNode(location);
+ if (file) {
+ if (file.localJsxFragmentFactory) {
+ return file.localJsxFragmentFactory;
+ }
+ var jsxFragPragmas = file.pragmas.get("jsxfrag");
+ var jsxFragPragma = ts.isArray(jsxFragPragmas) ? jsxFragPragmas[0] : jsxFragPragmas;
+ if (jsxFragPragma) {
+ file.localJsxFragmentFactory = ts.parseIsolatedEntityName(jsxFragPragma.arguments.factory, languageVersion);
+ return file.localJsxFragmentFactory;
+ }
+ }
+ }
+ if (compilerOptions.jsxFragmentFactory) {
+ return ts.parseIsolatedEntityName(compilerOptions.jsxFragmentFactory, languageVersion);
+ }
+ }
+ function createResolver() {
+ var resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives();
+ var fileToDirective;
+ if (resolvedTypeReferenceDirectives) {
+ fileToDirective = new ts.Map();
+ resolvedTypeReferenceDirectives.forEach(function (resolvedDirective, key) {
+ if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
+ return;
+ }
+ var file = host.getSourceFile(resolvedDirective.resolvedFileName);
+ if (file) {
+ addReferencedFilesToTypeDirective(file, key);
+ }
+ });
+ }
+ return {
+ getReferencedExportContainer: getReferencedExportContainer,
+ getReferencedImportDeclaration: getReferencedImportDeclaration,
+ getReferencedDeclarationWithCollidingName: getReferencedDeclarationWithCollidingName,
+ isDeclarationWithCollidingName: isDeclarationWithCollidingName,
+ isValueAliasDeclaration: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn);
+ return node ? isValueAliasDeclaration(node) : true;
+ },
+ hasGlobalName: hasGlobalName,
+ isReferencedAliasDeclaration: function (nodeIn, checkChildren) {
+ var node = ts.getParseTreeNode(nodeIn);
+ return node ? isReferencedAliasDeclaration(node, checkChildren) : true;
+ },
+ getNodeCheckFlags: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn);
+ return node ? getNodeCheckFlags(node) : 0;
+ },
+ isTopLevelValueImportEqualsWithEntityName: isTopLevelValueImportEqualsWithEntityName,
+ isDeclarationVisible: isDeclarationVisible,
+ isImplementationOfOverload: isImplementationOfOverload,
+ isRequiredInitializedParameter: isRequiredInitializedParameter,
+ isOptionalUninitializedParameterProperty: isOptionalUninitializedParameterProperty,
+ isExpandoFunctionDeclaration: isExpandoFunctionDeclaration,
+ getPropertiesOfContainerFunction: getPropertiesOfContainerFunction,
+ createTypeOfDeclaration: createTypeOfDeclaration,
+ createReturnTypeOfSignatureDeclaration: createReturnTypeOfSignatureDeclaration,
+ createTypeOfExpression: createTypeOfExpression,
+ createLiteralConstValue: createLiteralConstValue,
+ isSymbolAccessible: isSymbolAccessible,
+ isEntityNameVisible: isEntityNameVisible,
+ getConstantValue: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, canHaveConstantValue);
+ return node ? getConstantValue(node) : undefined;
+ },
+ collectLinkedAliases: collectLinkedAliases,
+ getReferencedValueDeclaration: getReferencedValueDeclaration,
+ getTypeReferenceSerializationKind: getTypeReferenceSerializationKind,
+ isOptionalParameter: isOptionalParameter,
+ moduleExportsSomeValue: moduleExportsSomeValue,
+ isArgumentsLocalBinding: isArgumentsLocalBinding,
+ getExternalModuleFileFromDeclaration: getExternalModuleFileFromDeclaration,
+ getTypeReferenceDirectivesForEntityName: getTypeReferenceDirectivesForEntityName,
+ getTypeReferenceDirectivesForSymbol: getTypeReferenceDirectivesForSymbol,
+ isLiteralConstDeclaration: isLiteralConstDeclaration,
+ isLateBound: function (nodeIn) {
+ var node = ts.getParseTreeNode(nodeIn, ts.isDeclaration);
+ var symbol = node && getSymbolOfNode(node);
+ return !!(symbol && ts.getCheckFlags(symbol) & 4096);
+ },
+ getJsxFactoryEntity: getJsxFactoryEntity,
+ getJsxFragmentFactoryEntity: getJsxFragmentFactoryEntity,
+ getAllAccessorDeclarations: function (accessor) {
+ accessor = ts.getParseTreeNode(accessor, ts.isGetOrSetAccessorDeclaration);
+ var otherKind = accessor.kind === 168 ? 167 : 168;
+ var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(accessor), otherKind);
+ var firstAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? otherAccessor : accessor;
+ var secondAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? accessor : otherAccessor;
+ var setAccessor = accessor.kind === 168 ? accessor : otherAccessor;
+ var getAccessor = accessor.kind === 167 ? accessor : otherAccessor;
+ return {
+ firstAccessor: firstAccessor,
+ secondAccessor: secondAccessor,
+ setAccessor: setAccessor,
+ getAccessor: getAccessor
+ };
+ },
+ getSymbolOfExternalModuleSpecifier: function (moduleName) { return resolveExternalModuleNameWorker(moduleName, moduleName, undefined); },
+ isBindingCapturedByNode: function (node, decl) {
+ var parseNode = ts.getParseTreeNode(node);
+ var parseDecl = ts.getParseTreeNode(decl);
+ return !!parseNode && !!parseDecl && (ts.isVariableDeclaration(parseDecl) || ts.isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
+ },
+ getDeclarationStatementsForSourceFile: function (node, flags, tracker, bundled) {
+ var n = ts.getParseTreeNode(node);
+ ts.Debug.assert(n && n.kind === 297, "Non-sourcefile node passed into getDeclarationsForSourceFile");
+ var sym = getSymbolOfNode(node);
+ if (!sym) {
+ return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker, bundled);
+ }
+ return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker, bundled);
+ },
+ isImportRequiredByAugmentation: isImportRequiredByAugmentation,
+ };
+ function isImportRequiredByAugmentation(node) {
+ var file = ts.getSourceFileOfNode(node);
+ if (!file.symbol)
+ return false;
+ var importTarget = getExternalModuleFileFromDeclaration(node);
+ if (!importTarget)
+ return false;
+ if (importTarget === file)
+ return false;
+ var exports = getExportsOfModule(file.symbol);
+ for (var _i = 0, _a = ts.arrayFrom(exports.values()); _i < _a.length; _i++) {
+ var s = _a[_i];
+ if (s.mergeId) {
+ var merged = getMergedSymbol(s);
+ for (var _b = 0, _c = merged.declarations; _b < _c.length; _b++) {
+ var d = _c[_b];
+ var declFile = ts.getSourceFileOfNode(d);
+ if (declFile === importTarget) {
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+ function isInHeritageClause(node) {
+ return node.parent && node.parent.kind === 223 && node.parent.parent && node.parent.parent.kind === 286;
+ }
+ function getTypeReferenceDirectivesForEntityName(node) {
+ if (!fileToDirective) {
+ return undefined;
+ }
+ var meaning = 788968 | 1920;
+ if ((node.kind === 78 && isInTypeQuery(node)) || (node.kind === 201 && !isInHeritageClause(node))) {
+ meaning = 111551 | 1048576;
+ }
+ var symbol = resolveEntityName(node, meaning, true);
+ return symbol && symbol !== unknownSymbol ? getTypeReferenceDirectivesForSymbol(symbol, meaning) : undefined;
+ }
+ function getTypeReferenceDirectivesForSymbol(symbol, meaning) {
+ if (!fileToDirective) {
+ return undefined;
+ }
+ if (!isSymbolFromTypeDeclarationFile(symbol)) {
+ return undefined;
+ }
+ var typeReferenceDirectives;
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ if (decl.symbol && decl.symbol.flags & meaning) {
+ var file = ts.getSourceFileOfNode(decl);
+ var typeReferenceDirective = fileToDirective.get(file.path);
+ if (typeReferenceDirective) {
+ (typeReferenceDirectives || (typeReferenceDirectives = [])).push(typeReferenceDirective);
+ }
+ else {
+ return undefined;
+ }
+ }
+ }
+ return typeReferenceDirectives;
+ }
+ function isSymbolFromTypeDeclarationFile(symbol) {
+ if (!symbol.declarations) {
+ return false;
+ }
+ var current = symbol;
+ while (true) {
+ var parent = getParentOfSymbol(current);
+ if (parent) {
+ current = parent;
+ }
+ else {
+ break;
+ }
+ }
+ if (current.valueDeclaration && current.valueDeclaration.kind === 297 && current.flags & 512) {
+ return false;
+ }
+ for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ var file = ts.getSourceFileOfNode(decl);
+ if (fileToDirective.has(file.path)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ function addReferencedFilesToTypeDirective(file, key) {
+ if (fileToDirective.has(file.path))
+ return;
+ fileToDirective.set(file.path, key);
+ for (var _i = 0, _a = file.referencedFiles; _i < _a.length; _i++) {
+ var fileName = _a[_i].fileName;
+ var resolvedFile = ts.resolveTripleslashReference(fileName, file.fileName);
+ var referencedFile = host.getSourceFile(resolvedFile);
+ if (referencedFile) {
+ addReferencedFilesToTypeDirective(referencedFile, key);
+ }
+ }
+ }
+ }
+ function getExternalModuleFileFromDeclaration(declaration) {
+ var specifier = declaration.kind === 256 ? ts.tryCast(declaration.name, ts.isStringLiteral) : ts.getExternalModuleName(declaration);
+ var moduleSymbol = resolveExternalModuleNameWorker(specifier, specifier, undefined);
+ if (!moduleSymbol) {
+ return undefined;
+ }
+ return ts.getDeclarationOfKind(moduleSymbol, 297);
+ }
+ function initializeTypeChecker() {
+ for (var _i = 0, _a = host.getSourceFiles(); _i < _a.length; _i++) {
+ var file = _a[_i];
+ ts.bindSourceFile(file, compilerOptions);
+ }
+ amalgamatedDuplicates = new ts.Map();
+ var augmentations;
+ for (var _b = 0, _c = host.getSourceFiles(); _b < _c.length; _b++) {
+ var file = _c[_b];
+ if (file.redirectInfo) {
+ continue;
+ }
+ if (!ts.isExternalOrCommonJsModule(file)) {
+ var fileGlobalThisSymbol = file.locals.get("globalThis");
+ if (fileGlobalThisSymbol) {
+ for (var _d = 0, _e = fileGlobalThisSymbol.declarations; _d < _e.length; _d++) {
+ var declaration = _e[_d];
+ diagnostics.add(ts.createDiagnosticForNode(declaration, ts.Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0, "globalThis"));
+ }
+ }
+ mergeSymbolTable(globals, file.locals);
+ }
+ if (file.jsGlobalAugmentations) {
+ mergeSymbolTable(globals, file.jsGlobalAugmentations);
+ }
+ if (file.patternAmbientModules && file.patternAmbientModules.length) {
+ patternAmbientModules = ts.concatenate(patternAmbientModules, file.patternAmbientModules);
+ }
+ if (file.moduleAugmentations.length) {
+ (augmentations || (augmentations = [])).push(file.moduleAugmentations);
+ }
+ if (file.symbol && file.symbol.globalExports) {
+ var source = file.symbol.globalExports;
+ source.forEach(function (sourceSymbol, id) {
+ if (!globals.has(id)) {
+ globals.set(id, sourceSymbol);
+ }
+ });
+ }
+ }
+ if (augmentations) {
+ for (var _f = 0, augmentations_1 = augmentations; _f < augmentations_1.length; _f++) {
+ var list = augmentations_1[_f];
+ for (var _g = 0, list_1 = list; _g < list_1.length; _g++) {
+ var augmentation = list_1[_g];
+ if (!ts.isGlobalScopeAugmentation(augmentation.parent))
+ continue;
+ mergeModuleAugmentation(augmentation);
+ }
+ }
+ }
+ addToSymbolTable(globals, builtinGlobals, ts.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, 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(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);
+ }
+ globalReadonlyArrayType = getGlobalTypeOrUndefined("ReadonlyArray", 1) || globalArrayType;
+ anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;
+ globalThisType = getGlobalTypeOrUndefined("ThisType", 1);
+ if (augmentations) {
+ for (var _h = 0, augmentations_2 = augmentations; _h < augmentations_2.length; _h++) {
+ var list = augmentations_2[_h];
+ for (var _j = 0, list_2 = list; _j < list_2.length; _j++) {
+ var augmentation = list_2[_j];
+ if (ts.isGlobalScopeAugmentation(augmentation.parent))
+ continue;
+ mergeModuleAugmentation(augmentation);
+ }
+ }
+ }
+ amalgamatedDuplicates.forEach(function (_a) {
+ var firstFile = _a.firstFile, secondFile = _a.secondFile, conflictingSymbols = _a.conflictingSymbols;
+ if (conflictingSymbols.size < 8) {
+ conflictingSymbols.forEach(function (_a, symbolName) {
+ var isBlockScoped = _a.isBlockScoped, firstFileLocations = _a.firstFileLocations, secondFileLocations = _a.secondFileLocations;
+ var message = isBlockScoped ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 : ts.Diagnostics.Duplicate_identifier_0;
+ for (var _i = 0, firstFileLocations_1 = firstFileLocations; _i < firstFileLocations_1.length; _i++) {
+ var node = firstFileLocations_1[_i];
+ addDuplicateDeclarationError(node, message, symbolName, secondFileLocations);
+ }
+ for (var _b = 0, secondFileLocations_1 = secondFileLocations; _b < secondFileLocations_1.length; _b++) {
+ var node = secondFileLocations_1[_b];
+ addDuplicateDeclarationError(node, message, symbolName, firstFileLocations);
+ }
+ });
+ }
+ else {
+ var list = ts.arrayFrom(conflictingSymbols.keys()).join(", ");
+ diagnostics.add(ts.addRelatedInfo(ts.createDiagnosticForNode(firstFile, ts.Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list), ts.createDiagnosticForNode(secondFile, ts.Diagnostics.Conflicts_are_in_this_file)));
+ diagnostics.add(ts.addRelatedInfo(ts.createDiagnosticForNode(secondFile, ts.Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list), ts.createDiagnosticForNode(firstFile, ts.Diagnostics.Conflicts_are_in_this_file)));
+ }
+ });
+ amalgamatedDuplicates = undefined;
+ }
+ function checkExternalEmitHelpers(location, helpers) {
+ if ((requestedExternalEmitHelpers & helpers) !== helpers && compilerOptions.importHelpers) {
+ var sourceFile = ts.getSourceFileOfNode(location);
+ if (ts.isEffectiveExternalModule(sourceFile, compilerOptions) && !(location.flags & 8388608)) {
+ var helpersModule = resolveHelpersModule(sourceFile, location);
+ if (helpersModule !== unknownSymbol) {
+ var uncheckedHelpers = helpers & ~requestedExternalEmitHelpers;
+ for (var helper = 1; helper <= 4194304; helper <<= 1) {
+ if (uncheckedHelpers & helper) {
+ var name = getHelperName(helper);
+ var symbol = getSymbol(helpersModule.exports, ts.escapeLeadingUnderscores(name), 111551);
+ if (!symbol) {
+ error(location, ts.Diagnostics.This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0, ts.externalHelpersModuleNameText, name);
+ }
+ }
}
}
- prependNode.texts = prependTexts || ts.emptyArray;
- (texts || (texts = [])).push(prependNode);
- break;
- case "internal":
- if (stripInternal) {
- if (!texts)
- texts = [];
- break;
- }
- case "text":
- (texts || (texts = [])).push(createUnparsedNode(section, node));
- break;
- default:
- ts.Debug.assertNever(section);
+ requestedExternalEmitHelpers |= helpers;
+ }
}
}
- node.prologues = prologues || ts.emptyArray;
- node.helpers = helpers;
- node.referencedFiles = referencedFiles || ts.emptyArray;
- node.typeReferenceDirectives = typeReferenceDirectives;
- node.libReferenceDirectives = libReferenceDirectives || ts.emptyArray;
- node.texts = texts || [createUnparsedNode({ kind: "text", pos: 0, end: node.text.length }, node)];
- }
- function parseOldFileOfCurrentEmit(node, bundleFileInfo) {
- ts.Debug.assert(!!node.oldFileOfCurrentEmit);
- var texts;
- var syntheticReferences;
- for (var _i = 0, _a = bundleFileInfo.sections; _i < _a.length; _i++) {
- var section = _a[_i];
- switch (section.kind) {
- case "internal":
- case "text":
- (texts || (texts = [])).push(createUnparsedNode(section, node));
- break;
- case "no-default-lib":
- case "reference":
- case "type":
- case "lib":
- (syntheticReferences || (syntheticReferences = [])).push(createUnparsedSyntheticReference(section, node));
- break;
- case "prologue":
- case "emitHelpers":
- case "prepend":
- break;
- default:
- ts.Debug.assertNever(section);
+ function getHelperName(helper) {
+ switch (helper) {
+ case 1: return "__extends";
+ case 2: return "__assign";
+ case 4: return "__rest";
+ case 8: return "__decorate";
+ case 16: return "__metadata";
+ case 32: return "__param";
+ case 64: return "__awaiter";
+ case 128: return "__generator";
+ case 256: return "__values";
+ case 512: return "__read";
+ case 1024: return "__spread";
+ case 2048: return "__spreadArrays";
+ case 4096: return "__await";
+ case 8192: return "__asyncGenerator";
+ case 16384: return "__asyncDelegator";
+ case 32768: return "__asyncValues";
+ case 65536: return "__exportStar";
+ case 131072: return "__importStar";
+ case 262144: return "__importDefault";
+ case 524288: return "__makeTemplateObject";
+ case 1048576: return "__classPrivateFieldGet";
+ case 2097152: return "__classPrivateFieldSet";
+ case 4194304: return "__createBinding";
+ default: return ts.Debug.fail("Unrecognized helper");
}
}
- node.texts = texts || ts.emptyArray;
- node.helpers = ts.map(bundleFileInfo.sources && bundleFileInfo.sources.helpers, function (name) { return getAllUnscopedEmitHelpers().get(name); });
- node.syntheticReferences = syntheticReferences;
- return node;
- }
- function mapBundleFileSectionKindToSyntaxKind(kind) {
- switch (kind) {
- case "prologue": return 285;
- case "prepend": return 286;
- case "internal": return 288;
- case "text": return 287;
- case "emitHelpers":
- case "no-default-lib":
- case "reference":
- case "type":
- case "lib":
- return ts.Debug.fail("BundleFileSectionKind: " + kind + " not yet mapped to SyntaxKind");
- default:
- return ts.Debug.assertNever(kind);
+ function resolveHelpersModule(node, errorNode) {
+ if (!externalHelpersModule) {
+ externalHelpersModule = resolveExternalModule(node, ts.externalHelpersModuleNameText, ts.Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found, errorNode) || unknownSymbol;
+ }
+ return externalHelpersModule;
}
- }
- function createUnparsedNode(section, parent) {
- var node = ts.createNode(mapBundleFileSectionKindToSyntaxKind(section.kind), section.pos, section.end);
- node.parent = parent;
- node.data = section.data;
- return node;
- }
- function createUnparsedSyntheticReference(section, parent) {
- var node = ts.createNode(289, section.pos, section.end);
- node.parent = parent;
- node.data = section.data;
- node.section = section;
- return node;
- }
- function createInputFiles(javascriptTextOrReadFileText, declarationTextOrJavascriptPath, javascriptMapPath, javascriptMapTextOrDeclarationPath, declarationMapPath, declarationMapTextOrBuildInfoPath, javascriptPath, declarationPath, buildInfoPath, buildInfo, oldFileOfCurrentEmit) {
- var node = ts.createNode(293);
- if (!ts.isString(javascriptTextOrReadFileText)) {
- var cache_1 = ts.createMap();
- var textGetter_1 = function (path) {
- if (path === undefined)
- return undefined;
- var value = cache_1.get(path);
- if (value === undefined) {
- value = javascriptTextOrReadFileText(path);
- cache_1.set(path, value !== undefined ? value : false);
+ function checkGrammarDecoratorsAndModifiers(node) {
+ return checkGrammarDecorators(node) || checkGrammarModifiers(node);
+ }
+ function checkGrammarDecorators(node) {
+ if (!node.decorators) {
+ return false;
+ }
+ if (!ts.nodeCanBeDecorated(node, node.parent, node.parent.parent)) {
+ if (node.kind === 165 && !ts.nodeIsPresent(node.body)) {
+ return grammarErrorOnFirstToken(node, ts.Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload);
}
- return value !== false ? value : undefined;
- };
- var definedTextGetter_1 = function (path) {
- var result = textGetter_1(path);
- return result !== undefined ? result : "/* Input file " + path + " was missing */\r\n";
- };
- var buildInfo_1;
- var getAndCacheBuildInfo_1 = function (getText) {
- if (buildInfo_1 === undefined) {
- var result = getText();
- buildInfo_1 = result !== undefined ? ts.getBuildInfo(result) : false;
+ else {
+ return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_not_valid_here);
}
- return buildInfo_1 || undefined;
- };
- node.javascriptPath = declarationTextOrJavascriptPath;
- node.javascriptMapPath = javascriptMapPath;
- node.declarationPath = ts.Debug.checkDefined(javascriptMapTextOrDeclarationPath);
- node.declarationMapPath = declarationMapPath;
- node.buildInfoPath = declarationMapTextOrBuildInfoPath;
- Object.defineProperties(node, {
- javascriptText: { get: function () { return definedTextGetter_1(declarationTextOrJavascriptPath); } },
- javascriptMapText: { get: function () { return textGetter_1(javascriptMapPath); } },
- declarationText: { get: function () { return definedTextGetter_1(ts.Debug.checkDefined(javascriptMapTextOrDeclarationPath)); } },
- declarationMapText: { get: function () { return textGetter_1(declarationMapPath); } },
- buildInfo: { get: function () { return getAndCacheBuildInfo_1(function () { return textGetter_1(declarationMapTextOrBuildInfoPath); }); } }
- });
- }
- else {
- node.javascriptText = javascriptTextOrReadFileText;
- node.javascriptMapPath = javascriptMapPath;
- node.javascriptMapText = javascriptMapTextOrDeclarationPath;
- node.declarationText = declarationTextOrJavascriptPath;
- node.declarationMapPath = declarationMapPath;
- node.declarationMapText = declarationMapTextOrBuildInfoPath;
- node.javascriptPath = javascriptPath;
- node.declarationPath = declarationPath;
- node.buildInfoPath = buildInfoPath;
- node.buildInfo = buildInfo;
- node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
- }
- return node;
- }
- ts.createInputFiles = createInputFiles;
- function updateBundle(node, sourceFiles, prepends) {
- if (prepends === void 0) { prepends = ts.emptyArray; }
- if (node.sourceFiles !== sourceFiles || node.prepends !== prepends) {
- return createBundle(sourceFiles, prepends);
- }
- return node;
- }
- ts.updateBundle = updateBundle;
- function createImmediatelyInvokedFunctionExpression(statements, param, paramValue) {
- return createCall(createFunctionExpression(undefined, undefined, undefined, undefined, param ? [param] : [], undefined, createBlock(statements, true)), undefined, paramValue ? [paramValue] : []);
- }
- ts.createImmediatelyInvokedFunctionExpression = createImmediatelyInvokedFunctionExpression;
- function createImmediatelyInvokedArrowFunction(statements, param, paramValue) {
- return createCall(createArrowFunction(undefined, undefined, param ? [param] : [], undefined, undefined, createBlock(statements, true)), undefined, paramValue ? [paramValue] : []);
- }
- ts.createImmediatelyInvokedArrowFunction = createImmediatelyInvokedArrowFunction;
- function createComma(left, right) {
- return createBinary(left, 27, right);
- }
- ts.createComma = createComma;
- function createLessThan(left, right) {
- return createBinary(left, 29, right);
- }
- ts.createLessThan = createLessThan;
- function createAssignment(left, right) {
- return createBinary(left, 62, right);
- }
- ts.createAssignment = createAssignment;
- function createStrictEquality(left, right) {
- return createBinary(left, 36, right);
- }
- ts.createStrictEquality = createStrictEquality;
- function createStrictInequality(left, right) {
- return createBinary(left, 37, right);
- }
- ts.createStrictInequality = createStrictInequality;
- function createAdd(left, right) {
- return createBinary(left, 39, right);
- }
- ts.createAdd = createAdd;
- function createSubtract(left, right) {
- return createBinary(left, 40, right);
- }
- ts.createSubtract = createSubtract;
- function createPostfixIncrement(operand) {
- return createPostfix(operand, 45);
- }
- ts.createPostfixIncrement = createPostfixIncrement;
- function createLogicalAnd(left, right) {
- return createBinary(left, 55, right);
- }
- ts.createLogicalAnd = createLogicalAnd;
- function createLogicalOr(left, right) {
- return createBinary(left, 56, right);
- }
- ts.createLogicalOr = createLogicalOr;
- function createNullishCoalesce(left, right) {
- return createBinary(left, 60, right);
- }
- ts.createNullishCoalesce = createNullishCoalesce;
- function createLogicalNot(operand) {
- return createPrefix(53, operand);
- }
- ts.createLogicalNot = createLogicalNot;
- function createVoidZero() {
- return createVoid(createLiteral(0));
- }
- ts.createVoidZero = createVoidZero;
- function createExportDefault(expression) {
- return createExportAssignment(undefined, undefined, false, expression);
- }
- ts.createExportDefault = createExportDefault;
- function createExternalModuleExport(exportName) {
- return createExportDeclaration(undefined, undefined, createNamedExports([createExportSpecifier(undefined, exportName)]));
- }
- ts.createExternalModuleExport = createExternalModuleExport;
- function asName(name) {
- return ts.isString(name) ? 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 asNodeArray(array) {
- return array ? createNodeArray(array) : undefined;
- }
- function asToken(value) {
- return typeof value === "number" ? createToken(value) : value;
- }
- function asEmbeddedStatement(statement) {
- return statement && ts.isNotEmittedStatement(statement) ? setTextRange(setOriginalNode(createEmptyStatement(), statement), statement) : statement;
- }
- function disposeEmitNodes(sourceFile) {
- sourceFile = ts.getSourceFileOfNode(ts.getParseTreeNode(sourceFile));
- var emitNode = sourceFile && sourceFile.emitNode;
- var annotatedNodes = emitNode && emitNode.annotatedNodes;
- if (annotatedNodes) {
- for (var _i = 0, annotatedNodes_1 = annotatedNodes; _i < annotatedNodes_1.length; _i++) {
- var node = annotatedNodes_1[_i];
- node.emitNode = undefined;
}
- }
- }
- ts.disposeEmitNodes = disposeEmitNodes;
- function getOrCreateEmitNode(node) {
- if (!node.emitNode) {
- if (ts.isParseTreeNode(node)) {
- if (node.kind === 290) {
- return node.emitNode = { annotatedNodes: [node] };
+ else if (node.kind === 167 || node.kind === 168) {
+ var accessors = ts.getAllAccessorDeclarations(node.parent.members, node);
+ if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) {
+ return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
}
- var sourceFile = ts.getSourceFileOfNode(ts.getParseTreeNode(ts.getSourceFileOfNode(node)));
- getOrCreateEmitNode(sourceFile).annotatedNodes.push(node);
}
- node.emitNode = {};
- }
- return node.emitNode;
- }
- ts.getOrCreateEmitNode = getOrCreateEmitNode;
- function removeAllComments(node) {
- var emitNode = getOrCreateEmitNode(node);
- emitNode.flags |= 1536;
- emitNode.leadingComments = undefined;
- emitNode.trailingComments = undefined;
- return node;
- }
- ts.removeAllComments = removeAllComments;
- function setTextRange(range, location) {
- if (location) {
- range.pos = location.pos;
- range.end = location.end;
+ return false;
}
- return range;
- }
- ts.setTextRange = setTextRange;
- function setEmitFlags(node, emitFlags) {
- getOrCreateEmitNode(node).flags = emitFlags;
- return node;
- }
- ts.setEmitFlags = setEmitFlags;
- function addEmitFlags(node, emitFlags) {
- var emitNode = getOrCreateEmitNode(node);
- emitNode.flags = emitNode.flags | emitFlags;
- return node;
- }
- ts.addEmitFlags = addEmitFlags;
- function getSourceMapRange(node) {
- var emitNode = node.emitNode;
- return (emitNode && emitNode.sourceMapRange) || node;
- }
- ts.getSourceMapRange = getSourceMapRange;
- function setSourceMapRange(node, range) {
- getOrCreateEmitNode(node).sourceMapRange = range;
- return node;
- }
- ts.setSourceMapRange = setSourceMapRange;
- var SourceMapSource;
- function createSourceMapSource(fileName, text, skipTrivia) {
- return new (SourceMapSource || (SourceMapSource = ts.objectAllocator.getSourceMapSourceConstructor()))(fileName, text, skipTrivia);
- }
- ts.createSourceMapSource = createSourceMapSource;
- function getTokenSourceMapRange(node, token) {
- var emitNode = node.emitNode;
- var tokenSourceMapRanges = emitNode && emitNode.tokenSourceMapRanges;
- return tokenSourceMapRanges && tokenSourceMapRanges[token];
- }
- ts.getTokenSourceMapRange = getTokenSourceMapRange;
- function setTokenSourceMapRange(node, token, range) {
- var emitNode = getOrCreateEmitNode(node);
- var tokenSourceMapRanges = emitNode.tokenSourceMapRanges || (emitNode.tokenSourceMapRanges = []);
- tokenSourceMapRanges[token] = range;
- return node;
- }
- ts.setTokenSourceMapRange = setTokenSourceMapRange;
- function getStartsOnNewLine(node) {
- var emitNode = node.emitNode;
- return emitNode && emitNode.startsOnNewLine;
- }
- ts.getStartsOnNewLine = getStartsOnNewLine;
- function setStartsOnNewLine(node, newLine) {
- getOrCreateEmitNode(node).startsOnNewLine = newLine;
- return node;
- }
- ts.setStartsOnNewLine = setStartsOnNewLine;
- function getCommentRange(node) {
- var emitNode = node.emitNode;
- return (emitNode && emitNode.commentRange) || node;
- }
- ts.getCommentRange = getCommentRange;
- function setCommentRange(node, range) {
- getOrCreateEmitNode(node).commentRange = range;
- return node;
- }
- ts.setCommentRange = setCommentRange;
- function getSyntheticLeadingComments(node) {
- var emitNode = node.emitNode;
- return emitNode && emitNode.leadingComments;
- }
- ts.getSyntheticLeadingComments = getSyntheticLeadingComments;
- function setSyntheticLeadingComments(node, comments) {
- getOrCreateEmitNode(node).leadingComments = comments;
- return node;
- }
- ts.setSyntheticLeadingComments = setSyntheticLeadingComments;
- function addSyntheticLeadingComment(node, kind, text, hasTrailingNewLine) {
- return setSyntheticLeadingComments(node, ts.append(getSyntheticLeadingComments(node), { kind: kind, pos: -1, end: -1, hasTrailingNewLine: hasTrailingNewLine, text: text }));
- }
- ts.addSyntheticLeadingComment = addSyntheticLeadingComment;
- function getSyntheticTrailingComments(node) {
- var emitNode = node.emitNode;
- return emitNode && emitNode.trailingComments;
- }
- ts.getSyntheticTrailingComments = getSyntheticTrailingComments;
- function setSyntheticTrailingComments(node, comments) {
- getOrCreateEmitNode(node).trailingComments = comments;
- return node;
- }
- ts.setSyntheticTrailingComments = setSyntheticTrailingComments;
- function addSyntheticTrailingComment(node, kind, text, hasTrailingNewLine) {
- return setSyntheticTrailingComments(node, ts.append(getSyntheticTrailingComments(node), { kind: kind, pos: -1, end: -1, hasTrailingNewLine: hasTrailingNewLine, text: text }));
- }
- ts.addSyntheticTrailingComment = addSyntheticTrailingComment;
- function moveSyntheticComments(node, original) {
- setSyntheticLeadingComments(node, getSyntheticLeadingComments(original));
- setSyntheticTrailingComments(node, getSyntheticTrailingComments(original));
- var emit = getOrCreateEmitNode(original);
- emit.leadingComments = undefined;
- emit.trailingComments = undefined;
- return node;
- }
- ts.moveSyntheticComments = moveSyntheticComments;
- function ignoreSourceNewlines(node) {
- getOrCreateEmitNode(node).flags |= 134217728;
- return node;
- }
- ts.ignoreSourceNewlines = ignoreSourceNewlines;
- function getConstantValue(node) {
- var emitNode = node.emitNode;
- return emitNode && emitNode.constantValue;
- }
- ts.getConstantValue = getConstantValue;
- function setConstantValue(node, value) {
- var emitNode = getOrCreateEmitNode(node);
- emitNode.constantValue = value;
- return node;
- }
- ts.setConstantValue = setConstantValue;
- function addEmitHelper(node, helper) {
- var emitNode = getOrCreateEmitNode(node);
- emitNode.helpers = ts.append(emitNode.helpers, helper);
- return node;
- }
- ts.addEmitHelper = addEmitHelper;
- function addEmitHelpers(node, helpers) {
- if (ts.some(helpers)) {
- var emitNode = getOrCreateEmitNode(node);
- for (var _i = 0, helpers_1 = helpers; _i < helpers_1.length; _i++) {
- var helper = helpers_1[_i];
- emitNode.helpers = ts.appendIfUnique(emitNode.helpers, helper);
+ function checkGrammarModifiers(node) {
+ var quickResult = reportObviousModifierErrors(node);
+ if (quickResult !== undefined) {
+ return quickResult;
+ }
+ var lastStatic, lastDeclare, lastAsync, lastReadonly;
+ var flags = 0;
+ for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
+ var modifier = _a[_i];
+ if (modifier.kind !== 142) {
+ if (node.kind === 162 || node.kind === 164) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_type_member, ts.tokenToString(modifier.kind));
+ }
+ if (node.kind === 171) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_an_index_signature, ts.tokenToString(modifier.kind));
+ }
+ }
+ switch (modifier.kind) {
+ case 84:
+ if (node.kind !== 255) {
+ return grammarErrorOnNode(node, ts.Diagnostics.A_class_member_cannot_have_the_0_keyword, ts.tokenToString(84));
+ }
+ break;
+ case 122:
+ case 121:
+ case 120:
+ var text = visibilityToString(ts.modifierToFlag(modifier.kind));
+ if (flags & 28) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen);
+ }
+ else if (flags & 32) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
+ }
+ else if (flags & 64) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly");
+ }
+ else if (flags & 256) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
+ }
+ else if (node.parent.kind === 257 || node.parent.kind === 297) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, text);
+ }
+ else if (flags & 128) {
+ if (modifier.kind === 120) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
+ }
+ else {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract");
+ }
+ }
+ else if (ts.isPrivateIdentifierPropertyDeclaration(node)) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier);
+ }
+ flags |= ts.modifierToFlag(modifier.kind);
+ break;
+ case 123:
+ if (flags & 32) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static");
+ }
+ else if (flags & 64) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "readonly");
+ }
+ else if (flags & 256) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
+ }
+ else if (node.parent.kind === 257 || node.parent.kind === 297) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static");
+ }
+ else if (node.kind === 160) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
+ }
+ else if (flags & 128) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
+ }
+ else if (ts.isPrivateIdentifierPropertyDeclaration(node)) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "static");
+ }
+ flags |= 32;
+ lastStatic = modifier;
+ break;
+ case 142:
+ if (flags & 64) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "readonly");
+ }
+ else if (node.kind !== 163 && node.kind !== 162 && node.kind !== 171 && node.kind !== 160) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature);
+ }
+ flags |= 64;
+ lastReadonly = modifier;
+ break;
+ case 92:
+ if (flags & 1) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export");
+ }
+ else if (flags & 2) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
+ }
+ else if (flags & 128) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
+ }
+ else if (flags & 256) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
+ }
+ else if (ts.isClassLike(node.parent)) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "export");
+ }
+ else if (node.kind === 160) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
+ }
+ flags |= 1;
+ break;
+ case 87:
+ var container = node.parent.kind === 297 ? node.parent : node.parent.parent;
+ if (container.kind === 256 && !ts.isAmbientModule(container)) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module);
+ }
+ flags |= 512;
+ break;
+ case 133:
+ if (flags & 2) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare");
+ }
+ else if (flags & 256) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
+ }
+ else if (ts.isClassLike(node.parent) && !ts.isPropertyDeclaration(node)) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "declare");
+ }
+ else if (node.kind === 160) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare");
+ }
+ else if ((node.parent.flags & 8388608) && node.parent.kind === 257) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
+ }
+ else if (ts.isPrivateIdentifierPropertyDeclaration(node)) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "declare");
+ }
+ flags |= 2;
+ lastDeclare = modifier;
+ break;
+ case 125:
+ if (flags & 128) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract");
+ }
+ if (node.kind !== 252) {
+ if (node.kind !== 165 &&
+ node.kind !== 163 &&
+ node.kind !== 167 &&
+ node.kind !== 168) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration);
+ }
+ if (!(node.parent.kind === 252 && ts.hasSyntacticModifier(node.parent, 128))) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
+ }
+ if (flags & 32) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
+ }
+ if (flags & 8) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
+ }
+ if (flags & 256 && lastAsync) {
+ return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
+ }
+ }
+ if (ts.isNamedDeclaration(node) && node.name.kind === 79) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "abstract");
+ }
+ flags |= 128;
+ break;
+ case 129:
+ if (flags & 256) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async");
+ }
+ else if (flags & 2 || node.parent.flags & 8388608) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
+ }
+ else if (node.kind === 160) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
+ }
+ if (flags & 128) {
+ return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
+ }
+ flags |= 256;
+ lastAsync = modifier;
+ break;
+ }
+ }
+ if (node.kind === 166) {
+ if (flags & 32) {
+ return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
+ }
+ if (flags & 128) {
+ return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "abstract");
+ }
+ else if (flags & 256) {
+ return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
+ }
+ else if (flags & 64) {
+ return grammarErrorOnNode(lastReadonly, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "readonly");
+ }
+ return false;
+ }
+ else if ((node.kind === 261 || node.kind === 260) && flags & 2) {
+ return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
+ }
+ else if (node.kind === 160 && (flags & 92) && ts.isBindingPattern(node.name)) {
+ return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern);
+ }
+ else if (node.kind === 160 && (flags & 92) && node.dotDotDotToken) {
+ return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter);
+ }
+ if (flags & 256) {
+ return checkGrammarAsyncModifier(node, lastAsync);
}
+ return false;
+ }
+ function reportObviousModifierErrors(node) {
+ return !node.modifiers
+ ? false
+ : shouldReportBadModifier(node)
+ ? grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here)
+ : undefined;
}
- return node;
- }
- ts.addEmitHelpers = addEmitHelpers;
- function removeEmitHelper(node, helper) {
- var emitNode = node.emitNode;
- if (emitNode) {
- var helpers = emitNode.helpers;
- if (helpers) {
- return ts.orderedRemoveItem(helpers, helper);
+ function shouldReportBadModifier(node) {
+ switch (node.kind) {
+ case 167:
+ case 168:
+ case 166:
+ case 163:
+ case 162:
+ case 165:
+ case 164:
+ case 171:
+ case 256:
+ case 261:
+ case 260:
+ case 267:
+ case 266:
+ case 208:
+ case 209:
+ case 160:
+ return false;
+ default:
+ if (node.parent.kind === 257 || node.parent.kind === 297) {
+ return false;
+ }
+ switch (node.kind) {
+ case 251:
+ return nodeHasAnyModifiersExcept(node, 129);
+ case 252:
+ return nodeHasAnyModifiersExcept(node, 125);
+ case 253:
+ case 232:
+ case 254:
+ return true;
+ case 255:
+ return nodeHasAnyModifiersExcept(node, 84);
+ default:
+ ts.Debug.fail();
+ return false;
+ }
}
}
- return false;
- }
- ts.removeEmitHelper = removeEmitHelper;
- function getEmitHelpers(node) {
- var emitNode = node.emitNode;
- return emitNode && emitNode.helpers;
- }
- ts.getEmitHelpers = getEmitHelpers;
- function moveEmitHelpers(source, target, predicate) {
- var sourceEmitNode = source.emitNode;
- var sourceEmitHelpers = sourceEmitNode && sourceEmitNode.helpers;
- if (!ts.some(sourceEmitHelpers))
- return;
- var targetEmitNode = getOrCreateEmitNode(target);
- var helpersRemoved = 0;
- for (var i = 0; i < sourceEmitHelpers.length; i++) {
- var helper = sourceEmitHelpers[i];
- if (predicate(helper)) {
- helpersRemoved++;
- targetEmitNode.helpers = ts.appendIfUnique(targetEmitNode.helpers, helper);
- }
- else if (helpersRemoved > 0) {
- sourceEmitHelpers[i - helpersRemoved] = helper;
+ function nodeHasAnyModifiersExcept(node, allowedModifier) {
+ return node.modifiers.length > 1 || node.modifiers[0].kind !== allowedModifier;
+ }
+ function checkGrammarAsyncModifier(node, asyncModifier) {
+ switch (node.kind) {
+ case 165:
+ case 251:
+ case 208:
+ case 209:
+ return false;
}
+ return grammarErrorOnNode(asyncModifier, ts.Diagnostics._0_modifier_cannot_be_used_here, "async");
}
- if (helpersRemoved > 0) {
- sourceEmitHelpers.length -= helpersRemoved;
+ function checkGrammarForDisallowedTrailingComma(list, diag) {
+ if (diag === void 0) { diag = ts.Diagnostics.Trailing_comma_not_allowed; }
+ if (list && list.hasTrailingComma) {
+ return grammarErrorAtPos(list[0], list.end - ",".length, ",".length, diag);
+ }
+ return false;
}
- }
- ts.moveEmitHelpers = moveEmitHelpers;
- function compareEmitHelpers(x, y) {
- if (x === y)
- return 0;
- if (x.priority === y.priority)
- return 0;
- if (x.priority === undefined)
- return 1;
- if (y.priority === undefined)
- return -1;
- return ts.compareValues(x.priority, y.priority);
- }
- ts.compareEmitHelpers = compareEmitHelpers;
- function setOriginalNode(node, original) {
- node.original = original;
- if (original) {
- var emitNode = original.emitNode;
- if (emitNode)
- node.emitNode = mergeEmitNode(emitNode, node.emitNode);
+ function checkGrammarTypeParameterList(typeParameters, file) {
+ if (typeParameters && typeParameters.length === 0) {
+ var start = typeParameters.pos - "<".length;
+ var end = ts.skipTrivia(file.text, typeParameters.end) + ">".length;
+ return grammarErrorAtPos(file, start, end - start, ts.Diagnostics.Type_parameter_list_cannot_be_empty);
+ }
+ return false;
}
- return node;
- }
- ts.setOriginalNode = setOriginalNode;
- function mergeEmitNode(sourceEmitNode, destEmitNode) {
- var flags = sourceEmitNode.flags, leadingComments = sourceEmitNode.leadingComments, trailingComments = sourceEmitNode.trailingComments, commentRange = sourceEmitNode.commentRange, sourceMapRange = sourceEmitNode.sourceMapRange, tokenSourceMapRanges = sourceEmitNode.tokenSourceMapRanges, constantValue = sourceEmitNode.constantValue, helpers = sourceEmitNode.helpers, startsOnNewLine = sourceEmitNode.startsOnNewLine;
- if (!destEmitNode)
- destEmitNode = {};
- if (leadingComments)
- destEmitNode.leadingComments = ts.addRange(leadingComments.slice(), destEmitNode.leadingComments);
- if (trailingComments)
- destEmitNode.trailingComments = ts.addRange(trailingComments.slice(), destEmitNode.trailingComments);
- if (flags)
- destEmitNode.flags = flags;
- if (commentRange)
- destEmitNode.commentRange = commentRange;
- if (sourceMapRange)
- destEmitNode.sourceMapRange = sourceMapRange;
- if (tokenSourceMapRanges)
- destEmitNode.tokenSourceMapRanges = mergeTokenSourceMapRanges(tokenSourceMapRanges, destEmitNode.tokenSourceMapRanges);
- if (constantValue !== undefined)
- destEmitNode.constantValue = constantValue;
- if (helpers)
- destEmitNode.helpers = ts.addRange(destEmitNode.helpers, helpers);
- if (startsOnNewLine !== undefined)
- destEmitNode.startsOnNewLine = startsOnNewLine;
- return destEmitNode;
- }
- function mergeTokenSourceMapRanges(sourceRanges, destRanges) {
- if (!destRanges)
- destRanges = [];
- for (var key in sourceRanges) {
- destRanges[key] = sourceRanges[key];
+ function checkGrammarParameterList(parameters) {
+ var seenOptionalParameter = false;
+ var parameterCount = parameters.length;
+ for (var i = 0; i < parameterCount; i++) {
+ var parameter = parameters[i];
+ if (parameter.dotDotDotToken) {
+ if (i !== (parameterCount - 1)) {
+ return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
+ }
+ if (!(parameter.flags & 8388608)) {
+ checkGrammarForDisallowedTrailingComma(parameters, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
+ }
+ if (parameter.questionToken) {
+ return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_rest_parameter_cannot_be_optional);
+ }
+ if (parameter.initializer) {
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer);
+ }
+ }
+ else if (isOptionalParameter(parameter)) {
+ seenOptionalParameter = true;
+ if (parameter.questionToken && parameter.initializer) {
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.Parameter_cannot_have_question_mark_and_initializer);
+ }
+ }
+ else if (seenOptionalParameter && !parameter.initializer) {
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter);
+ }
+ }
}
- return destRanges;
- }
-})(ts || (ts = {}));
-var ts;
-(function (ts) {
- ts.nullTransformationContext = {
- enableEmitNotification: ts.noop,
- enableSubstitution: ts.noop,
- endLexicalEnvironment: ts.returnUndefined,
- getCompilerOptions: function () { return ({}); },
- getEmitHost: ts.notImplemented,
- getEmitResolver: ts.notImplemented,
- setLexicalEnvironmentFlags: ts.noop,
- getLexicalEnvironmentFlags: function () { return 0; },
- hoistFunctionDeclaration: ts.noop,
- hoistVariableDeclaration: ts.noop,
- addInitializationStatement: ts.noop,
- isEmitNotificationEnabled: ts.notImplemented,
- isSubstitutionEnabled: ts.notImplemented,
- onEmitNode: ts.noop,
- onSubstituteNode: ts.notImplemented,
- readEmitHelpers: ts.notImplemented,
- requestEmitHelper: ts.noop,
- resumeLexicalEnvironment: ts.noop,
- startLexicalEnvironment: ts.noop,
- suspendLexicalEnvironment: ts.noop,
- addDiagnostic: ts.noop,
- };
- function createTypeCheck(value, tag) {
- return tag === "undefined"
- ? ts.createStrictEquality(value, ts.createVoidZero())
- : ts.createStrictEquality(ts.createTypeOf(value), ts.createLiteral(tag));
- }
- ts.createTypeCheck = createTypeCheck;
- function createMemberAccessForPropertyName(target, memberName, location) {
- if (ts.isComputedPropertyName(memberName)) {
- return ts.setTextRange(ts.createElementAccess(target, memberName.expression), location);
+ function getNonSimpleParameters(parameters) {
+ return ts.filter(parameters, function (parameter) { return !!parameter.initializer || ts.isBindingPattern(parameter.name) || ts.isRestParameter(parameter); });
}
- else {
- var expression = ts.setTextRange((ts.isIdentifier(memberName) || ts.isPrivateIdentifier(memberName))
- ? ts.createPropertyAccess(target, memberName)
- : ts.createElementAccess(target, memberName), memberName);
- ts.getOrCreateEmitNode(expression).flags |= 64;
- return expression;
+ function checkGrammarForUseStrictSimpleParameterList(node) {
+ if (languageVersion >= 3) {
+ var useStrictDirective_1 = node.body && ts.isBlock(node.body) && ts.findUseStrictPrologue(node.body.statements);
+ if (useStrictDirective_1) {
+ var nonSimpleParameters = getNonSimpleParameters(node.parameters);
+ if (ts.length(nonSimpleParameters)) {
+ ts.forEach(nonSimpleParameters, function (parameter) {
+ ts.addRelatedInfo(error(parameter, ts.Diagnostics.This_parameter_is_not_allowed_with_use_strict_directive), ts.createDiagnosticForNode(useStrictDirective_1, ts.Diagnostics.use_strict_directive_used_here));
+ });
+ var diagnostics_2 = nonSimpleParameters.map(function (parameter, index) { return (index === 0 ? ts.createDiagnosticForNode(parameter, ts.Diagnostics.Non_simple_parameter_declared_here) : ts.createDiagnosticForNode(parameter, ts.Diagnostics.and_here)); });
+ ts.addRelatedInfo.apply(void 0, __spreadArrays([error(useStrictDirective_1, ts.Diagnostics.use_strict_directive_cannot_be_used_with_non_simple_parameter_list)], diagnostics_2));
+ return true;
+ }
+ }
+ }
+ return false;
}
- }
- ts.createMemberAccessForPropertyName = createMemberAccessForPropertyName;
- function createFunctionCall(func, thisArg, argumentsList, location) {
- return ts.setTextRange(ts.createCall(ts.createPropertyAccess(func, "call"), undefined, __spreadArrays([
- thisArg
- ], argumentsList)), location);
- }
- ts.createFunctionCall = createFunctionCall;
- function createFunctionApply(func, thisArg, argumentsExpression, location) {
- return ts.setTextRange(ts.createCall(ts.createPropertyAccess(func, "apply"), undefined, [
- thisArg,
- argumentsExpression
- ]), location);
- }
- ts.createFunctionApply = createFunctionApply;
- function createArraySlice(array, start) {
- var argumentsList = [];
- if (start !== undefined) {
- argumentsList.push(typeof start === "number" ? ts.createLiteral(start) : start);
- }
- return ts.createCall(ts.createPropertyAccess(array, "slice"), undefined, argumentsList);
- }
- ts.createArraySlice = createArraySlice;
- function createArrayConcat(array, values) {
- return ts.createCall(ts.createPropertyAccess(array, "concat"), undefined, values);
- }
- ts.createArrayConcat = createArrayConcat;
- function createMathPow(left, right, location) {
- return ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Math"), "pow"), undefined, [left, right]), location);
- }
- ts.createMathPow = createMathPow;
- function createReactNamespace(reactNamespace, parent) {
- var react = ts.createIdentifier(reactNamespace || "React");
- react.flags &= ~8;
- react.parent = ts.getParseTreeNode(parent);
- return react;
- }
- function createJsxFactoryExpressionFromEntityName(jsxFactory, parent) {
- if (ts.isQualifiedName(jsxFactory)) {
- var left = createJsxFactoryExpressionFromEntityName(jsxFactory.left, parent);
- var right = ts.createIdentifier(ts.idText(jsxFactory.right));
- right.escapedText = jsxFactory.right.escapedText;
- return ts.createPropertyAccess(left, right);
+ function checkGrammarFunctionLikeDeclaration(node) {
+ var file = ts.getSourceFileOfNode(node);
+ return checkGrammarDecoratorsAndModifiers(node) ||
+ checkGrammarTypeParameterList(node.typeParameters, file) ||
+ checkGrammarParameterList(node.parameters) ||
+ checkGrammarArrowFunction(node, file) ||
+ (ts.isFunctionLikeDeclaration(node) && checkGrammarForUseStrictSimpleParameterList(node));
}
- else {
- return createReactNamespace(ts.idText(jsxFactory), parent);
+ function checkGrammarClassLikeDeclaration(node) {
+ var file = ts.getSourceFileOfNode(node);
+ return checkGrammarClassDeclarationHeritageClauses(node) ||
+ checkGrammarTypeParameterList(node.typeParameters, file);
}
- }
- function createJsxFactoryExpression(jsxFactoryEntity, reactNamespace, parent) {
- return jsxFactoryEntity ?
- createJsxFactoryExpressionFromEntityName(jsxFactoryEntity, parent) :
- ts.createPropertyAccess(createReactNamespace(reactNamespace, parent), "createElement");
- }
- function createExpressionForJsxElement(jsxFactoryEntity, reactNamespace, tagName, props, children, parentElement, location) {
- var argumentsList = [tagName];
- if (props) {
- argumentsList.push(props);
+ function checkGrammarArrowFunction(node, file) {
+ if (!ts.isArrowFunction(node)) {
+ return false;
+ }
+ var equalsGreaterThanToken = node.equalsGreaterThanToken;
+ var startLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.pos).line;
+ var endLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.end).line;
+ return startLine !== endLine && grammarErrorOnNode(equalsGreaterThanToken, ts.Diagnostics.Line_terminator_not_permitted_before_arrow);
}
- if (children && children.length > 0) {
- if (!props) {
- argumentsList.push(ts.createNull());
+ function checkGrammarIndexSignatureParameters(node) {
+ var parameter = node.parameters[0];
+ if (node.parameters.length !== 1) {
+ if (parameter) {
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter);
+ }
+ else {
+ return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter);
+ }
}
- if (children.length > 1) {
- for (var _i = 0, children_2 = children; _i < children_2.length; _i++) {
- var child = children_2[_i];
- startOnNewLine(child);
- argumentsList.push(child);
+ checkGrammarForDisallowedTrailingComma(node.parameters, ts.Diagnostics.An_index_signature_cannot_have_a_trailing_comma);
+ if (parameter.dotDotDotToken) {
+ return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
+ }
+ if (ts.hasEffectiveModifiers(parameter)) {
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
+ }
+ if (parameter.questionToken) {
+ return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark);
+ }
+ if (parameter.initializer) {
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_initializer);
+ }
+ if (!parameter.type) {
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation);
+ }
+ if (parameter.type.kind !== 147 && parameter.type.kind !== 144) {
+ var type = getTypeFromTypeNode(parameter.type);
+ if (type.flags & 4 || type.flags & 8) {
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_cannot_be_a_type_alias_Consider_writing_0_Colon_1_Colon_2_instead, ts.getTextOfNode(parameter.name), typeToString(type), typeToString(node.type ? getTypeFromTypeNode(node.type) : anyType));
+ }
+ if (type.flags & 1048576 && allTypesAssignableToKind(type, 384, true)) {
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_cannot_be_a_union_type_Consider_using_a_mapped_object_type_instead);
}
+ return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_either_string_or_number);
}
- else {
- argumentsList.push(children[0]);
+ if (!node.type) {
+ return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_a_type_annotation);
}
+ return false;
}
- return ts.setTextRange(ts.createCall(createJsxFactoryExpression(jsxFactoryEntity, reactNamespace, parentElement), undefined, argumentsList), location);
- }
- ts.createExpressionForJsxElement = createExpressionForJsxElement;
- function createExpressionForJsxFragment(jsxFactoryEntity, reactNamespace, children, parentElement, location) {
- var tagName = ts.createPropertyAccess(createReactNamespace(reactNamespace, parentElement), "Fragment");
- var argumentsList = [tagName];
- argumentsList.push(ts.createNull());
- if (children && children.length > 0) {
- if (children.length > 1) {
- for (var _i = 0, children_3 = children; _i < children_3.length; _i++) {
- var child = children_3[_i];
- startOnNewLine(child);
- argumentsList.push(child);
- }
+ function checkGrammarIndexSignature(node) {
+ return checkGrammarDecoratorsAndModifiers(node) || checkGrammarIndexSignatureParameters(node);
+ }
+ function checkGrammarForAtLeastOneTypeArgument(node, typeArguments) {
+ if (typeArguments && typeArguments.length === 0) {
+ var sourceFile = ts.getSourceFileOfNode(node);
+ var start = typeArguments.pos - "<".length;
+ var end = ts.skipTrivia(sourceFile.text, typeArguments.end) + ">".length;
+ return grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Type_argument_list_cannot_be_empty);
}
- else {
- argumentsList.push(children[0]);
+ return false;
+ }
+ function checkGrammarTypeArguments(node, typeArguments) {
+ return checkGrammarForDisallowedTrailingComma(typeArguments) ||
+ checkGrammarForAtLeastOneTypeArgument(node, typeArguments);
+ }
+ function checkGrammarTaggedTemplateChain(node) {
+ if (node.questionDotToken || node.flags & 32) {
+ return grammarErrorOnNode(node.template, ts.Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain);
}
+ return false;
}
- return ts.setTextRange(ts.createCall(createJsxFactoryExpression(jsxFactoryEntity, reactNamespace, parentElement), undefined, argumentsList), location);
- }
- ts.createExpressionForJsxFragment = createExpressionForJsxFragment;
- function getUnscopedHelperName(name) {
- return ts.setEmitFlags(ts.createIdentifier(name), 4096 | 2);
- }
- ts.getUnscopedHelperName = getUnscopedHelperName;
- ts.valuesHelper = {
- name: "typescript:values",
- importName: "__values",
- scoped: false,
- text: "\n var __values = (this && this.__values) || function(o) {\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n if (m) return m.call(o);\n if (o && typeof o.length === \"number\") return {\n next: function () {\n if (o && i >= o.length) o = void 0;\n return { value: o && o[i++], done: !o };\n }\n };\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n };"
- };
- function createValuesHelper(context, expression, location) {
- context.requestEmitHelper(ts.valuesHelper);
- return ts.setTextRange(ts.createCall(getUnscopedHelperName("__values"), undefined, [expression]), location);
- }
- ts.createValuesHelper = createValuesHelper;
- ts.readHelper = {
- name: "typescript:read",
- importName: "__read",
- scoped: false,
- text: "\n var __read = (this && this.__read) || function (o, n) {\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n if (!m) return o;\n var i = m.call(o), r, ar = [], e;\n try {\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n }\n catch (error) { e = { error: error }; }\n finally {\n try {\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\n }\n finally { if (e) throw e.error; }\n }\n return ar;\n };"
- };
- function createReadHelper(context, iteratorRecord, count, location) {
- context.requestEmitHelper(ts.readHelper);
- return ts.setTextRange(ts.createCall(getUnscopedHelperName("__read"), undefined, count !== undefined
- ? [iteratorRecord, ts.createLiteral(count)]
- : [iteratorRecord]), location);
- }
- ts.createReadHelper = createReadHelper;
- ts.spreadHelper = {
- name: "typescript:spread",
- importName: "__spread",
- scoped: false,
- dependencies: [ts.readHelper],
- text: "\n var __spread = (this && this.__spread) || function () {\n for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));\n return ar;\n };"
- };
- function createSpreadHelper(context, argumentList, location) {
- context.requestEmitHelper(ts.spreadHelper);
- return ts.setTextRange(ts.createCall(getUnscopedHelperName("__spread"), undefined, argumentList), location);
- }
- ts.createSpreadHelper = createSpreadHelper;
- ts.spreadArraysHelper = {
- name: "typescript:spreadArrays",
- importName: "__spreadArrays",
- scoped: false,
- text: "\n var __spreadArrays = (this && this.__spreadArrays) || function () {\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n r[k] = a[j];\n return r;\n };"
- };
- function createSpreadArraysHelper(context, argumentList, location) {
- context.requestEmitHelper(ts.spreadArraysHelper);
- return ts.setTextRange(ts.createCall(getUnscopedHelperName("__spreadArrays"), undefined, argumentList), location);
- }
- ts.createSpreadArraysHelper = createSpreadArraysHelper;
- function createForOfBindingStatement(node, boundValue) {
- if (ts.isVariableDeclarationList(node)) {
- var firstDeclaration = ts.first(node.declarations);
- var updatedDeclaration = ts.updateVariableDeclaration(firstDeclaration, firstDeclaration.name, undefined, boundValue);
- return ts.setTextRange(ts.createVariableStatement(undefined, ts.updateVariableDeclarationList(node, [updatedDeclaration])), node);
+ function checkGrammarForOmittedArgument(args) {
+ if (args) {
+ for (var _i = 0, args_4 = args; _i < args_4.length; _i++) {
+ var arg = args_4[_i];
+ if (arg.kind === 222) {
+ return grammarErrorAtPos(arg, arg.pos, 0, ts.Diagnostics.Argument_expression_expected);
+ }
+ }
+ }
+ return false;
}
- else {
- var updatedExpression = ts.setTextRange(ts.createAssignment(node, boundValue), node);
- return ts.setTextRange(ts.createStatement(updatedExpression), node);
+ function checkGrammarArguments(args) {
+ return checkGrammarForOmittedArgument(args);
}
- }
- ts.createForOfBindingStatement = createForOfBindingStatement;
- function insertLeadingStatement(dest, source) {
- if (ts.isBlock(dest)) {
- return ts.updateBlock(dest, ts.setTextRange(ts.createNodeArray(__spreadArrays([source], dest.statements)), dest.statements));
+ function checkGrammarHeritageClause(node) {
+ var types = node.types;
+ if (checkGrammarForDisallowedTrailingComma(types)) {
+ return true;
+ }
+ if (types && types.length === 0) {
+ var listType = ts.tokenToString(node.token);
+ return grammarErrorAtPos(node, types.pos, 0, ts.Diagnostics._0_list_cannot_be_empty, listType);
+ }
+ return ts.some(types, checkGrammarExpressionWithTypeArguments);
}
- else {
- return ts.createBlock(ts.createNodeArray([dest, source]), true);
+ function checkGrammarExpressionWithTypeArguments(node) {
+ return checkGrammarTypeArguments(node, node.typeArguments);
}
- }
- ts.insertLeadingStatement = insertLeadingStatement;
- function restoreEnclosingLabel(node, outermostLabeledStatement, afterRestoreLabelCallback) {
- if (!outermostLabeledStatement) {
- return node;
+ function checkGrammarClassDeclarationHeritageClauses(node) {
+ var seenExtendsClause = false;
+ var seenImplementsClause = false;
+ if (!checkGrammarDecoratorsAndModifiers(node) && node.heritageClauses) {
+ for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
+ var heritageClause = _a[_i];
+ if (heritageClause.token === 93) {
+ if (seenExtendsClause) {
+ return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen);
+ }
+ if (seenImplementsClause) {
+ return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_must_precede_implements_clause);
+ }
+ if (heritageClause.types.length > 1) {
+ return grammarErrorOnFirstToken(heritageClause.types[1], ts.Diagnostics.Classes_can_only_extend_a_single_class);
+ }
+ seenExtendsClause = true;
+ }
+ else {
+ ts.Debug.assert(heritageClause.token === 116);
+ if (seenImplementsClause) {
+ return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen);
+ }
+ seenImplementsClause = true;
+ }
+ checkGrammarHeritageClause(heritageClause);
+ }
+ }
}
- var updated = ts.updateLabel(outermostLabeledStatement, outermostLabeledStatement.label, outermostLabeledStatement.statement.kind === 238
- ? restoreEnclosingLabel(node, outermostLabeledStatement.statement)
- : node);
- if (afterRestoreLabelCallback) {
- afterRestoreLabelCallback(outermostLabeledStatement);
+ function checkGrammarInterfaceDeclaration(node) {
+ var seenExtendsClause = false;
+ if (node.heritageClauses) {
+ for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
+ var heritageClause = _a[_i];
+ if (heritageClause.token === 93) {
+ if (seenExtendsClause) {
+ return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen);
+ }
+ seenExtendsClause = true;
+ }
+ else {
+ ts.Debug.assert(heritageClause.token === 116);
+ return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause);
+ }
+ checkGrammarHeritageClause(heritageClause);
+ }
+ }
+ return false;
}
- return updated;
- }
- ts.restoreEnclosingLabel = restoreEnclosingLabel;
- function shouldBeCapturedInTempVariable(node, cacheIdentifiers) {
- var target = ts.skipParentheses(node);
- switch (target.kind) {
- case 75:
- return cacheIdentifiers;
- case 104:
- case 8:
- case 9:
- case 10:
+ function checkGrammarComputedPropertyName(node) {
+ if (node.kind !== 158) {
return false;
- case 192:
- var elements = target.elements;
- if (elements.length === 0) {
- return false;
+ }
+ var computedPropertyName = node;
+ if (computedPropertyName.expression.kind === 216 && computedPropertyName.expression.operatorToken.kind === 27) {
+ return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
+ }
+ return false;
+ }
+ function checkGrammarForGenerator(node) {
+ if (node.asteriskToken) {
+ ts.Debug.assert(node.kind === 251 ||
+ node.kind === 208 ||
+ node.kind === 165);
+ if (node.flags & 8388608) {
+ return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context);
+ }
+ if (!node.body) {
+ return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator);
+ }
+ }
+ }
+ function checkGrammarForInvalidQuestionMark(questionToken, message) {
+ return !!questionToken && grammarErrorOnNode(questionToken, message);
+ }
+ function checkGrammarForInvalidExclamationToken(exclamationToken, message) {
+ return !!exclamationToken && grammarErrorOnNode(exclamationToken, message);
+ }
+ function checkGrammarObjectLiteralExpression(node, inDestructuring) {
+ var seen = new ts.Map();
+ for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
+ var prop = _a[_i];
+ if (prop.kind === 290) {
+ if (inDestructuring) {
+ var expression = ts.skipParentheses(prop.expression);
+ if (ts.isArrayLiteralExpression(expression) || ts.isObjectLiteralExpression(expression)) {
+ return grammarErrorOnNode(prop.expression, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern);
+ }
+ }
+ continue;
+ }
+ var name = prop.name;
+ if (name.kind === 158) {
+ checkGrammarComputedPropertyName(name);
+ }
+ if (prop.kind === 289 && !inDestructuring && prop.objectAssignmentInitializer) {
+ return grammarErrorOnNode(prop.equalsToken, ts.Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern);
+ }
+ if (name.kind === 79) {
+ return grammarErrorOnNode(name, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+ }
+ if (prop.modifiers) {
+ for (var _b = 0, _c = prop.modifiers; _b < _c.length; _b++) {
+ var mod = _c[_b];
+ if (mod.kind !== 129 || prop.kind !== 165) {
+ grammarErrorOnNode(mod, ts.Diagnostics._0_modifier_cannot_be_used_here, ts.getTextOfNode(mod));
+ }
+ }
+ }
+ var currentKind = void 0;
+ switch (prop.kind) {
+ case 289:
+ checkGrammarForInvalidExclamationToken(prop.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context);
+ case 288:
+ checkGrammarForInvalidQuestionMark(prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional);
+ if (name.kind === 8) {
+ checkGrammarNumericLiteral(name);
+ }
+ currentKind = 4;
+ break;
+ case 165:
+ currentKind = 8;
+ break;
+ case 167:
+ currentKind = 1;
+ break;
+ case 168:
+ currentKind = 2;
+ break;
+ default:
+ throw ts.Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind);
+ }
+ if (!inDestructuring) {
+ var effectiveName = ts.getPropertyNameForPropertyNameNode(name);
+ if (effectiveName === undefined) {
+ continue;
+ }
+ var existingKind = seen.get(effectiveName);
+ if (!existingKind) {
+ seen.set(effectiveName, currentKind);
+ }
+ else {
+ if ((currentKind & 12) && (existingKind & 12)) {
+ grammarErrorOnNode(name, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(name));
+ }
+ else if ((currentKind & 3) && (existingKind & 3)) {
+ if (existingKind !== 3 && currentKind !== existingKind) {
+ seen.set(effectiveName, currentKind | existingKind);
+ }
+ else {
+ return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name);
+ }
+ }
+ else {
+ return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name);
+ }
+ }
}
- return true;
- case 193:
- return target.properties.length > 0;
- default:
- return true;
- }
- }
- function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers) {
- if (cacheIdentifiers === void 0) { cacheIdentifiers = false; }
- var callee = skipOuterExpressions(expression, 15);
- var thisArg;
- var target;
- if (ts.isSuperProperty(callee)) {
- thisArg = ts.createThis();
- target = callee;
+ }
}
- else if (callee.kind === 102) {
- thisArg = ts.createThis();
- target = languageVersion < 2
- ? ts.setTextRange(ts.createIdentifier("_super"), callee)
- : callee;
+ function checkGrammarJsxElement(node) {
+ checkGrammarTypeArguments(node, node.typeArguments);
+ var seen = new ts.Map();
+ for (var _i = 0, _a = node.attributes.properties; _i < _a.length; _i++) {
+ var attr = _a[_i];
+ if (attr.kind === 282) {
+ continue;
+ }
+ var name = attr.name, initializer = attr.initializer;
+ if (!seen.get(name.escapedText)) {
+ seen.set(name.escapedText, true);
+ }
+ else {
+ return grammarErrorOnNode(name, ts.Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name);
+ }
+ if (initializer && initializer.kind === 283 && !initializer.expression) {
+ return grammarErrorOnNode(initializer, ts.Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression);
+ }
+ }
}
- else if (ts.getEmitFlags(callee) & 4096) {
- thisArg = ts.createVoidZero();
- target = parenthesizeForAccess(callee);
+ function checkGrammarJsxExpression(node) {
+ if (node.expression && ts.isCommaSequence(node.expression)) {
+ return grammarErrorOnNode(node.expression, ts.Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array);
+ }
}
- else {
- switch (callee.kind) {
- case 194: {
- if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) {
- thisArg = ts.createTempVariable(recordTempVariable);
- target = ts.createPropertyAccess(ts.setTextRange(ts.createAssignment(thisArg, callee.expression), callee.expression), callee.name);
- ts.setTextRange(target, callee);
- }
- else {
- thisArg = callee.expression;
- target = callee;
+ function checkGrammarForInOrForOfStatement(forInOrOfStatement) {
+ if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) {
+ return true;
+ }
+ if (forInOrOfStatement.kind === 239 && forInOrOfStatement.awaitModifier) {
+ if ((forInOrOfStatement.flags & 32768) === 0) {
+ var sourceFile = ts.getSourceFileOfNode(forInOrOfStatement);
+ if (!hasParseDiagnostics(sourceFile)) {
+ var diagnostic = ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator);
+ var func = ts.getContainingFunction(forInOrOfStatement);
+ if (func && func.kind !== 166) {
+ ts.Debug.assert((ts.getFunctionFlags(func) & 2) === 0, "Enclosing function should never be an async function.");
+ var relatedInfo = ts.createDiagnosticForNode(func, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async);
+ ts.addRelatedInfo(diagnostic, relatedInfo);
+ }
+ diagnostics.add(diagnostic);
+ return true;
}
- break;
+ return false;
}
- case 195: {
- if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) {
- thisArg = ts.createTempVariable(recordTempVariable);
- target = ts.createElementAccess(ts.setTextRange(ts.createAssignment(thisArg, callee.expression), callee.expression), callee.argumentExpression);
- ts.setTextRange(target, callee);
+ }
+ if (forInOrOfStatement.initializer.kind === 250) {
+ var variableList = forInOrOfStatement.initializer;
+ if (!checkGrammarVariableDeclarationList(variableList)) {
+ var declarations = variableList.declarations;
+ if (!declarations.length) {
+ return false;
}
- else {
- thisArg = callee.expression;
- target = callee;
+ if (declarations.length > 1) {
+ var diagnostic = forInOrOfStatement.kind === 238
+ ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement
+ : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement;
+ return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic);
+ }
+ var firstDeclaration = declarations[0];
+ if (firstDeclaration.initializer) {
+ var diagnostic = forInOrOfStatement.kind === 238
+ ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer
+ : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer;
+ return grammarErrorOnNode(firstDeclaration.name, diagnostic);
+ }
+ if (firstDeclaration.type) {
+ var diagnostic = forInOrOfStatement.kind === 238
+ ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation
+ : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation;
+ return grammarErrorOnNode(firstDeclaration, diagnostic);
}
- break;
- }
- default: {
- thisArg = ts.createVoidZero();
- target = parenthesizeForAccess(expression);
- break;
}
}
+ return false;
}
- return { target: target, thisArg: thisArg };
- }
- ts.createCallBinding = createCallBinding;
- function inlineExpressions(expressions) {
- return expressions.length > 10
- ? ts.createCommaList(expressions)
- : ts.reduceLeft(expressions, ts.createComma);
- }
- ts.inlineExpressions = inlineExpressions;
- function createExpressionFromEntityName(node) {
- if (ts.isQualifiedName(node)) {
- var left = createExpressionFromEntityName(node.left);
- var right = ts.getMutableClone(node.right);
- return ts.setTextRange(ts.createPropertyAccess(left, right), node);
- }
- else {
- return ts.getMutableClone(node);
- }
- }
- ts.createExpressionFromEntityName = createExpressionFromEntityName;
- function createExpressionForPropertyName(memberName) {
- if (ts.isIdentifier(memberName)) {
- return ts.createLiteral(memberName);
- }
- else if (ts.isComputedPropertyName(memberName)) {
- return ts.getMutableClone(memberName.expression);
- }
- else {
- return ts.getMutableClone(memberName);
- }
- }
- ts.createExpressionForPropertyName = createExpressionForPropertyName;
- function createExpressionForObjectLiteralElementLike(node, property, receiver) {
- if (property.name && ts.isPrivateIdentifier(property.name)) {
- ts.Debug.failBadSyntaxKind(property.name, "Private identifiers are not allowed in object literals.");
- }
- switch (property.kind) {
- case 163:
- case 164:
- return createExpressionForAccessorDeclaration(node.properties, property, receiver, !!node.multiLine);
- case 281:
- return createExpressionForPropertyAssignment(property, receiver);
- case 282:
- return createExpressionForShorthandPropertyAssignment(property, receiver);
- case 161:
- return createExpressionForMethodDeclaration(property, receiver);
- }
- }
- ts.createExpressionForObjectLiteralElementLike = createExpressionForObjectLiteralElementLike;
- function createExpressionForAccessorDeclaration(properties, property, receiver, multiLine) {
- var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;
- if (property === firstAccessor) {
- var properties_7 = [];
- if (getAccessor) {
- var getterFunction = ts.createFunctionExpression(getAccessor.modifiers, undefined, undefined, undefined, getAccessor.parameters, undefined, getAccessor.body);
- ts.setTextRange(getterFunction, getAccessor);
- ts.setOriginalNode(getterFunction, getAccessor);
- var getter = ts.createPropertyAssignment("get", getterFunction);
- properties_7.push(getter);
+ function checkGrammarAccessor(accessor) {
+ if (!(accessor.flags & 8388608)) {
+ if (languageVersion < 1) {
+ return grammarErrorOnNode(accessor.name, ts.Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
+ }
+ if (accessor.body === undefined && !ts.hasSyntacticModifier(accessor, 128)) {
+ return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, ts.Diagnostics._0_expected, "{");
+ }
}
- if (setAccessor) {
- var setterFunction = ts.createFunctionExpression(setAccessor.modifiers, undefined, undefined, undefined, setAccessor.parameters, undefined, setAccessor.body);
- ts.setTextRange(setterFunction, setAccessor);
- ts.setOriginalNode(setterFunction, setAccessor);
- var setter = ts.createPropertyAssignment("set", setterFunction);
- properties_7.push(setter);
- }
- properties_7.push(ts.createPropertyAssignment("enumerable", getAccessor || setAccessor ? ts.createFalse() : ts.createTrue()));
- properties_7.push(ts.createPropertyAssignment("configurable", ts.createTrue()));
- var expression = ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"), undefined, [
- receiver,
- createExpressionForPropertyName(property.name),
- ts.createObjectLiteral(properties_7, multiLine)
- ]), firstAccessor);
- return ts.aggregateTransformFlags(expression);
+ if (accessor.body && ts.hasSyntacticModifier(accessor, 128)) {
+ return grammarErrorOnNode(accessor, ts.Diagnostics.An_abstract_accessor_cannot_have_an_implementation);
+ }
+ if (accessor.typeParameters) {
+ return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters);
+ }
+ if (!doesAccessorHaveCorrectParameterCount(accessor)) {
+ return grammarErrorOnNode(accessor.name, accessor.kind === 167 ?
+ ts.Diagnostics.A_get_accessor_cannot_have_parameters :
+ ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter);
+ }
+ if (accessor.kind === 168) {
+ if (accessor.type) {
+ return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation);
+ }
+ var parameter = ts.Debug.checkDefined(ts.getSetAccessorValueParameter(accessor), "Return value does not match parameter count assertion.");
+ if (parameter.dotDotDotToken) {
+ return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter);
+ }
+ if (parameter.questionToken) {
+ return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_set_accessor_cannot_have_an_optional_parameter);
+ }
+ if (parameter.initializer) {
+ return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer);
+ }
+ }
+ return false;
}
- return undefined;
- }
- function createExpressionForPropertyAssignment(property, receiver) {
- return ts.aggregateTransformFlags(ts.setOriginalNode(ts.setTextRange(ts.createAssignment(createMemberAccessForPropertyName(receiver, property.name, property.name), property.initializer), property), property));
- }
- function createExpressionForShorthandPropertyAssignment(property, receiver) {
- return ts.aggregateTransformFlags(ts.setOriginalNode(ts.setTextRange(ts.createAssignment(createMemberAccessForPropertyName(receiver, property.name, property.name), ts.getSynthesizedClone(property.name)), property), property));
- }
- function createExpressionForMethodDeclaration(method, receiver) {
- return ts.aggregateTransformFlags(ts.setOriginalNode(ts.setTextRange(ts.createAssignment(createMemberAccessForPropertyName(receiver, method.name, method.name), ts.setOriginalNode(ts.setTextRange(ts.createFunctionExpression(method.modifiers, method.asteriskToken, undefined, undefined, method.parameters, undefined, method.body), method), method)), method), method));
- }
- function getInternalName(node, allowComments, allowSourceMaps) {
- return getName(node, allowComments, allowSourceMaps, 16384 | 32768);
- }
- ts.getInternalName = getInternalName;
- function isInternalName(node) {
- return (ts.getEmitFlags(node) & 32768) !== 0;
- }
- ts.isInternalName = isInternalName;
- function getLocalName(node, allowComments, allowSourceMaps) {
- return getName(node, allowComments, allowSourceMaps, 16384);
- }
- ts.getLocalName = getLocalName;
- function isLocalName(node) {
- return (ts.getEmitFlags(node) & 16384) !== 0;
- }
- ts.isLocalName = isLocalName;
- function getExportName(node, allowComments, allowSourceMaps) {
- return getName(node, allowComments, allowSourceMaps, 8192);
- }
- ts.getExportName = getExportName;
- function isExportName(node) {
- return (ts.getEmitFlags(node) & 8192) !== 0;
- }
- ts.isExportName = isExportName;
- function getDeclarationName(node, allowComments, allowSourceMaps) {
- return getName(node, allowComments, allowSourceMaps);
- }
- ts.getDeclarationName = getDeclarationName;
- function getName(node, allowComments, allowSourceMaps, emitFlags) {
- if (emitFlags === void 0) { emitFlags = 0; }
- var nodeName = ts.getNameOfDeclaration(node);
- if (nodeName && ts.isIdentifier(nodeName) && !ts.isGeneratedIdentifier(nodeName)) {
- var name = ts.getMutableClone(nodeName);
- emitFlags |= ts.getEmitFlags(nodeName);
- if (!allowSourceMaps)
- emitFlags |= 48;
- if (!allowComments)
- emitFlags |= 1536;
- if (emitFlags)
- ts.setEmitFlags(name, emitFlags);
- return name;
+ function doesAccessorHaveCorrectParameterCount(accessor) {
+ return getAccessorThisParameter(accessor) || accessor.parameters.length === (accessor.kind === 167 ? 0 : 1);
}
- return ts.getGeneratedNameForNode(node);
- }
- function getExternalModuleOrNamespaceExportName(ns, node, allowComments, allowSourceMaps) {
- if (ns && ts.hasModifier(node, 1)) {
- return getNamespaceMemberName(ns, getName(node), allowComments, allowSourceMaps);
- }
- return getExportName(node, allowComments, allowSourceMaps);
- }
- ts.getExternalModuleOrNamespaceExportName = getExternalModuleOrNamespaceExportName;
- function getNamespaceMemberName(ns, name, allowComments, allowSourceMaps) {
- var qualifiedName = ts.createPropertyAccess(ns, ts.nodeIsSynthesized(name) ? name : ts.getSynthesizedClone(name));
- ts.setTextRange(qualifiedName, name);
- var emitFlags = 0;
- if (!allowSourceMaps)
- emitFlags |= 48;
- if (!allowComments)
- emitFlags |= 1536;
- if (emitFlags)
- ts.setEmitFlags(qualifiedName, emitFlags);
- return qualifiedName;
- }
- ts.getNamespaceMemberName = getNamespaceMemberName;
- function convertToFunctionBody(node, multiLine) {
- return ts.isBlock(node) ? node : ts.setTextRange(ts.createBlock([ts.setTextRange(ts.createReturn(node), node)], multiLine), node);
- }
- ts.convertToFunctionBody = convertToFunctionBody;
- function convertFunctionDeclarationToExpression(node) {
- if (!node.body)
- return ts.Debug.fail();
- var updated = ts.createFunctionExpression(node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body);
- ts.setOriginalNode(updated, node);
- ts.setTextRange(updated, node);
- if (ts.getStartsOnNewLine(node)) {
- ts.setStartsOnNewLine(updated, true);
+ function getAccessorThisParameter(accessor) {
+ if (accessor.parameters.length === (accessor.kind === 167 ? 1 : 2)) {
+ return ts.getThisParameter(accessor);
+ }
}
- ts.aggregateTransformFlags(updated);
- return updated;
- }
- ts.convertFunctionDeclarationToExpression = convertFunctionDeclarationToExpression;
- function isUseStrictPrologue(node) {
- return ts.isStringLiteral(node.expression) && node.expression.text === "use strict";
- }
- function addPrologue(target, source, ensureUseStrict, visitor) {
- var offset = addStandardPrologue(target, source, ensureUseStrict);
- return addCustomPrologue(target, source, offset, visitor);
- }
- ts.addPrologue = addPrologue;
- function addStandardPrologue(target, source, ensureUseStrict) {
- ts.Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array");
- var foundUseStrict = false;
- var statementOffset = 0;
- var numStatements = source.length;
- while (statementOffset < numStatements) {
- var statement = source[statementOffset];
- if (ts.isPrologueDirective(statement)) {
- if (isUseStrictPrologue(statement)) {
- foundUseStrict = true;
+ function checkGrammarTypeOperatorNode(node) {
+ if (node.operator === 151) {
+ if (node.type.kind !== 148) {
+ return grammarErrorOnNode(node.type, ts.Diagnostics._0_expected, ts.tokenToString(148));
+ }
+ var parent = ts.walkUpParenthesizedTypes(node.parent);
+ if (ts.isInJSFile(parent) && ts.isJSDocTypeExpression(parent)) {
+ parent = parent.parent;
+ if (ts.isJSDocTypeTag(parent)) {
+ parent = parent.parent.parent;
+ }
+ }
+ switch (parent.kind) {
+ case 249:
+ var decl = parent;
+ if (decl.name.kind !== 78) {
+ return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name);
+ }
+ if (!ts.isVariableDeclarationInVariableStatement(decl)) {
+ return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement);
+ }
+ if (!(decl.parent.flags & 2)) {
+ return grammarErrorOnNode(parent.name, ts.Diagnostics.A_variable_whose_type_is_a_unique_symbol_type_must_be_const);
+ }
+ break;
+ case 163:
+ if (!ts.hasSyntacticModifier(parent, 32) ||
+ !ts.hasEffectiveModifier(parent, 64)) {
+ return grammarErrorOnNode(parent.name, ts.Diagnostics.A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly);
+ }
+ break;
+ case 162:
+ if (!ts.hasSyntacticModifier(parent, 64)) {
+ return grammarErrorOnNode(parent.name, ts.Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly);
+ }
+ break;
+ default:
+ return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_are_not_allowed_here);
}
- target.push(statement);
}
- else {
- break;
+ else if (node.operator === 142) {
+ if (node.type.kind !== 178 && node.type.kind !== 179) {
+ return grammarErrorOnFirstToken(node, ts.Diagnostics.readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types, ts.tokenToString(148));
+ }
}
- statementOffset++;
}
- if (ensureUseStrict && !foundUseStrict) {
- target.push(startOnNewLine(ts.createStatement(ts.createLiteral("use strict"))));
+ function checkGrammarForInvalidDynamicName(node, message) {
+ if (isNonBindableDynamicName(node)) {
+ return grammarErrorOnNode(node, message);
+ }
}
- return statementOffset;
- }
- ts.addStandardPrologue = addStandardPrologue;
- function addCustomPrologue(target, source, statementOffset, visitor, filter) {
- if (filter === void 0) { filter = ts.returnTrue; }
- var numStatements = source.length;
- while (statementOffset !== undefined && statementOffset < numStatements) {
- var statement = source[statementOffset];
- if (ts.getEmitFlags(statement) & 1048576 && filter(statement)) {
- ts.append(target, visitor ? ts.visitNode(statement, visitor, ts.isStatement) : statement);
+ function checkGrammarMethod(node) {
+ if (checkGrammarFunctionLikeDeclaration(node)) {
+ return true;
}
- else {
- break;
+ if (node.kind === 165) {
+ if (node.parent.kind === 200) {
+ if (node.modifiers && !(node.modifiers.length === 1 && ts.first(node.modifiers).kind === 129)) {
+ return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here);
+ }
+ else if (checkGrammarForInvalidQuestionMark(node.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional)) {
+ return true;
+ }
+ else if (checkGrammarForInvalidExclamationToken(node.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context)) {
+ return true;
+ }
+ else if (node.body === undefined) {
+ return grammarErrorAtPos(node, node.end - 1, ";".length, ts.Diagnostics._0_expected, "{");
+ }
+ }
+ if (checkGrammarForGenerator(node)) {
+ return true;
+ }
}
- statementOffset++;
- }
- return statementOffset;
- }
- ts.addCustomPrologue = addCustomPrologue;
- function findUseStrictPrologue(statements) {
- for (var _i = 0, statements_4 = statements; _i < statements_4.length; _i++) {
- var statement = statements_4[_i];
- if (ts.isPrologueDirective(statement)) {
- if (isUseStrictPrologue(statement)) {
- return statement;
+ if (ts.isClassLike(node.parent)) {
+ if (node.flags & 8388608) {
+ return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
+ }
+ else if (node.kind === 165 && !node.body) {
+ return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
}
}
- else {
- break;
+ else if (node.parent.kind === 253) {
+ return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
+ }
+ else if (node.parent.kind === 177) {
+ return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
}
}
- return undefined;
- }
- ts.findUseStrictPrologue = findUseStrictPrologue;
- function startsWithUseStrict(statements) {
- var firstStatement = ts.firstOrUndefined(statements);
- return firstStatement !== undefined
- && ts.isPrologueDirective(firstStatement)
- && isUseStrictPrologue(firstStatement);
- }
- ts.startsWithUseStrict = startsWithUseStrict;
- function ensureUseStrict(statements) {
- var foundUseStrict = findUseStrictPrologue(statements);
- if (!foundUseStrict) {
- return ts.setTextRange(ts.createNodeArray(__spreadArrays([
- startOnNewLine(ts.createStatement(ts.createLiteral("use strict")))
- ], statements)), statements);
- }
- return statements;
- }
- ts.ensureUseStrict = ensureUseStrict;
- function parenthesizeBinaryOperand(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
- var skipped = ts.skipPartiallyEmittedExpressions(operand);
- if (skipped.kind === 200) {
- return operand;
- }
- return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand)
- ? ts.createParen(operand)
- : operand;
- }
- ts.parenthesizeBinaryOperand = parenthesizeBinaryOperand;
- function binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
- var binaryOperatorPrecedence = ts.getOperatorPrecedence(209, binaryOperator);
- var binaryOperatorAssociativity = ts.getOperatorAssociativity(209, binaryOperator);
- var emittedOperand = ts.skipPartiallyEmittedExpressions(operand);
- if (!isLeftSideOfBinary && operand.kind === 202 && binaryOperatorPrecedence > 3) {
- return true;
- }
- var operandPrecedence = ts.getExpressionPrecedence(emittedOperand);
- switch (ts.compareValues(operandPrecedence, binaryOperatorPrecedence)) {
- case -1:
- if (!isLeftSideOfBinary
- && binaryOperatorAssociativity === 1
- && operand.kind === 212) {
- return false;
- }
- return true;
- case 1:
- return false;
- case 0:
- if (isLeftSideOfBinary) {
- return binaryOperatorAssociativity === 1;
+ function checkGrammarBreakOrContinueStatement(node) {
+ var current = node;
+ while (current) {
+ if (ts.isFunctionLike(current)) {
+ return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary);
}
- else {
- if (ts.isBinaryExpression(emittedOperand)
- && emittedOperand.operatorToken.kind === binaryOperator) {
- if (operatorHasAssociativeProperty(binaryOperator)) {
+ switch (current.kind) {
+ case 245:
+ if (node.label && current.label.escapedText === node.label.escapedText) {
+ var isMisplacedContinueLabel = node.kind === 240
+ && !ts.isIterationStatement(current.statement, true);
+ if (isMisplacedContinueLabel) {
+ return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement);
+ }
return false;
}
- if (binaryOperator === 39) {
- var leftKind = leftOperand ? getLiteralKindOfBinaryPlusOperand(leftOperand) : 0;
- if (ts.isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(emittedOperand)) {
- return false;
- }
+ break;
+ case 244:
+ if (node.kind === 241 && !node.label) {
+ return false;
}
- }
- var operandAssociativity = ts.getExpressionAssociativity(emittedOperand);
- return operandAssociativity === 0;
+ break;
+ default:
+ if (ts.isIterationStatement(current, false) && !node.label) {
+ return false;
+ }
+ break;
}
- }
- }
- function operatorHasAssociativeProperty(binaryOperator) {
- return binaryOperator === 41
- || binaryOperator === 51
- || binaryOperator === 50
- || binaryOperator === 52;
- }
- function getLiteralKindOfBinaryPlusOperand(node) {
- node = ts.skipPartiallyEmittedExpressions(node);
- if (ts.isLiteralKind(node.kind)) {
- return node.kind;
- }
- if (node.kind === 209 && node.operatorToken.kind === 39) {
- if (node.cachedLiteralKind !== undefined) {
- return node.cachedLiteralKind;
+ current = current.parent;
}
- var leftKind = getLiteralKindOfBinaryPlusOperand(node.left);
- var literalKind = ts.isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(node.right) ? leftKind :
- 0;
- node.cachedLiteralKind = literalKind;
- return literalKind;
- }
- return 0;
- }
- function parenthesizeForConditionalHead(condition) {
- var conditionalPrecedence = ts.getOperatorPrecedence(210, 57);
- var emittedCondition = ts.skipPartiallyEmittedExpressions(condition);
- var conditionPrecedence = ts.getExpressionPrecedence(emittedCondition);
- if (ts.compareValues(conditionPrecedence, conditionalPrecedence) !== 1) {
- return ts.createParen(condition);
- }
- return condition;
- }
- ts.parenthesizeForConditionalHead = parenthesizeForConditionalHead;
- function parenthesizeSubexpressionOfConditionalExpression(e) {
- var emittedExpression = ts.skipPartiallyEmittedExpressions(e);
- return isCommaSequence(emittedExpression)
- ? ts.createParen(e)
- : e;
- }
- ts.parenthesizeSubexpressionOfConditionalExpression = parenthesizeSubexpressionOfConditionalExpression;
- function parenthesizeDefaultExpression(e) {
- var check = ts.skipPartiallyEmittedExpressions(e);
- var needsParens = isCommaSequence(check);
- if (!needsParens) {
- switch (getLeftmostExpression(check, false).kind) {
- case 214:
- case 201:
- needsParens = true;
+ if (node.label) {
+ var message = node.kind === 241
+ ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement
+ : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement;
+ return grammarErrorOnNode(node, message);
+ }
+ else {
+ var message = node.kind === 241
+ ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement
+ : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement;
+ return grammarErrorOnNode(node, message);
}
}
- return needsParens ? ts.createParen(e) : e;
- }
- ts.parenthesizeDefaultExpression = parenthesizeDefaultExpression;
- function parenthesizeForNew(expression) {
- var leftmostExpr = getLeftmostExpression(expression, true);
- switch (leftmostExpr.kind) {
- case 196:
- return ts.createParen(expression);
- case 197:
- return !leftmostExpr.arguments
- ? ts.createParen(expression)
- : expression;
- }
- return parenthesizeForAccess(expression);
- }
- ts.parenthesizeForNew = parenthesizeForNew;
- function parenthesizeForAccess(expression) {
- var emittedExpression = ts.skipPartiallyEmittedExpressions(expression);
- if (ts.isLeftHandSideExpression(emittedExpression)
- && (emittedExpression.kind !== 197 || emittedExpression.arguments)) {
- return expression;
- }
- return ts.setTextRange(ts.createParen(expression), expression);
- }
- ts.parenthesizeForAccess = parenthesizeForAccess;
- function parenthesizePostfixOperand(operand) {
- return ts.isLeftHandSideExpression(operand)
- ? operand
- : ts.setTextRange(ts.createParen(operand), operand);
- }
- ts.parenthesizePostfixOperand = parenthesizePostfixOperand;
- function parenthesizePrefixOperand(operand) {
- return ts.isUnaryExpression(operand)
- ? operand
- : ts.setTextRange(ts.createParen(operand), operand);
- }
- ts.parenthesizePrefixOperand = parenthesizePrefixOperand;
- function parenthesizeListElements(elements) {
- var result;
- for (var i = 0; i < elements.length; i++) {
- var element = parenthesizeExpressionForList(elements[i]);
- if (result !== undefined || element !== elements[i]) {
- if (result === undefined) {
- result = elements.slice(0, i);
+ function checkGrammarBindingElement(node) {
+ if (node.dotDotDotToken) {
+ var elements = node.parent.elements;
+ if (node !== ts.last(elements)) {
+ return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
+ }
+ checkGrammarForDisallowedTrailingComma(elements, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
+ if (node.propertyName) {
+ return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_have_a_property_name);
}
- result.push(element);
}
- }
- if (result !== undefined) {
- return ts.setTextRange(ts.createNodeArray(result, elements.hasTrailingComma), elements);
- }
- return elements;
- }
- ts.parenthesizeListElements = parenthesizeListElements;
- function parenthesizeExpressionForList(expression) {
- var emittedExpression = ts.skipPartiallyEmittedExpressions(expression);
- var expressionPrecedence = ts.getExpressionPrecedence(emittedExpression);
- var commaPrecedence = ts.getOperatorPrecedence(209, 27);
- return expressionPrecedence > commaPrecedence
- ? expression
- : ts.setTextRange(ts.createParen(expression), expression);
- }
- ts.parenthesizeExpressionForList = parenthesizeExpressionForList;
- function parenthesizeExpressionForExpressionStatement(expression) {
- var emittedExpression = ts.skipPartiallyEmittedExpressions(expression);
- if (ts.isCallExpression(emittedExpression)) {
- var callee = emittedExpression.expression;
- var kind = ts.skipPartiallyEmittedExpressions(callee).kind;
- if (kind === 201 || kind === 202) {
- var mutableCall = ts.getMutableClone(emittedExpression);
- mutableCall.expression = ts.setTextRange(ts.createParen(callee), callee);
- return recreateOuterExpressions(expression, mutableCall, 8);
+ if (node.dotDotDotToken && node.initializer) {
+ return grammarErrorAtPos(node, node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer);
}
}
- var leftmostExpressionKind = getLeftmostExpression(emittedExpression, false).kind;
- if (leftmostExpressionKind === 193 || leftmostExpressionKind === 201) {
- return ts.setTextRange(ts.createParen(expression), expression);
- }
- return expression;
- }
- ts.parenthesizeExpressionForExpressionStatement = parenthesizeExpressionForExpressionStatement;
- function parenthesizeConditionalTypeMember(member) {
- return member.kind === 180 ? ts.createParenthesizedType(member) : member;
- }
- ts.parenthesizeConditionalTypeMember = parenthesizeConditionalTypeMember;
- function parenthesizeElementTypeMember(member) {
- switch (member.kind) {
- case 178:
- case 179:
- case 170:
- case 171:
- return ts.createParenthesizedType(member);
+ function isStringOrNumberLiteralExpression(expr) {
+ return ts.isStringOrNumericLiteralLike(expr) ||
+ expr.kind === 214 && expr.operator === 40 &&
+ expr.operand.kind === 8;
}
- return parenthesizeConditionalTypeMember(member);
- }
- ts.parenthesizeElementTypeMember = parenthesizeElementTypeMember;
- function parenthesizeArrayTypeMember(member) {
- switch (member.kind) {
- case 172:
- case 184:
- case 181:
- return ts.createParenthesizedType(member);
+ function isBigIntLiteralExpression(expr) {
+ return expr.kind === 9 ||
+ expr.kind === 214 && expr.operator === 40 &&
+ expr.operand.kind === 9;
}
- return parenthesizeElementTypeMember(member);
- }
- ts.parenthesizeArrayTypeMember = parenthesizeArrayTypeMember;
- function parenthesizeElementTypeMembers(members) {
- return ts.createNodeArray(ts.sameMap(members, parenthesizeElementTypeMember));
- }
- ts.parenthesizeElementTypeMembers = parenthesizeElementTypeMembers;
- function parenthesizeTypeParameters(typeParameters) {
- if (ts.some(typeParameters)) {
- var params = [];
- for (var i = 0; i < typeParameters.length; ++i) {
- var entry = typeParameters[i];
- params.push(i === 0 && ts.isFunctionOrConstructorTypeNode(entry) && entry.typeParameters ?
- ts.createParenthesizedType(entry) :
- entry);
+ function isSimpleLiteralEnumReference(expr) {
+ if ((ts.isPropertyAccessExpression(expr) || (ts.isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression))) &&
+ ts.isEntityNameExpression(expr.expression)) {
+ return !!(checkExpressionCached(expr).flags & 1024);
}
- return ts.createNodeArray(params);
}
- }
- ts.parenthesizeTypeParameters = parenthesizeTypeParameters;
- function getLeftmostExpression(node, stopAtCallExpressions) {
- while (true) {
- switch (node.kind) {
- case 208:
- node = node.operand;
- continue;
- case 209:
- node = node.left;
- continue;
- case 210:
- node = node.condition;
- continue;
- case 198:
- node = node.tag;
- continue;
- case 196:
- if (stopAtCallExpressions) {
- return node;
+ function checkAmbientInitializer(node) {
+ var initializer = node.initializer;
+ if (initializer) {
+ var isInvalidInitializer = !(isStringOrNumberLiteralExpression(initializer) ||
+ isSimpleLiteralEnumReference(initializer) ||
+ initializer.kind === 109 || initializer.kind === 94 ||
+ isBigIntLiteralExpression(initializer));
+ var isConstOrReadonly = ts.isDeclarationReadonly(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node);
+ if (isConstOrReadonly && !node.type) {
+ if (isInvalidInitializer) {
+ return grammarErrorOnNode(initializer, ts.Diagnostics.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference);
}
- case 217:
- case 195:
- case 194:
- case 218:
- case 326:
- node = node.expression;
- continue;
+ }
+ else {
+ return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
+ }
+ if (!isConstOrReadonly || isInvalidInitializer) {
+ return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
+ }
}
- return node;
- }
- }
- ts.getLeftmostExpression = getLeftmostExpression;
- function parenthesizeConciseBody(body) {
- if (!ts.isBlock(body) && (isCommaSequence(body) || getLeftmostExpression(body, false).kind === 193)) {
- return ts.setTextRange(ts.createParen(body), body);
- }
- return body;
- }
- ts.parenthesizeConciseBody = parenthesizeConciseBody;
- function isCommaSequence(node) {
- return node.kind === 209 && node.operatorToken.kind === 27 ||
- node.kind === 327;
- }
- ts.isCommaSequence = isCommaSequence;
- function isOuterExpression(node, kinds) {
- if (kinds === void 0) { kinds = 15; }
- switch (node.kind) {
- case 200:
- return (kinds & 1) !== 0;
- case 199:
- case 217:
- return (kinds & 2) !== 0;
- case 218:
- return (kinds & 4) !== 0;
- case 326:
- return (kinds & 8) !== 0;
- }
- return false;
- }
- ts.isOuterExpression = isOuterExpression;
- function skipOuterExpressions(node, kinds) {
- if (kinds === void 0) { kinds = 15; }
- while (isOuterExpression(node, kinds)) {
- node = node.expression;
- }
- return node;
- }
- ts.skipOuterExpressions = skipOuterExpressions;
- function skipAssertions(node) {
- return skipOuterExpressions(node, 6);
- }
- ts.skipAssertions = skipAssertions;
- function updateOuterExpression(outerExpression, expression) {
- switch (outerExpression.kind) {
- case 200: return ts.updateParen(outerExpression, expression);
- case 199: return ts.updateTypeAssertion(outerExpression, outerExpression.type, expression);
- case 217: return ts.updateAsExpression(outerExpression, expression, outerExpression.type);
- case 218: return ts.updateNonNullExpression(outerExpression, expression);
- case 326: return ts.updatePartiallyEmittedExpression(outerExpression, expression);
- }
- }
- function isIgnorableParen(node) {
- return node.kind === 200
- && ts.nodeIsSynthesized(node)
- && ts.nodeIsSynthesized(ts.getSourceMapRange(node))
- && ts.nodeIsSynthesized(ts.getCommentRange(node))
- && !ts.some(ts.getSyntheticLeadingComments(node))
- && !ts.some(ts.getSyntheticTrailingComments(node));
- }
- function recreateOuterExpressions(outerExpression, innerExpression, kinds) {
- if (kinds === void 0) { kinds = 15; }
- if (outerExpression && isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) {
- return updateOuterExpression(outerExpression, recreateOuterExpressions(outerExpression.expression, innerExpression));
}
- return innerExpression;
- }
- ts.recreateOuterExpressions = recreateOuterExpressions;
- function startOnNewLine(node) {
- return ts.setStartsOnNewLine(node, true);
- }
- ts.startOnNewLine = startOnNewLine;
- function getExternalHelpersModuleName(node) {
- var parseNode = ts.getOriginalNode(node, ts.isSourceFile);
- var emitNode = parseNode && parseNode.emitNode;
- return emitNode && emitNode.externalHelpersModuleName;
- }
- ts.getExternalHelpersModuleName = getExternalHelpersModuleName;
- function hasRecordedExternalHelpers(sourceFile) {
- var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile);
- var emitNode = parseNode && parseNode.emitNode;
- return !!emitNode && (!!emitNode.externalHelpersModuleName || !!emitNode.externalHelpers);
- }
- ts.hasRecordedExternalHelpers = hasRecordedExternalHelpers;
- function createExternalHelpersImportDeclarationIfNeeded(sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault) {
- if (compilerOptions.importHelpers && ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
- var namedBindings = void 0;
- var moduleKind = ts.getEmitModuleKind(compilerOptions);
- if (moduleKind >= ts.ModuleKind.ES2015 && moduleKind <= ts.ModuleKind.ESNext) {
- var helpers = ts.getEmitHelpers(sourceFile);
- if (helpers) {
- var helperNames = [];
- for (var _i = 0, helpers_2 = helpers; _i < helpers_2.length; _i++) {
- var helper = helpers_2[_i];
- if (!helper.scoped) {
- var importName = helper.importName;
- if (importName) {
- ts.pushIfUnique(helperNames, importName);
- }
- }
+ function checkGrammarVariableDeclaration(node) {
+ if (node.parent.parent.kind !== 238 && node.parent.parent.kind !== 239) {
+ if (node.flags & 8388608) {
+ checkAmbientInitializer(node);
+ }
+ else if (!node.initializer) {
+ if (ts.isBindingPattern(node.name) && !ts.isBindingPattern(node.parent)) {
+ return grammarErrorOnNode(node, ts.Diagnostics.A_destructuring_declaration_must_have_an_initializer);
}
- if (ts.some(helperNames)) {
- helperNames.sort(ts.compareStringsCaseSensitive);
- namedBindings = ts.createNamedImports(ts.map(helperNames, function (name) { return ts.isFileLevelUniqueName(sourceFile, name)
- ? ts.createImportSpecifier(undefined, ts.createIdentifier(name))
- : ts.createImportSpecifier(ts.createIdentifier(name), getUnscopedHelperName(name)); }));
- var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile);
- var emitNode = ts.getOrCreateEmitNode(parseNode);
- emitNode.externalHelpers = true;
+ if (ts.isVarConst(node)) {
+ return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_must_be_initialized);
+ }
+ }
+ }
+ if (node.exclamationToken && (node.parent.parent.kind !== 232 || !node.type || node.initializer || node.flags & 8388608)) {
+ var message = node.initializer
+ ? ts.Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions
+ : ts.Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations;
+ return grammarErrorOnNode(node.exclamationToken, message);
+ }
+ var moduleKind = ts.getEmitModuleKind(compilerOptions);
+ if (moduleKind < ts.ModuleKind.ES2015 && moduleKind !== ts.ModuleKind.System &&
+ !(node.parent.parent.flags & 8388608) && ts.hasSyntacticModifier(node.parent.parent, 1)) {
+ checkESModuleMarker(node.name);
+ }
+ var checkLetConstNames = (ts.isLet(node) || ts.isVarConst(node));
+ return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name);
+ }
+ function checkESModuleMarker(name) {
+ if (name.kind === 78) {
+ if (ts.idText(name) === "__esModule") {
+ return grammarErrorOnNodeSkippedOn("noEmit", name, ts.Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules);
+ }
+ }
+ else {
+ var elements = name.elements;
+ for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
+ var element = elements_1[_i];
+ if (!ts.isOmittedExpression(element)) {
+ return checkESModuleMarker(element.name);
}
}
}
+ return false;
+ }
+ function checkGrammarNameInLetOrConstDeclarations(name) {
+ if (name.kind === 78) {
+ if (name.originalKeywordKind === 118) {
+ return grammarErrorOnNode(name, ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations);
+ }
+ }
else {
- var externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar || hasImportDefault);
- if (externalHelpersModuleName) {
- namedBindings = ts.createNamespaceImport(externalHelpersModuleName);
+ var elements = name.elements;
+ for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
+ var element = elements_2[_i];
+ if (!ts.isOmittedExpression(element)) {
+ checkGrammarNameInLetOrConstDeclarations(element.name);
+ }
}
}
- if (namedBindings) {
- var externalHelpersImportDeclaration = ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, namedBindings), ts.createLiteral(ts.externalHelpersModuleNameText));
- ts.addEmitFlags(externalHelpersImportDeclaration, 67108864);
- return externalHelpersImportDeclaration;
+ return false;
+ }
+ function checkGrammarVariableDeclarationList(declarationList) {
+ var declarations = declarationList.declarations;
+ if (checkGrammarForDisallowedTrailingComma(declarationList.declarations)) {
+ return true;
+ }
+ if (!declarationList.declarations.length) {
+ return grammarErrorAtPos(declarationList, declarations.pos, declarations.end - declarations.pos, ts.Diagnostics.Variable_declaration_list_cannot_be_empty);
}
+ return false;
}
- }
- ts.createExternalHelpersImportDeclarationIfNeeded = createExternalHelpersImportDeclarationIfNeeded;
- function getOrCreateExternalHelpersModuleNameIfNeeded(node, compilerOptions, hasExportStarsToExportValues, hasImportStarOrImportDefault) {
- if (compilerOptions.importHelpers && ts.isEffectiveExternalModule(node, compilerOptions)) {
- var externalHelpersModuleName = getExternalHelpersModuleName(node);
- if (externalHelpersModuleName) {
- return externalHelpersModuleName;
+ function allowLetAndConstDeclarations(parent) {
+ switch (parent.kind) {
+ case 234:
+ case 235:
+ case 236:
+ case 243:
+ case 237:
+ case 238:
+ case 239:
+ return false;
+ case 245:
+ return allowLetAndConstDeclarations(parent.parent);
}
- var moduleKind = ts.getEmitModuleKind(compilerOptions);
- var create = (hasExportStarsToExportValues || (compilerOptions.esModuleInterop && hasImportStarOrImportDefault))
- && moduleKind !== ts.ModuleKind.System
- && moduleKind < ts.ModuleKind.ES2015;
- if (!create) {
- var helpers = ts.getEmitHelpers(node);
- if (helpers) {
- for (var _i = 0, helpers_3 = helpers; _i < helpers_3.length; _i++) {
- var helper = helpers_3[_i];
- if (!helper.scoped) {
- create = true;
- break;
- }
- }
+ return true;
+ }
+ function checkGrammarForDisallowedLetOrConstStatement(node) {
+ if (!allowLetAndConstDeclarations(node.parent)) {
+ if (ts.isLet(node.declarationList)) {
+ return grammarErrorOnNode(node, ts.Diagnostics.let_declarations_can_only_be_declared_inside_a_block);
+ }
+ else if (ts.isVarConst(node.declarationList)) {
+ return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_can_only_be_declared_inside_a_block);
}
}
- if (create) {
- var parseNode = ts.getOriginalNode(node, ts.isSourceFile);
- var emitNode = ts.getOrCreateEmitNode(parseNode);
- return emitNode.externalHelpersModuleName || (emitNode.externalHelpersModuleName = ts.createUniqueName(ts.externalHelpersModuleNameText));
+ }
+ function checkGrammarMetaProperty(node) {
+ var escapedText = node.name.escapedText;
+ switch (node.keywordToken) {
+ case 102:
+ if (escapedText !== "target") {
+ return grammarErrorOnNode(node.name, ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, ts.tokenToString(node.keywordToken), "target");
+ }
+ break;
+ case 99:
+ if (escapedText !== "meta") {
+ return grammarErrorOnNode(node.name, ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, ts.tokenToString(node.keywordToken), "meta");
+ }
+ break;
}
}
- }
- ts.getOrCreateExternalHelpersModuleNameIfNeeded = getOrCreateExternalHelpersModuleNameIfNeeded;
- function getLocalNameForExternalImport(node, sourceFile) {
- var namespaceDeclaration = ts.getNamespaceDeclarationNode(node);
- if (namespaceDeclaration && !ts.isDefaultImport(node)) {
- var name = namespaceDeclaration.name;
- return ts.isGeneratedIdentifier(name) ? name : ts.createIdentifier(ts.getSourceTextOfNodeFromSourceFile(sourceFile, name) || ts.idText(name));
+ function hasParseDiagnostics(sourceFile) {
+ return sourceFile.parseDiagnostics.length > 0;
}
- if (node.kind === 254 && node.importClause) {
- return ts.getGeneratedNameForNode(node);
+ function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
+ var sourceFile = ts.getSourceFileOfNode(node);
+ if (!hasParseDiagnostics(sourceFile)) {
+ var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+ diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2));
+ return true;
+ }
+ return false;
}
- if (node.kind === 260 && node.moduleSpecifier) {
- return ts.getGeneratedNameForNode(node);
+ function grammarErrorAtPos(nodeForSourceFile, start, length, message, arg0, arg1, arg2) {
+ var sourceFile = ts.getSourceFileOfNode(nodeForSourceFile);
+ if (!hasParseDiagnostics(sourceFile)) {
+ diagnostics.add(ts.createFileDiagnostic(sourceFile, start, length, message, arg0, arg1, arg2));
+ return true;
+ }
+ return false;
}
- return undefined;
- }
- ts.getLocalNameForExternalImport = getLocalNameForExternalImport;
- function getExternalModuleNameLiteral(importNode, sourceFile, host, resolver, compilerOptions) {
- var moduleName = ts.getExternalModuleName(importNode);
- if (moduleName.kind === 10) {
- return tryGetModuleNameFromDeclaration(importNode, host, resolver, compilerOptions)
- || tryRenameExternalModule(moduleName, sourceFile)
- || ts.getSynthesizedClone(moduleName);
+ function grammarErrorOnNodeSkippedOn(key, node, message, arg0, arg1, arg2) {
+ var sourceFile = ts.getSourceFileOfNode(node);
+ if (!hasParseDiagnostics(sourceFile)) {
+ errorSkippedOn(key, node, message, arg0, arg1, arg2);
+ return true;
+ }
+ return false;
}
- return undefined;
- }
- ts.getExternalModuleNameLiteral = getExternalModuleNameLiteral;
- function tryRenameExternalModule(moduleName, sourceFile) {
- var rename = sourceFile.renamedDependencies && sourceFile.renamedDependencies.get(moduleName.text);
- return rename && ts.createLiteral(rename);
- }
- function tryGetModuleNameFromFile(file, host, options) {
- if (!file) {
- return undefined;
+ function grammarErrorOnNode(node, message, arg0, arg1, arg2) {
+ var sourceFile = ts.getSourceFileOfNode(node);
+ if (!hasParseDiagnostics(sourceFile)) {
+ diagnostics.add(ts.createDiagnosticForNode(node, message, arg0, arg1, arg2));
+ return true;
+ }
+ return false;
}
- if (file.moduleName) {
- return ts.createLiteral(file.moduleName);
+ function checkGrammarConstructorTypeParameters(node) {
+ var jsdocTypeParameters = ts.isInJSFile(node) ? ts.getJSDocTypeParameterDeclarations(node) : undefined;
+ var range = node.typeParameters || jsdocTypeParameters && ts.firstOrUndefined(jsdocTypeParameters);
+ if (range) {
+ var pos = range.pos === range.end ? range.pos : ts.skipTrivia(ts.getSourceFileOfNode(node).text, range.pos);
+ return grammarErrorAtPos(node, pos, range.end - pos, ts.Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);
+ }
}
- if (!file.isDeclarationFile && (options.out || options.outFile)) {
- return ts.createLiteral(ts.getExternalModuleNameFromPath(host, file.fileName));
+ function checkGrammarConstructorTypeAnnotation(node) {
+ var type = ts.getEffectiveReturnTypeNode(node);
+ if (type) {
+ return grammarErrorOnNode(type, ts.Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration);
+ }
}
- return undefined;
- }
- ts.tryGetModuleNameFromFile = tryGetModuleNameFromFile;
- function tryGetModuleNameFromDeclaration(declaration, host, resolver, compilerOptions) {
- return tryGetModuleNameFromFile(resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions);
- }
- function getInitializerOfBindingOrAssignmentElement(bindingElement) {
- if (ts.isDeclarationBindingElement(bindingElement)) {
- return bindingElement.initializer;
+ function checkGrammarProperty(node) {
+ if (ts.isClassLike(node.parent)) {
+ if (ts.isStringLiteral(node.name) && node.name.text === "constructor") {
+ return grammarErrorOnNode(node.name, ts.Diagnostics.Classes_may_not_have_a_field_named_constructor);
+ }
+ if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) {
+ return true;
+ }
+ if (languageVersion < 2 && ts.isPrivateIdentifier(node.name)) {
+ return grammarErrorOnNode(node.name, ts.Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
+ }
+ }
+ else if (node.parent.kind === 253) {
+ if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) {
+ return true;
+ }
+ if (node.initializer) {
+ return grammarErrorOnNode(node.initializer, ts.Diagnostics.An_interface_property_cannot_have_an_initializer);
+ }
+ }
+ else if (node.parent.kind === 177) {
+ if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) {
+ return true;
+ }
+ if (node.initializer) {
+ return grammarErrorOnNode(node.initializer, ts.Diagnostics.A_type_literal_property_cannot_have_an_initializer);
+ }
+ }
+ if (node.flags & 8388608) {
+ checkAmbientInitializer(node);
+ }
+ if (ts.isPropertyDeclaration(node) && node.exclamationToken && (!ts.isClassLike(node.parent) || !node.type || node.initializer ||
+ node.flags & 8388608 || ts.hasSyntacticModifier(node, 32 | 128))) {
+ var message = node.initializer
+ ? ts.Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions
+ : !node.type
+ ? ts.Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations
+ : ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context;
+ return grammarErrorOnNode(node.exclamationToken, message);
+ }
}
- if (ts.isPropertyAssignment(bindingElement)) {
- var initializer = bindingElement.initializer;
- return ts.isAssignmentExpression(initializer, true)
- ? initializer.right
- : undefined;
+ function checkGrammarTopLevelElementForRequiredDeclareModifier(node) {
+ if (node.kind === 253 ||
+ node.kind === 254 ||
+ node.kind === 261 ||
+ node.kind === 260 ||
+ node.kind === 267 ||
+ node.kind === 266 ||
+ node.kind === 259 ||
+ ts.hasSyntacticModifier(node, 2 | 1 | 512)) {
+ return false;
+ }
+ return grammarErrorOnFirstToken(node, ts.Diagnostics.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier);
}
- if (ts.isShorthandPropertyAssignment(bindingElement)) {
- return bindingElement.objectAssignmentInitializer;
+ function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) {
+ for (var _i = 0, _a = file.statements; _i < _a.length; _i++) {
+ var decl = _a[_i];
+ if (ts.isDeclaration(decl) || decl.kind === 232) {
+ if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) {
+ return true;
+ }
+ }
+ }
+ return false;
}
- if (ts.isAssignmentExpression(bindingElement, true)) {
- return bindingElement.right;
+ function checkGrammarSourceFile(node) {
+ return !!(node.flags & 8388608) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node);
}
- if (ts.isSpreadElement(bindingElement)) {
- return getInitializerOfBindingOrAssignmentElement(bindingElement.expression);
+ function checkGrammarStatementInAmbientContext(node) {
+ if (node.flags & 8388608) {
+ var links = getNodeLinks(node);
+ if (!links.hasReportedStatementInAmbientContext && (ts.isFunctionLike(node.parent) || ts.isAccessor(node.parent))) {
+ return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts);
+ }
+ if (node.parent.kind === 230 || node.parent.kind === 257 || node.parent.kind === 297) {
+ var links_2 = getNodeLinks(node.parent);
+ if (!links_2.hasReportedStatementInAmbientContext) {
+ return links_2.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts);
+ }
+ }
+ else {
+ }
+ }
+ return false;
}
- }
- ts.getInitializerOfBindingOrAssignmentElement = getInitializerOfBindingOrAssignmentElement;
- function getTargetOfBindingOrAssignmentElement(bindingElement) {
- if (ts.isDeclarationBindingElement(bindingElement)) {
- return bindingElement.name;
+ function checkGrammarNumericLiteral(node) {
+ if (node.numericLiteralFlags & 32) {
+ var diagnosticMessage = void 0;
+ if (languageVersion >= 1) {
+ diagnosticMessage = ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0;
+ }
+ else if (ts.isChildOfNodeWithKind(node, 191)) {
+ diagnosticMessage = ts.Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0;
+ }
+ else if (ts.isChildOfNodeWithKind(node, 291)) {
+ diagnosticMessage = ts.Diagnostics.Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0;
+ }
+ if (diagnosticMessage) {
+ var withMinus = ts.isPrefixUnaryExpression(node.parent) && node.parent.operator === 40;
+ var literal = (withMinus ? "-" : "") + "0o" + node.text;
+ return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal);
+ }
+ }
+ checkNumericLiteralValueSize(node);
+ return false;
}
- if (ts.isObjectLiteralElementLike(bindingElement)) {
- switch (bindingElement.kind) {
- case 281:
- return getTargetOfBindingOrAssignmentElement(bindingElement.initializer);
- case 282:
- return bindingElement.name;
- case 283:
- return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
+ function checkNumericLiteralValueSize(node) {
+ if (node.numericLiteralFlags & 16 || node.text.length <= 15 || node.text.indexOf(".") !== -1) {
+ return;
}
- return undefined;
+ var apparentValue = +ts.getTextOfNode(node);
+ if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) {
+ return;
+ }
+ addErrorOrSuggestion(false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
}
- if (ts.isAssignmentExpression(bindingElement, true)) {
- return getTargetOfBindingOrAssignmentElement(bindingElement.left);
+ function checkGrammarBigIntLiteral(node) {
+ var literalType = ts.isLiteralTypeNode(node.parent) ||
+ ts.isPrefixUnaryExpression(node.parent) && ts.isLiteralTypeNode(node.parent.parent);
+ if (!literalType) {
+ if (languageVersion < 7) {
+ if (grammarErrorOnNode(node, ts.Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020)) {
+ return true;
+ }
+ }
+ }
+ return false;
}
- if (ts.isSpreadElement(bindingElement)) {
- return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
+ function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) {
+ var sourceFile = ts.getSourceFileOfNode(node);
+ if (!hasParseDiagnostics(sourceFile)) {
+ var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+ diagnostics.add(ts.createFileDiagnostic(sourceFile, ts.textSpanEnd(span), 0, message, arg0, arg1, arg2));
+ return true;
+ }
+ return false;
}
- return bindingElement;
- }
- ts.getTargetOfBindingOrAssignmentElement = getTargetOfBindingOrAssignmentElement;
- function getRestIndicatorOfBindingOrAssignmentElement(bindingElement) {
- switch (bindingElement.kind) {
- case 156:
- case 191:
- return bindingElement.dotDotDotToken;
- case 213:
- case 283:
- return bindingElement;
+ function getAmbientModules() {
+ if (!ambientModulesCache) {
+ ambientModulesCache = [];
+ globals.forEach(function (global, sym) {
+ if (ambientModuleSymbolRegex.test(sym)) {
+ ambientModulesCache.push(global);
+ }
+ });
+ }
+ return ambientModulesCache;
}
- return undefined;
- }
- ts.getRestIndicatorOfBindingOrAssignmentElement = getRestIndicatorOfBindingOrAssignmentElement;
- function getPropertyNameOfBindingOrAssignmentElement(bindingElement) {
- var propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement);
- ts.Debug.assert(!!propertyName || ts.isSpreadAssignment(bindingElement), "Invalid property name for binding element.");
- return propertyName;
- }
- ts.getPropertyNameOfBindingOrAssignmentElement = getPropertyNameOfBindingOrAssignmentElement;
- function tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement) {
- switch (bindingElement.kind) {
- case 191:
- if (bindingElement.propertyName) {
- var propertyName = bindingElement.propertyName;
- if (ts.isPrivateIdentifier(propertyName)) {
- return ts.Debug.failBadSyntaxKind(propertyName);
+ function checkGrammarImportClause(node) {
+ if (node.isTypeOnly && node.name && node.namedBindings) {
+ return grammarErrorOnNode(node, ts.Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both);
+ }
+ return false;
+ }
+ function checkGrammarImportCallExpression(node) {
+ if (moduleKind === ts.ModuleKind.ES2015) {
+ return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system_or_umd);
+ }
+ if (node.typeArguments) {
+ return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
+ }
+ var nodeArguments = node.arguments;
+ if (nodeArguments.length !== 1) {
+ return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_must_have_one_specifier_as_an_argument);
+ }
+ checkGrammarForDisallowedTrailingComma(nodeArguments);
+ if (ts.isSpreadElement(nodeArguments[0])) {
+ return grammarErrorOnNode(nodeArguments[0], ts.Diagnostics.Specifier_of_dynamic_import_cannot_be_spread_element);
+ }
+ return false;
+ }
+ function findMatchingTypeReferenceOrTypeAliasReference(source, unionTarget) {
+ var sourceObjectFlags = ts.getObjectFlags(source);
+ if (sourceObjectFlags & (4 | 16) && unionTarget.flags & 1048576) {
+ return ts.find(unionTarget.types, function (target) {
+ if (target.flags & 524288) {
+ var overlapObjFlags = sourceObjectFlags & ts.getObjectFlags(target);
+ if (overlapObjFlags & 4) {
+ return source.target === target.target;
+ }
+ if (overlapObjFlags & 16) {
+ return !!source.aliasSymbol && source.aliasSymbol === target.aliasSymbol;
+ }
}
- return ts.isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression)
- ? propertyName.expression
- : propertyName;
+ return false;
+ });
+ }
+ }
+ function findBestTypeForObjectLiteral(source, unionTarget) {
+ if (ts.getObjectFlags(source) & 128 && forEachType(unionTarget, isArrayLikeType)) {
+ return ts.find(unionTarget.types, function (t) { return !isArrayLikeType(t); });
+ }
+ }
+ function findBestTypeForInvokable(source, unionTarget) {
+ var signatureKind = 0;
+ var hasSignatures = getSignaturesOfType(source, signatureKind).length > 0 ||
+ (signatureKind = 1, getSignaturesOfType(source, signatureKind).length > 0);
+ if (hasSignatures) {
+ return ts.find(unionTarget.types, function (t) { return getSignaturesOfType(t, signatureKind).length > 0; });
+ }
+ }
+ function findMostOverlappyType(source, unionTarget) {
+ var bestMatch;
+ var matchingCount = 0;
+ for (var _i = 0, _a = unionTarget.types; _i < _a.length; _i++) {
+ var target = _a[_i];
+ var overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
+ if (overlap.flags & 4194304) {
+ bestMatch = target;
+ matchingCount = Infinity;
}
- break;
- case 281:
- if (bindingElement.name) {
- var propertyName = bindingElement.name;
- if (ts.isPrivateIdentifier(propertyName)) {
- return ts.Debug.failBadSyntaxKind(propertyName);
+ else if (overlap.flags & 1048576) {
+ var len = ts.length(ts.filter(overlap.types, isUnitType));
+ if (len >= matchingCount) {
+ bestMatch = target;
+ matchingCount = len;
}
- return ts.isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression)
- ? propertyName.expression
- : propertyName;
}
- break;
- case 283:
- if (bindingElement.name && ts.isPrivateIdentifier(bindingElement.name)) {
- return ts.Debug.failBadSyntaxKind(bindingElement.name);
+ else if (isUnitType(overlap) && 1 >= matchingCount) {
+ bestMatch = target;
+ matchingCount = 1;
}
- return bindingElement.name;
- }
- var target = getTargetOfBindingOrAssignmentElement(bindingElement);
- if (target && ts.isPropertyName(target)) {
- return target;
- }
- }
- ts.tryGetPropertyNameOfBindingOrAssignmentElement = tryGetPropertyNameOfBindingOrAssignmentElement;
- function isStringOrNumericLiteral(node) {
- var kind = node.kind;
- return kind === 10
- || kind === 8;
- }
- function getElementsOfBindingOrAssignmentPattern(name) {
- switch (name.kind) {
- case 189:
- case 190:
- case 192:
- return name.elements;
- case 193:
- return name.properties;
- }
- }
- ts.getElementsOfBindingOrAssignmentPattern = getElementsOfBindingOrAssignmentPattern;
- function convertToArrayAssignmentElement(element) {
- if (ts.isBindingElement(element)) {
- if (element.dotDotDotToken) {
- ts.Debug.assertNode(element.name, ts.isIdentifier);
- return ts.setOriginalNode(ts.setTextRange(ts.createSpread(element.name), element), element);
}
- var expression = convertToAssignmentElementTarget(element.name);
- return element.initializer
- ? ts.setOriginalNode(ts.setTextRange(ts.createAssignment(expression, element.initializer), element), element)
- : expression;
+ return bestMatch;
}
- ts.Debug.assertNode(element, ts.isExpression);
- return element;
- }
- ts.convertToArrayAssignmentElement = convertToArrayAssignmentElement;
- function convertToObjectAssignmentElement(element) {
- if (ts.isBindingElement(element)) {
- if (element.dotDotDotToken) {
- ts.Debug.assertNode(element.name, ts.isIdentifier);
- return ts.setOriginalNode(ts.setTextRange(ts.createSpreadAssignment(element.name), element), element);
+ function filterPrimitivesIfContainsNonPrimitive(type) {
+ if (maybeTypeOfKind(type, 67108864)) {
+ var result = filterType(type, function (t) { return !(t.flags & 131068); });
+ if (!(result.flags & 131072)) {
+ return result;
+ }
}
- if (element.propertyName) {
- var expression = convertToAssignmentElementTarget(element.name);
- return ts.setOriginalNode(ts.setTextRange(ts.createPropertyAssignment(element.propertyName, element.initializer ? ts.createAssignment(expression, element.initializer) : expression), element), element);
+ return type;
+ }
+ function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) {
+ if (target.flags & 1048576 && source.flags & (2097152 | 524288)) {
+ var sourceProperties = getPropertiesOfType(source);
+ if (sourceProperties) {
+ var sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
+ if (sourcePropertiesFiltered) {
+ return discriminateTypeByDiscriminableItems(target, ts.map(sourcePropertiesFiltered, function (p) { return [function () { return getTypeOfSymbol(p); }, p.escapedName]; }), isRelatedTo, undefined, skipPartial);
+ }
+ }
}
- ts.Debug.assertNode(element.name, ts.isIdentifier);
- return ts.setOriginalNode(ts.setTextRange(ts.createShorthandPropertyAssignment(element.name, element.initializer), element), element);
+ return undefined;
}
- ts.Debug.assertNode(element, ts.isObjectLiteralElementLike);
- return element;
}
- ts.convertToObjectAssignmentElement = convertToObjectAssignmentElement;
- function convertToAssignmentPattern(node) {
- switch (node.kind) {
- case 190:
- case 192:
- return convertToArrayAssignmentPattern(node);
- case 189:
- case 193:
- return convertToObjectAssignmentPattern(node);
- }
+ ts.createTypeChecker = createTypeChecker;
+ function isNotAccessor(declaration) {
+ return !ts.isAccessor(declaration);
+ }
+ function isNotOverload(declaration) {
+ return (declaration.kind !== 251 && declaration.kind !== 165) ||
+ !!declaration.body;
}
- ts.convertToAssignmentPattern = convertToAssignmentPattern;
- function convertToObjectAssignmentPattern(node) {
- if (ts.isObjectBindingPattern(node)) {
- return ts.setOriginalNode(ts.setTextRange(ts.createObjectLiteral(ts.map(node.elements, convertToObjectAssignmentElement)), node), node);
+ function isDeclarationNameOrImportPropertyName(name) {
+ switch (name.parent.kind) {
+ case 265:
+ case 270:
+ return ts.isIdentifier(name);
+ default:
+ return ts.isDeclarationName(name);
}
- ts.Debug.assertNode(node, ts.isObjectLiteralExpression);
- return node;
}
- ts.convertToObjectAssignmentPattern = convertToObjectAssignmentPattern;
- function convertToArrayAssignmentPattern(node) {
- if (ts.isArrayBindingPattern(node)) {
- return ts.setOriginalNode(ts.setTextRange(ts.createArrayLiteral(ts.map(node.elements, convertToArrayAssignmentElement)), node), node);
+ function isSomeImportDeclaration(decl) {
+ switch (decl.kind) {
+ case 262:
+ case 260:
+ case 263:
+ case 265:
+ return true;
+ case 78:
+ return decl.parent.kind === 265;
+ default:
+ return false;
}
- ts.Debug.assertNode(node, ts.isArrayLiteralExpression);
- return node;
}
- ts.convertToArrayAssignmentPattern = convertToArrayAssignmentPattern;
- function convertToAssignmentElementTarget(node) {
- if (ts.isBindingPattern(node)) {
- return convertToAssignmentPattern(node);
+ var JsxNames;
+ (function (JsxNames) {
+ JsxNames.JSX = "JSX";
+ JsxNames.IntrinsicElements = "IntrinsicElements";
+ JsxNames.ElementClass = "ElementClass";
+ JsxNames.ElementAttributesPropertyNameContainer = "ElementAttributesProperty";
+ JsxNames.ElementChildrenAttributeNameContainer = "ElementChildrenAttribute";
+ JsxNames.Element = "Element";
+ JsxNames.IntrinsicAttributes = "IntrinsicAttributes";
+ JsxNames.IntrinsicClassAttributes = "IntrinsicClassAttributes";
+ JsxNames.LibraryManagedAttributes = "LibraryManagedAttributes";
+ })(JsxNames || (JsxNames = {}));
+ function getIterationTypesKeyFromIterationTypeKind(typeKind) {
+ switch (typeKind) {
+ case 0: return "yieldType";
+ case 1: return "returnType";
+ case 2: return "nextType";
}
- ts.Debug.assertNode(node, ts.isExpression);
- return node;
}
- ts.convertToAssignmentElementTarget = convertToAssignmentElementTarget;
+ function signatureHasRestParameter(s) {
+ return !!(s.flags & 1);
+ }
+ ts.signatureHasRestParameter = signatureHasRestParameter;
+ function signatureHasLiteralTypes(s) {
+ return !!(s.flags & 2);
+ }
+ ts.signatureHasLiteralTypes = signatureHasLiteralTypes;
})(ts || (ts = {}));
var ts;
(function (ts) {
if (node === undefined || visitor === undefined) {
return node;
}
- ts.aggregateTransformFlags(node);
var visited = visitor(node);
if (visited === node) {
return node;
visitedNode = visited;
}
ts.Debug.assertNode(visitedNode, test);
- ts.aggregateTransformFlags(visitedNode);
return visitedNode;
}
ts.visitNode = visitNode;
if (count === undefined || count > length - start) {
count = length - start;
}
+ var hasTrailingComma;
+ var pos = -1;
+ var end = -1;
if (start > 0 || count < length) {
- updated = ts.createNodeArray([], nodes.hasTrailingComma && start + count === length);
+ updated = [];
+ hasTrailingComma = nodes.hasTrailingComma && start + count === length;
}
for (var i = 0; i < count; i++) {
var node = nodes[i + start];
- ts.aggregateTransformFlags(node);
var visited = node !== undefined ? visitor(node) : undefined;
if (updated !== undefined || visited === undefined || visited !== node) {
if (updated === undefined) {
- updated = ts.createNodeArray(nodes.slice(0, i), nodes.hasTrailingComma);
- ts.setTextRange(updated, nodes);
+ updated = nodes.slice(0, i);
+ hasTrailingComma = nodes.hasTrailingComma;
+ pos = nodes.pos;
+ end = nodes.end;
}
if (visited) {
if (ts.isArray(visited)) {
for (var _i = 0, visited_1 = visited; _i < visited_1.length; _i++) {
var visitedNode = visited_1[_i];
- ts.Debug.assertNode(visitedNode, test);
- ts.aggregateTransformFlags(visitedNode);
+ void ts.Debug.assertNode(visitedNode, test);
updated.push(visitedNode);
}
}
else {
- ts.Debug.assertNode(visited, test);
- ts.aggregateTransformFlags(visited);
+ void ts.Debug.assertNode(visited, test);
updated.push(visited);
}
}
}
}
- return updated || nodes;
+ if (updated) {
+ var updatedArray = ts.factory.createNodeArray(updated, hasTrailingComma);
+ ts.setTextRangePosEnd(updatedArray, pos, end);
+ return updatedArray;
+ }
+ return nodes;
}
ts.visitNodes = visitNodes;
- function visitLexicalEnvironment(statements, visitor, context, start, ensureUseStrict) {
+ function visitLexicalEnvironment(statements, visitor, context, start, ensureUseStrict, nodesVisitor) {
+ if (nodesVisitor === void 0) { nodesVisitor = visitNodes; }
context.startLexicalEnvironment();
- statements = visitNodes(statements, visitor, ts.isStatement, start);
+ statements = nodesVisitor(statements, visitor, ts.isStatement, start);
if (ensureUseStrict)
- statements = ts.ensureUseStrict(statements);
- return ts.mergeLexicalEnvironment(statements, context.endLexicalEnvironment());
+ statements = context.factory.ensureUseStrict(statements);
+ return ts.factory.mergeLexicalEnvironment(statements, context.endLexicalEnvironment());
}
ts.visitLexicalEnvironment = visitLexicalEnvironment;
function visitParameterList(nodes, visitor, context, nodesVisitor) {
}
}
if (result) {
- return ts.setTextRange(ts.createNodeArray(result, parameters.hasTrailingComma), parameters);
+ return ts.setTextRange(context.factory.createNodeArray(result, parameters.hasTrailingComma), parameters);
}
return parameters;
}
parameter;
}
function addDefaultValueAssignmentForBindingPattern(parameter, context) {
- context.addInitializationStatement(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(parameter.name, parameter.type, parameter.initializer ?
- ts.createConditional(ts.createStrictEquality(ts.getGeneratedNameForNode(parameter), ts.createVoidZero()), parameter.initializer, ts.getGeneratedNameForNode(parameter)) :
- ts.getGeneratedNameForNode(parameter)),
+ var factory = context.factory;
+ context.addInitializationStatement(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(parameter.name, undefined, parameter.type, parameter.initializer ?
+ factory.createConditionalExpression(factory.createStrictEquality(factory.getGeneratedNameForNode(parameter), factory.createVoidZero()), undefined, parameter.initializer, undefined, factory.getGeneratedNameForNode(parameter)) :
+ factory.getGeneratedNameForNode(parameter)),
])));
- return ts.updateParameter(parameter, parameter.decorators, parameter.modifiers, parameter.dotDotDotToken, ts.getGeneratedNameForNode(parameter), parameter.questionToken, parameter.type, undefined);
+ return factory.updateParameterDeclaration(parameter, parameter.decorators, parameter.modifiers, parameter.dotDotDotToken, factory.getGeneratedNameForNode(parameter), parameter.questionToken, parameter.type, undefined);
}
function addDefaultValueAssignmentForInitializer(parameter, name, initializer, context) {
- context.addInitializationStatement(ts.createIf(ts.createTypeCheck(ts.getSynthesizedClone(name), "undefined"), ts.setEmitFlags(ts.setTextRange(ts.createBlock([
- ts.createExpressionStatement(ts.setEmitFlags(ts.setTextRange(ts.createAssignment(ts.setEmitFlags(ts.getMutableClone(name), 48), ts.setEmitFlags(initializer, 48 | ts.getEmitFlags(initializer) | 1536)), parameter), 1536))
+ var factory = context.factory;
+ context.addInitializationStatement(factory.createIfStatement(factory.createTypeCheck(factory.cloneNode(name), "undefined"), ts.setEmitFlags(ts.setTextRange(factory.createBlock([
+ factory.createExpressionStatement(ts.setEmitFlags(ts.setTextRange(factory.createAssignment(ts.setEmitFlags(factory.cloneNode(name), 48), ts.setEmitFlags(initializer, 48 | ts.getEmitFlags(initializer) | 1536)), parameter), 1536))
]), parameter), 1 | 32 | 384 | 1536)));
- return ts.updateParameter(parameter, parameter.decorators, parameter.modifiers, parameter.dotDotDotToken, parameter.name, parameter.questionToken, parameter.type, undefined);
+ return factory.updateParameterDeclaration(parameter, parameter.decorators, parameter.modifiers, parameter.dotDotDotToken, parameter.name, parameter.questionToken, parameter.type, undefined);
}
- function visitFunctionBody(node, visitor, context) {
+ function visitFunctionBody(node, visitor, context, nodeVisitor) {
+ if (nodeVisitor === void 0) { nodeVisitor = visitNode; }
context.resumeLexicalEnvironment();
- var updated = visitNode(node, visitor, ts.isConciseBody);
+ var updated = nodeVisitor(node, visitor, ts.isConciseBody);
var declarations = context.endLexicalEnvironment();
if (ts.some(declarations)) {
- var block = ts.convertToFunctionBody(updated);
- var statements = ts.mergeLexicalEnvironment(block.statements, declarations);
- return ts.updateBlock(block, statements);
+ if (!updated) {
+ return context.factory.createBlock(declarations);
+ }
+ var block = context.factory.converters.convertToFunctionBlock(updated);
+ var statements = ts.factory.mergeLexicalEnvironment(block.statements, declarations);
+ return context.factory.updateBlock(block, statements);
}
return updated;
}
ts.visitFunctionBody = visitFunctionBody;
- function visitEachChild(node, visitor, context, nodesVisitor, tokenVisitor) {
+ function visitEachChild(node, visitor, context, nodesVisitor, tokenVisitor, nodeVisitor) {
if (nodesVisitor === void 0) { nodesVisitor = visitNodes; }
+ if (nodeVisitor === void 0) { nodeVisitor = visitNode; }
if (node === undefined) {
return undefined;
}
var kind = node.kind;
- if ((kind > 0 && kind <= 152) || kind === 183) {
+ if ((kind > 0 && kind <= 156) || kind === 187) {
return node;
}
+ var factory = context.factory;
switch (kind) {
- case 75:
- return ts.updateIdentifier(node, nodesVisitor(node.typeArguments, visitor, isTypeNodeOrTypeParameterDeclaration));
- case 153:
- return ts.updateQualifiedName(node, visitNode(node.left, visitor, ts.isEntityName), visitNode(node.right, visitor, ts.isIdentifier));
- case 154:
- return ts.updateComputedPropertyName(node, visitNode(node.expression, visitor, ts.isExpression));
- case 155:
- return ts.updateTypeParameterDeclaration(node, visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.constraint, visitor, ts.isTypeNode), visitNode(node.default, visitor, ts.isTypeNode));
- case 156:
- return ts.updateParameter(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.dotDotDotToken, tokenVisitor, ts.isToken), visitNode(node.name, visitor, ts.isBindingName), visitNode(node.questionToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.initializer, visitor, ts.isExpression));
+ case 78:
+ return factory.updateIdentifier(node, nodesVisitor(node.typeArguments, visitor, isTypeNodeOrTypeParameterDeclaration));
case 157:
- return ts.updateDecorator(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateQualifiedName(node, nodeVisitor(node.left, visitor, ts.isEntityName), nodeVisitor(node.right, visitor, ts.isIdentifier));
case 158:
- return ts.updatePropertySignature(node, nodesVisitor(node.modifiers, visitor, ts.isToken), visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.questionToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.initializer, visitor, ts.isExpression));
+ return factory.updateComputedPropertyName(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 159:
- return ts.updateProperty(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.questionToken || node.exclamationToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.initializer, visitor, ts.isExpression));
+ return factory.updateTypeParameterDeclaration(node, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.constraint, visitor, ts.isTypeNode), nodeVisitor(node.default, visitor, ts.isTypeNode));
case 160:
- return ts.updateMethodSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.questionToken, tokenVisitor, ts.isToken));
+ return factory.updateParameterDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isToken), nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
case 161:
- return ts.updateMethod(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.asteriskToken, tokenVisitor, ts.isToken), visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.questionToken, tokenVisitor, ts.isToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context));
+ return factory.updateDecorator(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 162:
- return ts.updateConstructor(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context));
+ return factory.updatePropertySignature(node, nodesVisitor(node.modifiers, visitor, ts.isToken), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 163:
- return ts.updateGetAccessor(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context));
+ return factory.updatePropertyDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken || node.exclamationToken, tokenVisitor, ts.isToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
case 164:
- return ts.updateSetAccessor(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context));
+ return factory.updateMethodSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 165:
- return ts.updateCallSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateMethodDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isToken), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
case 166:
- return ts.updateConstructSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateConstructorDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context, nodeVisitor));
case 167:
- return ts.updateIndexSignature(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateGetAccessorDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
case 168:
- return ts.updateTypePredicateNodeWithModifier(node, visitNode(node.assertsModifier, visitor), visitNode(node.parameterName, visitor), visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateSetAccessorDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context, nodeVisitor));
case 169:
- return ts.updateTypeReferenceNode(node, visitNode(node.typeName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
+ return factory.updateCallSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 170:
- return ts.updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateConstructSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 171:
- return ts.updateConstructorTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateIndexSignature(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 172:
- return ts.updateTypeQueryNode(node, visitNode(node.exprName, visitor, ts.isEntityName));
+ return factory.updateTypePredicateNode(node, nodeVisitor(node.assertsModifier, visitor), nodeVisitor(node.parameterName, visitor), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 173:
- return ts.updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, ts.isTypeElement));
+ return factory.updateTypeReferenceNode(node, nodeVisitor(node.typeName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
case 174:
- return ts.updateArrayTypeNode(node, visitNode(node.elementType, visitor, ts.isTypeNode));
+ return factory.updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 175:
- return ts.updateTupleTypeNode(node, nodesVisitor(node.elementTypes, visitor, ts.isTypeNode));
+ return factory.updateConstructorTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 176:
- return ts.updateOptionalTypeNode(node, visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName));
case 177:
- return ts.updateRestTypeNode(node, visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, ts.isTypeElement));
case 178:
- return ts.updateUnionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode));
+ return factory.updateArrayTypeNode(node, nodeVisitor(node.elementType, visitor, ts.isTypeNode));
case 179:
- return ts.updateIntersectionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode));
+ return factory.updateTupleTypeNode(node, nodesVisitor(node.elements, visitor, ts.isTypeNode));
case 180:
- return ts.updateConditionalTypeNode(node, visitNode(node.checkType, visitor, ts.isTypeNode), visitNode(node.extendsType, visitor, ts.isTypeNode), visitNode(node.trueType, visitor, ts.isTypeNode), visitNode(node.falseType, visitor, ts.isTypeNode));
+ return factory.updateOptionalTypeNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
case 181:
- return ts.updateInferTypeNode(node, visitNode(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
- case 188:
- return ts.updateImportTypeNode(node, visitNode(node.argument, visitor, ts.isTypeNode), visitNode(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+ return factory.updateRestTypeNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
case 182:
- return ts.updateParenthesizedType(node, visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateUnionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode));
+ case 183:
+ return factory.updateIntersectionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode));
case 184:
- return ts.updateTypeOperatorNode(node, visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateConditionalTypeNode(node, nodeVisitor(node.checkType, visitor, ts.isTypeNode), nodeVisitor(node.extendsType, visitor, ts.isTypeNode), nodeVisitor(node.trueType, visitor, ts.isTypeNode), nodeVisitor(node.falseType, visitor, ts.isTypeNode));
case 185:
- return ts.updateIndexedAccessTypeNode(node, visitNode(node.objectType, visitor, ts.isTypeNode), visitNode(node.indexType, visitor, ts.isTypeNode));
+ return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
+ case 195:
+ return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+ case 192:
+ return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode));
case 186:
- return ts.updateMappedTypeNode(node, visitNode(node.readonlyToken, tokenVisitor, ts.isToken), visitNode(node.typeParameter, visitor, ts.isTypeParameterDeclaration), visitNode(node.questionToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode));
- case 187:
- return ts.updateLiteralTypeNode(node, visitNode(node.literal, visitor, ts.isExpression));
+ return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
+ case 188:
+ return factory.updateTypeOperatorNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
case 189:
- return ts.updateObjectBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isBindingElement));
+ return factory.updateIndexedAccessTypeNode(node, nodeVisitor(node.objectType, visitor, ts.isTypeNode), nodeVisitor(node.indexType, visitor, ts.isTypeNode));
case 190:
- return ts.updateArrayBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isArrayBindingElement));
+ return factory.updateMappedTypeNode(node, nodeVisitor(node.readonlyToken, tokenVisitor, ts.isToken), nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration), nodeVisitor(node.nameType, visitor, ts.isTypeNode), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 191:
- return ts.updateBindingElement(node, visitNode(node.dotDotDotToken, tokenVisitor, ts.isToken), visitNode(node.propertyName, visitor, ts.isPropertyName), visitNode(node.name, visitor, ts.isBindingName), visitNode(node.initializer, visitor, ts.isExpression));
- case 192:
- return ts.updateArrayLiteral(node, nodesVisitor(node.elements, visitor, ts.isExpression));
+ return factory.updateLiteralTypeNode(node, nodeVisitor(node.literal, visitor, ts.isExpression));
case 193:
- return ts.updateObjectLiteral(node, nodesVisitor(node.properties, visitor, ts.isObjectLiteralElementLike));
+ return factory.updateTemplateLiteralType(node, nodeVisitor(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateLiteralTypeSpan));
case 194:
- if (node.flags & 32) {
- return ts.updatePropertyAccessChain(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.questionDotToken, tokenVisitor, ts.isToken), visitNode(node.name, visitor, ts.isIdentifier));
- }
- return ts.updatePropertyAccess(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.name, visitor, ts.isIdentifierOrPrivateIdentifier));
- case 195:
- if (node.flags & 32) {
- return ts.updateElementAccessChain(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.questionDotToken, tokenVisitor, ts.isToken), visitNode(node.argumentExpression, visitor, ts.isExpression));
- }
- return ts.updateElementAccess(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.argumentExpression, visitor, ts.isExpression));
+ return factory.updateTemplateLiteralTypeSpan(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail));
case 196:
- if (node.flags & 32) {
- return ts.updateCallChain(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.questionDotToken, tokenVisitor, ts.isToken), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
- }
- return ts.updateCall(node, visitNode(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
+ return factory.updateObjectBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isBindingElement));
case 197:
- return ts.updateNew(node, visitNode(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
+ return factory.updateArrayBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isArrayBindingElement));
case 198:
- return ts.updateTaggedTemplate(node, visitNode(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isExpression), visitNode(node.template, visitor, ts.isTemplateLiteral));
+ return factory.updateBindingElement(node, nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isToken), nodeVisitor(node.propertyName, visitor, ts.isPropertyName), nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.initializer, visitor, ts.isExpression));
case 199:
- return ts.updateTypeAssertion(node, visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateArrayLiteralExpression(node, nodesVisitor(node.elements, visitor, ts.isExpression));
case 200:
- return ts.updateParen(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateObjectLiteralExpression(node, nodesVisitor(node.properties, visitor, ts.isObjectLiteralElementLike));
case 201:
- return ts.updateFunctionExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.asteriskToken, tokenVisitor, ts.isToken), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context));
+ if (node.flags & 32) {
+ return factory.updatePropertyAccessChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isToken), nodeVisitor(node.name, visitor, ts.isIdentifier));
+ }
+ return factory.updatePropertyAccessExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.name, visitor, ts.isIdentifierOrPrivateIdentifier));
case 202:
- return ts.updateArrowFunction(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.equalsGreaterThanToken, tokenVisitor, ts.isToken), visitFunctionBody(node.body, visitor, context));
+ if (node.flags & 32) {
+ return factory.updateElementAccessChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isToken), nodeVisitor(node.argumentExpression, visitor, ts.isExpression));
+ }
+ return factory.updateElementAccessExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.argumentExpression, visitor, ts.isExpression));
case 203:
- return ts.updateDelete(node, visitNode(node.expression, visitor, ts.isExpression));
+ if (node.flags & 32) {
+ return factory.updateCallChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isToken), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
+ }
+ return factory.updateCallExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
case 204:
- return ts.updateTypeOf(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
case 205:
- return ts.updateVoid(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isExpression), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
case 206:
- return ts.updateAwait(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
case 207:
- return ts.updatePrefix(node, visitNode(node.operand, visitor, ts.isExpression));
+ return factory.updateParenthesizedExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 208:
- return ts.updatePostfix(node, visitNode(node.operand, visitor, ts.isExpression));
+ return factory.updateFunctionExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
case 209:
- return ts.updateBinary(node, visitNode(node.left, visitor, ts.isExpression), visitNode(node.right, visitor, ts.isExpression), visitNode(node.operatorToken, tokenVisitor, ts.isToken));
+ return factory.updateArrowFunction(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.equalsGreaterThanToken, tokenVisitor, ts.isToken), visitFunctionBody(node.body, visitor, context, nodeVisitor));
case 210:
- return ts.updateConditional(node, visitNode(node.condition, visitor, ts.isExpression), visitNode(node.questionToken, tokenVisitor, ts.isToken), visitNode(node.whenTrue, visitor, ts.isExpression), visitNode(node.colonToken, tokenVisitor, ts.isToken), visitNode(node.whenFalse, visitor, ts.isExpression));
+ return factory.updateDeleteExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 211:
- return ts.updateTemplateExpression(node, visitNode(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateSpan));
+ return factory.updateTypeOfExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 212:
- return ts.updateYield(node, visitNode(node.asteriskToken, tokenVisitor, ts.isToken), visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateVoidExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 213:
- return ts.updateSpread(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateAwaitExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 214:
- return ts.updateClassExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement));
+ return factory.updatePrefixUnaryExpression(node, nodeVisitor(node.operand, visitor, ts.isExpression));
+ case 215:
+ return factory.updatePostfixUnaryExpression(node, nodeVisitor(node.operand, visitor, ts.isExpression));
case 216:
- return ts.updateExpressionWithTypeArguments(node, nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateBinaryExpression(node, nodeVisitor(node.left, visitor, ts.isExpression), nodeVisitor(node.operatorToken, tokenVisitor, ts.isToken), nodeVisitor(node.right, visitor, ts.isExpression));
case 217:
- return ts.updateAsExpression(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.type, visitor, ts.isTypeNode));
+ return factory.updateConditionalExpression(node, nodeVisitor(node.condition, visitor, ts.isExpression), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodeVisitor(node.whenTrue, visitor, ts.isExpression), nodeVisitor(node.colonToken, tokenVisitor, ts.isToken), nodeVisitor(node.whenFalse, visitor, ts.isExpression));
case 218:
- return ts.updateNonNullExpression(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateTemplateExpression(node, nodeVisitor(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateSpan));
case 219:
- return ts.updateMetaProperty(node, visitNode(node.name, visitor, ts.isIdentifier));
+ return factory.updateYieldExpression(node, nodeVisitor(node.asteriskToken, tokenVisitor, ts.isToken), nodeVisitor(node.expression, visitor, ts.isExpression));
+ case 220:
+ return factory.updateSpreadElement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 221:
- return ts.updateTemplateSpan(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail));
+ return factory.updateClassExpression(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement));
case 223:
- return ts.updateBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement));
+ return factory.updateExpressionWithTypeArguments(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
+ case 224:
+ return factory.updateAsExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 225:
- return ts.updateVariableStatement(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.declarationList, visitor, ts.isVariableDeclarationList));
+ if (node.flags & 32) {
+ return factory.updateNonNullChain(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+ }
+ return factory.updateNonNullExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 226:
- return ts.updateExpressionStatement(node, visitNode(node.expression, visitor, ts.isExpression));
- case 227:
- return ts.updateIf(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.thenStatement, visitor, ts.isStatement, ts.liftToBlock), visitNode(node.elseStatement, visitor, ts.isStatement, ts.liftToBlock));
+ return factory.updateMetaProperty(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
case 228:
- return ts.updateDo(node, visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock), visitNode(node.expression, visitor, ts.isExpression));
- case 229:
- return ts.updateWhile(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock));
+ return factory.updateTemplateSpan(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail));
case 230:
- return ts.updateFor(node, visitNode(node.initializer, visitor, ts.isForInitializer), visitNode(node.condition, visitor, ts.isExpression), visitNode(node.incrementor, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock));
- case 231:
- return ts.updateForIn(node, visitNode(node.initializer, visitor, ts.isForInitializer), visitNode(node.expression, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock));
+ return factory.updateBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement));
case 232:
- return ts.updateForOf(node, visitNode(node.awaitModifier, tokenVisitor, ts.isToken), visitNode(node.initializer, visitor, ts.isForInitializer), visitNode(node.expression, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock));
+ return factory.updateVariableStatement(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.declarationList, visitor, ts.isVariableDeclarationList));
case 233:
- return ts.updateContinue(node, visitNode(node.label, visitor, ts.isIdentifier));
+ return factory.updateExpressionStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 234:
- return ts.updateBreak(node, visitNode(node.label, visitor, ts.isIdentifier));
+ return factory.updateIfStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.thenStatement, visitor, ts.isStatement, factory.liftToBlock), nodeVisitor(node.elseStatement, visitor, ts.isStatement, factory.liftToBlock));
case 235:
- return ts.updateReturn(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateDoStatement(node, nodeVisitor(node.statement, visitor, ts.isStatement, factory.liftToBlock), nodeVisitor(node.expression, visitor, ts.isExpression));
case 236:
- return ts.updateWith(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock));
+ return factory.updateWhileStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.statement, visitor, ts.isStatement, factory.liftToBlock));
case 237:
- return ts.updateSwitch(node, visitNode(node.expression, visitor, ts.isExpression), visitNode(node.caseBlock, visitor, ts.isCaseBlock));
+ return factory.updateForStatement(node, nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.condition, visitor, ts.isExpression), nodeVisitor(node.incrementor, visitor, ts.isExpression), nodeVisitor(node.statement, visitor, ts.isStatement, factory.liftToBlock));
case 238:
- return ts.updateLabel(node, visitNode(node.label, visitor, ts.isIdentifier), visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock));
+ return factory.updateForInStatement(node, nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.statement, visitor, ts.isStatement, factory.liftToBlock));
case 239:
- return ts.updateThrow(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateForOfStatement(node, nodeVisitor(node.awaitModifier, tokenVisitor, ts.isToken), nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.statement, visitor, ts.isStatement, factory.liftToBlock));
case 240:
- return ts.updateTry(node, visitNode(node.tryBlock, visitor, ts.isBlock), visitNode(node.catchClause, visitor, ts.isCatchClause), visitNode(node.finallyBlock, visitor, ts.isBlock));
+ return factory.updateContinueStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier));
+ case 241:
+ return factory.updateBreakStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier));
case 242:
- return ts.updateTypeScriptVariableDeclaration(node, visitNode(node.name, visitor, ts.isBindingName), visitNode(node.exclamationToken, tokenVisitor, ts.isToken), visitNode(node.type, visitor, ts.isTypeNode), visitNode(node.initializer, visitor, ts.isExpression));
+ return factory.updateReturnStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 243:
- return ts.updateVariableDeclarationList(node, nodesVisitor(node.declarations, visitor, ts.isVariableDeclaration));
+ return factory.updateWithStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.statement, visitor, ts.isStatement, factory.liftToBlock));
case 244:
- return ts.updateFunctionDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.asteriskToken, tokenVisitor, ts.isToken), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context));
+ return factory.updateSwitchStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.caseBlock, visitor, ts.isCaseBlock));
case 245:
- return ts.updateClassDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement));
+ return factory.updateLabeledStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier), nodeVisitor(node.statement, visitor, ts.isStatement, factory.liftToBlock));
case 246:
- return ts.updateInterfaceDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isTypeElement));
+ return factory.updateThrowStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 247:
- return ts.updateTypeAliasDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitNode(node.type, visitor, ts.isTypeNode));
- case 248:
- return ts.updateEnumDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), nodesVisitor(node.members, visitor, ts.isEnumMember));
+ return factory.updateTryStatement(node, nodeVisitor(node.tryBlock, visitor, ts.isBlock), nodeVisitor(node.catchClause, visitor, ts.isCatchClause), nodeVisitor(node.finallyBlock, visitor, ts.isBlock));
case 249:
- return ts.updateModuleDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.body, visitor, ts.isModuleBody));
+ return factory.updateVariableDeclaration(node, nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.exclamationToken, tokenVisitor, ts.isToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
case 250:
- return ts.updateModuleBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement));
+ return factory.updateVariableDeclarationList(node, nodesVisitor(node.declarations, visitor, ts.isVariableDeclaration));
case 251:
- return ts.updateCaseBlock(node, nodesVisitor(node.clauses, visitor, ts.isCaseOrDefaultClause));
+ return factory.updateFunctionDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
case 252:
- return ts.updateNamespaceExportDeclaration(node, visitNode(node.name, visitor, ts.isIdentifier));
+ return factory.updateClassDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement));
case 253:
- return ts.updateImportEqualsDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.moduleReference, visitor, ts.isModuleReference));
+ return factory.updateInterfaceDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isTypeElement));
case 254:
- return ts.updateImportDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.importClause, visitor, ts.isImportClause), visitNode(node.moduleSpecifier, visitor, ts.isExpression));
+ return factory.updateTypeAliasDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
case 255:
- return ts.updateImportClause(node, visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.namedBindings, visitor, ts.isNamedImportBindings), node.isTypeOnly);
+ return factory.updateEnumDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.members, visitor, ts.isEnumMember));
case 256:
- return ts.updateNamespaceImport(node, visitNode(node.name, visitor, ts.isIdentifier));
- case 262:
- return ts.updateNamespaceExport(node, visitNode(node.name, visitor, ts.isIdentifier));
+ return factory.updateModuleDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.body, visitor, ts.isModuleBody));
case 257:
- return ts.updateNamedImports(node, nodesVisitor(node.elements, visitor, ts.isImportSpecifier));
+ return factory.updateModuleBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement));
case 258:
- return ts.updateImportSpecifier(node, visitNode(node.propertyName, visitor, ts.isIdentifier), visitNode(node.name, visitor, ts.isIdentifier));
+ return factory.updateCaseBlock(node, nodesVisitor(node.clauses, visitor, ts.isCaseOrDefaultClause));
case 259:
- return ts.updateExportAssignment(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateNamespaceExportDeclaration(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
case 260:
- return ts.updateExportDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), visitNode(node.exportClause, visitor, ts.isNamedExportBindings), visitNode(node.moduleSpecifier, visitor, ts.isExpression), node.isTypeOnly);
+ return factory.updateImportEqualsDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.moduleReference, visitor, ts.isModuleReference));
case 261:
- return ts.updateNamedExports(node, nodesVisitor(node.elements, visitor, ts.isExportSpecifier));
+ return factory.updateImportDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.importClause, visitor, ts.isImportClause), nodeVisitor(node.moduleSpecifier, visitor, ts.isExpression));
+ case 262:
+ return factory.updateImportClause(node, node.isTypeOnly, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.namedBindings, visitor, ts.isNamedImportBindings));
case 263:
- return ts.updateExportSpecifier(node, visitNode(node.propertyName, visitor, ts.isIdentifier), visitNode(node.name, visitor, ts.isIdentifier));
+ return factory.updateNamespaceImport(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
+ case 269:
+ return factory.updateNamespaceExport(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
+ case 264:
+ return factory.updateNamedImports(node, nodesVisitor(node.elements, visitor, ts.isImportSpecifier));
case 265:
- return ts.updateExternalModuleReference(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateImportSpecifier(node, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
case 266:
- return ts.updateJsxElement(node, visitNode(node.openingElement, visitor, ts.isJsxOpeningElement), nodesVisitor(node.children, visitor, ts.isJsxChild), visitNode(node.closingElement, visitor, ts.isJsxClosingElement));
+ return factory.updateExportAssignment(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.expression, visitor, ts.isExpression));
case 267:
- return ts.updateJsxSelfClosingElement(node, visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), visitNode(node.attributes, visitor, ts.isJsxAttributes));
+ return factory.updateExportDeclaration(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), node.isTypeOnly, nodeVisitor(node.exportClause, visitor, ts.isNamedExportBindings), nodeVisitor(node.moduleSpecifier, visitor, ts.isExpression));
case 268:
- return ts.updateJsxOpeningElement(node, visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), visitNode(node.attributes, visitor, ts.isJsxAttributes));
- case 269:
- return ts.updateJsxClosingElement(node, visitNode(node.tagName, visitor, ts.isJsxTagNameExpression));
+ return factory.updateNamedExports(node, nodesVisitor(node.elements, visitor, ts.isExportSpecifier));
case 270:
- return ts.updateJsxFragment(node, visitNode(node.openingFragment, visitor, ts.isJsxOpeningFragment), nodesVisitor(node.children, visitor, ts.isJsxChild), visitNode(node.closingFragment, visitor, ts.isJsxClosingFragment));
+ return factory.updateExportSpecifier(node, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
+ case 272:
+ return factory.updateExternalModuleReference(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 273:
- return ts.updateJsxAttribute(node, visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.initializer, visitor, ts.isStringLiteralOrJsxExpression));
+ return factory.updateJsxElement(node, nodeVisitor(node.openingElement, visitor, ts.isJsxOpeningElement), nodesVisitor(node.children, visitor, ts.isJsxChild), nodeVisitor(node.closingElement, visitor, ts.isJsxClosingElement));
case 274:
- return ts.updateJsxAttributes(node, nodesVisitor(node.properties, visitor, ts.isJsxAttributeLike));
+ return factory.updateJsxSelfClosingElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.attributes, visitor, ts.isJsxAttributes));
case 275:
- return ts.updateJsxSpreadAttribute(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateJsxOpeningElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.attributes, visitor, ts.isJsxAttributes));
case 276:
- return ts.updateJsxExpression(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateJsxClosingElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression));
case 277:
- return ts.updateCaseClause(node, visitNode(node.expression, visitor, ts.isExpression), nodesVisitor(node.statements, visitor, ts.isStatement));
- case 278:
- return ts.updateDefaultClause(node, nodesVisitor(node.statements, visitor, ts.isStatement));
- case 279:
- return ts.updateHeritageClause(node, nodesVisitor(node.types, visitor, ts.isExpressionWithTypeArguments));
+ return factory.updateJsxFragment(node, nodeVisitor(node.openingFragment, visitor, ts.isJsxOpeningFragment), nodesVisitor(node.children, visitor, ts.isJsxChild), nodeVisitor(node.closingFragment, visitor, ts.isJsxClosingFragment));
case 280:
- return ts.updateCatchClause(node, visitNode(node.variableDeclaration, visitor, ts.isVariableDeclaration), visitNode(node.block, visitor, ts.isBlock));
+ return factory.updateJsxAttribute(node, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.initializer, visitor, ts.isStringLiteralOrJsxExpression));
case 281:
- return ts.updatePropertyAssignment(node, visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.initializer, visitor, ts.isExpression));
+ return factory.updateJsxAttributes(node, nodesVisitor(node.properties, visitor, ts.isJsxAttributeLike));
case 282:
- return ts.updateShorthandPropertyAssignment(node, visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.objectAssignmentInitializer, visitor, ts.isExpression));
+ return factory.updateJsxSpreadAttribute(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 283:
- return ts.updateSpreadAssignment(node, visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateJsxExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
case 284:
- return ts.updateEnumMember(node, visitNode(node.name, visitor, ts.isPropertyName), visitNode(node.initializer, visitor, ts.isExpression));
+ return factory.updateCaseClause(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.statements, visitor, ts.isStatement));
+ case 285:
+ return factory.updateDefaultClause(node, nodesVisitor(node.statements, visitor, ts.isStatement));
+ case 286:
+ return factory.updateHeritageClause(node, nodesVisitor(node.types, visitor, ts.isExpressionWithTypeArguments));
+ case 287:
+ return factory.updateCatchClause(node, nodeVisitor(node.variableDeclaration, visitor, ts.isVariableDeclaration), nodeVisitor(node.block, visitor, ts.isBlock));
+ case 288:
+ return factory.updatePropertyAssignment(node, nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.initializer, visitor, ts.isExpression));
+ case 289:
+ return factory.updateShorthandPropertyAssignment(node, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.objectAssignmentInitializer, visitor, ts.isExpression));
case 290:
- return ts.updateSourceFileNode(node, visitLexicalEnvironment(node.statements, visitor, context));
- case 326:
- return ts.updatePartiallyEmittedExpression(node, visitNode(node.expression, visitor, ts.isExpression));
- case 327:
- return ts.updateCommaList(node, nodesVisitor(node.elements, visitor, ts.isExpression));
+ return factory.updateSpreadAssignment(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+ case 291:
+ return factory.updateEnumMember(node, nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.initializer, visitor, ts.isExpression));
+ case 297:
+ return factory.updateSourceFile(node, visitLexicalEnvironment(node.statements, visitor, context));
+ case 336:
+ return factory.updatePartiallyEmittedExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+ case 337:
+ return factory.updateCommaListExpression(node, nodesVisitor(node.elements, visitor, ts.isExpression));
default:
return node;
}
}
})(ts || (ts = {}));
var ts;
-(function (ts) {
- function reduceNode(node, f, initial) {
- return node ? f(initial, node) : initial;
- }
- function reduceNodeArray(nodes, f, initial) {
- return nodes ? f(initial, nodes) : initial;
- }
- function reduceEachChild(node, initial, cbNode, cbNodeArray) {
- if (node === undefined) {
- return initial;
- }
- var reduceNodes = cbNodeArray ? reduceNodeArray : ts.reduceLeft;
- var cbNodes = cbNodeArray || cbNode;
- var kind = node.kind;
- if ((kind > 0 && kind <= 152)) {
- return initial;
- }
- if ((kind >= 168 && kind <= 187)) {
- return initial;
- }
- var result = initial;
- switch (node.kind) {
- case 222:
- case 224:
- case 215:
- case 241:
- case 325:
- break;
- case 153:
- result = reduceNode(node.left, cbNode, result);
- result = reduceNode(node.right, cbNode, result);
- break;
- case 154:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 156:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.initializer, cbNode, result);
- break;
- case 157:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 158:
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.questionToken, cbNode, result);
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.initializer, cbNode, result);
- break;
- case 159:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.initializer, cbNode, result);
- break;
- case 161:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNodes(node.typeParameters, cbNodes, result);
- result = reduceNodes(node.parameters, cbNodes, result);
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.body, cbNode, result);
- break;
- case 162:
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNodes(node.parameters, cbNodes, result);
- result = reduceNode(node.body, cbNode, result);
- break;
- case 163:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNodes(node.parameters, cbNodes, result);
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.body, cbNode, result);
- break;
- case 164:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNodes(node.parameters, cbNodes, result);
- result = reduceNode(node.body, cbNode, result);
- break;
- case 189:
- case 190:
- result = reduceNodes(node.elements, cbNodes, result);
- break;
- case 191:
- result = reduceNode(node.propertyName, cbNode, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.initializer, cbNode, result);
- break;
- case 192:
- result = reduceNodes(node.elements, cbNodes, result);
- break;
- case 193:
- result = reduceNodes(node.properties, cbNodes, result);
- break;
- case 194:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNode(node.name, cbNode, result);
- break;
- case 195:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNode(node.argumentExpression, cbNode, result);
- break;
- case 196:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNodes(node.typeArguments, cbNodes, result);
- result = reduceNodes(node.arguments, cbNodes, result);
- break;
- case 197:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNodes(node.typeArguments, cbNodes, result);
- result = reduceNodes(node.arguments, cbNodes, result);
- break;
- case 198:
- result = reduceNode(node.tag, cbNode, result);
- result = reduceNodes(node.typeArguments, cbNodes, result);
- result = reduceNode(node.template, cbNode, result);
- break;
- case 199:
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 201:
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNodes(node.typeParameters, cbNodes, result);
- result = reduceNodes(node.parameters, cbNodes, result);
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.body, cbNode, result);
- break;
- case 202:
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNodes(node.typeParameters, cbNodes, result);
- result = reduceNodes(node.parameters, cbNodes, result);
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.body, cbNode, result);
- break;
- case 200:
- case 203:
- case 204:
- case 205:
- case 206:
- case 212:
- case 213:
- case 218:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 207:
- case 208:
- result = reduceNode(node.operand, cbNode, result);
- break;
- case 209:
- result = reduceNode(node.left, cbNode, result);
- result = reduceNode(node.right, cbNode, result);
- break;
- case 210:
- result = reduceNode(node.condition, cbNode, result);
- result = reduceNode(node.whenTrue, cbNode, result);
- result = reduceNode(node.whenFalse, cbNode, result);
- break;
- case 211:
- result = reduceNode(node.head, cbNode, result);
- result = reduceNodes(node.templateSpans, cbNodes, result);
- break;
- case 214:
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNodes(node.typeParameters, cbNodes, result);
- result = reduceNodes(node.heritageClauses, cbNodes, result);
- result = reduceNodes(node.members, cbNodes, result);
- break;
- case 216:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNodes(node.typeArguments, cbNodes, result);
- break;
- case 217:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNode(node.type, cbNode, result);
- break;
- case 221:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNode(node.literal, cbNode, result);
- break;
- case 223:
- result = reduceNodes(node.statements, cbNodes, result);
- break;
- case 225:
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.declarationList, cbNode, result);
- break;
- case 226:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 227:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNode(node.thenStatement, cbNode, result);
- result = reduceNode(node.elseStatement, cbNode, result);
- break;
- case 228:
- result = reduceNode(node.statement, cbNode, result);
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 229:
- case 236:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNode(node.statement, cbNode, result);
- break;
- case 230:
- result = reduceNode(node.initializer, cbNode, result);
- result = reduceNode(node.condition, cbNode, result);
- result = reduceNode(node.incrementor, cbNode, result);
- result = reduceNode(node.statement, cbNode, result);
- break;
- case 231:
- case 232:
- result = reduceNode(node.initializer, cbNode, result);
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNode(node.statement, cbNode, result);
- break;
- case 235:
- case 239:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 237:
- result = reduceNode(node.expression, cbNode, result);
- result = reduceNode(node.caseBlock, cbNode, result);
- break;
- case 238:
- result = reduceNode(node.label, cbNode, result);
- result = reduceNode(node.statement, cbNode, result);
- break;
- case 240:
- result = reduceNode(node.tryBlock, cbNode, result);
- result = reduceNode(node.catchClause, cbNode, result);
- result = reduceNode(node.finallyBlock, cbNode, result);
- break;
- case 242:
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.initializer, cbNode, result);
- break;
- case 243:
- result = reduceNodes(node.declarations, cbNodes, result);
- break;
- case 244:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNodes(node.typeParameters, cbNodes, result);
- result = reduceNodes(node.parameters, cbNodes, result);
- result = reduceNode(node.type, cbNode, result);
- result = reduceNode(node.body, cbNode, result);
- break;
- case 245:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNodes(node.typeParameters, cbNodes, result);
- result = reduceNodes(node.heritageClauses, cbNodes, result);
- result = reduceNodes(node.members, cbNodes, result);
- break;
- case 248:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNodes(node.members, cbNodes, result);
- break;
- case 249:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.body, cbNode, result);
- break;
- case 250:
- result = reduceNodes(node.statements, cbNodes, result);
- break;
- case 251:
- result = reduceNodes(node.clauses, cbNodes, result);
- break;
- case 253:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.moduleReference, cbNode, result);
- break;
- case 254:
- result = reduceNodes(node.decorators, cbNodes, result);
- result = reduceNodes(node.modifiers, cbNodes, result);
- result = reduceNode(node.importClause, cbNode, result);
- result = reduceNode(node.moduleSpecifier, cbNode, result);
- break;
- case 255:
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.namedBindings, cbNode, result);
- break;
- case 256:
- result = reduceNode(node.name, cbNode, result);
- break;
- case 262:
- result = reduceNode(node.name, cbNode, result);
- break;
- case 257:
- case 261:
- result = reduceNodes(node.elements, cbNodes, result);
- break;
- case 258:
- case 263:
- result = reduceNode(node.propertyName, cbNode, result);
- result = reduceNode(node.name, cbNode, result);
- break;
- case 259:
- result = ts.reduceLeft(node.decorators, cbNode, result);
- result = ts.reduceLeft(node.modifiers, cbNode, result);
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 260:
- result = ts.reduceLeft(node.decorators, cbNode, result);
- result = ts.reduceLeft(node.modifiers, cbNode, result);
- result = reduceNode(node.exportClause, cbNode, result);
- result = reduceNode(node.moduleSpecifier, cbNode, result);
- break;
- case 265:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 266:
- result = reduceNode(node.openingElement, cbNode, result);
- result = ts.reduceLeft(node.children, cbNode, result);
- result = reduceNode(node.closingElement, cbNode, result);
- break;
- case 270:
- result = reduceNode(node.openingFragment, cbNode, result);
- result = ts.reduceLeft(node.children, cbNode, result);
- result = reduceNode(node.closingFragment, cbNode, result);
- break;
- case 267:
- case 268:
- result = reduceNode(node.tagName, cbNode, result);
- result = reduceNodes(node.typeArguments, cbNode, result);
- result = reduceNode(node.attributes, cbNode, result);
- break;
- case 274:
- result = reduceNodes(node.properties, cbNodes, result);
- break;
- case 269:
- result = reduceNode(node.tagName, cbNode, result);
- break;
- case 273:
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.initializer, cbNode, result);
- break;
- case 275:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 276:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 277:
- result = reduceNode(node.expression, cbNode, result);
- case 278:
- result = reduceNodes(node.statements, cbNodes, result);
- break;
- case 279:
- result = reduceNodes(node.types, cbNodes, result);
- break;
- case 280:
- result = reduceNode(node.variableDeclaration, cbNode, result);
- result = reduceNode(node.block, cbNode, result);
- break;
- case 281:
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.initializer, cbNode, result);
- break;
- case 282:
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.objectAssignmentInitializer, cbNode, result);
- break;
- case 283:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 284:
- result = reduceNode(node.name, cbNode, result);
- result = reduceNode(node.initializer, cbNode, result);
- break;
- case 290:
- result = reduceNodes(node.statements, cbNodes, result);
- break;
- case 326:
- result = reduceNode(node.expression, cbNode, result);
- break;
- case 327:
- result = reduceNodes(node.elements, cbNodes, result);
- break;
- default:
- break;
- }
- return result;
- }
- ts.reduceEachChild = reduceEachChild;
- function findSpanEnd(array, test, start) {
- var i = start;
- while (i < array.length && test(array[i])) {
- i++;
- }
- return i;
- }
- function mergeLexicalEnvironment(statements, declarations) {
- if (!ts.some(declarations)) {
- return statements;
- }
- var leftStandardPrologueEnd = findSpanEnd(statements, ts.isPrologueDirective, 0);
- var leftHoistedFunctionsEnd = findSpanEnd(statements, ts.isHoistedFunction, leftStandardPrologueEnd);
- var leftHoistedVariablesEnd = findSpanEnd(statements, ts.isHoistedVariableStatement, leftHoistedFunctionsEnd);
- var rightStandardPrologueEnd = findSpanEnd(declarations, ts.isPrologueDirective, 0);
- var rightHoistedFunctionsEnd = findSpanEnd(declarations, ts.isHoistedFunction, rightStandardPrologueEnd);
- var rightHoistedVariablesEnd = findSpanEnd(declarations, ts.isHoistedVariableStatement, rightHoistedFunctionsEnd);
- var rightCustomPrologueEnd = findSpanEnd(declarations, ts.isCustomPrologue, rightHoistedVariablesEnd);
- ts.Debug.assert(rightCustomPrologueEnd === declarations.length, "Expected declarations to be valid standard or custom prologues");
- var left = ts.isNodeArray(statements) ? statements.slice() : statements;
- if (rightCustomPrologueEnd > rightHoistedVariablesEnd) {
- left.splice.apply(left, __spreadArrays([leftHoistedVariablesEnd, 0], declarations.slice(rightHoistedVariablesEnd, rightCustomPrologueEnd)));
- }
- if (rightHoistedVariablesEnd > rightHoistedFunctionsEnd) {
- left.splice.apply(left, __spreadArrays([leftHoistedFunctionsEnd, 0], declarations.slice(rightHoistedFunctionsEnd, rightHoistedVariablesEnd)));
- }
- if (rightHoistedFunctionsEnd > rightStandardPrologueEnd) {
- left.splice.apply(left, __spreadArrays([leftStandardPrologueEnd, 0], declarations.slice(rightStandardPrologueEnd, rightHoistedFunctionsEnd)));
- }
- if (rightStandardPrologueEnd > 0) {
- if (leftStandardPrologueEnd === 0) {
- left.splice.apply(left, __spreadArrays([0, 0], declarations.slice(0, rightStandardPrologueEnd)));
- }
- else {
- var leftPrologues = ts.createMap();
- for (var i = 0; i < leftStandardPrologueEnd; i++) {
- var leftPrologue = statements[i];
- leftPrologues.set(leftPrologue.expression.text, true);
- }
- for (var i = rightStandardPrologueEnd - 1; i >= 0; i--) {
- var rightPrologue = declarations[i];
- if (!leftPrologues.has(rightPrologue.expression.text)) {
- left.unshift(rightPrologue);
- }
- }
- }
- }
- if (ts.isNodeArray(statements)) {
- return ts.setTextRange(ts.createNodeArray(left, statements.hasTrailingComma), statements);
- }
- return statements;
- }
- ts.mergeLexicalEnvironment = mergeLexicalEnvironment;
- function liftToBlock(nodes) {
- ts.Debug.assert(ts.every(nodes, ts.isStatement), "Cannot lift nodes to a Block.");
- return ts.singleOrUndefined(nodes) || ts.createBlock(nodes);
- }
- ts.liftToBlock = liftToBlock;
- function aggregateTransformFlags(node) {
- aggregateTransformFlagsForNode(node);
- return node;
- }
- ts.aggregateTransformFlags = aggregateTransformFlags;
- function aggregateTransformFlagsForNode(node) {
- if (node === undefined) {
- return 0;
- }
- if (node.transformFlags & 536870912) {
- return node.transformFlags & ~ts.getTransformFlagsSubtreeExclusions(node.kind);
- }
- var subtreeFlags = aggregateTransformFlagsForSubtree(node);
- return ts.computeTransformFlagsForNode(node, subtreeFlags);
- }
- function aggregateTransformFlagsForNodeArray(nodes) {
- if (nodes === undefined) {
- return 0;
- }
- var subtreeFlags = 0;
- var nodeArrayFlags = 0;
- for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
- var node = nodes_3[_i];
- subtreeFlags |= aggregateTransformFlagsForNode(node);
- nodeArrayFlags |= node.transformFlags & ~536870912;
- }
- nodes.transformFlags = nodeArrayFlags | 536870912;
- return subtreeFlags;
- }
- function aggregateTransformFlagsForSubtree(node) {
- if (ts.hasModifier(node, 2) || (ts.isTypeNode(node) && node.kind !== 216)) {
- return 0;
- }
- return reduceEachChild(node, 0, aggregateTransformFlagsForChildNode, aggregateTransformFlagsForChildNodes);
- }
- function aggregateTransformFlagsForChildNode(transformFlags, node) {
- return transformFlags | aggregateTransformFlagsForNode(node);
- }
- function aggregateTransformFlagsForChildNodes(transformFlags, nodes) {
- return transformFlags | aggregateTransformFlagsForNodeArray(nodes);
- }
-})(ts || (ts = {}));
-var ts;
(function (ts) {
function createSourceMapGenerator(host, file, sourceRoot, sourcesDirectoryPath, generatorOptions) {
var _a = generatorOptions.extendedDiagnostics
: ts.performance.nullTimer, enter = _a.enter, exit = _a.exit;
var rawSources = [];
var sources = [];
- var sourceToSourceIndexMap = ts.createMap();
+ var sourceToSourceIndexMap = new ts.Map();
var sourcesContent;
var names = [];
var nameToNameIndexMap;
function addName(name) {
enter();
if (!nameToNameIndexMap)
- nameToNameIndexMap = ts.createMap();
+ nameToNameIndexMap = new ts.Map();
var nameIndex = nameToNameIndexMap.get(name);
if (nameIndex === undefined) {
nameIndex = names.length;
var generatedAbsoluteFilePath = ts.getNormalizedAbsolutePath(map.file, mapDirectory);
var generatedFile = host.getSourceFileLike(generatedAbsoluteFilePath);
var sourceFileAbsolutePaths = map.sources.map(function (source) { return ts.getNormalizedAbsolutePath(source, sourceRoot); });
- var sourceToSourceIndexMap = ts.createMapFromEntries(sourceFileAbsolutePaths.map(function (source, i) { return [host.getCanonicalFileName(source), i]; }));
+ var sourceToSourceIndexMap = new ts.Map(sourceFileAbsolutePaths.map(function (source, i) { return [host.getCanonicalFileName(source), i]; }));
var decodedMappings;
var generatedMappings;
var sourceMappings;
function isNamedDefaultReference(e) {
return e.propertyName !== undefined && e.propertyName.escapedText === "default";
}
- function chainBundle(transformSourceFile) {
+ function chainBundle(context, transformSourceFile) {
return transformSourceFileOrBundle;
function transformSourceFileOrBundle(node) {
- return node.kind === 290 ? transformSourceFile(node) : transformBundle(node);
+ return node.kind === 297 ? transformSourceFile(node) : transformBundle(node);
}
function transformBundle(node) {
- return ts.createBundle(ts.map(node.sourceFiles, transformSourceFile), node.prepends);
+ return context.factory.createBundle(ts.map(node.sourceFiles, transformSourceFile), node.prepends);
}
}
ts.chainBundle = chainBundle;
return !getImportNeedsImportStarHelper(node) && (ts.isDefaultImport(node) || (!!node.importClause && ts.isNamedImports(node.importClause.namedBindings) && containsDefaultReference(node.importClause.namedBindings)));
}
ts.getImportNeedsImportDefaultHelper = getImportNeedsImportDefaultHelper;
- function collectExternalModuleInfo(sourceFile, resolver, compilerOptions) {
+ function collectExternalModuleInfo(context, sourceFile, resolver, compilerOptions) {
var externalImports = [];
var exportSpecifiers = ts.createMultiMap();
var exportedBindings = [];
- var uniqueExports = ts.createMap();
+ var uniqueExports = new ts.Map();
var exportedNames;
var hasExportDefault = false;
var exportEquals;
for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) {
var node = _a[_i];
switch (node.kind) {
- case 254:
+ case 261:
externalImports.push(node);
if (!hasImportStar && getImportNeedsImportStarHelper(node)) {
hasImportStar = true;
hasImportDefault = true;
}
break;
- case 253:
- if (node.moduleReference.kind === 265) {
+ case 260:
+ if (node.moduleReference.kind === 272) {
externalImports.push(node);
}
break;
- case 260:
+ case 267:
if (node.moduleSpecifier) {
if (!node.exportClause) {
externalImports.push(node);
}
else {
externalImports.push(node);
- }
- }
- else {
- for (var _b = 0, _c = ts.cast(node.exportClause, ts.isNamedExports).elements; _b < _c.length; _b++) {
- var specifier = _c[_b];
- if (!uniqueExports.get(ts.idText(specifier.name))) {
- var name = specifier.propertyName || specifier.name;
- exportSpecifiers.add(ts.idText(name), specifier);
- var decl = resolver.getReferencedImportDeclaration(name)
- || resolver.getReferencedValueDeclaration(name);
- if (decl) {
- multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(decl), specifier.name);
+ if (ts.isNamedExports(node.exportClause)) {
+ addExportedNamesForExportDeclaration(node);
+ }
+ else {
+ var name = node.exportClause.name;
+ if (!uniqueExports.get(ts.idText(name))) {
+ multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name);
+ uniqueExports.set(ts.idText(name), true);
+ exportedNames = ts.append(exportedNames, name);
}
- uniqueExports.set(ts.idText(specifier.name), true);
- exportedNames = ts.append(exportedNames, specifier.name);
+ hasImportStar = true;
}
}
}
+ else {
+ addExportedNamesForExportDeclaration(node);
+ }
break;
- case 259:
+ case 266:
if (node.isExportEquals && !exportEquals) {
exportEquals = node;
}
break;
- case 225:
- if (ts.hasModifier(node, 1)) {
- for (var _d = 0, _e = node.declarationList.declarations; _d < _e.length; _d++) {
- var decl = _e[_d];
+ case 232:
+ if (ts.hasSyntacticModifier(node, 1)) {
+ for (var _b = 0, _c = node.declarationList.declarations; _b < _c.length; _b++) {
+ var decl = _c[_b];
exportedNames = collectExportedVariableInfo(decl, uniqueExports, exportedNames);
}
}
break;
- case 244:
- if (ts.hasModifier(node, 1)) {
- if (ts.hasModifier(node, 512)) {
+ case 251:
+ if (ts.hasSyntacticModifier(node, 1)) {
+ if (ts.hasSyntacticModifier(node, 512)) {
if (!hasExportDefault) {
- multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), ts.getDeclarationName(node));
+ multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
hasExportDefault = true;
}
}
}
}
break;
- case 245:
- if (ts.hasModifier(node, 1)) {
- if (ts.hasModifier(node, 512)) {
+ case 252:
+ if (ts.hasSyntacticModifier(node, 1)) {
+ if (ts.hasSyntacticModifier(node, 512)) {
if (!hasExportDefault) {
- multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), ts.getDeclarationName(node));
+ multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
hasExportDefault = true;
}
}
break;
}
}
- var externalHelpersImportDeclaration = ts.createExternalHelpersImportDeclarationIfNeeded(sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault);
+ var externalHelpersImportDeclaration = ts.createExternalHelpersImportDeclarationIfNeeded(context.factory, context.getEmitHelperFactory(), sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault);
if (externalHelpersImportDeclaration) {
externalImports.unshift(externalHelpersImportDeclaration);
}
return { externalImports: externalImports, exportSpecifiers: exportSpecifiers, exportEquals: exportEquals, hasExportStarsToExportValues: hasExportStarsToExportValues, exportedBindings: exportedBindings, exportedNames: exportedNames, externalHelpersImportDeclaration: externalHelpersImportDeclaration };
+ function addExportedNamesForExportDeclaration(node) {
+ for (var _i = 0, _a = ts.cast(node.exportClause, ts.isNamedExports).elements; _i < _a.length; _i++) {
+ var specifier = _a[_i];
+ if (!uniqueExports.get(ts.idText(specifier.name))) {
+ var name = specifier.propertyName || specifier.name;
+ if (!node.moduleSpecifier) {
+ exportSpecifiers.add(ts.idText(name), specifier);
+ }
+ var decl = resolver.getReferencedImportDeclaration(name)
+ || resolver.getReferencedValueDeclaration(name);
+ if (decl) {
+ multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(decl), specifier.name);
+ }
+ uniqueExports.set(ts.idText(specifier.name), true);
+ exportedNames = ts.append(exportedNames, specifier.name);
+ }
+ }
+ }
}
ts.collectExternalModuleInfo = collectExternalModuleInfo;
function collectExportedVariableInfo(decl, uniqueExports, exportedNames) {
ts.isSimpleInlineableExpression = isSimpleInlineableExpression;
function isCompoundAssignment(kind) {
return kind >= 63
- && kind <= 74;
+ && kind <= 77;
}
ts.isCompoundAssignment = isCompoundAssignment;
function getNonAssignmentOperatorForCompoundAssignment(kind) {
case 71: return 49;
case 72: return 50;
case 73: return 51;
- case 74: return 52;
+ case 77: return 52;
+ case 74: return 56;
+ case 75: return 55;
+ case 76: return 60;
}
}
ts.getNonAssignmentOperatorForCompoundAssignment = getNonAssignmentOperatorForCompoundAssignment;
- function addPrologueDirectivesAndInitialSuperCall(ctor, result, visitor) {
+ function addPrologueDirectivesAndInitialSuperCall(factory, ctor, result, visitor) {
if (ctor.body) {
var statements = ctor.body.statements;
- var index = ts.addPrologue(result, statements, false, visitor);
+ var index = factory.copyPrologue(statements, result, false, visitor);
if (index === statements.length) {
return index;
}
return 0;
}
ts.addPrologueDirectivesAndInitialSuperCall = addPrologueDirectivesAndInitialSuperCall;
- function helperString(input) {
- var args = [];
- for (var _i = 1; _i < arguments.length; _i++) {
- args[_i - 1] = arguments[_i];
- }
- return function (uniqueName) {
- var result = "";
- for (var i = 0; i < args.length; i++) {
- result += input[i];
- result += uniqueName(args[i]);
- }
- result += input[input.length - 1];
- return result;
- };
- }
- ts.helperString = helperString;
function getProperties(node, requireInitializer, isStatic) {
return ts.filter(node.members, function (m) { return isInitializedOrStaticProperty(m, requireInitializer, isStatic); });
}
&& ts.hasStaticModifier(member) === isStatic;
}
function isInitializedProperty(member) {
- return member.kind === 159
+ return member.kind === 163
&& member.initializer !== undefined;
}
ts.isInitializedProperty = isInitializedProperty;
hoistTempVariables: true,
emitExpression: emitExpression,
emitBindingOrAssignment: emitBindingOrAssignment,
- createArrayBindingOrAssignmentPattern: makeArrayAssignmentPattern,
- createObjectBindingOrAssignmentPattern: makeObjectAssignmentPattern,
+ createArrayBindingOrAssignmentPattern: function (elements) { return makeArrayAssignmentPattern(context.factory, elements); },
+ createObjectBindingOrAssignmentPattern: function (elements) { return makeObjectAssignmentPattern(context.factory, elements); },
createArrayBindingOrAssignmentElement: makeAssignmentElement,
visitor: visitor
};
}
expressions.push(value);
}
- return ts.aggregateTransformFlags(ts.inlineExpressions(expressions)) || ts.createOmittedExpression();
+ return context.factory.inlineExpressions(expressions) || context.factory.createOmittedExpression();
function emitExpression(expression) {
- ts.aggregateTransformFlags(expression);
expressions = ts.append(expressions, expression);
}
function emitBindingOrAssignment(target, value, location, original) {
ts.Debug.assertNode(target, createAssignmentCallback ? ts.isIdentifier : ts.isExpression);
var expression = createAssignmentCallback
? createAssignmentCallback(target, value, location)
- : ts.setTextRange(ts.createAssignment(ts.visitNode(target, visitor, ts.isExpression), value), location);
+ : ts.setTextRange(context.factory.createAssignment(ts.visitNode(target, visitor, ts.isExpression), value), location);
expression.original = original;
emitExpression(expression);
}
hoistTempVariables: hoistTempVariables,
emitExpression: emitExpression,
emitBindingOrAssignment: emitBindingOrAssignment,
- createArrayBindingOrAssignmentPattern: makeArrayBindingPattern,
- createObjectBindingOrAssignmentPattern: makeObjectBindingPattern,
- createArrayBindingOrAssignmentElement: makeBindingElement,
+ createArrayBindingOrAssignmentPattern: function (elements) { return makeArrayBindingPattern(context.factory, elements); },
+ createObjectBindingOrAssignmentPattern: function (elements) { return makeObjectBindingPattern(context.factory, elements); },
+ createArrayBindingOrAssignmentElement: function (name) { return makeBindingElement(context.factory, name); },
visitor: visitor
};
if (ts.isVariableDeclaration(node)) {
if (initializer && (ts.isIdentifier(initializer) && bindingOrAssignmentElementAssignsToName(node, initializer.escapedText) ||
bindingOrAssignmentElementContainsNonLiteralComputedName(node))) {
initializer = ensureIdentifier(flattenContext, initializer, false, initializer);
- node = ts.updateVariableDeclaration(node, node.name, node.type, initializer);
+ node = context.factory.updateVariableDeclaration(node, node.name, undefined, undefined, initializer);
}
}
flattenBindingOrAssignmentElement(flattenContext, node, rval, node, skipInitializer);
if (pendingExpressions) {
- var temp = ts.createTempVariable(undefined);
+ var temp = context.factory.createTempVariable(undefined);
if (hoistTempVariables) {
- var value = ts.inlineExpressions(pendingExpressions);
+ var value = context.factory.inlineExpressions(pendingExpressions);
pendingExpressions = undefined;
emitBindingOrAssignment(temp, value, undefined, undefined);
}
else {
context.hoistVariableDeclaration(temp);
var pendingDeclaration = ts.last(pendingDeclarations);
- pendingDeclaration.pendingExpressions = ts.append(pendingDeclaration.pendingExpressions, ts.createAssignment(temp, pendingDeclaration.value));
+ pendingDeclaration.pendingExpressions = ts.append(pendingDeclaration.pendingExpressions, context.factory.createAssignment(temp, pendingDeclaration.value));
ts.addRange(pendingDeclaration.pendingExpressions, pendingExpressions);
pendingDeclaration.value = temp;
}
}
for (var _i = 0, pendingDeclarations_1 = pendingDeclarations; _i < pendingDeclarations_1.length; _i++) {
var _a = pendingDeclarations_1[_i], pendingExpressions_1 = _a.pendingExpressions, name = _a.name, value = _a.value, location = _a.location, original = _a.original;
- var variable = ts.createVariableDeclaration(name, undefined, pendingExpressions_1 ? ts.inlineExpressions(ts.append(pendingExpressions_1, value)) : value);
+ var variable = context.factory.createVariableDeclaration(name, undefined, undefined, pendingExpressions_1 ? context.factory.inlineExpressions(ts.append(pendingExpressions_1, value)) : value);
variable.original = original;
ts.setTextRange(variable, location);
- ts.aggregateTransformFlags(variable);
declarations.push(variable);
}
return declarations;
function emitBindingOrAssignment(target, value, location, original) {
ts.Debug.assertNode(target, ts.isBindingName);
if (pendingExpressions) {
- value = ts.inlineExpressions(ts.append(pendingExpressions, value));
+ value = context.factory.inlineExpressions(ts.append(pendingExpressions, value));
pendingExpressions = undefined;
}
pendingDeclarations.push({ pendingExpressions: pendingExpressions, name: target, value: value, location: location, original: original });
}
ts.flattenDestructuringBinding = flattenDestructuringBinding;
function flattenBindingOrAssignmentElement(flattenContext, element, value, location, skipInitializer) {
+ var bindingTarget = ts.getTargetOfBindingOrAssignmentElement(element);
if (!skipInitializer) {
var initializer = ts.visitNode(ts.getInitializerOfBindingOrAssignmentElement(element), flattenContext.visitor, ts.isExpression);
if (initializer) {
- value = value ? createDefaultValueCheck(flattenContext, value, initializer, location) : initializer;
+ if (value) {
+ value = createDefaultValueCheck(flattenContext, value, initializer, location);
+ if (!ts.isSimpleInlineableExpression(initializer) && ts.isBindingOrAssignmentPattern(bindingTarget)) {
+ value = ensureIdentifier(flattenContext, value, true, location);
+ }
+ }
+ else {
+ value = initializer;
+ }
}
else if (!value) {
- value = ts.createVoidZero();
+ value = flattenContext.context.factory.createVoidZero();
}
}
- var bindingTarget = ts.getTargetOfBindingOrAssignmentElement(element);
if (ts.isObjectBindingOrAssignmentPattern(bindingTarget)) {
flattenObjectBindingOrAssignmentPattern(flattenContext, element, bindingTarget, value, location);
}
flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern);
bindingElements = undefined;
}
- var rhsValue = createRestCall(flattenContext.context, value, elements, computedTempVariables, pattern);
+ var rhsValue = flattenContext.context.getEmitHelperFactory().createRestHelper(value, elements, computedTempVariables, pattern);
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
}
}
var elements = ts.getElementsOfBindingOrAssignmentPattern(pattern);
var numElements = elements.length;
if (flattenContext.level < 1 && flattenContext.downlevelIteration) {
- value = ensureIdentifier(flattenContext, ts.createReadHelper(flattenContext.context, value, numElements > 0 && ts.getRestIndicatorOfBindingOrAssignmentElement(elements[numElements - 1])
+ value = ensureIdentifier(flattenContext, ts.setTextRange(flattenContext.context.getEmitHelperFactory().createReadHelper(value, numElements > 0 && ts.getRestIndicatorOfBindingOrAssignmentElement(elements[numElements - 1])
? undefined
- : numElements, location), false, location);
+ : numElements), location), false, location);
}
else if (numElements !== 1 && (flattenContext.level < 1 || numElements === 0)
|| ts.every(elements, ts.isOmittedExpression)) {
for (var i = 0; i < numElements; i++) {
var element = elements[i];
if (flattenContext.level >= 1) {
- if (element.transformFlags & 16384) {
- var temp = ts.createTempVariable(undefined);
+ if (element.transformFlags & 16384 || flattenContext.hasTransformedPriorElement && !isSimpleBindingOrAssignmentElement(element)) {
+ flattenContext.hasTransformedPriorElement = true;
+ var temp = flattenContext.context.factory.createTempVariable(undefined);
if (flattenContext.hoistTempVariables) {
flattenContext.context.hoistVariableDeclaration(temp);
}
continue;
}
else if (!ts.getRestIndicatorOfBindingOrAssignmentElement(element)) {
- var rhsValue = ts.createElementAccess(value, i);
+ var rhsValue = flattenContext.context.factory.createElementAccessExpression(value, i);
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
}
else if (i === numElements - 1) {
- var rhsValue = ts.createArraySlice(value, i);
+ var rhsValue = flattenContext.context.factory.createArraySliceCall(value, i);
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
}
}
}
}
}
+ function isSimpleBindingOrAssignmentElement(element) {
+ var target = ts.getTargetOfBindingOrAssignmentElement(element);
+ if (!target || ts.isOmittedExpression(target))
+ return true;
+ var propertyName = ts.tryGetPropertyNameOfBindingOrAssignmentElement(element);
+ if (propertyName && !ts.isPropertyNameLiteral(propertyName))
+ return false;
+ var initializer = ts.getInitializerOfBindingOrAssignmentElement(element);
+ if (initializer && !ts.isSimpleInlineableExpression(initializer))
+ return false;
+ if (ts.isBindingOrAssignmentPattern(target))
+ return ts.every(ts.getElementsOfBindingOrAssignmentPattern(target), isSimpleBindingOrAssignmentElement);
+ return ts.isIdentifier(target);
+ }
function createDefaultValueCheck(flattenContext, value, defaultValue, location) {
value = ensureIdentifier(flattenContext, value, true, location);
- return ts.createConditional(ts.createTypeCheck(value, "undefined"), defaultValue, value);
+ return flattenContext.context.factory.createConditionalExpression(flattenContext.context.factory.createTypeCheck(value, "undefined"), undefined, defaultValue, undefined, value);
}
function createDestructuringPropertyAccess(flattenContext, value, propertyName) {
if (ts.isComputedPropertyName(propertyName)) {
var argumentExpression = ensureIdentifier(flattenContext, ts.visitNode(propertyName.expression, flattenContext.visitor), false, propertyName);
- return ts.createElementAccess(value, argumentExpression);
+ return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
}
else if (ts.isStringOrNumericLiteralLike(propertyName)) {
- var argumentExpression = ts.getSynthesizedClone(propertyName);
- argumentExpression.text = argumentExpression.text;
- return ts.createElementAccess(value, argumentExpression);
+ var argumentExpression = ts.factory.cloneNode(propertyName);
+ return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
}
else {
- var name = ts.createIdentifier(ts.idText(propertyName));
- return ts.createPropertyAccess(value, name);
+ var name = flattenContext.context.factory.createIdentifier(ts.idText(propertyName));
+ return flattenContext.context.factory.createPropertyAccessExpression(value, name);
}
}
function ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location) {
return value;
}
else {
- var temp = ts.createTempVariable(undefined);
+ var temp = flattenContext.context.factory.createTempVariable(undefined);
if (flattenContext.hoistTempVariables) {
flattenContext.context.hoistVariableDeclaration(temp);
- flattenContext.emitExpression(ts.setTextRange(ts.createAssignment(temp, value), location));
+ flattenContext.emitExpression(ts.setTextRange(flattenContext.context.factory.createAssignment(temp, value), location));
}
else {
flattenContext.emitBindingOrAssignment(temp, value, location, undefined);
return temp;
}
}
- function makeArrayBindingPattern(elements) {
+ function makeArrayBindingPattern(factory, elements) {
ts.Debug.assertEachNode(elements, ts.isArrayBindingElement);
- return ts.createArrayBindingPattern(elements);
+ return factory.createArrayBindingPattern(elements);
}
- function makeArrayAssignmentPattern(elements) {
- return ts.createArrayLiteral(ts.map(elements, ts.convertToArrayAssignmentElement));
+ function makeArrayAssignmentPattern(factory, elements) {
+ return factory.createArrayLiteralExpression(ts.map(elements, factory.converters.convertToArrayAssignmentElement));
}
- function makeObjectBindingPattern(elements) {
+ function makeObjectBindingPattern(factory, elements) {
ts.Debug.assertEachNode(elements, ts.isBindingElement);
- return ts.createObjectBindingPattern(elements);
+ return factory.createObjectBindingPattern(elements);
}
- function makeObjectAssignmentPattern(elements) {
- return ts.createObjectLiteral(ts.map(elements, ts.convertToObjectAssignmentElement));
+ function makeObjectAssignmentPattern(factory, elements) {
+ return factory.createObjectLiteralExpression(ts.map(elements, factory.converters.convertToObjectAssignmentElement));
}
- function makeBindingElement(name) {
- return ts.createBindingElement(undefined, undefined, name);
+ function makeBindingElement(factory, name) {
+ return factory.createBindingElement(undefined, undefined, name);
}
function makeAssignmentElement(name) {
return name;
}
- ts.restHelper = {
- name: "typescript:rest",
- importName: "__rest",
- scoped: false,
- text: "\n var __rest = (this && this.__rest) || function (s, e) {\n var t = {};\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n };"
- };
- function createRestCall(context, value, elements, computedTempVariables, location) {
- context.requestEmitHelper(ts.restHelper);
- var propertyNames = [];
- var computedTempVariableOffset = 0;
- for (var i = 0; i < elements.length - 1; i++) {
- var propertyName = ts.getPropertyNameOfBindingOrAssignmentElement(elements[i]);
- if (propertyName) {
- if (ts.isComputedPropertyName(propertyName)) {
- var temp = computedTempVariables[computedTempVariableOffset];
- computedTempVariableOffset++;
- propertyNames.push(ts.createConditional(ts.createTypeCheck(temp, "symbol"), temp, ts.createAdd(temp, ts.createLiteral(""))));
- }
- else {
- propertyNames.push(ts.createLiteral(propertyName));
- }
- }
- }
- return ts.createCall(ts.getUnscopedHelperName("__rest"), undefined, [
- value,
- ts.setTextRange(ts.createArrayLiteral(propertyNames), location)
- ]);
- }
})(ts || (ts = {}));
var ts;
(function (ts) {
var cookedStrings = [];
var rawStrings = [];
var template = node.template;
- if (level === ProcessLevel.LiftRestriction && !ts.hasInvalidEscape(template))
- return node;
+ if (level === ProcessLevel.LiftRestriction && !ts.hasInvalidEscape(template)) {
+ return ts.visitEachChild(node, visitor, context);
+ }
if (ts.isNoSubstitutionTemplateLiteral(template)) {
cookedStrings.push(createTemplateCooked(template));
rawStrings.push(getRawLiteral(template, currentSourceFile));
templateArguments.push(ts.visitNode(templateSpan.expression, visitor, ts.isExpression));
}
}
- var helperCall = createTemplateObjectHelper(context, ts.createArrayLiteral(cookedStrings), ts.createArrayLiteral(rawStrings));
+ var helperCall = context.getEmitHelperFactory().createTemplateObjectHelper(ts.factory.createArrayLiteralExpression(cookedStrings), ts.factory.createArrayLiteralExpression(rawStrings));
if (ts.isExternalModule(currentSourceFile)) {
- var tempVar = ts.createUniqueName("templateObject");
+ var tempVar = ts.factory.createUniqueName("templateObject");
recordTaggedTemplateString(tempVar);
- templateArguments[0] = ts.createLogicalOr(tempVar, ts.createAssignment(tempVar, helperCall));
+ templateArguments[0] = ts.factory.createLogicalOr(tempVar, ts.factory.createAssignment(tempVar, helperCall));
}
else {
templateArguments[0] = helperCall;
}
- return ts.createCall(tag, undefined, templateArguments);
+ return ts.factory.createCallExpression(tag, undefined, templateArguments);
}
ts.processTaggedTemplateExpression = processTaggedTemplateExpression;
function createTemplateCooked(template) {
- return template.templateFlags ? ts.createIdentifier("undefined") : ts.createLiteral(template.text);
+ return template.templateFlags ? ts.factory.createVoidZero() : ts.factory.createStringLiteral(template.text);
}
function getRawLiteral(node, currentSourceFile) {
var text = node.rawText;
text = text.substring(1, text.length - (isLast ? 1 : 2));
}
text = text.replace(/\r\n?/g, "\n");
- return ts.setTextRange(ts.createLiteral(text), node);
- }
- function createTemplateObjectHelper(context, cooked, raw) {
- context.requestEmitHelper(ts.templateObjectHelper);
- return ts.createCall(ts.getUnscopedHelperName("__makeTemplateObject"), undefined, [
- cooked,
- raw
- ]);
+ return ts.setTextRange(ts.factory.createStringLiteral(text), node);
}
- ts.templateObjectHelper = {
- name: "typescript:makeTemplateObject",
- importName: "__makeTemplateObject",
- scoped: false,
- priority: 0,
- text: "\n var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n return cooked;\n };"
- };
})(ts || (ts = {}));
var ts;
(function (ts) {
var USE_NEW_TYPE_METADATA_FORMAT = false;
function transformTypeScript(context) {
- var startLexicalEnvironment = context.startLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
+ var factory = context.factory, emitHelpers = context.getEmitHelperFactory, startLexicalEnvironment = context.startLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
var resolver = context.getEmitResolver();
var compilerOptions = context.getCompilerOptions();
var strictNullChecks = ts.getStrictOptionValue(compilerOptions, "strictNullChecks");
var previousOnSubstituteNode = context.onSubstituteNode;
context.onEmitNode = onEmitNode;
context.onSubstituteNode = onSubstituteNode;
- context.enableSubstitution(194);
- context.enableSubstitution(195);
+ context.enableSubstitution(201);
+ context.enableSubstitution(202);
var currentSourceFile;
var currentNamespace;
var currentNamespaceContainerName;
var applicableSubstitutions;
return transformSourceFileOrBundle;
function transformSourceFileOrBundle(node) {
- if (node.kind === 291) {
+ if (node.kind === 298) {
return transformBundle(node);
}
return transformSourceFile(node);
}
function transformBundle(node) {
- return ts.createBundle(node.sourceFiles.map(transformSourceFile), ts.mapDefined(node.prepends, function (prepend) {
- if (prepend.kind === 293) {
+ return factory.createBundle(node.sourceFiles.map(transformSourceFile), ts.mapDefined(node.prepends, function (prepend) {
+ if (prepend.kind === 300) {
return ts.createUnparsedSourceFile(prepend, "js");
}
return prepend;
}
function onBeforeVisitNode(node) {
switch (node.kind) {
- case 290:
- case 251:
- case 250:
- case 223:
+ case 297:
+ case 258:
+ case 257:
+ case 230:
currentLexicalScope = node;
currentNameScope = undefined;
currentScopeFirstDeclarationsOfName = undefined;
break;
- case 245:
- case 244:
- if (ts.hasModifier(node, 2)) {
+ case 252:
+ case 251:
+ if (ts.hasSyntacticModifier(node, 2)) {
break;
}
if (node.name) {
recordEmittedDeclarationInScope(node);
}
else {
- ts.Debug.assert(node.kind === 245 || ts.hasModifier(node, 512));
+ ts.Debug.assert(node.kind === 252 || ts.hasSyntacticModifier(node, 512));
}
if (ts.isClassDeclaration(node)) {
currentNameScope = node;
}
function sourceElementVisitorWorker(node) {
switch (node.kind) {
- case 254:
- case 253:
- case 259:
+ case 261:
case 260:
- return visitEllidableStatement(node);
+ case 266:
+ case 267:
+ return visitElidableStatement(node);
default:
return visitorWorker(node);
}
}
- function visitEllidableStatement(node) {
+ function visitElidableStatement(node) {
var parsed = ts.getParseTreeNode(node);
if (parsed !== node) {
if (node.transformFlags & 1) {
return node;
}
switch (node.kind) {
- case 254:
+ case 261:
return visitImportDeclaration(node);
- case 253:
+ case 260:
return visitImportEqualsDeclaration(node);
- case 259:
+ case 266:
return visitExportAssignment(node);
- case 260:
+ case 267:
return visitExportDeclaration(node);
default:
ts.Debug.fail("Unhandled ellided statement");
return saveStateAndInvoke(node, namespaceElementVisitorWorker);
}
function namespaceElementVisitorWorker(node) {
- if (node.kind === 260 ||
- node.kind === 254 ||
- node.kind === 255 ||
- (node.kind === 253 &&
- node.moduleReference.kind === 265)) {
+ if (node.kind === 267 ||
+ node.kind === 261 ||
+ node.kind === 262 ||
+ (node.kind === 260 &&
+ node.moduleReference.kind === 272)) {
return undefined;
}
- else if (node.transformFlags & 1 || ts.hasModifier(node, 1)) {
+ else if (node.transformFlags & 1 || ts.hasSyntacticModifier(node, 1)) {
return visitTypeScript(node);
}
return node;
}
function classElementVisitorWorker(node) {
switch (node.kind) {
- case 162:
+ case 166:
return visitConstructor(node);
- case 159:
+ case 163:
return visitPropertyDeclaration(node);
+ case 171:
case 167:
- case 163:
- case 164:
- case 161:
+ case 168:
+ case 165:
return visitorWorker(node);
- case 222:
+ case 229:
return node;
default:
return ts.Debug.failBadSyntaxKind(node);
if (ts.modifierToFlag(node.kind) & 2270) {
return undefined;
}
- else if (currentNamespace && node.kind === 89) {
+ else if (currentNamespace && node.kind === 92) {
return undefined;
}
return node;
}
function visitTypeScript(node) {
- if (ts.isStatement(node) && ts.hasModifier(node, 2)) {
- return ts.createNotEmittedStatement(node);
+ if (ts.isStatement(node) && ts.hasSyntacticModifier(node, 2)) {
+ return factory.createNotEmittedStatement(node);
}
switch (node.kind) {
- case 89:
- case 84:
+ case 92:
+ case 87:
return currentNamespace ? undefined : node;
- case 119:
- case 117:
- case 118:
case 122:
- case 81:
- case 130:
- case 138:
- case 174:
- case 175:
- case 176:
- case 177:
- case 173:
- case 168:
- case 155:
+ case 120:
+ case 121:
case 125:
- case 148:
- case 128:
- case 143:
- case 140:
- case 137:
- case 110:
- case 144:
- case 171:
- case 170:
- case 172:
- case 169:
+ case 84:
+ case 133:
+ case 142:
case 178:
case 179:
case 180:
+ case 181:
+ case 177:
+ case 172:
+ case 159:
+ case 128:
+ case 152:
+ case 131:
+ case 147:
+ case 144:
+ case 141:
+ case 113:
+ case 148:
+ case 175:
+ case 174:
+ case 176:
+ case 173:
case 182:
case 183:
case 184:
- case 185:
case 186:
case 187:
- case 167:
- case 157:
- case 247:
+ case 188:
+ case 189:
+ case 190:
+ case 191:
+ case 171:
+ case 161:
+ case 254:
return undefined;
- case 159:
+ case 163:
return visitPropertyDeclaration(node);
- case 252:
+ case 259:
return undefined;
- case 162:
+ case 166:
return visitConstructor(node);
- case 246:
- return ts.createNotEmittedStatement(node);
- case 245:
+ case 253:
+ return factory.createNotEmittedStatement(node);
+ case 252:
return visitClassDeclaration(node);
- case 214:
+ case 221:
return visitClassExpression(node);
- case 279:
+ case 286:
return visitHeritageClause(node);
- case 216:
+ case 223:
return visitExpressionWithTypeArguments(node);
- case 161:
+ case 165:
return visitMethodDeclaration(node);
- case 163:
+ case 167:
return visitGetAccessor(node);
- case 164:
+ case 168:
return visitSetAccessor(node);
- case 244:
+ case 251:
return visitFunctionDeclaration(node);
- case 201:
+ case 208:
return visitFunctionExpression(node);
- case 202:
+ case 209:
return visitArrowFunction(node);
- case 156:
+ case 160:
return visitParameter(node);
- case 200:
+ case 207:
return visitParenthesizedExpression(node);
- case 199:
- case 217:
+ case 206:
+ case 224:
return visitAssertionExpression(node);
- case 196:
+ case 203:
return visitCallExpression(node);
- case 197:
+ case 204:
return visitNewExpression(node);
- case 198:
+ case 205:
return visitTaggedTemplateExpression(node);
- case 218:
+ case 225:
return visitNonNullExpression(node);
- case 248:
+ case 255:
return visitEnumDeclaration(node);
- case 225:
+ case 232:
return visitVariableStatement(node);
- case 242:
- return visitVariableDeclaration(node);
case 249:
+ return visitVariableDeclaration(node);
+ case 256:
return visitModuleDeclaration(node);
- case 253:
+ case 260:
return visitImportEqualsDeclaration(node);
- case 267:
+ case 274:
return visitJsxSelfClosingElement(node);
- case 268:
+ case 275:
return visitJsxJsxOpeningElement(node);
default:
return ts.visitEachChild(node, visitor, context);
var alwaysStrict = ts.getStrictOptionValue(compilerOptions, "alwaysStrict") &&
!(ts.isExternalModule(node) && moduleKind >= ts.ModuleKind.ES2015) &&
!ts.isJsonSourceFile(node);
- return ts.updateSourceFileNode(node, ts.visitLexicalEnvironment(node.statements, sourceElementVisitor, context, 0, alwaysStrict));
+ return factory.updateSourceFile(node, ts.visitLexicalEnvironment(node.statements, sourceElementVisitor, context, 0, alwaysStrict));
}
function shouldEmitDecorateCallForClass(node) {
if (node.decorators && node.decorators.length > 0) {
if (ts.some(staticProperties))
facts |= 1;
var extendsClauseElement = ts.getEffectiveBaseTypeNode(node);
- if (extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 100)
+ if (extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 103)
facts |= 64;
if (shouldEmitDecorateCallForClass(node))
facts |= 2;
|| ts.some(node.members, hasTypeScriptClassSyntax);
}
function visitClassDeclaration(node) {
- if (!isClassLikeDeclarationWithTypeScriptSyntax(node) && !(currentNamespace && ts.hasModifier(node, 1))) {
+ if (!isClassLikeDeclarationWithTypeScriptSyntax(node) && !(currentNamespace && ts.hasSyntacticModifier(node, 1))) {
return ts.visitEachChild(node, visitor, context);
}
var staticProperties = ts.getProperties(node, true, true);
if (facts & 128) {
context.startLexicalEnvironment();
}
- var name = node.name || (facts & 5 ? ts.getGeneratedNameForNode(node) : undefined);
+ var name = node.name || (facts & 5 ? factory.getGeneratedNameForNode(node) : undefined);
var classStatement = facts & 2
? createClassDeclarationHeadWithDecorators(node, name)
: createClassDeclarationHeadWithoutDecorators(node, name, facts);
addConstructorDecorationStatement(statements, node);
if (facts & 128) {
var closingBraceLocation = ts.createTokenRange(ts.skipTrivia(currentSourceFile.text, node.members.end), 19);
- var localName = ts.getInternalName(node);
- var outer = ts.createPartiallyEmittedExpression(localName);
- outer.end = closingBraceLocation.end;
+ var localName = factory.getInternalName(node);
+ var outer = factory.createPartiallyEmittedExpression(localName);
+ ts.setTextRangeEnd(outer, closingBraceLocation.end);
ts.setEmitFlags(outer, 1536);
- var statement = ts.createReturn(outer);
- statement.pos = closingBraceLocation.pos;
+ var statement = factory.createReturnStatement(outer);
+ ts.setTextRangePos(statement, closingBraceLocation.pos);
ts.setEmitFlags(statement, 1536 | 384);
statements.push(statement);
ts.insertStatementsAfterStandardPrologue(statements, context.endLexicalEnvironment());
- var iife = ts.createImmediatelyInvokedArrowFunction(statements);
+ var iife = factory.createImmediatelyInvokedArrowFunction(statements);
ts.setEmitFlags(iife, 33554432);
- var varStatement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(ts.getLocalName(node, false, false), undefined, iife)
+ var varStatement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(factory.getLocalName(node, false, false), undefined, undefined, iife)
]));
ts.setOriginalNode(varStatement, node);
ts.setCommentRange(varStatement, node);
}
else if (facts & 128 || facts & 2) {
if (facts & 32) {
- statements.push(ts.createExportDefault(ts.getLocalName(node, false, true)));
+ statements.push(factory.createExportDefault(factory.getLocalName(node, false, true)));
}
else if (facts & 16) {
- statements.push(ts.createExternalModuleExport(ts.getLocalName(node, false, true)));
+ statements.push(factory.createExternalModuleExport(factory.getLocalName(node, false, true)));
}
}
if (statements.length > 1) {
- statements.push(ts.createEndOfDeclarationMarker(node));
+ statements.push(factory.createEndOfDeclarationMarker(node));
ts.setEmitFlags(classStatement, ts.getEmitFlags(classStatement) | 4194304);
}
return ts.singleOrMany(statements);
var modifiers = !(facts & 128)
? ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier)
: undefined;
- var classDeclaration = ts.createClassDeclaration(undefined, modifiers, name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node));
+ var classDeclaration = factory.createClassDeclaration(undefined, modifiers, name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node));
var emitFlags = ts.getEmitFlags(node);
if (facts & 1) {
emitFlags |= 32;
}
- ts.aggregateTransformFlags(classDeclaration);
ts.setTextRange(classDeclaration, node);
ts.setOriginalNode(classDeclaration, node);
ts.setEmitFlags(classDeclaration, emitFlags);
function createClassDeclarationHeadWithDecorators(node, name) {
var location = ts.moveRangePastDecorators(node);
var classAlias = getClassAliasIfNeeded(node);
- var declName = ts.getLocalName(node, false, true);
+ var declName = factory.getLocalName(node, false, true);
var heritageClauses = ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause);
var members = transformClassMembers(node);
- var classExpression = ts.createClassExpression(undefined, name, undefined, heritageClauses, members);
- ts.aggregateTransformFlags(classExpression);
+ var classExpression = factory.createClassExpression(undefined, undefined, name, undefined, heritageClauses, members);
ts.setOriginalNode(classExpression, node);
ts.setTextRange(classExpression, location);
- var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(declName, undefined, classAlias ? ts.createAssignment(classAlias, classExpression) : classExpression)
+ var statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(declName, undefined, undefined, classAlias ? factory.createAssignment(classAlias, classExpression) : classExpression)
], 1));
ts.setOriginalNode(statement, node);
ts.setTextRange(statement, location);
if (!isClassLikeDeclarationWithTypeScriptSyntax(node)) {
return ts.visitEachChild(node, visitor, context);
}
- var classExpression = ts.createClassExpression(undefined, node.name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node));
- ts.aggregateTransformFlags(classExpression);
+ var classExpression = factory.createClassExpression(undefined, undefined, node.name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node));
ts.setOriginalNode(classExpression, node);
ts.setTextRange(classExpression, node);
return classExpression;
for (var _i = 0, parametersWithPropertyAssignments_1 = parametersWithPropertyAssignments; _i < parametersWithPropertyAssignments_1.length; _i++) {
var parameter = parametersWithPropertyAssignments_1[_i];
if (ts.isIdentifier(parameter.name)) {
- members.push(ts.setOriginalNode(ts.aggregateTransformFlags(ts.createProperty(undefined, undefined, parameter.name, undefined, undefined, undefined)), parameter));
+ members.push(ts.setOriginalNode(factory.createPropertyDeclaration(undefined, undefined, parameter.name, undefined, undefined, undefined), parameter));
}
}
}
ts.addRange(members, ts.visitNodes(node.members, classElementVisitor, ts.isClassElement));
- return ts.setTextRange(ts.createNodeArray(members), node.members);
+ return ts.setTextRange(factory.createNodeArray(members), node.members);
}
function getDecoratedClassElements(node, isStatic) {
return ts.filter(node.members, isStatic ? function (m) { return isStaticDecoratedClassElement(m, node); } : function (m) { return isInstanceDecoratedClassElement(m, node); });
}
function isDecoratedClassElement(member, isStatic, parent) {
return ts.nodeOrChildIsDecorated(member, parent)
- && isStatic === ts.hasModifier(member, 32);
+ && isStatic === ts.hasSyntacticModifier(member, 32);
}
function getDecoratorsOfParameters(node) {
var decorators;
}
function getAllDecoratorsOfClassElement(node, member) {
switch (member.kind) {
- case 163:
- case 164:
+ case 167:
+ case 168:
return getAllDecoratorsOfAccessors(node, member);
- case 161:
+ case 165:
return getAllDecoratorsOfMethod(member);
- case 159:
+ case 163:
return getAllDecoratorsOfProperty(member);
default:
return undefined;
var prefix = getClassMemberPrefix(node, member);
var memberName = getExpressionForPropertyName(member, true);
var descriptor = languageVersion > 0
- ? member.kind === 159
- ? ts.createVoidZero()
- : ts.createNull()
+ ? member.kind === 163
+ ? factory.createVoidZero()
+ : factory.createNull()
: undefined;
- var helper = createDecorateHelper(context, decoratorExpressions, prefix, memberName, descriptor, ts.moveRangePastDecorators(member));
+ var helper = emitHelpers().createDecorateHelper(decoratorExpressions, prefix, memberName, descriptor);
+ ts.setTextRange(helper, ts.moveRangePastDecorators(member));
ts.setEmitFlags(helper, 1536);
return helper;
}
function addConstructorDecorationStatement(statements, node) {
var expression = generateConstructorDecorationExpression(node);
if (expression) {
- statements.push(ts.setOriginalNode(ts.createExpressionStatement(expression), node));
+ statements.push(ts.setOriginalNode(factory.createExpressionStatement(expression), node));
}
}
function generateConstructorDecorationExpression(node) {
return undefined;
}
var classAlias = classAliases && classAliases[ts.getOriginalNodeId(node)];
- var localName = ts.getLocalName(node, false, true);
- var decorate = createDecorateHelper(context, decoratorExpressions, localName);
- var expression = ts.createAssignment(localName, classAlias ? ts.createAssignment(classAlias, decorate) : decorate);
+ var localName = factory.getLocalName(node, false, true);
+ var decorate = emitHelpers().createDecorateHelper(decoratorExpressions, localName);
+ var expression = factory.createAssignment(localName, classAlias ? factory.createAssignment(classAlias, decorate) : decorate);
ts.setEmitFlags(expression, 1536);
ts.setSourceMapRange(expression, ts.moveRangePastDecorators(node));
return expression;
expressions = [];
for (var _i = 0, decorators_1 = decorators; _i < decorators_1.length; _i++) {
var decorator = decorators_1[_i];
- var helper = createParamHelper(context, transformDecorator(decorator), parameterOffset, decorator.expression);
+ var helper = emitHelpers().createParamHelper(transformDecorator(decorator), parameterOffset);
+ ts.setTextRange(helper, decorator.expression);
ts.setEmitFlags(helper, 1536);
expressions.push(helper);
}
function addOldTypeMetadata(node, container, decoratorExpressions) {
if (compilerOptions.emitDecoratorMetadata) {
if (shouldAddTypeMetadata(node)) {
- decoratorExpressions.push(createMetadataHelper(context, "design:type", serializeTypeOfNode(node)));
+ decoratorExpressions.push(emitHelpers().createMetadataHelper("design:type", serializeTypeOfNode(node)));
}
if (shouldAddParamTypesMetadata(node)) {
- decoratorExpressions.push(createMetadataHelper(context, "design:paramtypes", serializeParameterTypesOfNode(node, container)));
+ decoratorExpressions.push(emitHelpers().createMetadataHelper("design:paramtypes", serializeParameterTypesOfNode(node, container)));
}
if (shouldAddReturnTypeMetadata(node)) {
- decoratorExpressions.push(createMetadataHelper(context, "design:returntype", serializeReturnTypeOfNode(node)));
+ decoratorExpressions.push(emitHelpers().createMetadataHelper("design:returntype", serializeReturnTypeOfNode(node)));
}
}
}
if (compilerOptions.emitDecoratorMetadata) {
var properties = void 0;
if (shouldAddTypeMetadata(node)) {
- (properties || (properties = [])).push(ts.createPropertyAssignment("type", ts.createArrowFunction(undefined, undefined, [], undefined, ts.createToken(38), serializeTypeOfNode(node))));
+ (properties || (properties = [])).push(factory.createPropertyAssignment("type", factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(38), serializeTypeOfNode(node))));
}
if (shouldAddParamTypesMetadata(node)) {
- (properties || (properties = [])).push(ts.createPropertyAssignment("paramTypes", ts.createArrowFunction(undefined, undefined, [], undefined, ts.createToken(38), serializeParameterTypesOfNode(node, container))));
+ (properties || (properties = [])).push(factory.createPropertyAssignment("paramTypes", factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(38), serializeParameterTypesOfNode(node, container))));
}
if (shouldAddReturnTypeMetadata(node)) {
- (properties || (properties = [])).push(ts.createPropertyAssignment("returnType", ts.createArrowFunction(undefined, undefined, [], undefined, ts.createToken(38), serializeReturnTypeOfNode(node))));
+ (properties || (properties = [])).push(factory.createPropertyAssignment("returnType", factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(38), serializeReturnTypeOfNode(node))));
}
if (properties) {
- decoratorExpressions.push(createMetadataHelper(context, "design:typeinfo", ts.createObjectLiteral(properties, true)));
+ decoratorExpressions.push(emitHelpers().createMetadataHelper("design:typeinfo", factory.createObjectLiteralExpression(properties, true)));
}
}
}
function shouldAddTypeMetadata(node) {
var kind = node.kind;
- return kind === 161
- || kind === 163
- || kind === 164
- || kind === 159;
+ return kind === 165
+ || kind === 167
+ || kind === 168
+ || kind === 163;
}
function shouldAddReturnTypeMetadata(node) {
- return node.kind === 161;
+ return node.kind === 165;
}
function shouldAddParamTypesMetadata(node) {
switch (node.kind) {
- case 245:
- case 214:
+ case 252:
+ case 221:
return ts.getFirstConstructorWithBody(node) !== undefined;
- case 161:
- case 163:
- case 164:
+ case 165:
+ case 167:
+ case 168:
return true;
}
return false;
}
function serializeTypeOfNode(node) {
switch (node.kind) {
- case 159:
- case 156:
- return serializeTypeNode(node.type);
- case 164:
case 163:
+ case 160:
+ return serializeTypeNode(node.type);
+ case 168:
+ case 167:
return serializeTypeNode(getAccessorTypeNode(node));
- case 245:
- case 214:
- case 161:
- return ts.createIdentifier("Function");
+ case 252:
+ case 221:
+ case 165:
+ return factory.createIdentifier("Function");
default:
- return ts.createVoidZero();
+ return factory.createVoidZero();
}
}
function serializeParameterTypesOfNode(node, container) {
}
}
}
- return ts.createArrayLiteral(expressions);
+ return factory.createArrayLiteralExpression(expressions);
}
function getParametersOfDecoratedDeclaration(node, container) {
- if (container && node.kind === 163) {
+ if (container && node.kind === 167) {
var setAccessor = ts.getAllAccessorDeclarations(container.members, node).setAccessor;
if (setAccessor) {
return setAccessor.parameters;
return serializeTypeNode(node.type);
}
else if (ts.isAsyncFunction(node)) {
- return ts.createIdentifier("Promise");
+ return factory.createIdentifier("Promise");
}
- return ts.createVoidZero();
+ return factory.createVoidZero();
}
function serializeTypeNode(node) {
if (node === undefined) {
- return ts.createIdentifier("Object");
+ return factory.createIdentifier("Object");
}
switch (node.kind) {
- case 110:
- case 146:
- case 100:
- case 137:
- return ts.createVoidZero();
- case 182:
+ case 113:
+ case 150:
+ case 141:
+ return factory.createVoidZero();
+ case 186:
return serializeTypeNode(node.type);
- case 170:
- case 171:
- return ts.createIdentifier("Function");
case 174:
case 175:
- return ts.createIdentifier("Array");
- case 168:
- case 128:
- return ts.createIdentifier("Boolean");
- case 143:
- return ts.createIdentifier("String");
- case 141:
- return ts.createIdentifier("Object");
- case 187:
+ return factory.createIdentifier("Function");
+ case 178:
+ case 179:
+ return factory.createIdentifier("Array");
+ case 172:
+ case 131:
+ return factory.createIdentifier("Boolean");
+ case 147:
+ return factory.createIdentifier("String");
+ case 145:
+ return factory.createIdentifier("Object");
+ case 191:
switch (node.literal.kind) {
case 10:
- return ts.createIdentifier("String");
- case 207:
+ case 14:
+ return factory.createIdentifier("String");
+ case 214:
case 8:
- return ts.createIdentifier("Number");
+ return factory.createIdentifier("Number");
case 9:
return getGlobalBigIntNameWithFallback();
- case 106:
- case 91:
- return ts.createIdentifier("Boolean");
+ case 109:
+ case 94:
+ return factory.createIdentifier("Boolean");
+ case 103:
+ return factory.createVoidZero();
default:
return ts.Debug.failBadSyntaxKind(node.literal);
}
- case 140:
- return ts.createIdentifier("Number");
- case 151:
- return getGlobalBigIntNameWithFallback();
case 144:
+ return factory.createIdentifier("Number");
+ case 155:
+ return getGlobalBigIntNameWithFallback();
+ case 148:
return languageVersion < 2
? getGlobalSymbolNameWithFallback()
- : ts.createIdentifier("Symbol");
- case 169:
+ : factory.createIdentifier("Symbol");
+ case 173:
return serializeTypeReferenceNode(node);
- case 179:
- case 178:
+ case 183:
+ case 182:
return serializeTypeList(node.types);
- case 180:
- return serializeTypeList([node.trueType, node.falseType]);
case 184:
- if (node.operator === 138) {
+ return serializeTypeList([node.trueType, node.falseType]);
+ case 188:
+ if (node.operator === 142) {
return serializeTypeNode(node.type);
}
break;
- case 172:
- case 185:
- case 186:
- case 173:
- case 125:
- case 148:
- case 183:
- case 188:
+ case 176:
+ case 189:
+ case 190:
+ case 177:
+ case 128:
+ case 152:
+ case 187:
+ case 195:
break;
- case 295:
- case 296:
- case 300:
- case 301:
- case 302:
+ case 303:
+ case 304:
+ case 308:
+ case 309:
+ case 310:
break;
- case 297:
- case 298:
- case 299:
+ case 305:
+ case 306:
+ case 307:
return serializeTypeNode(node.type);
default:
return ts.Debug.failBadSyntaxKind(node);
}
- return ts.createIdentifier("Object");
+ return factory.createIdentifier("Object");
}
function serializeTypeList(types) {
var serializedUnion;
- for (var _i = 0, types_21 = types; _i < types_21.length; _i++) {
- var typeNode = types_21[_i];
- while (typeNode.kind === 182) {
+ for (var _i = 0, types_22 = types; _i < types_22.length; _i++) {
+ var typeNode = types_22[_i];
+ while (typeNode.kind === 186) {
typeNode = typeNode.type;
}
- if (typeNode.kind === 137) {
+ if (typeNode.kind === 141) {
continue;
}
- if (!strictNullChecks && (typeNode.kind === 100 || typeNode.kind === 146)) {
+ if (!strictNullChecks && (typeNode.kind === 191 && typeNode.literal.kind === 103 || typeNode.kind === 150)) {
continue;
}
var serializedIndividual = serializeTypeNode(typeNode);
if (!ts.isIdentifier(serializedUnion) ||
!ts.isIdentifier(serializedIndividual) ||
serializedUnion.escapedText !== serializedIndividual.escapedText) {
- return ts.createIdentifier("Object");
+ return factory.createIdentifier("Object");
}
}
else {
serializedUnion = serializedIndividual;
}
}
- return serializedUnion || ts.createVoidZero();
+ return serializedUnion || factory.createVoidZero();
}
function serializeTypeReferenceNode(node) {
var kind = resolver.getTypeReferenceSerializationKind(node.typeName, currentNameScope || currentLexicalScope);
switch (kind) {
case ts.TypeReferenceSerializationKind.Unknown:
if (ts.findAncestor(node, function (n) { return n.parent && ts.isConditionalTypeNode(n.parent) && (n.parent.trueType === n || n.parent.falseType === n); })) {
- return ts.createIdentifier("Object");
+ return factory.createIdentifier("Object");
}
var serialized = serializeEntityNameAsExpressionFallback(node.typeName);
- var temp = ts.createTempVariable(hoistVariableDeclaration);
- return ts.createConditional(ts.createTypeCheck(ts.createAssignment(temp, serialized), "function"), temp, ts.createIdentifier("Object"));
+ var temp = factory.createTempVariable(hoistVariableDeclaration);
+ return factory.createConditionalExpression(factory.createTypeCheck(factory.createAssignment(temp, serialized), "function"), undefined, temp, undefined, factory.createIdentifier("Object"));
case ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue:
return serializeEntityNameAsExpression(node.typeName);
case ts.TypeReferenceSerializationKind.VoidNullableOrNeverType:
- return ts.createVoidZero();
+ return factory.createVoidZero();
case ts.TypeReferenceSerializationKind.BigIntLikeType:
return getGlobalBigIntNameWithFallback();
case ts.TypeReferenceSerializationKind.BooleanType:
- return ts.createIdentifier("Boolean");
+ return factory.createIdentifier("Boolean");
case ts.TypeReferenceSerializationKind.NumberLikeType:
- return ts.createIdentifier("Number");
+ return factory.createIdentifier("Number");
case ts.TypeReferenceSerializationKind.StringLikeType:
- return ts.createIdentifier("String");
+ return factory.createIdentifier("String");
case ts.TypeReferenceSerializationKind.ArrayLikeType:
- return ts.createIdentifier("Array");
+ return factory.createIdentifier("Array");
case ts.TypeReferenceSerializationKind.ESSymbolType:
return languageVersion < 2
? getGlobalSymbolNameWithFallback()
- : ts.createIdentifier("Symbol");
+ : factory.createIdentifier("Symbol");
case ts.TypeReferenceSerializationKind.TypeWithCallSignature:
- return ts.createIdentifier("Function");
+ return factory.createIdentifier("Function");
case ts.TypeReferenceSerializationKind.Promise:
- return ts.createIdentifier("Promise");
+ return factory.createIdentifier("Promise");
case ts.TypeReferenceSerializationKind.ObjectType:
- return ts.createIdentifier("Object");
+ return factory.createIdentifier("Object");
default:
return ts.Debug.assertNever(kind);
}
}
function createCheckedValue(left, right) {
- return ts.createLogicalAnd(ts.createStrictInequality(ts.createTypeOf(left), ts.createLiteral("undefined")), right);
+ return factory.createLogicalAnd(factory.createStrictInequality(factory.createTypeOfExpression(left), factory.createStringLiteral("undefined")), right);
}
function serializeEntityNameAsExpressionFallback(node) {
- if (node.kind === 75) {
+ if (node.kind === 78) {
var copied = serializeEntityNameAsExpression(node);
return createCheckedValue(copied, copied);
}
- if (node.left.kind === 75) {
+ if (node.left.kind === 78) {
return createCheckedValue(serializeEntityNameAsExpression(node.left), serializeEntityNameAsExpression(node));
}
var left = serializeEntityNameAsExpressionFallback(node.left);
- var temp = ts.createTempVariable(hoistVariableDeclaration);
- return ts.createLogicalAnd(ts.createLogicalAnd(left.left, ts.createStrictInequality(ts.createAssignment(temp, left.right), ts.createVoidZero())), ts.createPropertyAccess(temp, node.right));
+ var 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 75:
- var name = ts.getMutableClone(node);
- name.flags &= ~8;
+ case 78:
+ var name = ts.setParent(ts.setTextRange(ts.parseNodeFactory.cloneNode(node), node), node.parent);
name.original = undefined;
- name.parent = ts.getParseTreeNode(currentLexicalScope);
+ ts.setParent(name, ts.getParseTreeNode(currentLexicalScope));
return name;
- case 153:
+ case 157:
return serializeQualifiedNameAsExpression(node);
}
}
function serializeQualifiedNameAsExpression(node) {
- return ts.createPropertyAccess(serializeEntityNameAsExpression(node.left), node.right);
+ return factory.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right);
}
function getGlobalSymbolNameWithFallback() {
- return ts.createConditional(ts.createTypeCheck(ts.createIdentifier("Symbol"), "function"), ts.createIdentifier("Symbol"), ts.createIdentifier("Object"));
+ return factory.createConditionalExpression(factory.createTypeCheck(factory.createIdentifier("Symbol"), "function"), undefined, factory.createIdentifier("Symbol"), undefined, factory.createIdentifier("Object"));
}
function getGlobalBigIntNameWithFallback() {
return languageVersion < 99
- ? ts.createConditional(ts.createTypeCheck(ts.createIdentifier("BigInt"), "function"), ts.createIdentifier("BigInt"), ts.createIdentifier("Object"))
- : ts.createIdentifier("BigInt");
+ ? factory.createConditionalExpression(factory.createTypeCheck(factory.createIdentifier("BigInt"), "function"), undefined, factory.createIdentifier("BigInt"), undefined, factory.createIdentifier("Object"))
+ : factory.createIdentifier("BigInt");
}
function getExpressionForPropertyName(member, generateNameForComputedPropertyName) {
var name = member.name;
if (ts.isPrivateIdentifier(name)) {
- return ts.createIdentifier("");
+ return factory.createIdentifier("");
}
else if (ts.isComputedPropertyName(name)) {
return generateNameForComputedPropertyName && !ts.isSimpleInlineableExpression(name.expression)
- ? ts.getGeneratedNameForNode(name)
+ ? factory.getGeneratedNameForNode(name)
: name.expression;
}
else if (ts.isIdentifier(name)) {
- return ts.createLiteral(ts.idText(name));
+ return factory.createStringLiteral(ts.idText(name));
}
else {
- return ts.getSynthesizedClone(name);
+ return factory.cloneNode(name);
}
}
function visitPropertyNameOfClassElement(member) {
var expression = ts.visitNode(name.expression, visitor, ts.isExpression);
var innerExpression = ts.skipPartiallyEmittedExpressions(expression);
if (!ts.isSimpleInlineableExpression(innerExpression)) {
- var generatedName = ts.getGeneratedNameForNode(name);
+ var generatedName = factory.getGeneratedNameForNode(name);
hoistVariableDeclaration(generatedName);
- return ts.updateComputedPropertyName(name, ts.createAssignment(generatedName, expression));
+ return factory.updateComputedPropertyName(name, factory.createAssignment(generatedName, expression));
}
}
return ts.visitNode(name, visitor, ts.isPropertyName);
}
function visitHeritageClause(node) {
- if (node.token === 113) {
+ if (node.token === 116) {
return undefined;
}
return ts.visitEachChild(node, visitor, context);
}
function visitExpressionWithTypeArguments(node) {
- return ts.updateExpressionWithTypeArguments(node, undefined, ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression));
+ return factory.updateExpressionWithTypeArguments(node, ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression), undefined);
}
function shouldEmitFunctionLikeDeclaration(node) {
return !ts.nodeIsMissing(node.body);
if (node.flags & 8388608) {
return undefined;
}
- var updated = ts.updateProperty(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), visitPropertyNameOfClassElement(node), undefined, undefined, ts.visitNode(node.initializer, visitor));
+ var updated = factory.updatePropertyDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), visitPropertyNameOfClassElement(node), undefined, undefined, ts.visitNode(node.initializer, visitor));
if (updated !== node) {
ts.setCommentRange(updated, node);
ts.setSourceMapRange(updated, ts.moveRangePastDecorators(node));
if (!shouldEmitFunctionLikeDeclaration(node)) {
return undefined;
}
- return ts.updateConstructor(node, undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), transformConstructorBody(node.body, node));
+ return factory.updateConstructorDeclaration(node, undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), transformConstructorBody(node.body, node));
}
function transformConstructorBody(body, constructor) {
var parametersWithPropertyAssignments = constructor &&
var statements = [];
var indexOfFirstStatement = 0;
resumeLexicalEnvironment();
- indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(constructor, statements, visitor);
+ indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(factory, constructor, statements, visitor);
ts.addRange(statements, ts.map(parametersWithPropertyAssignments, transformParameterWithPropertyAssignment));
ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, indexOfFirstStatement));
- statements = ts.mergeLexicalEnvironment(statements, endLexicalEnvironment());
- var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), body.statements), true);
+ statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
+ var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), true);
ts.setTextRange(block, body);
ts.setOriginalNode(block, body);
return block;
if (!ts.isIdentifier(name)) {
return undefined;
}
- var propertyName = ts.getMutableClone(name);
+ var propertyName = ts.setParent(ts.setTextRange(factory.cloneNode(name), name), name.parent);
ts.setEmitFlags(propertyName, 1536 | 48);
- var localName = ts.getMutableClone(name);
+ var localName = ts.setParent(ts.setTextRange(factory.cloneNode(name), name), name.parent);
ts.setEmitFlags(localName, 1536);
- return ts.startOnNewLine(ts.removeAllComments(ts.setTextRange(ts.setOriginalNode(ts.createExpressionStatement(ts.createAssignment(ts.setTextRange(ts.createPropertyAccess(ts.createThis(), propertyName), node.name), localName)), node), ts.moveRangePos(node, -1))));
+ return ts.startOnNewLine(ts.removeAllComments(ts.setTextRange(ts.setOriginalNode(factory.createExpressionStatement(factory.createAssignment(ts.setTextRange(factory.createPropertyAccessExpression(factory.createThis(), propertyName), node.name), localName)), node), ts.moveRangePos(node, -1))));
}
function visitMethodDeclaration(node) {
if (!shouldEmitFunctionLikeDeclaration(node)) {
return undefined;
}
- var updated = ts.updateMethod(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, visitPropertyNameOfClassElement(node), undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context));
+ var updated = factory.updateMethodDeclaration(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, visitPropertyNameOfClassElement(node), undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context));
if (updated !== node) {
ts.setCommentRange(updated, node);
ts.setSourceMapRange(updated, ts.moveRangePastDecorators(node));
return updated;
}
function shouldEmitAccessorDeclaration(node) {
- return !(ts.nodeIsMissing(node.body) && ts.hasModifier(node, 128));
+ return !(ts.nodeIsMissing(node.body) && ts.hasSyntacticModifier(node, 128));
}
function visitGetAccessor(node) {
if (!shouldEmitAccessorDeclaration(node)) {
return undefined;
}
- var updated = ts.updateGetAccessor(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), visitPropertyNameOfClassElement(node), ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context) || ts.createBlock([]));
+ var updated = factory.updateGetAccessorDeclaration(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), visitPropertyNameOfClassElement(node), ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context) || factory.createBlock([]));
if (updated !== node) {
ts.setCommentRange(updated, node);
ts.setSourceMapRange(updated, ts.moveRangePastDecorators(node));
if (!shouldEmitAccessorDeclaration(node)) {
return undefined;
}
- var updated = ts.updateSetAccessor(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), visitPropertyNameOfClassElement(node), ts.visitParameterList(node.parameters, visitor, context), ts.visitFunctionBody(node.body, visitor, context) || ts.createBlock([]));
+ var updated = factory.updateSetAccessorDeclaration(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), visitPropertyNameOfClassElement(node), ts.visitParameterList(node.parameters, visitor, context), ts.visitFunctionBody(node.body, visitor, context) || factory.createBlock([]));
if (updated !== node) {
ts.setCommentRange(updated, node);
ts.setSourceMapRange(updated, ts.moveRangePastDecorators(node));
}
function visitFunctionDeclaration(node) {
if (!shouldEmitFunctionLikeDeclaration(node)) {
- return ts.createNotEmittedStatement(node);
+ return factory.createNotEmittedStatement(node);
}
- var updated = ts.updateFunctionDeclaration(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context) || ts.createBlock([]));
+ var updated = factory.updateFunctionDeclaration(node, undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context) || factory.createBlock([]));
if (isExportOfNamespace(node)) {
var statements = [updated];
addExportMemberAssignment(statements, node);
}
function visitFunctionExpression(node) {
if (!shouldEmitFunctionLikeDeclaration(node)) {
- return ts.createOmittedExpression();
+ return factory.createOmittedExpression();
}
- var updated = ts.updateFunctionExpression(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context) || ts.createBlock([]));
+ var updated = factory.updateFunctionExpression(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.visitFunctionBody(node.body, visitor, context) || factory.createBlock([]));
return updated;
}
function visitArrowFunction(node) {
- var updated = ts.updateArrowFunction(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, ts.visitFunctionBody(node.body, visitor, context));
+ var updated = factory.updateArrowFunction(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, ts.visitFunctionBody(node.body, visitor, context));
return updated;
}
function visitParameter(node) {
if (ts.parameterIsThisKeyword(node)) {
return undefined;
}
- var updated = ts.updateParameter(node, undefined, undefined, node.dotDotDotToken, ts.visitNode(node.name, visitor, ts.isBindingName), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression));
+ var updated = factory.updateParameterDeclaration(node, undefined, undefined, node.dotDotDotToken, ts.visitNode(node.name, visitor, ts.isBindingName), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression));
if (updated !== node) {
ts.setCommentRange(updated, node);
ts.setTextRange(updated, ts.moveRangePastModifiers(node));
if (variables.length === 0) {
return undefined;
}
- return ts.setTextRange(ts.createExpressionStatement(ts.inlineExpressions(ts.map(variables, transformInitializedVariable))), node);
+ return ts.setTextRange(factory.createExpressionStatement(factory.inlineExpressions(ts.map(variables, transformInitializedVariable))), node);
}
else {
return ts.visitEachChild(node, visitor, context);
return ts.flattenDestructuringAssignment(node, visitor, context, 0, false, createNamespaceExportExpression);
}
else {
- return ts.setTextRange(ts.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(name), ts.visitNode(node.initializer, visitor, ts.isExpression)), node);
+ return ts.setTextRange(factory.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(name), ts.visitNode(node.initializer, visitor, ts.isExpression)), node);
}
}
function visitVariableDeclaration(node) {
- return ts.updateTypeScriptVariableDeclaration(node, ts.visitNode(node.name, visitor, ts.isBindingName), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression));
+ return factory.updateVariableDeclaration(node, ts.visitNode(node.name, visitor, ts.isBindingName), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression));
}
function visitParenthesizedExpression(node) {
var innerExpression = ts.skipOuterExpressions(node.expression, ~6);
if (ts.isAssertionExpression(innerExpression)) {
var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
if (ts.length(ts.getLeadingCommentRangesOfNode(expression, currentSourceFile))) {
- return ts.updateParen(node, expression);
+ return factory.updateParenthesizedExpression(node, expression);
}
- return ts.createPartiallyEmittedExpression(expression, node);
+ return factory.createPartiallyEmittedExpression(expression, node);
}
return ts.visitEachChild(node, visitor, context);
}
function visitAssertionExpression(node) {
var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
- return ts.createPartiallyEmittedExpression(expression, node);
+ return factory.createPartiallyEmittedExpression(expression, node);
}
function visitNonNullExpression(node) {
var expression = ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression);
- return ts.createPartiallyEmittedExpression(expression, node);
+ return factory.createPartiallyEmittedExpression(expression, node);
}
function visitCallExpression(node) {
- return ts.updateCall(node, ts.visitNode(node.expression, visitor, ts.isExpression), undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression));
+ return factory.updateCallExpression(node, ts.visitNode(node.expression, visitor, ts.isExpression), undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression));
}
function visitNewExpression(node) {
- return ts.updateNew(node, ts.visitNode(node.expression, visitor, ts.isExpression), undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression));
+ return factory.updateNewExpression(node, ts.visitNode(node.expression, visitor, ts.isExpression), undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression));
}
function visitTaggedTemplateExpression(node) {
- return ts.updateTaggedTemplate(node, ts.visitNode(node.tag, visitor, ts.isExpression), undefined, ts.visitNode(node.template, visitor, ts.isExpression));
+ return factory.updateTaggedTemplateExpression(node, ts.visitNode(node.tag, visitor, ts.isExpression), undefined, ts.visitNode(node.template, visitor, ts.isExpression));
}
function visitJsxSelfClosingElement(node) {
- return ts.updateJsxSelfClosingElement(node, ts.visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), undefined, ts.visitNode(node.attributes, visitor, ts.isJsxAttributes));
+ return factory.updateJsxSelfClosingElement(node, ts.visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), undefined, ts.visitNode(node.attributes, visitor, ts.isJsxAttributes));
}
function visitJsxJsxOpeningElement(node) {
- return ts.updateJsxOpeningElement(node, ts.visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), undefined, ts.visitNode(node.attributes, visitor, ts.isJsxAttributes));
+ return factory.updateJsxOpeningElement(node, ts.visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), undefined, ts.visitNode(node.attributes, visitor, ts.isJsxAttributes));
}
function shouldEmitEnumDeclaration(node) {
return !ts.isEnumConst(node)
}
function visitEnumDeclaration(node) {
if (!shouldEmitEnumDeclaration(node)) {
- return ts.createNotEmittedStatement(node);
+ return factory.createNotEmittedStatement(node);
}
var statements = [];
var emitFlags = 2;
}
var parameterName = getNamespaceParameterName(node);
var containerName = getNamespaceContainerName(node);
- var exportName = ts.hasModifier(node, 1)
- ? ts.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true)
- : ts.getLocalName(node, false, true);
- var moduleArg = ts.createLogicalOr(exportName, ts.createAssignment(exportName, ts.createObjectLiteral()));
+ var exportName = ts.hasSyntacticModifier(node, 1)
+ ? factory.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true)
+ : factory.getLocalName(node, false, true);
+ var moduleArg = factory.createLogicalOr(exportName, factory.createAssignment(exportName, factory.createObjectLiteralExpression()));
if (hasNamespaceQualifiedExportName(node)) {
- var localName = ts.getLocalName(node, false, true);
- moduleArg = ts.createAssignment(localName, moduleArg);
+ var localName = factory.getLocalName(node, false, true);
+ moduleArg = factory.createAssignment(localName, moduleArg);
}
- var enumStatement = ts.createExpressionStatement(ts.createCall(ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, parameterName)], undefined, transformEnumBody(node, containerName)), undefined, [moduleArg]));
+ var enumStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createFunctionExpression(undefined, undefined, undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, parameterName)], undefined, transformEnumBody(node, containerName)), undefined, [moduleArg]));
ts.setOriginalNode(enumStatement, node);
if (varAdded) {
ts.setSyntheticLeadingComments(enumStatement, undefined);
ts.setTextRange(enumStatement, node);
ts.addEmitFlags(enumStatement, emitFlags);
statements.push(enumStatement);
- statements.push(ts.createEndOfDeclarationMarker(node));
+ statements.push(factory.createEndOfDeclarationMarker(node));
return statements;
}
function transformEnumBody(node, localName) {
ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
ts.addRange(statements, members);
currentNamespaceContainerName = savedCurrentNamespaceLocalName;
- return ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), node.members), true);
+ return factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), node.members), true);
}
function transformEnumMember(member) {
var name = getExpressionForPropertyName(member, false);
var valueExpression = transformEnumMemberDeclarationValue(member);
- var innerAssignment = ts.createAssignment(ts.createElementAccess(currentNamespaceContainerName, name), valueExpression);
+ var innerAssignment = factory.createAssignment(factory.createElementAccessExpression(currentNamespaceContainerName, name), valueExpression);
var outerAssignment = valueExpression.kind === 10 ?
innerAssignment :
- ts.createAssignment(ts.createElementAccess(currentNamespaceContainerName, innerAssignment), name);
- return ts.setTextRange(ts.createExpressionStatement(ts.setTextRange(outerAssignment, member)), member);
+ factory.createAssignment(factory.createElementAccessExpression(currentNamespaceContainerName, innerAssignment), name);
+ return ts.setTextRange(factory.createExpressionStatement(ts.setTextRange(outerAssignment, member)), member);
}
function transformEnumMemberDeclarationValue(member) {
var value = resolver.getConstantValue(member);
if (value !== undefined) {
- return ts.createLiteral(value);
+ return typeof value === "string" ? factory.createStringLiteral(value) : factory.createNumericLiteral(value);
}
else {
enableSubstitutionForNonQualifiedEnumMembers();
return ts.visitNode(member.initializer, visitor, ts.isExpression);
}
else {
- return ts.createVoidZero();
+ return factory.createVoidZero();
}
}
}
}
function recordEmittedDeclarationInScope(node) {
if (!currentScopeFirstDeclarationsOfName) {
- currentScopeFirstDeclarationsOfName = ts.createUnderscoreEscapedMap();
+ currentScopeFirstDeclarationsOfName = new ts.Map();
}
var name = declaredNameInScope(node);
if (!currentScopeFirstDeclarationsOfName.has(name)) {
return node.name.escapedText;
}
function addVarForEnumOrModuleDeclaration(statements, node) {
- var statement = ts.createVariableStatement(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.createVariableDeclarationList([
- ts.createVariableDeclaration(ts.getLocalName(node, false, true))
- ], currentLexicalScope.kind === 290 ? 0 : 1));
+ var statement = factory.createVariableStatement(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(factory.getLocalName(node, false, true))
+ ], currentLexicalScope.kind === 297 ? 0 : 1));
ts.setOriginalNode(statement, node);
recordEmittedDeclarationInScope(node);
if (isFirstEmittedDeclarationInScope(node)) {
- if (node.kind === 248) {
+ if (node.kind === 255) {
ts.setSourceMapRange(statement.declarationList, node);
}
else {
return true;
}
else {
- var mergeMarker = ts.createMergeDeclarationMarker(statement);
+ var mergeMarker = factory.createMergeDeclarationMarker(statement);
ts.setEmitFlags(mergeMarker, 1536 | 4194304);
statements.push(mergeMarker);
return false;
}
function visitModuleDeclaration(node) {
if (!shouldEmitModuleDeclaration(node)) {
- return ts.createNotEmittedStatement(node);
+ return factory.createNotEmittedStatement(node);
}
ts.Debug.assertNode(node.name, ts.isIdentifier, "A TypeScript namespace should have an Identifier name.");
enableSubstitutionForNamespaceExports();
}
var parameterName = getNamespaceParameterName(node);
var containerName = getNamespaceContainerName(node);
- var exportName = ts.hasModifier(node, 1)
- ? ts.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true)
- : ts.getLocalName(node, false, true);
- var moduleArg = ts.createLogicalOr(exportName, ts.createAssignment(exportName, ts.createObjectLiteral()));
+ var exportName = ts.hasSyntacticModifier(node, 1)
+ ? factory.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true)
+ : factory.getLocalName(node, false, true);
+ var moduleArg = factory.createLogicalOr(exportName, factory.createAssignment(exportName, factory.createObjectLiteralExpression()));
if (hasNamespaceQualifiedExportName(node)) {
- var localName = ts.getLocalName(node, false, true);
- moduleArg = ts.createAssignment(localName, moduleArg);
+ var localName = factory.getLocalName(node, false, true);
+ moduleArg = factory.createAssignment(localName, moduleArg);
}
- var moduleStatement = ts.createExpressionStatement(ts.createCall(ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, parameterName)], undefined, transformModuleBody(node, containerName)), undefined, [moduleArg]));
+ var moduleStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createFunctionExpression(undefined, undefined, undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, parameterName)], undefined, transformModuleBody(node, containerName)), undefined, [moduleArg]));
ts.setOriginalNode(moduleStatement, node);
if (varAdded) {
ts.setSyntheticLeadingComments(moduleStatement, undefined);
ts.setTextRange(moduleStatement, node);
ts.addEmitFlags(moduleStatement, emitFlags);
statements.push(moduleStatement);
- statements.push(ts.createEndOfDeclarationMarker(node));
+ statements.push(factory.createEndOfDeclarationMarker(node));
return statements;
}
function transformModuleBody(node, namespaceLocalName) {
var statementsLocation;
var blockLocation;
if (node.body) {
- if (node.body.kind === 250) {
+ if (node.body.kind === 257) {
saveStateAndInvoke(node.body, function (body) { return ts.addRange(statements, ts.visitNodes(body.statements, namespaceElementVisitor, ts.isStatement)); });
statementsLocation = node.body.statements;
blockLocation = node.body;
currentNamespaceContainerName = savedCurrentNamespaceContainerName;
currentNamespace = savedCurrentNamespace;
currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;
- var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), statementsLocation), true);
+ var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), true);
ts.setTextRange(block, blockLocation);
- if (!node.body || node.body.kind !== 250) {
+ if (!node.body || node.body.kind !== 257) {
ts.setEmitFlags(block, ts.getEmitFlags(block) | 1536);
}
return block;
}
function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) {
- if (moduleDeclaration.body.kind === 249) {
+ if (moduleDeclaration.body.kind === 256) {
var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body);
return recursiveInnerModule || moduleDeclaration.body;
}
return importClause ||
compilerOptions.importsNotUsedAsValues === 1 ||
compilerOptions.importsNotUsedAsValues === 2
- ? ts.updateImportDeclaration(node, undefined, undefined, importClause, node.moduleSpecifier)
+ ? factory.updateImportDeclaration(node, undefined, undefined, importClause, node.moduleSpecifier)
: undefined;
}
function visitImportClause(node) {
}
var name = resolver.isReferencedAliasDeclaration(node) ? node.name : undefined;
var namedBindings = ts.visitNode(node.namedBindings, visitNamedImportBindings, ts.isNamedImportBindings);
- return (name || namedBindings) ? ts.updateImportClause(node, name, namedBindings, false) : undefined;
+ return (name || namedBindings) ? factory.updateImportClause(node, false, name, namedBindings) : undefined;
}
function visitNamedImportBindings(node) {
- if (node.kind === 256) {
+ if (node.kind === 263) {
return resolver.isReferencedAliasDeclaration(node) ? node : undefined;
}
else {
var elements = ts.visitNodes(node.elements, visitImportSpecifier, ts.isImportSpecifier);
- return ts.some(elements) ? ts.updateNamedImports(node, elements) : undefined;
+ return ts.some(elements) ? factory.updateNamedImports(node, elements) : undefined;
}
}
function visitImportSpecifier(node) {
}
var exportClause = ts.visitNode(node.exportClause, visitNamedExportBindings, ts.isNamedExportBindings);
return exportClause
- ? ts.updateExportDeclaration(node, undefined, undefined, exportClause, node.moduleSpecifier, node.isTypeOnly)
+ ? factory.updateExportDeclaration(node, undefined, undefined, node.isTypeOnly, exportClause, node.moduleSpecifier)
: undefined;
}
function visitNamedExports(node) {
var elements = ts.visitNodes(node.elements, visitExportSpecifier, ts.isExportSpecifier);
- return ts.some(elements) ? ts.updateNamedExports(node, elements) : undefined;
+ return ts.some(elements) ? factory.updateNamedExports(node, elements) : undefined;
}
function visitNamespaceExports(node) {
- return ts.updateNamespaceExport(node, ts.visitNode(node.name, visitor, ts.isIdentifier));
+ return factory.updateNamespaceExport(node, ts.visitNode(node.name, visitor, ts.isIdentifier));
}
function visitNamedExportBindings(node) {
return ts.isNamespaceExport(node) ? visitNamespaceExports(node) : visitNamedExports(node);
if (ts.isExternalModuleImportEqualsDeclaration(node)) {
var isReferenced = resolver.isReferencedAliasDeclaration(node);
if (!isReferenced && compilerOptions.importsNotUsedAsValues === 1) {
- return ts.setOriginalNode(ts.setTextRange(ts.createImportDeclaration(undefined, undefined, undefined, node.moduleReference.expression), node), node);
+ return ts.setOriginalNode(ts.setTextRange(factory.createImportDeclaration(undefined, undefined, undefined, node.moduleReference.expression), node), node);
}
return isReferenced ? ts.visitEachChild(node, visitor, context) : undefined;
}
if (!shouldEmitImportEqualsDeclaration(node)) {
return undefined;
}
- var moduleReference = ts.createExpressionFromEntityName(node.moduleReference);
+ var moduleReference = ts.createExpressionFromEntityName(factory, node.moduleReference);
ts.setEmitFlags(moduleReference, 1536 | 2048);
if (isNamedExternalModuleExport(node) || !isExportOfNamespace(node)) {
- return ts.setOriginalNode(ts.setTextRange(ts.createVariableStatement(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.createVariableDeclarationList([
- ts.setOriginalNode(ts.createVariableDeclaration(node.name, undefined, moduleReference), node)
+ return ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), factory.createVariableDeclarationList([
+ ts.setOriginalNode(factory.createVariableDeclaration(node.name, undefined, undefined, moduleReference), node)
])), node), node);
}
else {
}
}
function isExportOfNamespace(node) {
- return currentNamespace !== undefined && ts.hasModifier(node, 1);
+ return currentNamespace !== undefined && ts.hasSyntacticModifier(node, 1);
}
function isExternalModuleExport(node) {
- return currentNamespace === undefined && ts.hasModifier(node, 1);
+ return currentNamespace === undefined && ts.hasSyntacticModifier(node, 1);
}
function isNamedExternalModuleExport(node) {
return isExternalModuleExport(node)
- && !ts.hasModifier(node, 512);
+ && !ts.hasSyntacticModifier(node, 512);
}
function isDefaultExternalModuleExport(node) {
return isExternalModuleExport(node)
- && ts.hasModifier(node, 512);
+ && ts.hasSyntacticModifier(node, 512);
}
function expressionToStatement(expression) {
- return ts.createExpressionStatement(expression);
+ return factory.createExpressionStatement(expression);
}
function addExportMemberAssignment(statements, node) {
- var expression = ts.createAssignment(ts.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true), ts.getLocalName(node));
+ var expression = factory.createAssignment(factory.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true), factory.getLocalName(node));
ts.setSourceMapRange(expression, ts.createRange(node.name ? node.name.pos : node.pos, node.end));
- var statement = ts.createExpressionStatement(expression);
+ var statement = factory.createExpressionStatement(expression);
ts.setSourceMapRange(statement, ts.createRange(-1, node.end));
statements.push(statement);
}
function createNamespaceExport(exportName, exportValue, location) {
- return ts.setTextRange(ts.createExpressionStatement(ts.createAssignment(ts.getNamespaceMemberName(currentNamespaceContainerName, exportName, false, true), exportValue)), location);
+ return ts.setTextRange(factory.createExpressionStatement(factory.createAssignment(factory.getNamespaceMemberName(currentNamespaceContainerName, exportName, false, true), exportValue)), location);
}
function createNamespaceExportExpression(exportName, exportValue, location) {
- return ts.setTextRange(ts.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(exportName), exportValue), location);
+ return ts.setTextRange(factory.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(exportName), exportValue), location);
}
function getNamespaceMemberNameWithSourceMapsAndWithoutComments(name) {
- return ts.getNamespaceMemberName(currentNamespaceContainerName, name, false, true);
+ return factory.getNamespaceMemberName(currentNamespaceContainerName, name, false, true);
}
function getNamespaceParameterName(node) {
- var name = ts.getGeneratedNameForNode(node);
+ var name = factory.getGeneratedNameForNode(node);
ts.setSourceMapRange(name, node.name);
return name;
}
function getNamespaceContainerName(node) {
- return ts.getGeneratedNameForNode(node);
+ return factory.getGeneratedNameForNode(node);
}
function getClassAliasIfNeeded(node) {
if (resolver.getNodeCheckFlags(node) & 16777216) {
enableSubstitutionForClassAliases();
- var classAlias = ts.createUniqueName(node.name && !ts.isGeneratedIdentifier(node.name) ? ts.idText(node.name) : "default");
+ var classAlias = factory.createUniqueName(node.name && !ts.isGeneratedIdentifier(node.name) ? ts.idText(node.name) : "default");
classAliases[ts.getOriginalNodeId(node)] = classAlias;
hoistVariableDeclaration(classAlias);
return classAlias;
}
}
function getClassPrototype(node) {
- return ts.createPropertyAccess(ts.getDeclarationName(node), "prototype");
+ return factory.createPropertyAccessExpression(factory.getDeclarationName(node), "prototype");
}
function getClassMemberPrefix(node, member) {
- return ts.hasModifier(member, 32)
- ? ts.getDeclarationName(node)
+ return ts.hasSyntacticModifier(member, 32)
+ ? factory.getDeclarationName(node)
: getClassPrototype(node);
}
function enableSubstitutionForNonQualifiedEnumMembers() {
if ((enabledSubstitutions & 8) === 0) {
enabledSubstitutions |= 8;
- context.enableSubstitution(75);
+ context.enableSubstitution(78);
}
}
function enableSubstitutionForClassAliases() {
if ((enabledSubstitutions & 1) === 0) {
enabledSubstitutions |= 1;
- context.enableSubstitution(75);
+ context.enableSubstitution(78);
classAliases = [];
}
}
function enableSubstitutionForNamespaceExports() {
if ((enabledSubstitutions & 2) === 0) {
enabledSubstitutions |= 2;
- context.enableSubstitution(75);
- context.enableSubstitution(282);
- context.enableEmitNotification(249);
+ context.enableSubstitution(78);
+ context.enableSubstitution(289);
+ context.enableEmitNotification(256);
}
}
function isTransformedModuleDeclaration(node) {
- return ts.getOriginalNode(node).kind === 249;
+ return ts.getOriginalNode(node).kind === 256;
}
function isTransformedEnumDeclaration(node) {
- return ts.getOriginalNode(node).kind === 248;
+ return ts.getOriginalNode(node).kind === 255;
}
function onEmitNode(hint, node, emitCallback) {
var savedApplicableSubstitutions = applicableSubstitutions;
var exportedName = trySubstituteNamespaceExportedName(name);
if (exportedName) {
if (node.objectAssignmentInitializer) {
- var initializer = ts.createAssignment(exportedName, node.objectAssignmentInitializer);
- return ts.setTextRange(ts.createPropertyAssignment(name, initializer), node);
+ var initializer = factory.createAssignment(exportedName, node.objectAssignmentInitializer);
+ return ts.setTextRange(factory.createPropertyAssignment(name, initializer), node);
}
- return ts.setTextRange(ts.createPropertyAssignment(name, exportedName), node);
+ return ts.setTextRange(factory.createPropertyAssignment(name, exportedName), node);
}
}
return node;
}
function substituteExpression(node) {
switch (node.kind) {
- case 75:
+ case 78:
return substituteExpressionIdentifier(node);
- case 194:
+ case 201:
return substitutePropertyAccessExpression(node);
- case 195:
+ case 202:
return substituteElementAccessExpression(node);
}
return node;
if (declaration) {
var classAlias = classAliases[declaration.id];
if (classAlias) {
- var clone_1 = ts.getSynthesizedClone(classAlias);
+ var clone_1 = factory.cloneNode(classAlias);
ts.setSourceMapRange(clone_1, node);
ts.setCommentRange(clone_1, node);
return clone_1;
function trySubstituteNamespaceExportedName(node) {
if (enabledSubstitutions & applicableSubstitutions && !ts.isGeneratedIdentifier(node) && !ts.isLocalName(node)) {
var container = resolver.getReferencedExportContainer(node, false);
- if (container && container.kind !== 290) {
- var substitute = (applicableSubstitutions & 2 && container.kind === 249) ||
- (applicableSubstitutions & 8 && container.kind === 248);
+ if (container && container.kind !== 297) {
+ var substitute = (applicableSubstitutions & 2 && container.kind === 256) ||
+ (applicableSubstitutions & 8 && container.kind === 255);
if (substitute) {
- return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(container), node), node);
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(container), node), node);
}
}
}
var constantValue = tryGetConstEnumValue(node);
if (constantValue !== undefined) {
ts.setConstantValue(node, constantValue);
- var substitute = ts.createLiteral(constantValue);
+ var substitute = typeof constantValue === "string" ? factory.createStringLiteral(constantValue) : factory.createNumericLiteral(constantValue);
if (!compilerOptions.removeComments) {
var originalNode = ts.getOriginalNode(node, ts.isAccessExpression);
var propertyName = ts.isPropertyAccessExpression(originalNode)
}
}
ts.transformTypeScript = transformTypeScript;
- function createDecorateHelper(context, decoratorExpressions, target, memberName, descriptor, location) {
- var argumentsArray = [];
- argumentsArray.push(ts.createArrayLiteral(decoratorExpressions, true));
- argumentsArray.push(target);
- if (memberName) {
- argumentsArray.push(memberName);
- if (descriptor) {
- argumentsArray.push(descriptor);
- }
- }
- context.requestEmitHelper(ts.decorateHelper);
- return ts.setTextRange(ts.createCall(ts.getUnscopedHelperName("__decorate"), undefined, argumentsArray), location);
- }
- ts.decorateHelper = {
- name: "typescript:decorate",
- importName: "__decorate",
- scoped: false,
- priority: 2,
- text: "\n var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n };"
- };
- function createMetadataHelper(context, metadataKey, metadataValue) {
- context.requestEmitHelper(ts.metadataHelper);
- return ts.createCall(ts.getUnscopedHelperName("__metadata"), undefined, [
- ts.createLiteral(metadataKey),
- metadataValue
- ]);
- }
- ts.metadataHelper = {
- name: "typescript:metadata",
- importName: "__metadata",
- scoped: false,
- priority: 3,
- text: "\n var __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n };"
- };
- function createParamHelper(context, expression, parameterOffset, location) {
- context.requestEmitHelper(ts.paramHelper);
- return ts.setTextRange(ts.createCall(ts.getUnscopedHelperName("__param"), undefined, [
- ts.createLiteral(parameterOffset),
- expression
- ]), location);
- }
- ts.paramHelper = {
- name: "typescript:param",
- importName: "__param",
- scoped: false,
- priority: 4,
- text: "\n var __param = (this && this.__param) || function (paramIndex, decorator) {\n return function (target, key) { decorator(target, key, paramIndex); }\n };"
- };
})(ts || (ts = {}));
var ts;
(function (ts) {
function transformClassFields(context) {
- var hoistVariableDeclaration = context.hoistVariableDeclaration, endLexicalEnvironment = context.endLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment;
+ var factory = context.factory, hoistVariableDeclaration = context.hoistVariableDeclaration, endLexicalEnvironment = context.endLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment;
var resolver = context.getEmitResolver();
var compilerOptions = context.getCompilerOptions();
var languageVersion = ts.getEmitScriptTarget(compilerOptions);
var pendingStatements;
var privateIdentifierEnvironmentStack = [];
var currentPrivateIdentifierEnvironment;
- return ts.chainBundle(transformSourceFile);
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
var options = context.getCompilerOptions();
if (node.isDeclarationFile
if (!(node.transformFlags & 4194304))
return node;
switch (node.kind) {
- case 214:
- case 245:
+ case 221:
+ case 252:
return visitClassLike(node);
- case 159:
+ case 163:
return visitPropertyDeclaration(node);
- case 225:
+ case 232:
return visitVariableStatement(node);
- case 154:
+ case 158:
return visitComputedPropertyName(node);
- case 194:
+ case 201:
return visitPropertyAccessExpression(node);
- case 207:
+ case 214:
return visitPrefixUnaryExpression(node);
- case 208:
+ case 215:
return visitPostfixUnaryExpression(node, false);
- case 196:
+ case 203:
return visitCallExpression(node);
- case 209:
+ case 216:
return visitBinaryExpression(node);
- case 76:
+ case 79:
return visitPrivateIdentifier(node);
- case 226:
+ case 233:
return visitExpressionStatement(node);
- case 230:
+ case 237:
return visitForStatement(node);
- case 198:
+ case 205:
return visitTaggedTemplateExpression(node);
}
return ts.visitEachChild(node, visitor, context);
}
function visitorDestructuringTarget(node) {
switch (node.kind) {
- case 193:
- case 192:
+ case 200:
+ case 199:
return visitAssignmentPattern(node);
default:
return visitor(node);
if (!shouldTransformPrivateFields) {
return node;
}
- return ts.setOriginalNode(ts.createIdentifier(""), node);
+ return ts.setOriginalNode(factory.createIdentifier(""), node);
}
function classElementVisitor(node) {
switch (node.kind) {
- case 162:
+ case 166:
return undefined;
- case 163:
- case 164:
- case 161:
+ case 167:
+ case 168:
+ case 165:
return ts.visitEachChild(node, classElementVisitor, context);
- case 159:
+ case 163:
return visitPropertyDeclaration(node);
- case 154:
+ case 158:
return visitComputedPropertyName(node);
- case 222:
+ case 229:
return node;
default:
return visitor(node);
var expressions = pendingExpressions;
expressions.push(name.expression);
pendingExpressions = [];
- node = ts.updateComputedPropertyName(node, ts.inlineExpressions(expressions));
+ node = factory.updateComputedPropertyName(node, factory.inlineExpressions(expressions));
}
return node;
}
function visitPropertyDeclaration(node) {
ts.Debug.assert(!ts.some(node.decorators));
if (!shouldTransformPrivateFields && ts.isPrivateIdentifier(node.name)) {
- return ts.updateProperty(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.name, undefined, undefined, undefined);
+ return factory.updatePropertyDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.name, undefined, undefined, undefined);
}
var expr = getPropertyNameExpressionIfNeeded(node.name, !!node.initializer || !!context.getCompilerOptions().useDefineForClassFields);
if (expr && !ts.isSimpleInlineableExpression(expr)) {
- (pendingExpressions || (pendingExpressions = [])).push(expr);
+ getPendingExpressions().push(expr);
}
return undefined;
}
receiver = ts.visitNode(receiver, visitor, ts.isExpression);
switch (info.placement) {
case 0:
- return createClassPrivateFieldGetHelper(context, ts.nodeIsSynthesized(receiver) ? receiver : ts.getSynthesizedClone(receiver), info.weakMapName);
+ return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(ts.nodeIsSynthesized(receiver) ? receiver : factory.cloneNode(receiver), info.weakMapName);
default: return ts.Debug.fail("Unexpected private identifier placement");
}
}
if (operator && (info = accessPrivateIdentifier(node.operand.name))) {
var receiver = ts.visitNode(node.operand.expression, visitor, ts.isExpression);
var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression;
- var existingValue = ts.createPrefix(39, createPrivateIdentifierAccess(info, readExpression));
- return ts.setOriginalNode(createPrivateIdentifierAssignment(info, initializeExpression || readExpression, ts.createBinary(existingValue, operator, ts.createLiteral(1)), 62), node);
+ var existingValue = factory.createPrefixUnaryExpression(39, createPrivateIdentifierAccess(info, readExpression));
+ return ts.setOriginalNode(createPrivateIdentifierAssignment(info, initializeExpression || readExpression, factory.createBinaryExpression(existingValue, operator, factory.createNumericLiteral(1)), 62), node);
}
}
return ts.visitEachChild(node, visitor, context);
if (operator && (info = accessPrivateIdentifier(node.operand.name))) {
var receiver = ts.visitNode(node.operand.expression, visitor, ts.isExpression);
var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression;
- var existingValue = ts.createPrefix(39, createPrivateIdentifierAccess(info, readExpression));
- var returnValue = valueIsDiscarded ? undefined : ts.createTempVariable(hoistVariableDeclaration);
- return ts.setOriginalNode(ts.inlineExpressions(ts.compact([
- createPrivateIdentifierAssignment(info, initializeExpression || readExpression, ts.createBinary(returnValue ? ts.createAssignment(returnValue, existingValue) : existingValue, operator, ts.createLiteral(1)), 62),
+ var existingValue = factory.createPrefixUnaryExpression(39, createPrivateIdentifierAccess(info, readExpression));
+ var returnValue = valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration);
+ return ts.setOriginalNode(factory.inlineExpressions(ts.compact([
+ createPrivateIdentifierAssignment(info, initializeExpression || readExpression, factory.createBinaryExpression(returnValue ? factory.createAssignment(returnValue, existingValue) : existingValue, operator, factory.createNumericLiteral(1)), 62),
returnValue
])), node);
}
}
function visitForStatement(node) {
if (node.incrementor && ts.isPostfixUnaryExpression(node.incrementor)) {
- return ts.updateFor(node, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), visitPostfixUnaryExpression(node.incrementor, true), ts.visitNode(node.statement, visitor, ts.isStatement));
+ return factory.updateForStatement(node, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), visitPostfixUnaryExpression(node.incrementor, true), ts.visitNode(node.statement, visitor, ts.isStatement));
}
return ts.visitEachChild(node, visitor, context);
}
function visitExpressionStatement(node) {
if (ts.isPostfixUnaryExpression(node.expression)) {
- return ts.updateExpressionStatement(node, visitPostfixUnaryExpression(node.expression, true));
+ return factory.updateExpressionStatement(node, visitPostfixUnaryExpression(node.expression, true));
}
return ts.visitEachChild(node, visitor, context);
}
function createCopiableReceiverExpr(receiver) {
- var clone = ts.nodeIsSynthesized(receiver) ? receiver : ts.getSynthesizedClone(receiver);
+ var clone = ts.nodeIsSynthesized(receiver) ? receiver : factory.cloneNode(receiver);
if (ts.isSimpleInlineableExpression(receiver)) {
return { readExpression: clone, initializeExpression: undefined };
}
- var readExpression = ts.createTempVariable(hoistVariableDeclaration);
- var initializeExpression = ts.createAssignment(readExpression, clone);
+ var readExpression = factory.createTempVariable(hoistVariableDeclaration);
+ var initializeExpression = factory.createAssignment(readExpression, clone);
return { readExpression: readExpression, initializeExpression: initializeExpression };
}
function visitCallExpression(node) {
if (shouldTransformPrivateFields && ts.isPrivateIdentifierPropertyAccessExpression(node.expression)) {
- var _a = ts.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion), thisArg = _a.thisArg, target = _a.target;
- return ts.updateCall(node, ts.createPropertyAccess(ts.visitNode(target, visitor), "call"), undefined, __spreadArrays([ts.visitNode(thisArg, visitor, ts.isExpression)], ts.visitNodes(node.arguments, visitor, ts.isExpression)));
+ var _a = factory.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion), thisArg = _a.thisArg, target = _a.target;
+ return factory.updateCallExpression(node, factory.createPropertyAccessExpression(ts.visitNode(target, visitor), "call"), undefined, __spreadArrays([ts.visitNode(thisArg, visitor, ts.isExpression)], ts.visitNodes(node.arguments, visitor, ts.isExpression)));
}
return ts.visitEachChild(node, visitor, context);
}
function visitTaggedTemplateExpression(node) {
if (shouldTransformPrivateFields && ts.isPrivateIdentifierPropertyAccessExpression(node.tag)) {
- var _a = ts.createCallBinding(node.tag, hoistVariableDeclaration, languageVersion), thisArg = _a.thisArg, target = _a.target;
- return ts.updateTaggedTemplate(node, ts.createCall(ts.createPropertyAccess(ts.visitNode(target, visitor), "bind"), undefined, [ts.visitNode(thisArg, visitor, ts.isExpression)]), ts.visitNode(node.template, visitor, ts.isTemplateLiteral));
+ var _a = factory.createCallBinding(node.tag, hoistVariableDeclaration, languageVersion), thisArg = _a.thisArg, target = _a.target;
+ return factory.updateTaggedTemplateExpression(node, factory.createCallExpression(factory.createPropertyAccessExpression(ts.visitNode(target, visitor), "bind"), undefined, [ts.visitNode(thisArg, visitor, ts.isExpression)]), undefined, ts.visitNode(node.template, visitor, ts.isTemplateLiteral));
}
return ts.visitEachChild(node, visitor, context);
}
if (ts.isDestructuringAssignment(node)) {
var savedPendingExpressions = pendingExpressions;
pendingExpressions = undefined;
- node = ts.updateBinary(node, ts.visitNode(node.left, visitorDestructuringTarget), ts.visitNode(node.right, visitor), node.operatorToken);
+ node = factory.updateBinaryExpression(node, ts.visitNode(node.left, visitorDestructuringTarget), node.operatorToken, ts.visitNode(node.right, visitor));
var expr = ts.some(pendingExpressions) ?
- ts.inlineExpressions(ts.compact(__spreadArrays(pendingExpressions, [node]))) :
+ factory.inlineExpressions(ts.compact(__spreadArrays(pendingExpressions, [node]))) :
node;
pendingExpressions = savedPendingExpressions;
return expr;
right = ts.visitNode(right, visitor, ts.isExpression);
if (ts.isCompoundAssignment(operator)) {
var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression;
- return createClassPrivateFieldSetHelper(context, initializeExpression || readExpression, info.weakMapName, ts.createBinary(createClassPrivateFieldGetHelper(context, readExpression, info.weakMapName), ts.getNonAssignmentOperatorForCompoundAssignment(operator), right));
+ return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(initializeExpression || readExpression, info.weakMapName, factory.createBinaryExpression(context.getEmitHelperFactory().createClassPrivateFieldGetHelper(readExpression, info.weakMapName), ts.getNonAssignmentOperatorForCompoundAssignment(operator), right));
}
else {
- return createClassPrivateFieldSetHelper(context, receiver, info.weakMapName, right);
+ return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(receiver, info.weakMapName, right);
}
}
function visitClassLike(node) {
return ts.visitEachChild(node, visitor, context);
}
var extendsClauseElement = ts.getEffectiveBaseTypeNode(node);
- var isDerivedClass = !!(extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 100);
+ var isDerivedClass = !!(extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 103);
var statements = [
- ts.updateClassDeclaration(node, undefined, node.modifiers, node.name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass))
+ factory.updateClassDeclaration(node, undefined, node.modifiers, node.name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass))
];
if (ts.some(pendingExpressions)) {
- statements.push(ts.createExpressionStatement(ts.inlineExpressions(pendingExpressions)));
+ statements.push(factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions)));
}
var staticProperties = ts.getProperties(node, true, true);
if (ts.some(staticProperties)) {
- addPropertyStatements(statements, staticProperties, ts.getInternalName(node));
+ addPropertyStatements(statements, staticProperties, factory.getInternalName(node));
}
return statements;
}
var isDecoratedClassDeclaration = ts.isClassDeclaration(ts.getOriginalNode(node));
var staticProperties = ts.getProperties(node, true, true);
var extendsClauseElement = ts.getEffectiveBaseTypeNode(node);
- var isDerivedClass = !!(extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 100);
- var classExpression = ts.updateClassExpression(node, node.modifiers, node.name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass));
+ var isDerivedClass = !!(extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 103);
+ var classExpression = factory.updateClassExpression(node, ts.visitNodes(node.decorators, visitor, ts.isDecorator), node.modifiers, node.name, undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass));
if (ts.some(staticProperties) || ts.some(pendingExpressions)) {
if (isDecoratedClassDeclaration) {
ts.Debug.assertIsDefined(pendingStatements, "Decorated classes transformed by TypeScript are expected to be within a variable declaration.");
if (pendingStatements && pendingExpressions && ts.some(pendingExpressions)) {
- pendingStatements.push(ts.createExpressionStatement(ts.inlineExpressions(pendingExpressions)));
+ pendingStatements.push(factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions)));
}
if (pendingStatements && ts.some(staticProperties)) {
- addPropertyStatements(pendingStatements, staticProperties, ts.getInternalName(node));
+ addPropertyStatements(pendingStatements, staticProperties, factory.getInternalName(node));
}
return classExpression;
}
else {
var expressions = [];
var isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 16777216;
- var temp = ts.createTempVariable(hoistVariableDeclaration, !!isClassWithConstructorReference);
+ var temp = factory.createTempVariable(hoistVariableDeclaration, !!isClassWithConstructorReference);
if (isClassWithConstructorReference) {
enableSubstitutionForClassAliases();
- var alias = ts.getSynthesizedClone(temp);
+ var alias = factory.cloneNode(temp);
alias.autoGenerateFlags &= ~8;
classAliases[ts.getOriginalNodeId(node)] = alias;
}
ts.setEmitFlags(classExpression, 65536 | ts.getEmitFlags(classExpression));
- expressions.push(ts.startOnNewLine(ts.createAssignment(temp, classExpression)));
+ expressions.push(ts.startOnNewLine(factory.createAssignment(temp, classExpression)));
ts.addRange(expressions, ts.map(pendingExpressions, ts.startOnNewLine));
ts.addRange(expressions, generateInitializedPropertyExpressions(staticProperties, temp));
expressions.push(ts.startOnNewLine(temp));
- return ts.inlineExpressions(expressions);
+ return factory.inlineExpressions(expressions);
}
}
return classExpression;
members.push(constructor);
}
ts.addRange(members, ts.visitNodes(node.members, classElementVisitor, ts.isClassElement));
- return ts.setTextRange(ts.createNodeArray(members), node.members);
+ return ts.setTextRange(factory.createNodeArray(members), node.members);
}
function isPropertyDeclarationThatRequiresConstructorStatement(member) {
if (!ts.isPropertyDeclaration(member) || ts.hasStaticModifier(member)) {
if (!body) {
return undefined;
}
- return ts.startOnNewLine(ts.setOriginalNode(ts.setTextRange(ts.createConstructor(undefined, undefined, parameters !== null && parameters !== void 0 ? parameters : [], body), constructor || node), constructor));
+ return ts.startOnNewLine(ts.setOriginalNode(ts.setTextRange(factory.createConstructorDeclaration(undefined, undefined, parameters !== null && parameters !== void 0 ? parameters : [], body), constructor || node), constructor));
}
function transformConstructorBody(node, constructor, isDerivedClass) {
var useDefineForClassFields = context.getCompilerOptions().useDefineForClassFields;
var indexOfFirstStatement = 0;
var statements = [];
if (!constructor && isDerivedClass) {
- statements.push(ts.createExpressionStatement(ts.createCall(ts.createSuper(), undefined, [ts.createSpread(ts.createIdentifier("arguments"))])));
+ statements.push(factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), undefined, [factory.createSpreadElement(factory.createIdentifier("arguments"))])));
}
if (constructor) {
- indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(constructor, statements, visitor);
+ indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(factory, constructor, statements, visitor);
}
if (constructor === null || constructor === void 0 ? void 0 : constructor.body) {
var afterParameterProperties = ts.findIndex(constructor.body.statements, function (s) { return !ts.isParameterPropertyDeclaration(ts.getOriginalNode(s), constructor); }, indexOfFirstStatement);
indexOfFirstStatement = afterParameterProperties;
}
}
- addPropertyStatements(statements, properties, ts.createThis());
+ addPropertyStatements(statements, properties, factory.createThis());
if (constructor) {
ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatement));
}
- statements = ts.mergeLexicalEnvironment(statements, endLexicalEnvironment());
- return ts.setTextRange(ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), constructor ? constructor.body.statements : node.members), true), constructor ? constructor.body : undefined);
+ statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
+ return ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), constructor ? constructor.body.statements : node.members), true), constructor ? constructor.body : undefined);
}
function addPropertyStatements(statements, properties, receiver) {
- for (var _i = 0, properties_8 = properties; _i < properties_8.length; _i++) {
- var property = properties_8[_i];
+ for (var _i = 0, properties_7 = properties; _i < properties_7.length; _i++) {
+ var property = properties_7[_i];
var expression = transformProperty(property, receiver);
if (!expression) {
continue;
}
- var statement = ts.createExpressionStatement(expression);
+ var statement = factory.createExpressionStatement(expression);
ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
ts.setCommentRange(statement, property);
ts.setOriginalNode(statement, property);
}
function generateInitializedPropertyExpressions(properties, receiver) {
var expressions = [];
- for (var _i = 0, properties_9 = properties; _i < properties_9.length; _i++) {
- var property = properties_9[_i];
+ for (var _i = 0, properties_8 = properties; _i < properties_8.length; _i++) {
+ var property = properties_8[_i];
var expression = transformProperty(property, receiver);
if (!expression) {
continue;
return expressions;
}
function transformProperty(property, receiver) {
+ var _a;
var emitAssignment = !context.getCompilerOptions().useDefineForClassFields;
var propertyName = ts.isComputedPropertyName(property.name) && !ts.isSimpleInlineableExpression(property.name.expression)
- ? ts.updateComputedPropertyName(property.name, ts.getGeneratedNameForNode(property.name))
+ ? factory.updateComputedPropertyName(property.name, factory.getGeneratedNameForNode(property.name))
: property.name;
if (shouldTransformPrivateFields && ts.isPrivateIdentifier(propertyName)) {
var privateIdentifierInfo = accessPrivateIdentifier(propertyName);
return undefined;
}
var propertyOriginalNode = ts.getOriginalNode(property);
- var initializer = property.initializer || emitAssignment ? ts.visitNode(property.initializer, visitor, ts.isExpression)
- : ts.isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && ts.isIdentifier(propertyName) ? propertyName
- : ts.createVoidZero();
+ var initializer = property.initializer || emitAssignment ? (_a = ts.visitNode(property.initializer, visitor, ts.isExpression)) !== null && _a !== void 0 ? _a : factory.createVoidZero() : ts.isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && ts.isIdentifier(propertyName) ? propertyName
+ : factory.createVoidZero();
if (emitAssignment || ts.isPrivateIdentifier(propertyName)) {
- var memberAccess = ts.createMemberAccessForPropertyName(receiver, propertyName, propertyName);
- return ts.createAssignment(memberAccess, initializer);
+ var memberAccess = ts.createMemberAccessForPropertyName(factory, receiver, propertyName, propertyName);
+ return factory.createAssignment(memberAccess, initializer);
}
else {
var name = ts.isComputedPropertyName(propertyName) ? propertyName.expression
- : ts.isIdentifier(propertyName) ? ts.createStringLiteral(ts.unescapeLeadingUnderscores(propertyName.escapedText))
+ : ts.isIdentifier(propertyName) ? factory.createStringLiteral(ts.unescapeLeadingUnderscores(propertyName.escapedText))
: propertyName;
- var descriptor = ts.createPropertyDescriptor({ value: initializer, configurable: true, writable: true, enumerable: true });
- return ts.createObjectDefinePropertyCall(receiver, name, descriptor);
+ var descriptor = factory.createPropertyDescriptor({ value: initializer, configurable: true, writable: true, enumerable: true });
+ return factory.createObjectDefinePropertyCall(receiver, name, descriptor);
}
}
function enableSubstitutionForClassAliases() {
if ((enabledSubstitutions & 1) === 0) {
enabledSubstitutions |= 1;
- context.enableSubstitution(75);
+ context.enableSubstitution(78);
classAliases = [];
}
}
}
function substituteExpression(node) {
switch (node.kind) {
- case 75:
+ case 78:
return substituteExpressionIdentifier(node);
}
return node;
if (declaration) {
var classAlias = classAliases[declaration.id];
if (classAlias) {
- var clone_2 = ts.getSynthesizedClone(classAlias);
+ var clone_2 = factory.cloneNode(classAlias);
ts.setSourceMapRange(clone_2, node);
ts.setCommentRange(clone_2, node);
return clone_2;
var inlinable = ts.isSimpleInlineableExpression(innerExpression);
var alreadyTransformed = ts.isAssignmentExpression(innerExpression) && ts.isGeneratedIdentifier(innerExpression.left);
if (!alreadyTransformed && !inlinable && shouldHoist) {
- var generatedName = ts.getGeneratedNameForNode(name);
+ var generatedName = factory.getGeneratedNameForNode(name);
hoistVariableDeclaration(generatedName);
- return ts.createAssignment(generatedName, expression);
+ return factory.createAssignment(generatedName, expression);
}
return (inlinable || ts.isIdentifier(innerExpression)) ? undefined : expression;
}
function endPrivateIdentifierEnvironment() {
currentPrivateIdentifierEnvironment = privateIdentifierEnvironmentStack.pop();
}
+ function getPrivateIdentifierEnvironment() {
+ return currentPrivateIdentifierEnvironment || (currentPrivateIdentifierEnvironment = new ts.Map());
+ }
+ function getPendingExpressions() {
+ return pendingExpressions || (pendingExpressions = []);
+ }
function addPrivateIdentifierToEnvironment(name) {
var text = ts.getTextOfPropertyName(name);
- var weakMapName = ts.createOptimisticUniqueName("_" + text.substring(1));
- weakMapName.autoGenerateFlags |= 8;
+ var weakMapName = factory.createUniqueName("_" + text.substring(1), 16 | 8);
hoistVariableDeclaration(weakMapName);
- (currentPrivateIdentifierEnvironment || (currentPrivateIdentifierEnvironment = ts.createUnderscoreEscapedMap()))
- .set(name.escapedText, { placement: 0, weakMapName: weakMapName });
- (pendingExpressions || (pendingExpressions = [])).push(ts.createAssignment(weakMapName, ts.createNew(ts.createIdentifier("WeakMap"), undefined, [])));
+ getPrivateIdentifierEnvironment().set(name.escapedText, { placement: 0, weakMapName: weakMapName });
+ getPendingExpressions().push(factory.createAssignment(weakMapName, factory.createNewExpression(factory.createIdentifier("WeakMap"), undefined, [])));
}
function accessPrivateIdentifier(name) {
if (currentPrivateIdentifierEnvironment) {
return undefined;
}
function wrapPrivateIdentifierForDestructuringTarget(node) {
- var parameter = ts.getGeneratedNameForNode(node);
+ var parameter = factory.getGeneratedNameForNode(node);
var info = accessPrivateIdentifier(node.name);
if (!info) {
return ts.visitEachChild(node, visitor, context);
}
var receiver = node.expression;
if (ts.isThisProperty(node) || ts.isSuperProperty(node) || !ts.isSimpleCopiableExpression(node.expression)) {
- receiver = ts.createTempVariable(hoistVariableDeclaration);
- receiver.autoGenerateFlags |= 8;
- (pendingExpressions || (pendingExpressions = [])).push(ts.createBinary(receiver, 62, node.expression));
+ receiver = factory.createTempVariable(hoistVariableDeclaration, true);
+ getPendingExpressions().push(factory.createBinaryExpression(receiver, 62, node.expression));
}
- return ts.createPropertyAccess(ts.createParen(ts.createObjectLiteral([
- ts.createSetAccessor(undefined, undefined, "value", [ts.createParameter(undefined, undefined, undefined, parameter, undefined, undefined, undefined)], ts.createBlock([ts.createExpressionStatement(createPrivateIdentifierAssignment(info, receiver, parameter, 62))]))
+ return factory.createPropertyAccessExpression(factory.createParenthesizedExpression(factory.createObjectLiteralExpression([
+ factory.createSetAccessorDeclaration(undefined, undefined, "value", [factory.createParameterDeclaration(undefined, undefined, undefined, parameter, undefined, undefined, undefined)], factory.createBlock([factory.createExpressionStatement(createPrivateIdentifierAssignment(info, receiver, parameter, 62))]))
])), "value");
}
function visitArrayAssignmentTarget(node) {
if (target && ts.isPrivateIdentifierPropertyAccessExpression(target)) {
var wrapped = wrapPrivateIdentifierForDestructuringTarget(target);
if (ts.isAssignmentExpression(node)) {
- return ts.updateBinary(node, wrapped, ts.visitNode(node.right, visitor, ts.isExpression), node.operatorToken);
+ return factory.updateBinaryExpression(node, wrapped, node.operatorToken, ts.visitNode(node.right, visitor, ts.isExpression));
}
else if (ts.isSpreadElement(node)) {
- return ts.updateSpread(node, wrapped);
+ return factory.updateSpreadElement(node, wrapped);
}
else {
return wrapped;
if (target && ts.isPrivateIdentifierPropertyAccessExpression(target)) {
var initializer = ts.getInitializerOfBindingOrAssignmentElement(node);
var wrapped = wrapPrivateIdentifierForDestructuringTarget(target);
- return ts.updatePropertyAssignment(node, ts.visitNode(node.name, visitor), initializer ? ts.createAssignment(wrapped, ts.visitNode(initializer, visitor)) : wrapped);
+ return factory.updatePropertyAssignment(node, ts.visitNode(node.name, visitor), initializer ? factory.createAssignment(wrapped, ts.visitNode(initializer, visitor)) : wrapped);
}
- return ts.updatePropertyAssignment(node, ts.visitNode(node.name, visitor), ts.visitNode(node.initializer, visitorDestructuringTarget));
+ return factory.updatePropertyAssignment(node, ts.visitNode(node.name, visitor), ts.visitNode(node.initializer, visitorDestructuringTarget));
}
return ts.visitNode(node, visitor);
}
function visitAssignmentPattern(node) {
if (ts.isArrayLiteralExpression(node)) {
- return ts.updateArrayLiteral(node, ts.visitNodes(node.elements, visitArrayAssignmentTarget, ts.isExpression));
+ return factory.updateArrayLiteralExpression(node, ts.visitNodes(node.elements, visitArrayAssignmentTarget, ts.isExpression));
}
else {
- return ts.updateObjectLiteral(node, ts.visitNodes(node.properties, visitObjectAssignmentTarget, ts.isObjectLiteralElementLike));
+ return factory.updateObjectLiteralExpression(node, ts.visitNodes(node.properties, visitObjectAssignmentTarget, ts.isObjectLiteralElementLike));
}
}
}
ts.transformClassFields = transformClassFields;
function createPrivateInstanceFieldInitializer(receiver, initializer, weakMapName) {
- return ts.createCall(ts.createPropertyAccess(weakMapName, "set"), undefined, [receiver, initializer || ts.createVoidZero()]);
- }
- ts.classPrivateFieldGetHelper = {
- name: "typescript:classPrivateFieldGet",
- scoped: false,
- text: "\n var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {\n if (!privateMap.has(receiver)) {\n throw new TypeError(\"attempted to get private field on non-instance\");\n }\n return privateMap.get(receiver);\n };"
- };
- function createClassPrivateFieldGetHelper(context, receiver, privateField) {
- context.requestEmitHelper(ts.classPrivateFieldGetHelper);
- return ts.createCall(ts.getUnscopedHelperName("__classPrivateFieldGet"), undefined, [receiver, privateField]);
- }
- ts.classPrivateFieldSetHelper = {
- name: "typescript:classPrivateFieldSet",
- scoped: false,
- text: "\n var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {\n if (!privateMap.has(receiver)) {\n throw new TypeError(\"attempted to set private field on non-instance\");\n }\n privateMap.set(receiver, value);\n return value;\n };"
- };
- function createClassPrivateFieldSetHelper(context, receiver, privateField, value) {
- context.requestEmitHelper(ts.classPrivateFieldSetHelper);
- return ts.createCall(ts.getUnscopedHelperName("__classPrivateFieldSet"), undefined, [receiver, privateField, value]);
+ return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(weakMapName, "set"), undefined, [receiver, initializer || ts.factory.createVoidZero()]);
}
})(ts || (ts = {}));
var ts;
(function (ts) {
function transformES2017(context) {
- var resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
+ var factory = context.factory, emitHelpers = context.getEmitHelperFactory, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
var resolver = context.getEmitResolver();
var compilerOptions = context.getCompilerOptions();
var languageVersion = ts.getEmitScriptTarget(compilerOptions);
var previousOnSubstituteNode = context.onSubstituteNode;
context.onEmitNode = onEmitNode;
context.onSubstituteNode = onSubstituteNode;
- return ts.chainBundle(transformSourceFile);
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile) {
return node;
return node;
}
switch (node.kind) {
- case 126:
+ case 129:
return undefined;
- case 206:
+ case 213:
return visitAwaitExpression(node);
- case 161:
+ case 165:
return doWithContext(1 | 2, visitMethodDeclaration, node);
- case 244:
+ case 251:
return doWithContext(1 | 2, visitFunctionDeclaration, node);
- case 201:
+ case 208:
return doWithContext(1 | 2, visitFunctionExpression, node);
- case 202:
+ case 209:
return doWithContext(1, visitArrowFunction, node);
- case 194:
- if (capturedSuperProperties && ts.isPropertyAccessExpression(node) && node.expression.kind === 102) {
- capturedSuperProperties.set(node.name.escapedText, true);
+ case 201:
+ if (capturedSuperProperties && ts.isPropertyAccessExpression(node) && node.expression.kind === 105) {
+ capturedSuperProperties.add(node.name.escapedText);
}
return ts.visitEachChild(node, visitor, context);
- case 195:
- if (capturedSuperProperties && node.expression.kind === 102) {
+ case 202:
+ if (capturedSuperProperties && node.expression.kind === 105) {
hasSuperElementAccess = true;
}
return ts.visitEachChild(node, visitor, context);
- case 163:
- case 164:
- case 162:
- case 245:
- case 214:
+ case 167:
+ case 168:
+ case 166:
+ case 252:
+ case 221:
return doWithContext(1 | 2, visitDefault, node);
default:
return ts.visitEachChild(node, visitor, context);
function asyncBodyVisitor(node) {
if (ts.isNodeWithPossibleHoistedDeclaration(node)) {
switch (node.kind) {
- case 225:
+ case 232:
return visitVariableStatementInAsyncBody(node);
- case 230:
+ case 237:
return visitForStatementInAsyncBody(node);
- case 231:
+ case 238:
return visitForInStatementInAsyncBody(node);
- case 232:
+ case 239:
return visitForOfStatementInAsyncBody(node);
- case 280:
+ case 287:
return visitCatchClauseInAsyncBody(node);
- case 223:
- case 237:
- case 251:
- case 277:
- case 278:
- case 240:
- case 228:
- case 229:
- case 227:
+ case 230:
+ case 244:
+ case 258:
+ case 284:
+ case 285:
+ case 247:
+ case 235:
case 236:
- case 238:
+ case 234:
+ case 243:
+ case 245:
return ts.visitEachChild(node, asyncBodyVisitor, context);
default:
return ts.Debug.assertNever(node, "Unhandled node.");
return visitor(node);
}
function visitCatchClauseInAsyncBody(node) {
- var catchClauseNames = ts.createUnderscoreEscapedMap();
+ var catchClauseNames = new ts.Set();
recordDeclarationName(node.variableDeclaration, catchClauseNames);
var catchClauseUnshadowedNames;
catchClauseNames.forEach(function (_, escapedName) {
if (enclosingFunctionParameterNames.has(escapedName)) {
if (!catchClauseUnshadowedNames) {
- catchClauseUnshadowedNames = ts.cloneMap(enclosingFunctionParameterNames);
+ catchClauseUnshadowedNames = new ts.Set(enclosingFunctionParameterNames);
}
catchClauseUnshadowedNames.delete(escapedName);
}
function visitVariableStatementInAsyncBody(node) {
if (isVariableDeclarationListWithCollidingName(node.declarationList)) {
var expression = visitVariableDeclarationListWithCollidingNames(node.declarationList, false);
- return expression ? ts.createExpressionStatement(expression) : undefined;
+ return expression ? factory.createExpressionStatement(expression) : undefined;
}
return ts.visitEachChild(node, visitor, context);
}
function visitForInStatementInAsyncBody(node) {
- return ts.updateForIn(node, isVariableDeclarationListWithCollidingName(node.initializer)
+ return factory.updateForInStatement(node, isVariableDeclarationListWithCollidingName(node.initializer)
? visitVariableDeclarationListWithCollidingNames(node.initializer, true)
- : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, asyncBodyVisitor, ts.isStatement, ts.liftToBlock));
+ : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, asyncBodyVisitor, ts.isStatement, factory.liftToBlock));
}
function visitForOfStatementInAsyncBody(node) {
- return ts.updateForOf(node, ts.visitNode(node.awaitModifier, visitor, ts.isToken), isVariableDeclarationListWithCollidingName(node.initializer)
+ return factory.updateForOfStatement(node, ts.visitNode(node.awaitModifier, visitor, ts.isToken), isVariableDeclarationListWithCollidingName(node.initializer)
? visitVariableDeclarationListWithCollidingNames(node.initializer, true)
- : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, asyncBodyVisitor, ts.isStatement, ts.liftToBlock));
+ : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, asyncBodyVisitor, ts.isStatement, factory.liftToBlock));
}
function visitForStatementInAsyncBody(node) {
var initializer = node.initializer;
- return ts.updateFor(node, isVariableDeclarationListWithCollidingName(initializer)
+ return factory.updateForStatement(node, isVariableDeclarationListWithCollidingName(initializer)
? visitVariableDeclarationListWithCollidingNames(initializer, false)
- : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitNode(node.statement, asyncBodyVisitor, ts.isStatement, ts.liftToBlock));
+ : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitNode(node.statement, asyncBodyVisitor, ts.isStatement, factory.liftToBlock));
}
function visitAwaitExpression(node) {
if (inTopLevelContext()) {
return ts.visitEachChild(node, visitor, context);
}
- return ts.setOriginalNode(ts.setTextRange(ts.createYield(undefined, ts.visitNode(node.expression, visitor, ts.isExpression)), node), node);
+ return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression(undefined, ts.visitNode(node.expression, visitor, ts.isExpression)), node), node);
}
function visitMethodDeclaration(node) {
- return ts.updateMethod(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.getFunctionFlags(node) & 2
+ return factory.updateMethodDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.getFunctionFlags(node) & 2
? transformAsyncFunctionBody(node)
: ts.visitFunctionBody(node.body, visitor, context));
}
function visitFunctionDeclaration(node) {
- return ts.updateFunctionDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.getFunctionFlags(node) & 2
+ return factory.updateFunctionDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.getFunctionFlags(node) & 2
? transformAsyncFunctionBody(node)
: ts.visitFunctionBody(node.body, visitor, context));
}
function visitFunctionExpression(node) {
- return ts.updateFunctionExpression(node, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.getFunctionFlags(node) & 2
+ return factory.updateFunctionExpression(node, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, ts.getFunctionFlags(node) & 2
? transformAsyncFunctionBody(node)
: ts.visitFunctionBody(node.body, visitor, context));
}
function visitArrowFunction(node) {
- return ts.updateArrowFunction(node, ts.visitNodes(node.modifiers, visitor, ts.isModifier), undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, ts.getFunctionFlags(node) & 2
+ return factory.updateArrowFunction(node, ts.visitNodes(node.modifiers, visitor, ts.isModifier), undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, ts.getFunctionFlags(node) & 2
? transformAsyncFunctionBody(node)
: ts.visitFunctionBody(node.body, visitor, context));
}
function recordDeclarationName(_a, names) {
var name = _a.name;
if (ts.isIdentifier(name)) {
- names.set(name.escapedText, true);
+ names.add(name.escapedText);
}
else {
for (var _i = 0, _b = name.elements; _i < _b.length; _i++) {
var variables = ts.getInitializedVariables(node);
if (variables.length === 0) {
if (hasReceiver) {
- return ts.visitNode(ts.convertToAssignmentElementTarget(node.declarations[0].name), visitor, ts.isExpression);
+ return ts.visitNode(factory.converters.convertToAssignmentElementTarget(node.declarations[0].name), visitor, ts.isExpression);
}
return undefined;
}
- return ts.inlineExpressions(ts.map(variables, transformInitializedVariable));
+ return factory.inlineExpressions(ts.map(variables, transformInitializedVariable));
}
function hoistVariableDeclarationList(node) {
ts.forEach(node.declarations, hoistVariable);
}
}
function transformInitializedVariable(node) {
- var converted = ts.setSourceMapRange(ts.createAssignment(ts.convertToAssignmentElementTarget(node.name), node.initializer), node);
+ var converted = ts.setSourceMapRange(factory.createAssignment(factory.converters.convertToAssignmentElementTarget(node.name), node.initializer), node);
return ts.visitNode(converted, visitor, ts.isExpression);
}
function collidesWithParameterName(_a) {
var original = ts.getOriginalNode(node, ts.isFunctionLike);
var nodeType = original.type;
var promiseConstructor = languageVersion < 2 ? getPromiseConstructor(nodeType) : undefined;
- var isArrowFunction = node.kind === 202;
+ var isArrowFunction = node.kind === 209;
var hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 8192) !== 0;
var savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames;
- enclosingFunctionParameterNames = ts.createUnderscoreEscapedMap();
+ enclosingFunctionParameterNames = new ts.Set();
for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) {
var parameter = _a[_i];
recordDeclarationName(parameter, enclosingFunctionParameterNames);
var savedCapturedSuperProperties = capturedSuperProperties;
var savedHasSuperElementAccess = hasSuperElementAccess;
if (!isArrowFunction) {
- capturedSuperProperties = ts.createUnderscoreEscapedMap();
+ capturedSuperProperties = new ts.Set();
hasSuperElementAccess = false;
}
var result;
if (!isArrowFunction) {
var statements = [];
- var statementOffset = ts.addPrologue(statements, node.body.statements, false, visitor);
- statements.push(ts.createReturn(createAwaiterHelper(context, inHasLexicalThisContext(), hasLexicalArguments, promiseConstructor, transformAsyncFunctionBodyWorker(node.body, statementOffset))));
+ var statementOffset = factory.copyPrologue(node.body.statements, statements, false, visitor);
+ statements.push(factory.createReturnStatement(emitHelpers().createAwaiterHelper(inHasLexicalThisContext(), hasLexicalArguments, promiseConstructor, transformAsyncFunctionBodyWorker(node.body, statementOffset))));
ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
var emitSuperHelpers = languageVersion >= 2 && resolver.getNodeCheckFlags(node) & (4096 | 2048);
if (emitSuperHelpers) {
enableSubstitutionForAsyncMethodsWithSuper();
- if (ts.hasEntries(capturedSuperProperties)) {
- var variableStatement = createSuperAccessVariableStatement(resolver, node, capturedSuperProperties);
+ if (capturedSuperProperties.size) {
+ var variableStatement = createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties);
substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true;
ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]);
}
}
- var block = ts.createBlock(statements, true);
+ var block = factory.createBlock(statements, true);
ts.setTextRange(block, node.body);
if (emitSuperHelpers && hasSuperElementAccess) {
if (resolver.getNodeCheckFlags(node) & 4096) {
result = block;
}
else {
- var expression = createAwaiterHelper(context, inHasLexicalThisContext(), hasLexicalArguments, promiseConstructor, transformAsyncFunctionBodyWorker(node.body));
+ var expression = emitHelpers().createAwaiterHelper(inHasLexicalThisContext(), hasLexicalArguments, promiseConstructor, transformAsyncFunctionBodyWorker(node.body));
var declarations = endLexicalEnvironment();
if (ts.some(declarations)) {
- var block = ts.convertToFunctionBody(expression);
- result = ts.updateBlock(block, ts.setTextRange(ts.createNodeArray(ts.concatenate(declarations, block.statements)), block.statements));
+ var block = factory.converters.convertToFunctionBlock(expression);
+ result = factory.updateBlock(block, ts.setTextRange(factory.createNodeArray(ts.concatenate(declarations, block.statements)), block.statements));
}
else {
result = expression;
}
function transformAsyncFunctionBodyWorker(body, start) {
if (ts.isBlock(body)) {
- return ts.updateBlock(body, ts.visitNodes(body.statements, asyncBodyVisitor, ts.isStatement, start));
+ return factory.updateBlock(body, ts.visitNodes(body.statements, asyncBodyVisitor, ts.isStatement, start));
}
else {
- return ts.convertToFunctionBody(ts.visitNode(body, asyncBodyVisitor, ts.isConciseBody));
+ return factory.converters.convertToFunctionBlock(ts.visitNode(body, asyncBodyVisitor, ts.isConciseBody));
}
}
function getPromiseConstructor(type) {
function enableSubstitutionForAsyncMethodsWithSuper() {
if ((enabledSubstitutions & 1) === 0) {
enabledSubstitutions |= 1;
- context.enableSubstitution(196);
- context.enableSubstitution(194);
- context.enableSubstitution(195);
- context.enableEmitNotification(245);
- context.enableEmitNotification(161);
- context.enableEmitNotification(163);
- context.enableEmitNotification(164);
- context.enableEmitNotification(162);
- context.enableEmitNotification(225);
+ context.enableSubstitution(203);
+ context.enableSubstitution(201);
+ context.enableSubstitution(202);
+ context.enableEmitNotification(252);
+ context.enableEmitNotification(165);
+ context.enableEmitNotification(167);
+ context.enableEmitNotification(168);
+ context.enableEmitNotification(166);
+ context.enableEmitNotification(232);
}
}
function onEmitNode(hint, node, emitCallback) {
}
function substituteExpression(node) {
switch (node.kind) {
- case 194:
+ case 201:
return substitutePropertyAccessExpression(node);
- case 195:
+ case 202:
return substituteElementAccessExpression(node);
- case 196:
+ case 203:
return substituteCallExpression(node);
}
return node;
}
function substitutePropertyAccessExpression(node) {
- if (node.expression.kind === 102) {
- return ts.setTextRange(ts.createPropertyAccess(ts.createFileLevelUniqueName("_super"), node.name), node);
+ if (node.expression.kind === 105) {
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.createUniqueName("_super", 16 | 32), node.name), node);
}
return node;
}
function substituteElementAccessExpression(node) {
- if (node.expression.kind === 102) {
+ if (node.expression.kind === 105) {
return createSuperElementAccessInAsyncMethod(node.argumentExpression, node);
}
return node;
var argumentExpression = ts.isPropertyAccessExpression(expression)
? substitutePropertyAccessExpression(expression)
: substituteElementAccessExpression(expression);
- return ts.createCall(ts.createPropertyAccess(argumentExpression, "call"), undefined, __spreadArrays([
- ts.createThis()
+ return factory.createCallExpression(factory.createPropertyAccessExpression(argumentExpression, "call"), undefined, __spreadArrays([
+ factory.createThis()
], node.arguments));
}
return node;
}
function isSuperContainer(node) {
var kind = node.kind;
- return kind === 245
- || kind === 162
- || kind === 161
- || kind === 163
- || kind === 164;
+ return kind === 252
+ || kind === 166
+ || kind === 165
+ || kind === 167
+ || kind === 168;
}
function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
if (enclosingSuperContainerFlags & 4096) {
- return ts.setTextRange(ts.createPropertyAccess(ts.createCall(ts.createFileLevelUniqueName("_superIndex"), undefined, [argumentExpression]), "value"), location);
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createUniqueName("_superIndex", 16 | 32), undefined, [argumentExpression]), "value"), location);
}
else {
- return ts.setTextRange(ts.createCall(ts.createFileLevelUniqueName("_superIndex"), undefined, [argumentExpression]), location);
+ return ts.setTextRange(factory.createCallExpression(factory.createUniqueName("_superIndex", 16 | 32), undefined, [argumentExpression]), location);
}
}
}
ts.transformES2017 = transformES2017;
- function createSuperAccessVariableStatement(resolver, node, names) {
+ function createSuperAccessVariableStatement(factory, resolver, node, names) {
var hasBinding = (resolver.getNodeCheckFlags(node) & 4096) !== 0;
var accessors = [];
names.forEach(function (_, key) {
var name = ts.unescapeLeadingUnderscores(key);
var getterAndSetter = [];
- getterAndSetter.push(ts.createPropertyAssignment("get", ts.createArrowFunction(undefined, undefined, [], undefined, undefined, ts.setEmitFlags(ts.createPropertyAccess(ts.setEmitFlags(ts.createSuper(), 4), name), 4))));
+ getterAndSetter.push(factory.createPropertyAssignment("get", factory.createArrowFunction(undefined, undefined, [], undefined, undefined, ts.setEmitFlags(factory.createPropertyAccessExpression(ts.setEmitFlags(factory.createSuper(), 4), name), 4))));
if (hasBinding) {
- getterAndSetter.push(ts.createPropertyAssignment("set", ts.createArrowFunction(undefined, undefined, [
- ts.createParameter(undefined, undefined, undefined, "v", undefined, undefined, undefined)
- ], undefined, undefined, ts.createAssignment(ts.setEmitFlags(ts.createPropertyAccess(ts.setEmitFlags(ts.createSuper(), 4), name), 4), ts.createIdentifier("v")))));
+ getterAndSetter.push(factory.createPropertyAssignment("set", factory.createArrowFunction(undefined, undefined, [
+ factory.createParameterDeclaration(undefined, undefined, undefined, "v", undefined, undefined, undefined)
+ ], undefined, undefined, factory.createAssignment(ts.setEmitFlags(factory.createPropertyAccessExpression(ts.setEmitFlags(factory.createSuper(), 4), name), 4), factory.createIdentifier("v")))));
}
- accessors.push(ts.createPropertyAssignment(name, ts.createObjectLiteral(getterAndSetter)));
+ accessors.push(factory.createPropertyAssignment(name, factory.createObjectLiteralExpression(getterAndSetter)));
});
- return ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(ts.createFileLevelUniqueName("_super"), undefined, ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "create"), undefined, [
- ts.createNull(),
- ts.createObjectLiteral(accessors, true)
+ return factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(factory.createUniqueName("_super", 16 | 32), undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "create"), undefined, [
+ factory.createNull(),
+ factory.createObjectLiteralExpression(accessors, true)
]))
], 2));
}
ts.createSuperAccessVariableStatement = createSuperAccessVariableStatement;
- ts.awaiterHelper = {
- name: "typescript:awaiter",
- importName: "__awaiter",
- scoped: false,
- priority: 5,
- text: "\n var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n };"
- };
- function createAwaiterHelper(context, hasLexicalThis, hasLexicalArguments, promiseConstructor, body) {
- context.requestEmitHelper(ts.awaiterHelper);
- var generatorFunc = ts.createFunctionExpression(undefined, ts.createToken(41), undefined, undefined, [], undefined, body);
- (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 262144 | 524288;
- return ts.createCall(ts.getUnscopedHelperName("__awaiter"), undefined, [
- hasLexicalThis ? ts.createThis() : ts.createVoidZero(),
- hasLexicalArguments ? ts.createIdentifier("arguments") : ts.createVoidZero(),
- promiseConstructor ? ts.createExpressionFromEntityName(promiseConstructor) : ts.createVoidZero(),
- generatorFunc
- ]);
- }
- ts.asyncSuperHelper = {
- name: "typescript:async-super",
- scoped: true,
- text: ts.helperString(__makeTemplateObject(["\n const ", " = name => super[name];"], ["\n const ", " = name => super[name];"]), "_superIndex")
- };
- ts.advancedAsyncSuperHelper = {
- name: "typescript:advanced-async-super",
- scoped: true,
- text: ts.helperString(__makeTemplateObject(["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"], ["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"]), "_superIndex")
- };
})(ts || (ts = {}));
var ts;
(function (ts) {
function transformES2018(context) {
- var resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
+ var factory = context.factory, emitHelpers = context.getEmitHelperFactory, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
var resolver = context.getEmitResolver();
var compilerOptions = context.getCompilerOptions();
var languageVersion = ts.getEmitScriptTarget(compilerOptions);
var capturedSuperProperties;
var hasSuperElementAccess;
var substitutedSuperAccessors = [];
- return ts.chainBundle(transformSourceFile);
+ return ts.chainBundle(context, transformSourceFile);
function affectsSubtree(excludeFacts, includeFacts) {
return hierarchyFacts !== (hierarchyFacts & ~excludeFacts | includeFacts);
}
hierarchyFacts = ancestorFacts;
}
function recordTaggedTemplateString(temp) {
- taggedTemplateStringDeclarations = ts.append(taggedTemplateStringDeclarations, ts.createVariableDeclaration(temp));
+ taggedTemplateStringDeclarations = ts.append(taggedTemplateStringDeclarations, factory.createVariableDeclaration(temp));
}
function transformSourceFile(node) {
if (node.isDeclarationFile) {
function visitor(node) {
return visitorWorker(node, false);
}
- function visitorNoDestructuringValue(node) {
+ function visitorWithUnusedExpressionResult(node) {
return visitorWorker(node, true);
}
function visitorNoAsyncModifier(node) {
- if (node.kind === 126) {
+ if (node.kind === 129) {
return undefined;
}
return node;
function visitDefault(node) {
return ts.visitEachChild(node, visitor, context);
}
- function visitorWorker(node, noDestructuringValue) {
+ function visitorWorker(node, expressionResultIsUnused) {
if ((node.transformFlags & 32) === 0) {
return node;
}
switch (node.kind) {
- case 206:
+ case 213:
return visitAwaitExpression(node);
- case 212:
+ case 219:
return visitYieldExpression(node);
- case 235:
+ case 242:
return visitReturnStatement(node);
- case 238:
+ case 245:
return visitLabeledStatement(node);
- case 193:
+ case 200:
return visitObjectLiteralExpression(node);
- case 209:
- return visitBinaryExpression(node, noDestructuringValue);
- case 280:
+ case 216:
+ return visitBinaryExpression(node, expressionResultIsUnused);
+ case 337:
+ return visitCommaListExpression(node, expressionResultIsUnused);
+ case 287:
return visitCatchClause(node);
- case 225:
+ case 232:
return visitVariableStatement(node);
- case 242:
+ case 249:
return visitVariableDeclaration(node);
- case 228:
- case 229:
- case 231:
+ case 235:
+ case 236:
+ case 238:
return doWithHierarchyFacts(visitDefault, node, 0, 2);
- case 232:
+ case 239:
return visitForOfStatement(node, undefined);
- case 230:
+ case 237:
return doWithHierarchyFacts(visitForStatement, node, 0, 2);
- case 205:
+ case 212:
return visitVoidExpression(node);
- case 162:
+ case 166:
return doWithHierarchyFacts(visitConstructorDeclaration, node, 2, 1);
- case 161:
+ case 165:
return doWithHierarchyFacts(visitMethodDeclaration, node, 2, 1);
- case 163:
+ case 167:
return doWithHierarchyFacts(visitGetAccessorDeclaration, node, 2, 1);
- case 164:
+ case 168:
return doWithHierarchyFacts(visitSetAccessorDeclaration, node, 2, 1);
- case 244:
+ case 251:
return doWithHierarchyFacts(visitFunctionDeclaration, node, 2, 1);
- case 201:
+ case 208:
return doWithHierarchyFacts(visitFunctionExpression, node, 2, 1);
- case 202:
+ case 209:
return doWithHierarchyFacts(visitArrowFunction, node, 2, 0);
- case 156:
+ case 160:
return visitParameter(node);
- case 226:
+ case 233:
return visitExpressionStatement(node);
- case 200:
- return visitParenthesizedExpression(node, noDestructuringValue);
- case 198:
+ case 207:
+ return visitParenthesizedExpression(node, expressionResultIsUnused);
+ case 205:
return visitTaggedTemplateExpression(node);
- case 194:
- if (capturedSuperProperties && ts.isPropertyAccessExpression(node) && node.expression.kind === 102) {
- capturedSuperProperties.set(node.name.escapedText, true);
+ case 201:
+ if (capturedSuperProperties && ts.isPropertyAccessExpression(node) && node.expression.kind === 105) {
+ capturedSuperProperties.add(node.name.escapedText);
}
return ts.visitEachChild(node, visitor, context);
- case 195:
- if (capturedSuperProperties && node.expression.kind === 102) {
+ case 202:
+ if (capturedSuperProperties && node.expression.kind === 105) {
hasSuperElementAccess = true;
}
return ts.visitEachChild(node, visitor, context);
- case 245:
- case 214:
+ case 252:
+ case 221:
return doWithHierarchyFacts(visitDefault, node, 2, 1);
default:
return ts.visitEachChild(node, visitor, context);
}
function visitAwaitExpression(node) {
if (enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1) {
- return ts.setOriginalNode(ts.setTextRange(ts.createYield(createAwaitHelper(context, ts.visitNode(node.expression, visitor, ts.isExpression))), node), node);
+ return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression(undefined, emitHelpers().createAwaitHelper(ts.visitNode(node.expression, visitor, ts.isExpression))), node), node);
}
return ts.visitEachChild(node, visitor, context);
}
function visitYieldExpression(node) {
if (enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1) {
if (node.asteriskToken) {
- var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
- return ts.setOriginalNode(ts.setTextRange(ts.createYield(createAwaitHelper(context, ts.updateYield(node, node.asteriskToken, createAsyncDelegatorHelper(context, createAsyncValuesHelper(context, expression, expression), expression)))), node), node);
+ var expression = ts.visitNode(ts.Debug.assertDefined(node.expression), visitor, ts.isExpression);
+ return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression(undefined, emitHelpers().createAwaitHelper(factory.updateYieldExpression(node, node.asteriskToken, ts.setTextRange(emitHelpers().createAsyncDelegatorHelper(ts.setTextRange(emitHelpers().createAsyncValuesHelper(expression), expression)), expression)))), node), node);
}
- return ts.setOriginalNode(ts.setTextRange(ts.createYield(createDownlevelAwait(node.expression
+ return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression(undefined, createDownlevelAwait(node.expression
? ts.visitNode(node.expression, visitor, ts.isExpression)
- : ts.createVoidZero())), node), node);
+ : factory.createVoidZero())), node), node);
}
return ts.visitEachChild(node, visitor, context);
}
function visitReturnStatement(node) {
if (enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1) {
- return ts.updateReturn(node, createDownlevelAwait(node.expression ? ts.visitNode(node.expression, visitor, ts.isExpression) : ts.createVoidZero()));
+ return factory.updateReturnStatement(node, createDownlevelAwait(node.expression ? ts.visitNode(node.expression, visitor, ts.isExpression) : factory.createVoidZero()));
}
return ts.visitEachChild(node, visitor, context);
}
function visitLabeledStatement(node) {
if (enclosingFunctionFlags & 2) {
var statement = ts.unwrapInnermostStatementOfLabel(node);
- if (statement.kind === 232 && statement.awaitModifier) {
+ if (statement.kind === 239 && statement.awaitModifier) {
return visitForOfStatement(statement, node);
}
- return ts.restoreEnclosingLabel(ts.visitNode(statement, visitor, ts.isStatement, ts.liftToBlock), node);
+ return factory.restoreEnclosingLabel(ts.visitNode(statement, visitor, ts.isStatement, factory.liftToBlock), node);
}
return ts.visitEachChild(node, visitor, context);
}
var objects = [];
for (var _i = 0, elements_4 = elements; _i < elements_4.length; _i++) {
var e = elements_4[_i];
- if (e.kind === 283) {
+ if (e.kind === 290) {
if (chunkObject) {
- objects.push(ts.createObjectLiteral(chunkObject));
+ objects.push(factory.createObjectLiteralExpression(chunkObject));
chunkObject = undefined;
}
var target = e.expression;
objects.push(ts.visitNode(target, visitor, ts.isExpression));
}
else {
- chunkObject = ts.append(chunkObject, e.kind === 281
- ? ts.createPropertyAssignment(e.name, ts.visitNode(e.initializer, visitor, ts.isExpression))
+ chunkObject = ts.append(chunkObject, e.kind === 288
+ ? factory.createPropertyAssignment(e.name, ts.visitNode(e.initializer, visitor, ts.isExpression))
: ts.visitNode(e, visitor, ts.isObjectLiteralElementLike));
}
}
if (chunkObject) {
- objects.push(ts.createObjectLiteral(chunkObject));
+ objects.push(factory.createObjectLiteralExpression(chunkObject));
}
return objects;
}
function visitObjectLiteralExpression(node) {
if (node.transformFlags & 16384) {
var objects = chunkObjectLiteralElements(node.properties);
- if (objects.length && objects[0].kind !== 193) {
- objects.unshift(ts.createObjectLiteral());
+ if (objects.length && objects[0].kind !== 200) {
+ objects.unshift(factory.createObjectLiteralExpression());
}
var expression = objects[0];
if (objects.length > 1) {
for (var i = 1; i < objects.length; i++) {
- expression = createAssignHelper(context, [expression, objects[i]]);
+ expression = emitHelpers().createAssignHelper([expression, objects[i]]);
}
return expression;
}
else {
- return createAssignHelper(context, objects);
+ return emitHelpers().createAssignHelper(objects);
}
}
return ts.visitEachChild(node, visitor, context);
}
function visitExpressionStatement(node) {
- return ts.visitEachChild(node, visitorNoDestructuringValue, context);
+ return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context);
}
- function visitParenthesizedExpression(node, noDestructuringValue) {
- return ts.visitEachChild(node, noDestructuringValue ? visitorNoDestructuringValue : visitor, context);
+ function visitParenthesizedExpression(node, expressionResultIsUnused) {
+ return ts.visitEachChild(node, expressionResultIsUnused ? visitorWithUnusedExpressionResult : visitor, context);
}
function visitSourceFile(node) {
var ancestorFacts = enterSubtree(2, ts.isEffectiveStrictModeSourceFile(node, compilerOptions) ?
exportedVariableStatement = false;
var visited = ts.visitEachChild(node, visitor, context);
var statement = ts.concatenate(visited.statements, taggedTemplateStringDeclarations && [
- ts.createVariableStatement(undefined, ts.createVariableDeclarationList(taggedTemplateStringDeclarations))
+ factory.createVariableStatement(undefined, factory.createVariableDeclarationList(taggedTemplateStringDeclarations))
]);
- var result = ts.updateSourceFileNode(visited, ts.setTextRange(ts.createNodeArray(statement), node.statements));
+ var result = factory.updateSourceFile(visited, ts.setTextRange(factory.createNodeArray(statement), node.statements));
exitSubtree(ancestorFacts);
return result;
}
function visitTaggedTemplateExpression(node) {
return ts.processTaggedTemplateExpression(context, node, visitor, currentSourceFile, recordTaggedTemplateString, ts.ProcessLevel.LiftRestriction);
}
- function visitBinaryExpression(node, noDestructuringValue) {
+ function visitBinaryExpression(node, expressionResultIsUnused) {
if (ts.isDestructuringAssignment(node) && node.left.transformFlags & 16384) {
- return ts.flattenDestructuringAssignment(node, visitor, context, 1, !noDestructuringValue);
+ return ts.flattenDestructuringAssignment(node, visitor, context, 1, !expressionResultIsUnused);
}
- else if (node.operatorToken.kind === 27) {
- return ts.updateBinary(node, ts.visitNode(node.left, visitorNoDestructuringValue, ts.isExpression), ts.visitNode(node.right, noDestructuringValue ? visitorNoDestructuringValue : visitor, ts.isExpression));
+ if (node.operatorToken.kind === 27) {
+ return factory.updateBinaryExpression(node, ts.visitNode(node.left, visitorWithUnusedExpressionResult, ts.isExpression), node.operatorToken, ts.visitNode(node.right, expressionResultIsUnused ? visitorWithUnusedExpressionResult : visitor, ts.isExpression));
}
return ts.visitEachChild(node, visitor, context);
}
+ function visitCommaListExpression(node, expressionResultIsUnused) {
+ if (expressionResultIsUnused) {
+ return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context);
+ }
+ var result;
+ for (var i = 0; i < node.elements.length; i++) {
+ var element = node.elements[i];
+ var visited = ts.visitNode(element, i < node.elements.length - 1 ? visitorWithUnusedExpressionResult : visitor, ts.isExpression);
+ if (result || visited !== element) {
+ result || (result = node.elements.slice(0, i));
+ result.push(visited);
+ }
+ }
+ var elements = result ? ts.setTextRange(factory.createNodeArray(result), node.elements) : node.elements;
+ return factory.updateCommaListExpression(node, elements);
+ }
function visitCatchClause(node) {
if (node.variableDeclaration &&
ts.isBindingPattern(node.variableDeclaration.name) &&
node.variableDeclaration.name.transformFlags & 16384) {
- var name = ts.getGeneratedNameForNode(node.variableDeclaration.name);
- var updatedDecl = ts.updateVariableDeclaration(node.variableDeclaration, node.variableDeclaration.name, undefined, name);
+ var name = factory.getGeneratedNameForNode(node.variableDeclaration.name);
+ var updatedDecl = factory.updateVariableDeclaration(node.variableDeclaration, node.variableDeclaration.name, undefined, undefined, name);
var visitedBindings = ts.flattenDestructuringBinding(updatedDecl, visitor, context, 1);
var block = ts.visitNode(node.block, visitor, ts.isBlock);
if (ts.some(visitedBindings)) {
- block = ts.updateBlock(block, __spreadArrays([
- ts.createVariableStatement(undefined, visitedBindings)
+ block = factory.updateBlock(block, __spreadArrays([
+ factory.createVariableStatement(undefined, visitedBindings)
], block.statements));
}
- return ts.updateCatchClause(node, ts.updateVariableDeclaration(node.variableDeclaration, name, undefined, undefined), block);
+ return factory.updateCatchClause(node, factory.updateVariableDeclaration(node.variableDeclaration, name, undefined, undefined, undefined), block);
}
return ts.visitEachChild(node, visitor, context);
}
function visitVariableStatement(node) {
- if (ts.hasModifier(node, 1)) {
+ if (ts.hasSyntacticModifier(node, 1)) {
var savedExportedVariableStatement = exportedVariableStatement;
exportedVariableStatement = true;
var visited = ts.visitEachChild(node, visitor, context);
return ts.visitEachChild(node, visitor, context);
}
function visitForStatement(node) {
- return ts.updateFor(node, ts.visitNode(node.initializer, visitorNoDestructuringValue, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement));
+ return factory.updateForStatement(node, ts.visitNode(node.initializer, visitorWithUnusedExpressionResult, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitorWithUnusedExpressionResult, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement));
}
function visitVoidExpression(node) {
- return ts.visitEachChild(node, visitorNoDestructuringValue, context);
+ return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context);
}
function visitForOfStatement(node, outermostLabeledStatement) {
var ancestorFacts = enterSubtree(0, 2);
}
var result = node.awaitModifier ?
transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) :
- ts.restoreEnclosingLabel(ts.visitEachChild(node, visitor, context), outermostLabeledStatement);
+ factory.restoreEnclosingLabel(ts.visitEachChild(node, visitor, context), outermostLabeledStatement);
exitSubtree(ancestorFacts);
return result;
}
if (ts.isVariableDeclarationList(initializerWithoutParens) || ts.isAssignmentPattern(initializerWithoutParens)) {
var bodyLocation = void 0;
var statementsLocation = void 0;
- var temp = ts.createTempVariable(undefined);
- var statements = [ts.createForOfBindingStatement(initializerWithoutParens, temp)];
+ var temp = factory.createTempVariable(undefined);
+ var statements = [ts.createForOfBindingStatement(factory, initializerWithoutParens, temp)];
if (ts.isBlock(node.statement)) {
ts.addRange(statements, node.statement.statements);
bodyLocation = node.statement;
bodyLocation = node.statement;
statementsLocation = node.statement;
}
- return ts.updateForOf(node, node.awaitModifier, ts.setTextRange(ts.createVariableDeclarationList([
- ts.setTextRange(ts.createVariableDeclaration(temp), node.initializer)
- ], 1), node.initializer), node.expression, ts.setTextRange(ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), statementsLocation), true), bodyLocation));
+ return factory.updateForOfStatement(node, node.awaitModifier, ts.setTextRange(factory.createVariableDeclarationList([
+ ts.setTextRange(factory.createVariableDeclaration(temp), node.initializer)
+ ], 1), node.initializer), node.expression, ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), true), bodyLocation));
}
return node;
}
function convertForOfStatementHead(node, boundValue) {
- var binding = ts.createForOfBindingStatement(node.initializer, boundValue);
+ var binding = ts.createForOfBindingStatement(factory, node.initializer, boundValue);
var bodyLocation;
var statementsLocation;
var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
else {
statements.push(statement);
}
- return ts.setEmitFlags(ts.setTextRange(ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), statementsLocation), true), bodyLocation), 48 | 384);
+ return ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), true), bodyLocation), 48 | 384);
}
function createDownlevelAwait(expression) {
return enclosingFunctionFlags & 1
- ? ts.createYield(undefined, createAwaitHelper(context, expression))
- : ts.createAwait(expression);
+ ? factory.createYieldExpression(undefined, emitHelpers().createAwaitHelper(expression))
+ : factory.createAwaitExpression(expression);
}
function transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) {
var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
- var iterator = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(expression) : ts.createTempVariable(undefined);
- var result = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(iterator) : ts.createTempVariable(undefined);
- var errorRecord = ts.createUniqueName("e");
- var catchVariable = ts.getGeneratedNameForNode(errorRecord);
- var returnMethod = ts.createTempVariable(undefined);
- var callValues = createAsyncValuesHelper(context, expression, node.expression);
- var callNext = ts.createCall(ts.createPropertyAccess(iterator, "next"), undefined, []);
- var getDone = ts.createPropertyAccess(result, "done");
- var getValue = ts.createPropertyAccess(result, "value");
- var callReturn = ts.createFunctionCall(returnMethod, iterator, []);
+ var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(undefined);
+ var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(undefined);
+ var errorRecord = factory.createUniqueName("e");
+ var catchVariable = factory.getGeneratedNameForNode(errorRecord);
+ var returnMethod = factory.createTempVariable(undefined);
+ var callValues = ts.setTextRange(emitHelpers().createAsyncValuesHelper(expression), node.expression);
+ var callNext = factory.createCallExpression(factory.createPropertyAccessExpression(iterator, "next"), undefined, []);
+ var getDone = factory.createPropertyAccessExpression(result, "done");
+ var getValue = factory.createPropertyAccessExpression(result, "value");
+ var callReturn = factory.createFunctionCallCall(returnMethod, iterator, []);
hoistVariableDeclaration(errorRecord);
hoistVariableDeclaration(returnMethod);
var initializer = ancestorFacts & 2 ?
- ts.inlineExpressions([ts.createAssignment(errorRecord, ts.createVoidZero()), callValues]) :
+ factory.inlineExpressions([factory.createAssignment(errorRecord, factory.createVoidZero()), callValues]) :
callValues;
- var forStatement = ts.setEmitFlags(ts.setTextRange(ts.createFor(ts.setEmitFlags(ts.setTextRange(ts.createVariableDeclarationList([
- ts.setTextRange(ts.createVariableDeclaration(iterator, undefined, initializer), node.expression),
- ts.createVariableDeclaration(result)
- ]), node.expression), 2097152), ts.createComma(ts.createAssignment(result, createDownlevelAwait(callNext)), ts.createLogicalNot(getDone)), undefined, convertForOfStatementHead(node, getValue)), node), 256);
- return ts.createTry(ts.createBlock([
- ts.restoreEnclosingLabel(forStatement, outermostLabeledStatement)
- ]), ts.createCatchClause(ts.createVariableDeclaration(catchVariable), ts.setEmitFlags(ts.createBlock([
- ts.createExpressionStatement(ts.createAssignment(errorRecord, ts.createObjectLiteral([
- ts.createPropertyAssignment("error", catchVariable)
+ var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
+ ts.setTextRange(factory.createVariableDeclaration(iterator, undefined, undefined, initializer), node.expression),
+ factory.createVariableDeclaration(result)
+ ]), node.expression), 2097152), factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)), undefined, convertForOfStatementHead(node, getValue)), node), 256);
+ return factory.createTryStatement(factory.createBlock([
+ factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement)
+ ]), factory.createCatchClause(factory.createVariableDeclaration(catchVariable), ts.setEmitFlags(factory.createBlock([
+ factory.createExpressionStatement(factory.createAssignment(errorRecord, factory.createObjectLiteralExpression([
+ factory.createPropertyAssignment("error", catchVariable)
])))
- ]), 1)), ts.createBlock([
- ts.createTry(ts.createBlock([
- ts.setEmitFlags(ts.createIf(ts.createLogicalAnd(ts.createLogicalAnd(result, ts.createLogicalNot(getDone)), ts.createAssignment(returnMethod, ts.createPropertyAccess(iterator, "return"))), ts.createExpressionStatement(createDownlevelAwait(callReturn))), 1)
- ]), undefined, ts.setEmitFlags(ts.createBlock([
- ts.setEmitFlags(ts.createIf(errorRecord, ts.createThrow(ts.createPropertyAccess(errorRecord, "error"))), 1)
+ ]), 1)), factory.createBlock([
+ factory.createTryStatement(factory.createBlock([
+ ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(getDone)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1)
+ ]), undefined, ts.setEmitFlags(factory.createBlock([
+ ts.setEmitFlags(factory.createIfStatement(errorRecord, factory.createThrowStatement(factory.createPropertyAccessExpression(errorRecord, "error"))), 1)
]), 1))
]));
}
function visitParameter(node) {
if (node.transformFlags & 16384) {
- return ts.updateParameter(node, undefined, undefined, node.dotDotDotToken, ts.getGeneratedNameForNode(node), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression));
+ return factory.updateParameterDeclaration(node, undefined, undefined, node.dotDotDotToken, factory.getGeneratedNameForNode(node), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression));
}
return ts.visitEachChild(node, visitor, context);
}
function visitConstructorDeclaration(node) {
var savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = 0;
- var updated = ts.updateConstructor(node, undefined, node.modifiers, ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node));
+ var updated = factory.updateConstructorDeclaration(node, undefined, node.modifiers, ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node));
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitGetAccessorDeclaration(node) {
var savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = 0;
- var updated = ts.updateGetAccessor(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), undefined, transformFunctionBody(node));
+ var updated = factory.updateGetAccessorDeclaration(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), undefined, transformFunctionBody(node));
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitSetAccessorDeclaration(node) {
var savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = 0;
- var updated = ts.updateSetAccessor(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node));
+ var updated = factory.updateSetAccessorDeclaration(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node));
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitMethodDeclaration(node) {
var savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = ts.getFunctionFlags(node);
- var updated = ts.updateMethod(node, undefined, enclosingFunctionFlags & 1
+ var updated = factory.updateMethodDeclaration(node, undefined, enclosingFunctionFlags & 1
? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier)
: node.modifiers, enclosingFunctionFlags & 2
? undefined
function visitFunctionDeclaration(node) {
var savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = ts.getFunctionFlags(node);
- var updated = ts.updateFunctionDeclaration(node, undefined, enclosingFunctionFlags & 1
+ var updated = factory.updateFunctionDeclaration(node, undefined, enclosingFunctionFlags & 1
? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier)
: node.modifiers, enclosingFunctionFlags & 2
? undefined
function visitArrowFunction(node) {
var savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = ts.getFunctionFlags(node);
- var updated = ts.updateArrowFunction(node, node.modifiers, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, transformFunctionBody(node));
+ var updated = factory.updateArrowFunction(node, node.modifiers, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, transformFunctionBody(node));
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitFunctionExpression(node) {
var savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = ts.getFunctionFlags(node);
- var updated = ts.updateFunctionExpression(node, enclosingFunctionFlags & 1
+ var updated = factory.updateFunctionExpression(node, enclosingFunctionFlags & 1
? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier)
: node.modifiers, enclosingFunctionFlags & 2
? undefined
function transformAsyncGeneratorFunctionBody(node) {
resumeLexicalEnvironment();
var statements = [];
- var statementOffset = ts.addPrologue(statements, node.body.statements, false, visitor);
+ var statementOffset = factory.copyPrologue(node.body.statements, statements, false, visitor);
appendObjectRestAssignmentsIfNeeded(statements, node);
var savedCapturedSuperProperties = capturedSuperProperties;
var savedHasSuperElementAccess = hasSuperElementAccess;
- capturedSuperProperties = ts.createUnderscoreEscapedMap();
+ capturedSuperProperties = new ts.Set();
hasSuperElementAccess = false;
- var returnStatement = ts.createReturn(createAsyncGeneratorHelper(context, ts.createFunctionExpression(undefined, ts.createToken(41), node.name && ts.getGeneratedNameForNode(node.name), undefined, [], undefined, ts.updateBlock(node.body, ts.visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset))), !!(hierarchyFacts & 1)));
+ var returnStatement = factory.createReturnStatement(emitHelpers().createAsyncGeneratorHelper(factory.createFunctionExpression(undefined, factory.createToken(41), node.name && factory.getGeneratedNameForNode(node.name), undefined, [], undefined, factory.updateBlock(node.body, ts.visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset))), !!(hierarchyFacts & 1)));
var emitSuperHelpers = languageVersion >= 2 && resolver.getNodeCheckFlags(node) & (4096 | 2048);
if (emitSuperHelpers) {
enableSubstitutionForAsyncMethodsWithSuper();
- var variableStatement = ts.createSuperAccessVariableStatement(resolver, node, capturedSuperProperties);
+ var variableStatement = ts.createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties);
substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true;
ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]);
}
statements.push(returnStatement);
ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
- var block = ts.updateBlock(node.body, statements);
+ var block = factory.updateBlock(node.body, statements);
if (emitSuperHelpers && hasSuperElementAccess) {
if (resolver.getNodeCheckFlags(node) & 4096) {
ts.addEmitHelper(block, ts.advancedAsyncSuperHelper);
return block;
}
function transformFunctionBody(node) {
+ var _a;
resumeLexicalEnvironment();
var statementOffset = 0;
var statements = [];
- var body = ts.visitNode(node.body, visitor, ts.isConciseBody);
+ var body = (_a = ts.visitNode(node.body, visitor, ts.isConciseBody)) !== null && _a !== void 0 ? _a : factory.createBlock([]);
if (ts.isBlock(body)) {
- statementOffset = ts.addPrologue(statements, body.statements, false, visitor);
+ statementOffset = factory.copyPrologue(body.statements, statements, false, visitor);
}
ts.addRange(statements, appendObjectRestAssignmentsIfNeeded(undefined, node));
var leadingStatements = endLexicalEnvironment();
if (statementOffset > 0 || ts.some(statements) || ts.some(leadingStatements)) {
- var block = ts.convertToFunctionBody(body, true);
+ var block = factory.converters.convertToFunctionBlock(body, true);
ts.insertStatementsAfterStandardPrologue(statements, leadingStatements);
ts.addRange(statements, block.statements.slice(statementOffset));
- return ts.updateBlock(block, ts.setTextRange(ts.createNodeArray(statements), block.statements));
+ return factory.updateBlock(block, ts.setTextRange(factory.createNodeArray(statements), block.statements));
}
return body;
}
for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) {
var parameter = _a[_i];
if (parameter.transformFlags & 16384) {
- var temp = ts.getGeneratedNameForNode(parameter);
+ var temp = factory.getGeneratedNameForNode(parameter);
var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 1, temp, false, true);
if (ts.some(declarations)) {
- var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList(declarations));
+ var statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(declarations));
ts.setEmitFlags(statement, 1048576);
statements = ts.append(statements, statement);
}
function enableSubstitutionForAsyncMethodsWithSuper() {
if ((enabledSubstitutions & 1) === 0) {
enabledSubstitutions |= 1;
- context.enableSubstitution(196);
- context.enableSubstitution(194);
- context.enableSubstitution(195);
- context.enableEmitNotification(245);
- context.enableEmitNotification(161);
- context.enableEmitNotification(163);
- context.enableEmitNotification(164);
- context.enableEmitNotification(162);
- context.enableEmitNotification(225);
+ context.enableSubstitution(203);
+ context.enableSubstitution(201);
+ context.enableSubstitution(202);
+ context.enableEmitNotification(252);
+ context.enableEmitNotification(165);
+ context.enableEmitNotification(167);
+ context.enableEmitNotification(168);
+ context.enableEmitNotification(166);
+ context.enableEmitNotification(232);
}
}
function onEmitNode(hint, node, emitCallback) {
}
function substituteExpression(node) {
switch (node.kind) {
- case 194:
+ case 201:
return substitutePropertyAccessExpression(node);
- case 195:
+ case 202:
return substituteElementAccessExpression(node);
- case 196:
+ case 203:
return substituteCallExpression(node);
}
return node;
}
function substitutePropertyAccessExpression(node) {
- if (node.expression.kind === 102) {
- return ts.setTextRange(ts.createPropertyAccess(ts.createFileLevelUniqueName("_super"), node.name), node);
+ if (node.expression.kind === 105) {
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.createUniqueName("_super", 16 | 32), node.name), node);
}
return node;
}
function substituteElementAccessExpression(node) {
- if (node.expression.kind === 102) {
+ if (node.expression.kind === 105) {
return createSuperElementAccessInAsyncMethod(node.argumentExpression, node);
}
return node;
var argumentExpression = ts.isPropertyAccessExpression(expression)
? substitutePropertyAccessExpression(expression)
: substituteElementAccessExpression(expression);
- return ts.createCall(ts.createPropertyAccess(argumentExpression, "call"), undefined, __spreadArrays([
- ts.createThis()
+ return factory.createCallExpression(factory.createPropertyAccessExpression(argumentExpression, "call"), undefined, __spreadArrays([
+ factory.createThis()
], node.arguments));
}
return node;
}
function isSuperContainer(node) {
var kind = node.kind;
- return kind === 245
- || kind === 162
- || kind === 161
- || kind === 163
- || kind === 164;
+ return kind === 252
+ || kind === 166
+ || kind === 165
+ || kind === 167
+ || kind === 168;
}
function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
if (enclosingSuperContainerFlags & 4096) {
- return ts.setTextRange(ts.createPropertyAccess(ts.createCall(ts.createIdentifier("_superIndex"), undefined, [argumentExpression]), "value"), location);
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createIdentifier("_superIndex"), undefined, [argumentExpression]), "value"), location);
}
else {
- return ts.setTextRange(ts.createCall(ts.createIdentifier("_superIndex"), undefined, [argumentExpression]), location);
+ return ts.setTextRange(factory.createCallExpression(factory.createIdentifier("_superIndex"), undefined, [argumentExpression]), location);
}
}
}
ts.transformES2018 = transformES2018;
- ts.assignHelper = {
- name: "typescript:assign",
- importName: "__assign",
- scoped: false,
- priority: 1,
- text: "\n var __assign = (this && this.__assign) || function () {\n __assign = Object.assign || function(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n t[p] = s[p];\n }\n return t;\n };\n return __assign.apply(this, arguments);\n };"
- };
- function createAssignHelper(context, attributesSegments) {
- if (context.getCompilerOptions().target >= 2) {
- return ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "assign"), undefined, attributesSegments);
- }
- context.requestEmitHelper(ts.assignHelper);
- return ts.createCall(ts.getUnscopedHelperName("__assign"), undefined, attributesSegments);
- }
- ts.createAssignHelper = createAssignHelper;
- ts.awaitHelper = {
- name: "typescript:await",
- importName: "__await",
- scoped: false,
- text: "\n var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }"
- };
- function createAwaitHelper(context, expression) {
- context.requestEmitHelper(ts.awaitHelper);
- return ts.createCall(ts.getUnscopedHelperName("__await"), undefined, [expression]);
- }
- ts.asyncGeneratorHelper = {
- name: "typescript:asyncGenerator",
- importName: "__asyncGenerator",
- scoped: false,
- dependencies: [ts.awaitHelper],
- text: "\n var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n function fulfill(value) { resume(\"next\", value); }\n function reject(value) { resume(\"throw\", value); }\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n };"
- };
- function createAsyncGeneratorHelper(context, generatorFunc, hasLexicalThis) {
- context.requestEmitHelper(ts.asyncGeneratorHelper);
- (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 262144 | 524288;
- return ts.createCall(ts.getUnscopedHelperName("__asyncGenerator"), undefined, [
- hasLexicalThis ? ts.createThis() : ts.createVoidZero(),
- ts.createIdentifier("arguments"),
- generatorFunc
- ]);
- }
- ts.asyncDelegator = {
- name: "typescript:asyncDelegator",
- importName: "__asyncDelegator",
- scoped: false,
- dependencies: [ts.awaitHelper],
- text: "\n var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {\n var i, p;\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\n };"
- };
- function createAsyncDelegatorHelper(context, expression, location) {
- context.requestEmitHelper(ts.asyncDelegator);
- return ts.setTextRange(ts.createCall(ts.getUnscopedHelperName("__asyncDelegator"), undefined, [expression]), location);
- }
- ts.asyncValues = {
- name: "typescript:asyncValues",
- importName: "__asyncValues",
- scoped: false,
- text: "\n var __asyncValues = (this && this.__asyncValues) || function (o) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var m = o[Symbol.asyncIterator], i;\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n };"
- };
- function createAsyncValuesHelper(context, expression, location) {
- context.requestEmitHelper(ts.asyncValues);
- return ts.setTextRange(ts.createCall(ts.getUnscopedHelperName("__asyncValues"), undefined, [expression]), location);
- }
})(ts || (ts = {}));
var ts;
(function (ts) {
function transformES2019(context) {
- return ts.chainBundle(transformSourceFile);
+ var factory = context.factory;
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile) {
return node;
return node;
}
switch (node.kind) {
- case 280:
+ case 287:
return visitCatchClause(node);
default:
return ts.visitEachChild(node, visitor, context);
}
function visitCatchClause(node) {
if (!node.variableDeclaration) {
- return ts.updateCatchClause(node, ts.createVariableDeclaration(ts.createTempVariable(undefined)), ts.visitNode(node.block, visitor, ts.isBlock));
+ return factory.updateCatchClause(node, factory.createVariableDeclaration(factory.createTempVariable(undefined)), ts.visitNode(node.block, visitor, ts.isBlock));
}
return ts.visitEachChild(node, visitor, context);
}
var ts;
(function (ts) {
function transformES2020(context) {
- var hoistVariableDeclaration = context.hoistVariableDeclaration;
- return ts.chainBundle(transformSourceFile);
+ var factory = context.factory, hoistVariableDeclaration = context.hoistVariableDeclaration;
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile) {
return node;
return node;
}
switch (node.kind) {
- case 194:
- case 195:
- case 196:
+ case 201:
+ case 202:
+ case 203:
if (node.flags & 32) {
var updated = visitOptionalExpression(node, false, false);
ts.Debug.assertNotNode(updated, ts.isSyntheticReference);
return updated;
}
return ts.visitEachChild(node, visitor, context);
- case 209:
+ case 216:
if (node.operatorToken.kind === 60) {
return transformNullishCoalescingExpression(node);
}
return ts.visitEachChild(node, visitor, context);
- case 203:
+ case 210:
return visitDeleteExpression(node);
default:
return ts.visitEachChild(node, visitor, context);
function visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete) {
var expression = visitNonOptionalExpression(node.expression, captureThisArg, isDelete);
if (ts.isSyntheticReference(expression)) {
- return ts.createSyntheticReferenceExpression(ts.updateParen(node, expression.expression), expression.thisArg);
+ return factory.createSyntheticReferenceExpression(factory.updateParenthesizedExpression(node, expression.expression), expression.thisArg);
}
- return ts.updateParen(node, expression);
+ return factory.updateParenthesizedExpression(node, expression);
}
function visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete) {
if (ts.isOptionalChain(node)) {
ts.Debug.assertNotNode(expression, ts.isSyntheticReference);
var thisArg;
if (captureThisArg) {
- if (shouldCaptureInTempVariable(expression)) {
- thisArg = ts.createTempVariable(hoistVariableDeclaration);
- expression = ts.createAssignment(thisArg, expression);
+ if (!ts.isSimpleCopiableExpression(expression)) {
+ thisArg = factory.createTempVariable(hoistVariableDeclaration);
+ expression = factory.createAssignment(thisArg, expression);
}
else {
thisArg = expression;
}
}
- expression = node.kind === 194
- ? ts.updatePropertyAccess(node, expression, ts.visitNode(node.name, visitor, ts.isIdentifier))
- : ts.updateElementAccess(node, expression, ts.visitNode(node.argumentExpression, visitor, ts.isExpression));
- return thisArg ? ts.createSyntheticReferenceExpression(expression, thisArg) : expression;
+ expression = node.kind === 201
+ ? factory.updatePropertyAccessExpression(node, expression, ts.visitNode(node.name, visitor, ts.isIdentifier))
+ : factory.updateElementAccessExpression(node, expression, ts.visitNode(node.argumentExpression, visitor, ts.isExpression));
+ return thisArg ? factory.createSyntheticReferenceExpression(expression, thisArg) : expression;
}
function visitNonOptionalCallExpression(node, captureThisArg) {
if (ts.isOptionalChain(node)) {
}
function visitNonOptionalExpression(node, captureThisArg, isDelete) {
switch (node.kind) {
- case 200: return visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete);
- case 194:
- case 195: return visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete);
- case 196: return visitNonOptionalCallExpression(node, captureThisArg);
+ case 207: return visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete);
+ case 201:
+ case 202: return visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete);
+ case 203: return visitNonOptionalCallExpression(node, captureThisArg);
default: return ts.visitNode(node, visitor, ts.isExpression);
}
}
var leftThisArg = ts.isSyntheticReference(left) ? left.thisArg : undefined;
var leftExpression = ts.isSyntheticReference(left) ? left.expression : left;
var capturedLeft = leftExpression;
- if (shouldCaptureInTempVariable(leftExpression)) {
- capturedLeft = ts.createTempVariable(hoistVariableDeclaration);
- leftExpression = ts.createAssignment(capturedLeft, leftExpression);
+ if (!ts.isSimpleCopiableExpression(leftExpression)) {
+ capturedLeft = factory.createTempVariable(hoistVariableDeclaration);
+ leftExpression = factory.createAssignment(capturedLeft, leftExpression);
}
var rightExpression = capturedLeft;
var thisArg;
for (var i = 0; i < chain.length; i++) {
var segment = chain[i];
switch (segment.kind) {
- case 194:
- case 195:
+ case 201:
+ case 202:
if (i === chain.length - 1 && captureThisArg) {
- if (shouldCaptureInTempVariable(rightExpression)) {
- thisArg = ts.createTempVariable(hoistVariableDeclaration);
- rightExpression = ts.createAssignment(thisArg, rightExpression);
+ if (!ts.isSimpleCopiableExpression(rightExpression)) {
+ thisArg = factory.createTempVariable(hoistVariableDeclaration);
+ rightExpression = factory.createAssignment(thisArg, rightExpression);
}
else {
thisArg = rightExpression;
}
}
- rightExpression = segment.kind === 194
- ? ts.createPropertyAccess(rightExpression, ts.visitNode(segment.name, visitor, ts.isIdentifier))
- : ts.createElementAccess(rightExpression, ts.visitNode(segment.argumentExpression, visitor, ts.isExpression));
+ rightExpression = segment.kind === 201
+ ? factory.createPropertyAccessExpression(rightExpression, ts.visitNode(segment.name, visitor, ts.isIdentifier))
+ : factory.createElementAccessExpression(rightExpression, ts.visitNode(segment.argumentExpression, visitor, ts.isExpression));
break;
- case 196:
+ case 203:
if (i === 0 && leftThisArg) {
- rightExpression = ts.createFunctionCall(rightExpression, leftThisArg.kind === 102 ? ts.createThis() : leftThisArg, ts.visitNodes(segment.arguments, visitor, ts.isExpression));
+ rightExpression = factory.createFunctionCallCall(rightExpression, leftThisArg.kind === 105 ? factory.createThis() : leftThisArg, ts.visitNodes(segment.arguments, visitor, ts.isExpression));
}
else {
- rightExpression = ts.createCall(rightExpression, undefined, ts.visitNodes(segment.arguments, visitor, ts.isExpression));
+ rightExpression = factory.createCallExpression(rightExpression, undefined, ts.visitNodes(segment.arguments, visitor, ts.isExpression));
}
break;
}
ts.setOriginalNode(rightExpression, segment);
}
var target = isDelete
- ? ts.createConditional(createNotNullCondition(leftExpression, capturedLeft, true), ts.createTrue(), ts.createDelete(rightExpression))
- : ts.createConditional(createNotNullCondition(leftExpression, capturedLeft, true), ts.createVoidZero(), rightExpression);
- return thisArg ? ts.createSyntheticReferenceExpression(target, thisArg) : target;
+ ? factory.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, true), undefined, factory.createTrue(), undefined, factory.createDeleteExpression(rightExpression))
+ : factory.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, true), undefined, factory.createVoidZero(), undefined, rightExpression);
+ return thisArg ? factory.createSyntheticReferenceExpression(target, thisArg) : target;
}
function createNotNullCondition(left, right, invert) {
- return ts.createBinary(ts.createBinary(left, ts.createToken(invert ? 36 : 37), ts.createNull()), ts.createToken(invert ? 56 : 55), ts.createBinary(right, ts.createToken(invert ? 36 : 37), ts.createVoidZero()));
+ return factory.createBinaryExpression(factory.createBinaryExpression(left, factory.createToken(invert ? 36 : 37), factory.createNull()), factory.createToken(invert ? 56 : 55), factory.createBinaryExpression(right, factory.createToken(invert ? 36 : 37), factory.createVoidZero()));
}
function transformNullishCoalescingExpression(node) {
var left = ts.visitNode(node.left, visitor, ts.isExpression);
var right = left;
- if (shouldCaptureInTempVariable(left)) {
- right = ts.createTempVariable(hoistVariableDeclaration);
- left = ts.createAssignment(right, left);
+ if (!ts.isSimpleCopiableExpression(left)) {
+ right = factory.createTempVariable(hoistVariableDeclaration);
+ left = factory.createAssignment(right, left);
}
- return ts.createConditional(createNotNullCondition(left, right), right, ts.visitNode(node.right, visitor, ts.isExpression));
- }
- function shouldCaptureInTempVariable(expression) {
- return !ts.isIdentifier(expression) &&
- expression.kind !== 104 &&
- expression.kind !== 102;
+ return factory.createConditionalExpression(createNotNullCondition(left, right), undefined, right, undefined, ts.visitNode(node.right, visitor, ts.isExpression));
}
function visitDeleteExpression(node) {
return ts.isOptionalChain(ts.skipParentheses(node.expression))
? ts.setOriginalNode(visitNonOptionalExpression(node.expression, false, true), node)
- : ts.updateDelete(node, ts.visitNode(node.expression, visitor, ts.isExpression));
+ : factory.updateDeleteExpression(node, ts.visitNode(node.expression, visitor, ts.isExpression));
}
}
ts.transformES2020 = transformES2020;
var ts;
(function (ts) {
function transformESNext(context) {
- return ts.chainBundle(transformSourceFile);
+ var hoistVariableDeclaration = context.hoistVariableDeclaration, factory = context.factory;
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile) {
return node;
return node;
}
switch (node.kind) {
+ case 216:
+ var binaryExpression = node;
+ if (ts.isLogicalOrCoalescingAssignmentExpression(binaryExpression)) {
+ return transformLogicalAssignment(binaryExpression);
+ }
default:
return ts.visitEachChild(node, visitor, context);
}
}
+ function transformLogicalAssignment(binaryExpression) {
+ var operator = binaryExpression.operatorToken;
+ var nonAssignmentOperator = ts.getNonAssignmentOperatorForCompoundAssignment(operator.kind);
+ var left = ts.skipParentheses(ts.visitNode(binaryExpression.left, visitor, ts.isLeftHandSideExpression));
+ var assignmentTarget = left;
+ var right = ts.skipParentheses(ts.visitNode(binaryExpression.right, visitor, ts.isExpression));
+ if (ts.isAccessExpression(left)) {
+ var propertyAccessTargetSimpleCopiable = ts.isSimpleCopiableExpression(left.expression);
+ var propertyAccessTarget = propertyAccessTargetSimpleCopiable ? left.expression :
+ factory.createTempVariable(hoistVariableDeclaration);
+ var propertyAccessTargetAssignment = propertyAccessTargetSimpleCopiable ? left.expression : factory.createAssignment(propertyAccessTarget, left.expression);
+ if (ts.isPropertyAccessExpression(left)) {
+ assignmentTarget = factory.createPropertyAccessExpression(propertyAccessTarget, left.name);
+ left = factory.createPropertyAccessExpression(propertyAccessTargetAssignment, left.name);
+ }
+ else {
+ var elementAccessArgumentSimpleCopiable = ts.isSimpleCopiableExpression(left.argumentExpression);
+ var elementAccessArgument = elementAccessArgumentSimpleCopiable ? left.argumentExpression :
+ factory.createTempVariable(hoistVariableDeclaration);
+ assignmentTarget = factory.createElementAccessExpression(propertyAccessTarget, elementAccessArgument);
+ left = factory.createElementAccessExpression(propertyAccessTargetAssignment, elementAccessArgumentSimpleCopiable ? left.argumentExpression : factory.createAssignment(elementAccessArgument, left.argumentExpression));
+ }
+ }
+ return factory.createBinaryExpression(left, nonAssignmentOperator, factory.createParenthesizedExpression(factory.createAssignment(assignmentTarget, right)));
+ }
}
ts.transformESNext = transformESNext;
})(ts || (ts = {}));
var ts;
(function (ts) {
function transformJsx(context) {
+ var factory = context.factory, emitHelpers = context.getEmitHelperFactory;
var compilerOptions = context.getCompilerOptions();
var currentSourceFile;
- return ts.chainBundle(transformSourceFile);
+ var currentFileState;
+ return ts.chainBundle(context, transformSourceFile);
+ function getCurrentFileNameExpression() {
+ if (currentFileState.filenameDeclaration) {
+ return currentFileState.filenameDeclaration.name;
+ }
+ var declaration = factory.createVariableDeclaration(factory.createUniqueName("_jsxFileName", 16 | 32), undefined, undefined, factory.createStringLiteral(currentSourceFile.fileName));
+ currentFileState.filenameDeclaration = declaration;
+ return currentFileState.filenameDeclaration.name;
+ }
+ function getJsxFactoryCalleePrimitive(childrenLength) {
+ return compilerOptions.jsx === 5 ? "jsxDEV" : childrenLength > 1 ? "jsxs" : "jsx";
+ }
+ function getJsxFactoryCallee(childrenLength) {
+ var type = getJsxFactoryCalleePrimitive(childrenLength);
+ return getImplicitImportForName(type);
+ }
+ function getImplicitJsxFragmentReference() {
+ return getImplicitImportForName("Fragment");
+ }
+ function getImplicitImportForName(name) {
+ var _a, _b;
+ var importSource = name === "createElement"
+ ? currentFileState.importSpecifier
+ : ts.getJSXRuntimeImport(currentFileState.importSpecifier, compilerOptions);
+ var existing = (_b = (_a = currentFileState.utilizedImplicitRuntimeImports) === null || _a === void 0 ? void 0 : _a.get(importSource)) === null || _b === void 0 ? void 0 : _b.get(name);
+ if (existing) {
+ return existing.name;
+ }
+ if (!currentFileState.utilizedImplicitRuntimeImports) {
+ currentFileState.utilizedImplicitRuntimeImports = ts.createMap();
+ }
+ var specifierSourceImports = currentFileState.utilizedImplicitRuntimeImports.get(importSource);
+ if (!specifierSourceImports) {
+ specifierSourceImports = ts.createMap();
+ currentFileState.utilizedImplicitRuntimeImports.set(importSource, specifierSourceImports);
+ }
+ var generatedName = factory.createUniqueName("_" + name, 16 | 32 | 64);
+ var specifier = factory.createImportSpecifier(factory.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 = ts.getJSXImplicitImportBase(compilerOptions, node);
var visited = ts.visitEachChild(node, visitor, context);
ts.addEmitHelpers(visited, context.readEmitHelpers());
+ var statements = visited.statements;
+ if (currentFileState.filenameDeclaration) {
+ statements = ts.insertStatementAfterCustomPrologue(statements.slice(), factory.createVariableStatement(undefined, factory.createVariableDeclarationList([currentFileState.filenameDeclaration], 2)));
+ }
+ if (currentFileState.utilizedImplicitRuntimeImports) {
+ for (var _i = 0, _a = ts.arrayFrom(currentFileState.utilizedImplicitRuntimeImports.entries()); _i < _a.length; _i++) {
+ var _b = _a[_i], importSource = _b[0], importSpecifiersMap = _b[1];
+ if (ts.isExternalModule(node)) {
+ var importStatement = factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports(ts.arrayFrom(importSpecifiersMap.values()))), factory.createStringLiteral(importSource));
+ ts.setParentRecursive(importStatement, false);
+ statements = ts.insertStatementAfterCustomPrologue(statements.slice(), importStatement);
+ }
+ else if (ts.isExternalOrCommonJsModule(node)) {
+ var requireStatement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(factory.createObjectBindingPattern(ts.map(ts.arrayFrom(importSpecifiersMap.values()), function (s) { return factory.createBindingElement(undefined, s.propertyName, s.name); })), undefined, undefined, factory.createCallExpression(factory.createIdentifier("require"), undefined, [factory.createStringLiteral(importSource)]))
+ ], 2));
+ ts.setParentRecursive(requireStatement, false);
+ statements = ts.insertStatementAfterCustomPrologue(statements.slice(), requireStatement);
+ }
+ else {
+ }
+ }
+ }
+ if (statements !== visited.statements) {
+ visited = factory.updateSourceFile(visited, statements);
+ }
+ currentFileState = undefined;
return visited;
}
function visitor(node) {
}
function visitorWorker(node) {
switch (node.kind) {
- case 266:
+ case 273:
return visitJsxElement(node, false);
- case 267:
+ case 274:
return visitJsxSelfClosingElement(node, false);
- case 270:
+ case 277:
return visitJsxFragment(node, false);
- case 276:
+ case 283:
return visitJsxExpression(node);
default:
return ts.visitEachChild(node, visitor, context);
switch (node.kind) {
case 11:
return visitJsxText(node);
- case 276:
+ case 283:
return visitJsxExpression(node);
- case 266:
+ case 273:
return visitJsxElement(node, true);
- case 267:
+ case 274:
return visitJsxSelfClosingElement(node, true);
- case 270:
+ case 277:
return visitJsxFragment(node, true);
default:
return ts.Debug.failBadSyntaxKind(node);
}
}
+ function hasKeyAfterPropsSpread(node) {
+ var spread = false;
+ for (var _i = 0, _a = node.attributes.properties; _i < _a.length; _i++) {
+ var elem = _a[_i];
+ if (ts.isJsxSpreadAttribute(elem)) {
+ spread = true;
+ }
+ else if (spread && ts.isJsxAttribute(elem) && elem.name.escapedText === "key") {
+ return true;
+ }
+ }
+ return false;
+ }
+ function shouldUseCreateElement(node) {
+ return currentFileState.importSpecifier === undefined || hasKeyAfterPropsSpread(node);
+ }
function visitJsxElement(node, isChild) {
- return visitJsxOpeningLikeElement(node.openingElement, node.children, isChild, node);
+ var tagTransform = shouldUseCreateElement(node.openingElement) ? visitJsxOpeningLikeElementCreateElement : visitJsxOpeningLikeElementJSX;
+ return tagTransform(node.openingElement, node.children, isChild, node);
}
function visitJsxSelfClosingElement(node, isChild) {
- return visitJsxOpeningLikeElement(node, undefined, isChild, node);
+ var tagTransform = shouldUseCreateElement(node) ? visitJsxOpeningLikeElementCreateElement : visitJsxOpeningLikeElementJSX;
+ return tagTransform(node, undefined, isChild, node);
}
function visitJsxFragment(node, isChild) {
- return visitJsxOpeningFragment(node.openingFragment, node.children, isChild, node);
+ var tagTransform = currentFileState.importSpecifier === undefined ? visitJsxOpeningFragmentCreateElement : visitJsxOpeningFragmentJSX;
+ return tagTransform(node.openingFragment, node.children, isChild, node);
+ }
+ function convertJsxChildrenToChildrenPropObject(children) {
+ var nonWhitespaceChildren = ts.getSemanticJsxChildren(children);
+ if (ts.length(nonWhitespaceChildren) === 1) {
+ var result_13 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
+ return result_13 && factory.createObjectLiteralExpression([
+ factory.createPropertyAssignment("children", result_13)
+ ]);
+ }
+ var result = ts.mapDefined(children, transformJsxChildToExpression);
+ return !result.length ? undefined : factory.createObjectLiteralExpression([
+ factory.createPropertyAssignment("children", factory.createArrayLiteralExpression(result))
+ ]);
}
- function visitJsxOpeningLikeElement(node, children, isChild, location) {
+ function visitJsxOpeningLikeElementJSX(node, children, isChild, location) {
+ var tagName = getTagName(node);
+ var objectProperties;
+ var keyAttr = ts.find(node.attributes.properties, function (p) { return !!p.name && ts.isIdentifier(p.name) && p.name.escapedText === "key"; });
+ var attrs = keyAttr ? ts.filter(node.attributes.properties, function (p) { return p !== keyAttr; }) : node.attributes.properties;
+ var segments = [];
+ if (attrs.length) {
+ segments = ts.flatten(ts.spanMap(attrs, ts.isJsxSpreadAttribute, function (attrs, isSpread) { return isSpread
+ ? ts.map(attrs, transformJsxSpreadAttributeToExpression)
+ : factory.createObjectLiteralExpression(ts.map(attrs, transformJsxAttributeToObjectLiteralElement)); }));
+ if (ts.isJsxSpreadAttribute(attrs[0])) {
+ segments.unshift(factory.createObjectLiteralExpression());
+ }
+ }
+ if (children && children.length) {
+ var result = convertJsxChildrenToChildrenPropObject(children);
+ if (result) {
+ segments.push(result);
+ }
+ }
+ if (segments.length === 0) {
+ objectProperties = factory.createObjectLiteralExpression([]);
+ }
+ else {
+ objectProperties = ts.singleOrUndefined(segments) || emitHelpers().createAssignHelper(segments);
+ }
+ return visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, ts.length(ts.getSemanticJsxChildren(children || ts.emptyArray)), isChild, location);
+ }
+ function visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, childrenLength, isChild, location) {
+ var args = [tagName, objectProperties, !keyAttr ? factory.createVoidZero() : transformJsxAttributeInitializer(keyAttr.initializer)];
+ if (compilerOptions.jsx === 5) {
+ var originalFile = ts.getOriginalNode(currentSourceFile);
+ if (originalFile && ts.isSourceFile(originalFile)) {
+ args.push(childrenLength > 1 ? factory.createTrue() : factory.createFalse());
+ var lineCol = ts.getLineAndCharacterOfPosition(originalFile, location.pos);
+ args.push(factory.createObjectLiteralExpression([
+ factory.createPropertyAssignment("fileName", getCurrentFileNameExpression()),
+ factory.createPropertyAssignment("lineNumber", factory.createNumericLiteral(lineCol.line + 1)),
+ factory.createPropertyAssignment("columnNumber", factory.createNumericLiteral(lineCol.character + 1))
+ ]));
+ args.push(factory.createThis());
+ }
+ }
+ var element = ts.setTextRange(factory.createCallExpression(getJsxFactoryCallee(childrenLength), undefined, args), location);
+ if (isChild) {
+ ts.startOnNewLine(element);
+ }
+ return element;
+ }
+ function visitJsxOpeningLikeElementCreateElement(node, children, isChild, location) {
var tagName = getTagName(node);
var objectProperties;
var attrs = node.attributes.properties;
if (attrs.length === 0) {
- objectProperties = ts.createNull();
+ objectProperties = factory.createNull();
}
else {
var segments = ts.flatten(ts.spanMap(attrs, ts.isJsxSpreadAttribute, function (attrs, isSpread) { return isSpread
? ts.map(attrs, transformJsxSpreadAttributeToExpression)
- : ts.createObjectLiteral(ts.map(attrs, transformJsxAttributeToObjectLiteralElement)); }));
+ : factory.createObjectLiteralExpression(ts.map(attrs, transformJsxAttributeToObjectLiteralElement)); }));
if (ts.isJsxSpreadAttribute(attrs[0])) {
- segments.unshift(ts.createObjectLiteral());
+ segments.unshift(factory.createObjectLiteralExpression());
}
objectProperties = ts.singleOrUndefined(segments);
if (!objectProperties) {
- objectProperties = ts.createAssignHelper(context, segments);
+ objectProperties = emitHelpers().createAssignHelper(segments);
}
}
- var element = ts.createExpressionForJsxElement(context.getEmitResolver().getJsxFactoryEntity(currentSourceFile), compilerOptions.reactNamespace, tagName, objectProperties, ts.mapDefined(children, transformJsxChildToExpression), node, location);
+ var callee = currentFileState.importSpecifier === undefined
+ ? ts.createJsxFactoryExpression(factory, context.getEmitResolver().getJsxFactoryEntity(currentSourceFile), compilerOptions.reactNamespace, node)
+ : getImplicitImportForName("createElement");
+ var element = ts.createExpressionForJsxElement(factory, callee, tagName, objectProperties, ts.mapDefined(children, transformJsxChildToExpression), location);
if (isChild) {
ts.startOnNewLine(element);
}
return element;
}
- function visitJsxOpeningFragment(node, children, isChild, location) {
- var element = ts.createExpressionForJsxFragment(context.getEmitResolver().getJsxFactoryEntity(currentSourceFile), compilerOptions.reactNamespace, ts.mapDefined(children, transformJsxChildToExpression), node, location);
+ function visitJsxOpeningFragmentJSX(_node, children, isChild, location) {
+ var childrenProps;
+ if (children && children.length) {
+ var result = convertJsxChildrenToChildrenPropObject(children);
+ if (result) {
+ childrenProps = result;
+ }
+ }
+ return visitJsxOpeningLikeElementOrFragmentJSX(getImplicitJsxFragmentReference(), childrenProps || factory.createObjectLiteralExpression([]), undefined, ts.length(ts.getSemanticJsxChildren(children)), isChild, location);
+ }
+ function visitJsxOpeningFragmentCreateElement(node, children, isChild, location) {
+ var element = ts.createExpressionForJsxFragment(factory, context.getEmitResolver().getJsxFactoryEntity(currentSourceFile), context.getEmitResolver().getJsxFragmentFactoryEntity(currentSourceFile), compilerOptions.reactNamespace, ts.mapDefined(children, transformJsxChildToExpression), node, location);
if (isChild) {
ts.startOnNewLine(element);
}
function transformJsxAttributeToObjectLiteralElement(node) {
var name = getAttributeName(node);
var expression = transformJsxAttributeInitializer(node.initializer);
- return ts.createPropertyAssignment(name, expression);
+ return factory.createPropertyAssignment(name, expression);
}
function transformJsxAttributeInitializer(node) {
if (node === undefined) {
- return ts.createTrue();
+ return factory.createTrue();
}
else if (node.kind === 10) {
- var literal = ts.createLiteral(tryDecodeEntities(node.text) || node.text);
- literal.singleQuote = node.singleQuote !== undefined ? node.singleQuote : !ts.isStringDoubleQuoted(node, currentSourceFile);
+ var singleQuote = node.singleQuote !== undefined ? node.singleQuote : !ts.isStringDoubleQuoted(node, currentSourceFile);
+ var literal = factory.createStringLiteral(tryDecodeEntities(node.text) || node.text, singleQuote);
return ts.setTextRange(literal, node);
}
- else if (node.kind === 276) {
+ else if (node.kind === 283) {
if (node.expression === undefined) {
- return ts.createTrue();
+ return factory.createTrue();
}
- return visitJsxExpression(node);
+ return ts.visitNode(node.expression, visitor, ts.isExpression);
}
else {
return ts.Debug.failBadSyntaxKind(node);
}
function visitJsxText(node) {
var fixed = fixupWhitespaceAndDecodeEntities(node.text);
- return fixed === undefined ? undefined : ts.createLiteral(fixed);
+ return fixed === undefined ? undefined : factory.createStringLiteral(fixed);
}
function fixupWhitespaceAndDecodeEntities(text) {
var acc;
return decoded === text ? undefined : decoded;
}
function getTagName(node) {
- if (node.kind === 266) {
+ if (node.kind === 273) {
return getTagName(node.openingElement);
}
else {
var name = node.tagName;
if (ts.isIdentifier(name) && ts.isIntrinsicJsxName(name.escapedText)) {
- return ts.createLiteral(ts.idText(name));
+ return factory.createStringLiteral(ts.idText(name));
}
else {
- return ts.createExpressionFromEntityName(name);
+ return ts.createExpressionFromEntityName(factory, name);
}
}
}
return name;
}
else {
- return ts.createLiteral(text);
+ return factory.createStringLiteral(text);
}
}
function visitJsxExpression(node) {
}
}
ts.transformJsx = transformJsx;
- var entities = ts.createMapFromTemplate({
+ var entities = new ts.Map(ts.getEntries({
quot: 0x0022,
amp: 0x0026,
apos: 0x0027,
clubs: 0x2663,
hearts: 0x2665,
diams: 0x2666
- });
+ }));
})(ts || (ts = {}));
var ts;
(function (ts) {
function transformES2016(context) {
- var hoistVariableDeclaration = context.hoistVariableDeclaration;
- return ts.chainBundle(transformSourceFile);
+ var factory = context.factory, hoistVariableDeclaration = context.hoistVariableDeclaration;
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile) {
return node;
return node;
}
switch (node.kind) {
- case 209:
+ case 216:
return visitBinaryExpression(node);
default:
return ts.visitEachChild(node, visitor, context);
var left = ts.visitNode(node.left, visitor, ts.isExpression);
var right = ts.visitNode(node.right, visitor, ts.isExpression);
if (ts.isElementAccessExpression(left)) {
- var expressionTemp = ts.createTempVariable(hoistVariableDeclaration);
- var argumentExpressionTemp = ts.createTempVariable(hoistVariableDeclaration);
- target = ts.setTextRange(ts.createElementAccess(ts.setTextRange(ts.createAssignment(expressionTemp, left.expression), left.expression), ts.setTextRange(ts.createAssignment(argumentExpressionTemp, left.argumentExpression), left.argumentExpression)), left);
- value = ts.setTextRange(ts.createElementAccess(expressionTemp, argumentExpressionTemp), left);
+ var expressionTemp = factory.createTempVariable(hoistVariableDeclaration);
+ var argumentExpressionTemp = factory.createTempVariable(hoistVariableDeclaration);
+ target = ts.setTextRange(factory.createElementAccessExpression(ts.setTextRange(factory.createAssignment(expressionTemp, left.expression), left.expression), ts.setTextRange(factory.createAssignment(argumentExpressionTemp, left.argumentExpression), left.argumentExpression)), left);
+ value = ts.setTextRange(factory.createElementAccessExpression(expressionTemp, argumentExpressionTemp), left);
}
else if (ts.isPropertyAccessExpression(left)) {
- var expressionTemp = ts.createTempVariable(hoistVariableDeclaration);
- target = ts.setTextRange(ts.createPropertyAccess(ts.setTextRange(ts.createAssignment(expressionTemp, left.expression), left.expression), left.name), left);
- value = ts.setTextRange(ts.createPropertyAccess(expressionTemp, left.name), left);
+ var expressionTemp = factory.createTempVariable(hoistVariableDeclaration);
+ target = ts.setTextRange(factory.createPropertyAccessExpression(ts.setTextRange(factory.createAssignment(expressionTemp, left.expression), left.expression), left.name), left);
+ value = ts.setTextRange(factory.createPropertyAccessExpression(expressionTemp, left.name), left);
}
else {
target = left;
value = left;
}
- return ts.setTextRange(ts.createAssignment(target, ts.createMathPow(value, right, node)), node);
+ return ts.setTextRange(factory.createAssignment(target, ts.setTextRange(factory.createGlobalMethodCall("Math", "pow", [value, right]), node)), node);
}
function visitExponentiationExpression(node) {
var left = ts.visitNode(node.left, visitor, ts.isExpression);
var right = ts.visitNode(node.right, visitor, ts.isExpression);
- return ts.createMathPow(left, right, node);
+ return ts.setTextRange(factory.createGlobalMethodCall("Math", "pow", [left, right]), node);
}
}
ts.transformES2016 = transformES2016;
var ts;
(function (ts) {
function transformES2015(context) {
- var startLexicalEnvironment = context.startLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
+ var factory = context.factory, emitHelpers = context.getEmitHelperFactory, startLexicalEnvironment = context.startLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
var compilerOptions = context.getCompilerOptions();
var resolver = context.getEmitResolver();
var previousOnSubstituteNode = context.onSubstituteNode;
var hierarchyFacts;
var taggedTemplateStringDeclarations;
function recordTaggedTemplateString(temp) {
- taggedTemplateStringDeclarations = ts.append(taggedTemplateStringDeclarations, ts.createVariableDeclaration(temp));
+ taggedTemplateStringDeclarations = ts.append(taggedTemplateStringDeclarations, factory.createVariableDeclaration(temp));
}
var convertedLoopState;
var enabledSubstitutions;
- return ts.chainBundle(transformSourceFile);
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile) {
return node;
}
function isReturnVoidStatementInConstructorWithCapturedSuper(node) {
return (hierarchyFacts & 8192) !== 0
- && node.kind === 235
+ && node.kind === 242
&& !node.expression;
}
+ function isOrMayContainReturnCompletion(node) {
+ return node.transformFlags & 1048576
+ && (ts.isReturnStatement(node)
+ || ts.isIfStatement(node)
+ || ts.isWithStatement(node)
+ || ts.isSwitchStatement(node)
+ || ts.isCaseBlock(node)
+ || ts.isCaseClause(node)
+ || ts.isDefaultClause(node)
+ || ts.isTryStatement(node)
+ || ts.isCatchClause(node)
+ || ts.isLabeledStatement(node)
+ || ts.isIterationStatement(node, false)
+ || ts.isBlock(node));
+ }
function shouldVisitNode(node) {
return (node.transformFlags & 256) !== 0
|| convertedLoopState !== undefined
- || (hierarchyFacts & 8192 && (ts.isStatement(node) || (node.kind === 223)))
+ || (hierarchyFacts & 8192 && isOrMayContainReturnCompletion(node))
|| (ts.isIterationStatement(node, false) && shouldConvertIterationStatement(node))
|| (ts.getEmitFlags(node) & 33554432) !== 0;
}
function visitor(node) {
- if (shouldVisitNode(node)) {
- return visitJavaScript(node);
- }
- else {
- return node;
- }
+ return shouldVisitNode(node) ? visitorWorker(node, false) : node;
+ }
+ function visitorWithUnusedExpressionResult(node) {
+ return shouldVisitNode(node) ? visitorWorker(node, true) : node;
}
function callExpressionVisitor(node) {
- if (node.kind === 102) {
+ if (node.kind === 105) {
return visitSuperKeyword(true);
}
return visitor(node);
}
- function visitJavaScript(node) {
+ function visitorWorker(node, expressionResultIsUnused) {
switch (node.kind) {
- case 120:
+ case 123:
return undefined;
- case 245:
+ case 252:
return visitClassDeclaration(node);
- case 214:
+ case 221:
return visitClassExpression(node);
- case 156:
+ case 160:
return visitParameter(node);
- case 244:
+ case 251:
return visitFunctionDeclaration(node);
- case 202:
+ case 209:
return visitArrowFunction(node);
- case 201:
+ case 208:
return visitFunctionExpression(node);
- case 242:
+ case 249:
return visitVariableDeclaration(node);
- case 75:
+ case 78:
return visitIdentifier(node);
- case 243:
+ case 250:
return visitVariableDeclarationList(node);
- case 237:
+ case 244:
return visitSwitchStatement(node);
- case 251:
+ case 258:
return visitCaseBlock(node);
- case 223:
+ case 230:
return visitBlock(node, false);
- case 234:
- case 233:
+ case 241:
+ case 240:
return visitBreakOrContinueStatement(node);
- case 238:
+ case 245:
return visitLabeledStatement(node);
- case 228:
- case 229:
+ case 235:
+ case 236:
return visitDoOrWhileStatement(node, undefined);
- case 230:
+ case 237:
return visitForStatement(node, undefined);
- case 231:
+ case 238:
return visitForInStatement(node, undefined);
- case 232:
+ case 239:
return visitForOfStatement(node, undefined);
- case 226:
+ case 233:
return visitExpressionStatement(node);
- case 193:
+ case 200:
return visitObjectLiteralExpression(node);
- case 280:
+ case 287:
return visitCatchClause(node);
- case 282:
+ case 289:
return visitShorthandPropertyAssignment(node);
- case 154:
+ case 158:
return visitComputedPropertyName(node);
- case 192:
+ case 199:
return visitArrayLiteralExpression(node);
- case 196:
+ case 203:
return visitCallExpression(node);
- case 197:
+ case 204:
return visitNewExpression(node);
- case 200:
- return visitParenthesizedExpression(node, true);
- case 209:
- return visitBinaryExpression(node, true);
+ case 207:
+ return visitParenthesizedExpression(node, expressionResultIsUnused);
+ case 216:
+ return visitBinaryExpression(node, expressionResultIsUnused);
+ case 337:
+ return visitCommaListExpression(node, expressionResultIsUnused);
case 14:
case 15:
case 16:
return visitStringLiteral(node);
case 8:
return visitNumericLiteral(node);
- case 198:
+ case 205:
return visitTaggedTemplateExpression(node);
- case 211:
+ case 218:
return visitTemplateExpression(node);
- case 212:
+ case 219:
return visitYieldExpression(node);
- case 213:
+ case 220:
return visitSpreadElement(node);
- case 102:
+ case 105:
return visitSuperKeyword(false);
- case 104:
+ case 107:
return visitThisKeyword(node);
- case 219:
+ case 226:
return visitMetaProperty(node);
- case 161:
+ case 165:
return visitMethodDeclaration(node);
- case 163:
- case 164:
+ case 167:
+ case 168:
return visitAccessorDeclaration(node);
- case 225:
+ case 232:
return visitVariableStatement(node);
- case 235:
+ case 242:
return visitReturnStatement(node);
+ case 212:
+ return visitVoidExpression(node);
default:
return ts.visitEachChild(node, visitor, context);
}
var prologue = [];
var statements = [];
startLexicalEnvironment();
- var statementOffset = ts.addStandardPrologue(prologue, node.statements, false);
- statementOffset = ts.addCustomPrologue(prologue, node.statements, statementOffset, visitor);
+ var statementOffset = factory.copyPrologue(node.statements, prologue, false, visitor);
ts.addRange(statements, ts.visitNodes(node.statements, visitor, ts.isStatement, statementOffset));
if (taggedTemplateStringDeclarations) {
- statements.push(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(taggedTemplateStringDeclarations)));
+ statements.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList(taggedTemplateStringDeclarations)));
}
- ts.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
+ factory.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
insertCaptureThisForNodeIfNeeded(prologue, node);
exitSubtree(ancestorFacts, 0, 0);
- return ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray(ts.concatenate(prologue, statements)), node.statements));
+ return factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray(ts.concatenate(prologue, statements)), node.statements));
}
function visitSwitchStatement(node) {
if (convertedLoopState !== undefined) {
return updated;
}
function returnCapturedThis(node) {
- return ts.setOriginalNode(ts.createReturn(ts.createFileLevelUniqueName("_this")), node);
+ return ts.setOriginalNode(factory.createReturnStatement(factory.createUniqueName("_this", 16 | 32)), node);
}
function visitReturnStatement(node) {
if (convertedLoopState) {
if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) {
node = returnCapturedThis(node);
}
- return ts.createReturn(ts.createObjectLiteral([
- ts.createPropertyAssignment(ts.createIdentifier("value"), node.expression
+ return factory.createReturnStatement(factory.createObjectLiteralExpression([
+ factory.createPropertyAssignment(factory.createIdentifier("value"), node.expression
? ts.visitNode(node.expression, visitor, ts.isExpression)
- : ts.createVoidZero())
+ : factory.createVoidZero())
]));
}
else if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) {
convertedLoopState.containsLexicalThis = true;
return node;
}
- return convertedLoopState.thisName || (convertedLoopState.thisName = ts.createUniqueName("this"));
+ return convertedLoopState.thisName || (convertedLoopState.thisName = factory.createUniqueName("this"));
}
return node;
}
+ function visitVoidExpression(node) {
+ return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context);
+ }
function visitIdentifier(node) {
if (!convertedLoopState) {
return node;
}
- if (ts.isGeneratedIdentifier(node)) {
- return node;
- }
- if (node.escapedText !== "arguments" || !resolver.isArgumentsLocalBinding(node)) {
- return node;
+ if (resolver.isArgumentsLocalBinding(node)) {
+ return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = factory.createUniqueName("arguments"));
}
- return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = ts.createUniqueName("arguments"));
+ return node;
}
function visitBreakOrContinueStatement(node) {
if (convertedLoopState) {
- var jump = node.kind === 234 ? 2 : 4;
+ var jump = node.kind === 241 ? 2 : 4;
var canUseBreakOrContinue = (node.label && convertedLoopState.labels && convertedLoopState.labels.get(ts.idText(node.label))) ||
(!node.label && (convertedLoopState.allowedNonLabeledJumps & jump));
if (!canUseBreakOrContinue) {
var labelMarker = void 0;
var label = node.label;
if (!label) {
- if (node.kind === 234) {
+ if (node.kind === 241) {
convertedLoopState.nonLocalJumps |= 2;
labelMarker = "break";
}
}
}
else {
- if (node.kind === 234) {
+ if (node.kind === 241) {
labelMarker = "break-" + label.escapedText;
setLabeledJump(convertedLoopState, true, ts.idText(label), labelMarker);
}
setLabeledJump(convertedLoopState, false, ts.idText(label), labelMarker);
}
}
- var returnExpression = ts.createLiteral(labelMarker);
+ var returnExpression = factory.createStringLiteral(labelMarker);
if (convertedLoopState.loopOutParameters.length) {
var outParams = convertedLoopState.loopOutParameters;
var expr = void 0;
expr = copyExpr;
}
else {
- expr = ts.createBinary(expr, 27, copyExpr);
+ expr = factory.createBinaryExpression(expr, 27, copyExpr);
}
}
- returnExpression = ts.createBinary(expr, 27, returnExpression);
+ returnExpression = factory.createBinaryExpression(expr, 27, returnExpression);
}
- return ts.createReturn(returnExpression);
+ return factory.createReturnStatement(returnExpression);
}
}
return ts.visitEachChild(node, visitor, context);
}
function visitClassDeclaration(node) {
- var variable = ts.createVariableDeclaration(ts.getLocalName(node, true), undefined, transformClassLikeDeclarationToExpression(node));
+ var variable = factory.createVariableDeclaration(factory.getLocalName(node, true), undefined, undefined, transformClassLikeDeclarationToExpression(node));
ts.setOriginalNode(variable, node);
var statements = [];
- var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([variable]));
+ var statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([variable]));
ts.setOriginalNode(statement, node);
ts.setTextRange(statement, node);
ts.startOnNewLine(statement);
statements.push(statement);
- if (ts.hasModifier(node, 1)) {
- var exportStatement = ts.hasModifier(node, 512)
- ? ts.createExportDefault(ts.getLocalName(node))
- : ts.createExternalModuleExport(ts.getLocalName(node));
+ if (ts.hasSyntacticModifier(node, 1)) {
+ var exportStatement = ts.hasSyntacticModifier(node, 512)
+ ? factory.createExportDefault(factory.getLocalName(node))
+ : factory.createExternalModuleExport(factory.getLocalName(node));
ts.setOriginalNode(exportStatement, statement);
statements.push(exportStatement);
}
var emitFlags = ts.getEmitFlags(node);
if ((emitFlags & 4194304) === 0) {
- statements.push(ts.createEndOfDeclarationMarker(node));
+ statements.push(factory.createEndOfDeclarationMarker(node));
ts.setEmitFlags(statement, emitFlags | 4194304);
}
return ts.singleOrMany(statements);
enableSubstitutionsForBlockScopedBindings();
}
var extendsClauseElement = ts.getClassExtendsHeritageElement(node);
- var classFunction = ts.createFunctionExpression(undefined, undefined, undefined, undefined, extendsClauseElement ? [ts.createParameter(undefined, undefined, undefined, ts.createFileLevelUniqueName("_super"))] : [], undefined, transformClassBody(node, extendsClauseElement));
+ var classFunction = factory.createFunctionExpression(undefined, undefined, undefined, undefined, extendsClauseElement ? [factory.createParameterDeclaration(undefined, undefined, undefined, factory.createUniqueName("_super", 16 | 32))] : [], undefined, transformClassBody(node, extendsClauseElement));
ts.setEmitFlags(classFunction, (ts.getEmitFlags(node) & 65536) | 524288);
- var inner = ts.createPartiallyEmittedExpression(classFunction);
- inner.end = node.end;
+ var inner = factory.createPartiallyEmittedExpression(classFunction);
+ ts.setTextRangeEnd(inner, node.end);
ts.setEmitFlags(inner, 1536);
- var outer = ts.createPartiallyEmittedExpression(inner);
- outer.end = ts.skipTrivia(currentText, node.pos);
+ var outer = factory.createPartiallyEmittedExpression(inner);
+ ts.setTextRangeEnd(outer, ts.skipTrivia(currentText, node.pos));
ts.setEmitFlags(outer, 1536);
- var result = ts.createParen(ts.createCall(outer, undefined, extendsClauseElement
+ var result = factory.createParenthesizedExpression(factory.createCallExpression(outer, undefined, extendsClauseElement
? [ts.visitNode(extendsClauseElement.expression, visitor, ts.isExpression)]
: []));
ts.addSyntheticLeadingComment(result, 3, "* @class ");
}
function transformClassBody(node, extendsClauseElement) {
var statements = [];
+ var name = factory.getInternalName(node);
+ var constructorLikeName = ts.isIdentifierANonContextualKeyword(name) ? factory.getGeneratedNameForNode(name) : name;
startLexicalEnvironment();
addExtendsHelperIfNeeded(statements, node, extendsClauseElement);
- addConstructor(statements, node, extendsClauseElement);
+ addConstructor(statements, node, constructorLikeName, extendsClauseElement);
addClassMembers(statements, node);
var closingBraceLocation = ts.createTokenRange(ts.skipTrivia(currentText, node.members.end), 19);
- var localName = ts.getInternalName(node);
- var outer = ts.createPartiallyEmittedExpression(localName);
- outer.end = closingBraceLocation.end;
+ var outer = factory.createPartiallyEmittedExpression(constructorLikeName);
+ ts.setTextRangeEnd(outer, closingBraceLocation.end);
ts.setEmitFlags(outer, 1536);
- var statement = ts.createReturn(outer);
- statement.pos = closingBraceLocation.pos;
+ var statement = factory.createReturnStatement(outer);
+ ts.setTextRangePos(statement, closingBraceLocation.pos);
ts.setEmitFlags(statement, 1536 | 384);
statements.push(statement);
ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
- var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), node.members), true);
+ var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), node.members), true);
ts.setEmitFlags(block, 1536);
return block;
}
function addExtendsHelperIfNeeded(statements, node, extendsClauseElement) {
if (extendsClauseElement) {
- statements.push(ts.setTextRange(ts.createExpressionStatement(createExtendsHelper(context, ts.getInternalName(node))), extendsClauseElement));
+ statements.push(ts.setTextRange(factory.createExpressionStatement(emitHelpers().createExtendsHelper(factory.getInternalName(node))), extendsClauseElement));
}
}
- function addConstructor(statements, node, extendsClauseElement) {
+ function addConstructor(statements, node, name, extendsClauseElement) {
var savedConvertedLoopState = convertedLoopState;
convertedLoopState = undefined;
var ancestorFacts = enterSubtree(16278, 73);
var constructor = ts.getFirstConstructorWithBody(node);
var hasSynthesizedSuper = hasSynthesizedDefaultSuperCall(constructor, extendsClauseElement !== undefined);
- var constructorFunction = ts.createFunctionDeclaration(undefined, undefined, undefined, ts.getInternalName(node), undefined, transformConstructorParameters(constructor, hasSynthesizedSuper), undefined, transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper));
+ var constructorFunction = factory.createFunctionDeclaration(undefined, undefined, undefined, name, undefined, transformConstructorParameters(constructor, hasSynthesizedSuper), undefined, transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper));
ts.setTextRange(constructorFunction, constructor || node);
if (extendsClauseElement) {
ts.setEmitFlags(constructorFunction, 8);
function createDefaultConstructorBody(node, isDerivedClass) {
var statements = [];
resumeLexicalEnvironment();
- ts.mergeLexicalEnvironment(statements, endLexicalEnvironment());
+ factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
if (isDerivedClass) {
- statements.push(ts.createReturn(createDefaultSuperCallOrThis()));
+ statements.push(factory.createReturnStatement(createDefaultSuperCallOrThis()));
}
- var statementsArray = ts.createNodeArray(statements);
+ var statementsArray = factory.createNodeArray(statements);
ts.setTextRange(statementsArray, node.members);
- var block = ts.createBlock(statementsArray, true);
+ var block = factory.createBlock(statementsArray, true);
ts.setTextRange(block, node);
ts.setEmitFlags(block, 1536);
return block;
}
function transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper) {
- var isDerivedClass = !!extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 100;
+ var isDerivedClass = !!extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 103;
if (!constructor)
return createDefaultConstructorBody(node, isDerivedClass);
var prologue = [];
resumeLexicalEnvironment();
var statementOffset = 0;
if (!hasSynthesizedSuper)
- statementOffset = ts.addStandardPrologue(prologue, constructor.body.statements, false);
+ statementOffset = factory.copyStandardPrologue(constructor.body.statements, prologue, false);
addDefaultValueAssignmentsIfNeeded(statements, constructor);
addRestParameterIfNeeded(statements, constructor, hasSynthesizedSuper);
if (!hasSynthesizedSuper)
- statementOffset = ts.addCustomPrologue(statements, constructor.body.statements, statementOffset, visitor);
+ statementOffset = factory.copyCustomPrologue(constructor.body.statements, statements, statementOffset, visitor);
var superCallExpression;
if (hasSynthesizedSuper) {
superCallExpression = createDefaultSuperCallOrThis();
statementOffset++;
}
ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, statementOffset));
- ts.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
+ factory.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
insertCaptureNewTargetIfNeeded(prologue, constructor, false);
if (isDerivedClass) {
if (superCallExpression && statementOffset === constructor.body.statements.length && !(constructor.body.transformFlags & 4096)) {
var superCall = ts.cast(ts.cast(superCallExpression, ts.isBinaryExpression).left, ts.isCallExpression);
- var returnStatement = ts.createReturn(superCallExpression);
+ var returnStatement = factory.createReturnStatement(superCallExpression);
ts.setCommentRange(returnStatement, ts.getCommentRange(superCall));
ts.setEmitFlags(superCall, 1536);
statements.push(returnStatement);
else {
insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis());
if (!isSufficientlyCoveredByReturnStatements(constructor.body)) {
- statements.push(ts.createReturn(ts.createFileLevelUniqueName("_this")));
+ statements.push(factory.createReturnStatement(factory.createUniqueName("_this", 16 | 32)));
}
}
}
else {
insertCaptureThisForNodeIfNeeded(prologue, constructor);
}
- var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(ts.concatenate(prologue, statements)), constructor.body.statements), true);
+ var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(ts.concatenate(prologue, statements)), constructor.body.statements), true);
ts.setTextRange(block, constructor.body);
return block;
}
function isSufficientlyCoveredByReturnStatements(statement) {
- if (statement.kind === 235) {
+ if (statement.kind === 242) {
return true;
}
- else if (statement.kind === 227) {
+ else if (statement.kind === 234) {
var ifStatement = statement;
if (ifStatement.elseStatement) {
return isSufficientlyCoveredByReturnStatements(ifStatement.thenStatement) &&
isSufficientlyCoveredByReturnStatements(ifStatement.elseStatement);
}
}
- else if (statement.kind === 223) {
+ else if (statement.kind === 230) {
var lastStatement = ts.lastOrUndefined(statement.statements);
if (lastStatement && isSufficientlyCoveredByReturnStatements(lastStatement)) {
return true;
return false;
}
function createActualThis() {
- return ts.setEmitFlags(ts.createThis(), 4);
+ return ts.setEmitFlags(factory.createThis(), 4);
}
function createDefaultSuperCallOrThis() {
- return ts.createLogicalOr(ts.createLogicalAnd(ts.createStrictInequality(ts.createFileLevelUniqueName("_super"), ts.createNull()), ts.createFunctionApply(ts.createFileLevelUniqueName("_super"), createActualThis(), ts.createIdentifier("arguments"))), createActualThis());
+ return factory.createLogicalOr(factory.createLogicalAnd(factory.createStrictInequality(factory.createUniqueName("_super", 16 | 32), factory.createNull()), factory.createFunctionApplyCall(factory.createUniqueName("_super", 16 | 32), createActualThis(), factory.createIdentifier("arguments"))), createActualThis());
}
function visitParameter(node) {
if (node.dotDotDotToken) {
return undefined;
}
else if (ts.isBindingPattern(node.name)) {
- return ts.setOriginalNode(ts.setTextRange(ts.createParameter(undefined, undefined, undefined, ts.getGeneratedNameForNode(node), undefined, undefined, undefined), node), node);
+ return ts.setOriginalNode(ts.setTextRange(factory.createParameterDeclaration(undefined, undefined, undefined, factory.getGeneratedNameForNode(node), undefined, undefined, undefined), node), node);
}
else if (node.initializer) {
- return ts.setOriginalNode(ts.setTextRange(ts.createParameter(undefined, undefined, undefined, node.name, undefined, undefined, undefined), node), node);
+ return ts.setOriginalNode(ts.setTextRange(factory.createParameterDeclaration(undefined, undefined, undefined, node.name, undefined, undefined, undefined), node), node);
}
else {
return node;
}
function insertDefaultValueAssignmentForBindingPattern(statements, parameter, name, initializer) {
if (name.elements.length > 0) {
- ts.insertStatementAfterCustomPrologue(statements, ts.setEmitFlags(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(ts.flattenDestructuringBinding(parameter, visitor, context, 0, ts.getGeneratedNameForNode(parameter)))), 1048576));
+ ts.insertStatementAfterCustomPrologue(statements, ts.setEmitFlags(factory.createVariableStatement(undefined, factory.createVariableDeclarationList(ts.flattenDestructuringBinding(parameter, visitor, context, 0, factory.getGeneratedNameForNode(parameter)))), 1048576));
return true;
}
else if (initializer) {
- ts.insertStatementAfterCustomPrologue(statements, ts.setEmitFlags(ts.createExpressionStatement(ts.createAssignment(ts.getGeneratedNameForNode(parameter), ts.visitNode(initializer, visitor, ts.isExpression))), 1048576));
+ ts.insertStatementAfterCustomPrologue(statements, ts.setEmitFlags(factory.createExpressionStatement(factory.createAssignment(factory.getGeneratedNameForNode(parameter), ts.visitNode(initializer, visitor, ts.isExpression))), 1048576));
return true;
}
return false;
}
function insertDefaultValueAssignmentForInitializer(statements, parameter, name, initializer) {
initializer = ts.visitNode(initializer, visitor, ts.isExpression);
- var statement = ts.createIf(ts.createTypeCheck(ts.getSynthesizedClone(name), "undefined"), ts.setEmitFlags(ts.setTextRange(ts.createBlock([
- ts.createExpressionStatement(ts.setEmitFlags(ts.setTextRange(ts.createAssignment(ts.setEmitFlags(ts.getMutableClone(name), 48), ts.setEmitFlags(initializer, 48 | ts.getEmitFlags(initializer) | 1536)), parameter), 1536))
+ var statement = factory.createIfStatement(factory.createTypeCheck(factory.cloneNode(name), "undefined"), ts.setEmitFlags(ts.setTextRange(factory.createBlock([
+ factory.createExpressionStatement(ts.setEmitFlags(ts.setTextRange(factory.createAssignment(ts.setEmitFlags(ts.setParent(ts.setTextRange(factory.cloneNode(name), name), name.parent), 48), ts.setEmitFlags(initializer, 48 | ts.getEmitFlags(initializer) | 1536)), parameter), 1536))
]), parameter), 1 | 32 | 384 | 1536));
ts.startOnNewLine(statement);
ts.setTextRange(statement, parameter);
if (!shouldAddRestParameter(parameter, inConstructorWithSynthesizedSuper)) {
return false;
}
- var declarationName = parameter.name.kind === 75 ? ts.getMutableClone(parameter.name) : ts.createTempVariable(undefined);
+ var declarationName = parameter.name.kind === 78 ? ts.setParent(ts.setTextRange(factory.cloneNode(parameter.name), parameter.name), parameter.name.parent) : factory.createTempVariable(undefined);
ts.setEmitFlags(declarationName, 48);
- var expressionName = parameter.name.kind === 75 ? ts.getSynthesizedClone(parameter.name) : declarationName;
+ var expressionName = parameter.name.kind === 78 ? factory.cloneNode(parameter.name) : declarationName;
var restIndex = node.parameters.length - 1;
- var temp = ts.createLoopVariable();
- prologueStatements.push(ts.setEmitFlags(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(declarationName, undefined, ts.createArrayLiteral([]))
+ var temp = factory.createLoopVariable();
+ prologueStatements.push(ts.setEmitFlags(ts.setTextRange(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(declarationName, undefined, undefined, factory.createArrayLiteralExpression([]))
])), parameter), 1048576));
- var forStatement = ts.createFor(ts.setTextRange(ts.createVariableDeclarationList([
- ts.createVariableDeclaration(temp, undefined, ts.createLiteral(restIndex))
- ]), parameter), ts.setTextRange(ts.createLessThan(temp, ts.createPropertyAccess(ts.createIdentifier("arguments"), "length")), parameter), ts.setTextRange(ts.createPostfixIncrement(temp), parameter), ts.createBlock([
- ts.startOnNewLine(ts.setTextRange(ts.createExpressionStatement(ts.createAssignment(ts.createElementAccess(expressionName, restIndex === 0
+ var forStatement = factory.createForStatement(ts.setTextRange(factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(temp, undefined, undefined, factory.createNumericLiteral(restIndex))
+ ]), parameter), ts.setTextRange(factory.createLessThan(temp, factory.createPropertyAccessExpression(factory.createIdentifier("arguments"), "length")), parameter), ts.setTextRange(factory.createPostfixIncrement(temp), parameter), factory.createBlock([
+ ts.startOnNewLine(ts.setTextRange(factory.createExpressionStatement(factory.createAssignment(factory.createElementAccessExpression(expressionName, restIndex === 0
? temp
- : ts.createSubtract(temp, ts.createLiteral(restIndex))), ts.createElementAccess(ts.createIdentifier("arguments"), temp))), parameter))
+ : factory.createSubtract(temp, factory.createNumericLiteral(restIndex))), factory.createElementAccessExpression(factory.createIdentifier("arguments"), temp))), parameter))
]));
ts.setEmitFlags(forStatement, 1048576);
ts.startOnNewLine(forStatement);
prologueStatements.push(forStatement);
- if (parameter.name.kind !== 75) {
- prologueStatements.push(ts.setEmitFlags(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(ts.flattenDestructuringBinding(parameter, visitor, context, 0, expressionName))), parameter), 1048576));
+ if (parameter.name.kind !== 78) {
+ prologueStatements.push(ts.setEmitFlags(ts.setTextRange(factory.createVariableStatement(undefined, factory.createVariableDeclarationList(ts.flattenDestructuringBinding(parameter, visitor, context, 0, expressionName))), parameter), 1048576));
}
ts.insertStatementsAfterCustomPrologue(statements, prologueStatements);
return true;
}
function insertCaptureThisForNodeIfNeeded(statements, node) {
- if (hierarchyFacts & 32768 && node.kind !== 202) {
- insertCaptureThisForNode(statements, node, ts.createThis());
+ if (hierarchyFacts & 32768 && node.kind !== 209) {
+ insertCaptureThisForNode(statements, node, factory.createThis());
return true;
}
return false;
}
function insertCaptureThisForNode(statements, node, initializer) {
enableSubstitutionsForCapturedThis();
- var captureThisStatement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(ts.createFileLevelUniqueName("_this"), undefined, initializer)
+ var captureThisStatement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(factory.createUniqueName("_this", 16 | 32), undefined, undefined, initializer)
]));
ts.setEmitFlags(captureThisStatement, 1536 | 1048576);
ts.setSourceMapRange(captureThisStatement, node);
if (hierarchyFacts & 16384) {
var newTarget = void 0;
switch (node.kind) {
- case 202:
+ case 209:
return statements;
- case 161:
- case 163:
- case 164:
- newTarget = ts.createVoidZero();
+ case 165:
+ case 167:
+ case 168:
+ newTarget = factory.createVoidZero();
break;
- case 162:
- newTarget = ts.createPropertyAccess(ts.setEmitFlags(ts.createThis(), 4), "constructor");
+ case 166:
+ newTarget = factory.createPropertyAccessExpression(ts.setEmitFlags(factory.createThis(), 4), "constructor");
break;
- case 244:
- case 201:
- newTarget = ts.createConditional(ts.createLogicalAnd(ts.setEmitFlags(ts.createThis(), 4), ts.createBinary(ts.setEmitFlags(ts.createThis(), 4), 98, ts.getLocalName(node))), ts.createPropertyAccess(ts.setEmitFlags(ts.createThis(), 4), "constructor"), ts.createVoidZero());
+ case 251:
+ case 208:
+ newTarget = factory.createConditionalExpression(factory.createLogicalAnd(ts.setEmitFlags(factory.createThis(), 4), factory.createBinaryExpression(ts.setEmitFlags(factory.createThis(), 4), 101, factory.getLocalName(node))), undefined, factory.createPropertyAccessExpression(ts.setEmitFlags(factory.createThis(), 4), "constructor"), undefined, factory.createVoidZero());
break;
default:
return ts.Debug.failBadSyntaxKind(node);
}
- var captureNewTargetStatement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(ts.createFileLevelUniqueName("_newTarget"), undefined, newTarget)
+ var captureNewTargetStatement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(factory.createUniqueName("_newTarget", 16 | 32), undefined, undefined, newTarget)
]));
ts.setEmitFlags(captureNewTargetStatement, 1536 | 1048576);
if (copyOnWrite) {
for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
var member = _a[_i];
switch (member.kind) {
- case 222:
+ case 229:
statements.push(transformSemicolonClassElementToStatement(member));
break;
- case 161:
+ case 165:
statements.push(transformClassMethodDeclarationToStatement(getClassMemberPrefix(node, member), member, node));
break;
- case 163:
- case 164:
+ case 167:
+ case 168:
var accessors = ts.getAllAccessorDeclarations(node.members, member);
if (member === accessors.firstAccessor) {
statements.push(transformAccessorsToStatement(getClassMemberPrefix(node, member), accessors, node));
}
break;
- case 162:
+ case 166:
break;
default:
ts.Debug.failBadSyntaxKind(member, currentSourceFile && currentSourceFile.fileName);
}
}
function transformSemicolonClassElementToStatement(member) {
- return ts.setTextRange(ts.createEmptyStatement(), member);
+ return ts.setTextRange(factory.createEmptyStatement(), member);
}
function transformClassMethodDeclarationToStatement(receiver, member, container) {
var commentRange = ts.getCommentRange(member);
var e;
if (!ts.isPrivateIdentifier(propertyName) && context.getCompilerOptions().useDefineForClassFields) {
var name = ts.isComputedPropertyName(propertyName) ? propertyName.expression
- : ts.isIdentifier(propertyName) ? ts.createStringLiteral(ts.unescapeLeadingUnderscores(propertyName.escapedText))
+ : ts.isIdentifier(propertyName) ? factory.createStringLiteral(ts.unescapeLeadingUnderscores(propertyName.escapedText))
: propertyName;
- e = ts.createObjectDefinePropertyCall(receiver, name, ts.createPropertyDescriptor({ value: memberFunction, enumerable: false, writable: true, configurable: true }));
+ e = factory.createObjectDefinePropertyCall(receiver, name, factory.createPropertyDescriptor({ value: memberFunction, enumerable: false, writable: true, configurable: true }));
}
else {
- var memberName = ts.createMemberAccessForPropertyName(receiver, propertyName, member.name);
- e = ts.createAssignment(memberName, memberFunction);
+ var memberName = ts.createMemberAccessForPropertyName(factory, receiver, propertyName, member.name);
+ e = factory.createAssignment(memberName, memberFunction);
}
ts.setEmitFlags(memberFunction, 1536);
ts.setSourceMapRange(memberFunction, sourceMapRange);
- var statement = ts.setTextRange(ts.createExpressionStatement(e), member);
+ var statement = ts.setTextRange(factory.createExpressionStatement(e), member);
ts.setOriginalNode(statement, member);
ts.setCommentRange(statement, commentRange);
ts.setEmitFlags(statement, 48);
return statement;
}
function transformAccessorsToStatement(receiver, accessors, container) {
- var statement = ts.createExpressionStatement(transformAccessorsToExpression(receiver, accessors, container, false));
+ var statement = factory.createExpressionStatement(transformAccessorsToExpression(receiver, accessors, container, false));
ts.setEmitFlags(statement, 1536);
ts.setSourceMapRange(statement, ts.getSourceMapRange(accessors.firstAccessor));
return statement;
}
function transformAccessorsToExpression(receiver, _a, container, startsOnNewLine) {
var firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;
- var target = ts.getMutableClone(receiver);
+ var target = ts.setParent(ts.setTextRange(factory.cloneNode(receiver), receiver), receiver.parent);
ts.setEmitFlags(target, 1536 | 32);
ts.setSourceMapRange(target, firstAccessor.name);
var visitedAccessorName = ts.visitNode(firstAccessor.name, visitor, ts.isPropertyName);
if (ts.isPrivateIdentifier(visitedAccessorName)) {
return ts.Debug.failBadSyntaxKind(visitedAccessorName, "Encountered unhandled private identifier while transforming ES2015.");
}
- var propertyName = ts.createExpressionForPropertyName(visitedAccessorName);
+ var propertyName = ts.createExpressionForPropertyName(factory, visitedAccessorName);
ts.setEmitFlags(propertyName, 1536 | 16);
ts.setSourceMapRange(propertyName, firstAccessor.name);
var properties = [];
var getterFunction = transformFunctionLikeToExpression(getAccessor, undefined, undefined, container);
ts.setSourceMapRange(getterFunction, ts.getSourceMapRange(getAccessor));
ts.setEmitFlags(getterFunction, 512);
- var getter = ts.createPropertyAssignment("get", getterFunction);
+ var getter = factory.createPropertyAssignment("get", getterFunction);
ts.setCommentRange(getter, ts.getCommentRange(getAccessor));
properties.push(getter);
}
var setterFunction = transformFunctionLikeToExpression(setAccessor, undefined, undefined, container);
ts.setSourceMapRange(setterFunction, ts.getSourceMapRange(setAccessor));
ts.setEmitFlags(setterFunction, 512);
- var setter = ts.createPropertyAssignment("set", setterFunction);
+ var setter = factory.createPropertyAssignment("set", setterFunction);
ts.setCommentRange(setter, ts.getCommentRange(setAccessor));
properties.push(setter);
}
- properties.push(ts.createPropertyAssignment("enumerable", getAccessor || setAccessor ? ts.createFalse() : ts.createTrue()), ts.createPropertyAssignment("configurable", ts.createTrue()));
- var call = ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"), undefined, [
+ properties.push(factory.createPropertyAssignment("enumerable", getAccessor || setAccessor ? factory.createFalse() : factory.createTrue()), factory.createPropertyAssignment("configurable", factory.createTrue()));
+ var call = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "defineProperty"), undefined, [
target,
propertyName,
- ts.createObjectLiteral(properties, true)
+ factory.createObjectLiteralExpression(properties, true)
]);
if (startsOnNewLine) {
ts.startOnNewLine(call);
var savedConvertedLoopState = convertedLoopState;
convertedLoopState = undefined;
var ancestorFacts = enterSubtree(15232, 66);
- var func = ts.createFunctionExpression(undefined, undefined, undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, transformFunctionBody(node));
+ var func = factory.createFunctionExpression(undefined, undefined, undefined, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, transformFunctionBody(node));
ts.setTextRange(func, node);
ts.setOriginalNode(func, node);
ts.setEmitFlags(func, 8);
var parameters = ts.visitParameterList(node.parameters, visitor, context);
var body = transformFunctionBody(node);
var name = hierarchyFacts & 16384
- ? ts.getLocalName(node)
+ ? factory.getLocalName(node)
: node.name;
exitSubtree(ancestorFacts, 49152, 0);
convertedLoopState = savedConvertedLoopState;
- return ts.updateFunctionExpression(node, undefined, node.asteriskToken, name, undefined, parameters, undefined, body);
+ return factory.updateFunctionExpression(node, undefined, node.asteriskToken, name, undefined, parameters, undefined, body);
}
function visitFunctionDeclaration(node) {
var savedConvertedLoopState = convertedLoopState;
var parameters = ts.visitParameterList(node.parameters, visitor, context);
var body = transformFunctionBody(node);
var name = hierarchyFacts & 16384
- ? ts.getLocalName(node)
+ ? factory.getLocalName(node)
: node.name;
exitSubtree(ancestorFacts, 49152, 0);
convertedLoopState = savedConvertedLoopState;
- return ts.updateFunctionDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, name, undefined, parameters, undefined, body);
+ return factory.updateFunctionDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, name, undefined, parameters, undefined, body);
}
function transformFunctionLikeToExpression(node, location, name, container) {
var savedConvertedLoopState = convertedLoopState;
convertedLoopState = undefined;
- var ancestorFacts = container && ts.isClassLike(container) && !ts.hasModifier(node, 32)
+ var ancestorFacts = container && ts.isClassLike(container) && !ts.hasSyntacticModifier(node, 32)
? enterSubtree(16286, 65 | 8)
: enterSubtree(16286, 65);
var parameters = ts.visitParameterList(node.parameters, visitor, context);
var body = transformFunctionBody(node);
- if (hierarchyFacts & 16384 && !name && (node.kind === 244 || node.kind === 201)) {
- name = ts.getGeneratedNameForNode(node);
+ if (hierarchyFacts & 16384 && !name && (node.kind === 251 || node.kind === 208)) {
+ name = factory.getGeneratedNameForNode(node);
}
exitSubtree(ancestorFacts, 49152, 0);
convertedLoopState = savedConvertedLoopState;
- return ts.setOriginalNode(ts.setTextRange(ts.createFunctionExpression(undefined, node.asteriskToken, name, undefined, parameters, undefined, body), location), node);
+ return ts.setOriginalNode(ts.setTextRange(factory.createFunctionExpression(undefined, node.asteriskToken, name, undefined, parameters, undefined, body), location), node);
}
function transformFunctionBody(node) {
var multiLine = false;
var statementOffset;
resumeLexicalEnvironment();
if (ts.isBlock(body)) {
- statementOffset = ts.addStandardPrologue(prologue, body.statements, false);
- statementOffset = ts.addCustomPrologue(statements, body.statements, statementOffset, visitor, ts.isHoistedFunction);
- statementOffset = ts.addCustomPrologue(statements, body.statements, statementOffset, visitor, ts.isHoistedVariableStatement);
+ statementOffset = factory.copyStandardPrologue(body.statements, prologue, false);
+ statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor, ts.isHoistedFunction);
+ statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor, ts.isHoistedVariableStatement);
}
multiLine = addDefaultValueAssignmentsIfNeeded(statements, node) || multiLine;
multiLine = addRestParameterIfNeeded(statements, node, false) || multiLine;
if (ts.isBlock(body)) {
- statementOffset = ts.addCustomPrologue(statements, body.statements, statementOffset, visitor);
+ statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor);
statementsLocation = body.statements;
ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, statementOffset));
if (!multiLine && body.multiLine) {
}
}
else {
- ts.Debug.assert(node.kind === 202);
+ ts.Debug.assert(node.kind === 209);
statementsLocation = ts.moveRangeEnd(body, -1);
var equalsGreaterThanToken = node.equalsGreaterThanToken;
if (!ts.nodeIsSynthesized(equalsGreaterThanToken) && !ts.nodeIsSynthesized(body)) {
}
}
var expression = ts.visitNode(body, visitor, ts.isExpression);
- var returnStatement = ts.createReturn(expression);
+ var returnStatement = factory.createReturnStatement(expression);
ts.setTextRange(returnStatement, body);
ts.moveSyntheticComments(returnStatement, body);
ts.setEmitFlags(returnStatement, 384 | 32 | 1024);
statements.push(returnStatement);
closeBraceLocation = body;
}
- ts.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
+ factory.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
insertCaptureNewTargetIfNeeded(prologue, node, false);
insertCaptureThisForNodeIfNeeded(prologue, node);
if (ts.some(prologue)) {
if (ts.isBlock(body) && ts.arrayIsEqualTo(statements, body.statements)) {
return body;
}
- var block = ts.createBlock(ts.setTextRange(ts.createNodeArray(statements), statementsLocation), multiLine);
+ var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), multiLine);
ts.setTextRange(block, node.body);
if (!multiLine && singleLine) {
ts.setEmitFlags(block, 1);
return updated;
}
function visitExpressionStatement(node) {
- switch (node.expression.kind) {
- case 200:
- return ts.updateExpressionStatement(node, visitParenthesizedExpression(node.expression, false));
- case 209:
- return ts.updateExpressionStatement(node, visitBinaryExpression(node.expression, false));
- }
- return ts.visitEachChild(node, visitor, context);
+ return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context);
}
- function visitParenthesizedExpression(node, needsDestructuringValue) {
- if (!needsDestructuringValue) {
- switch (node.expression.kind) {
- case 200:
- return ts.updateParen(node, visitParenthesizedExpression(node.expression, false));
- case 209:
- return ts.updateParen(node, visitBinaryExpression(node.expression, false));
- }
- }
- return ts.visitEachChild(node, visitor, context);
+ function visitParenthesizedExpression(node, expressionResultIsUnused) {
+ return ts.visitEachChild(node, expressionResultIsUnused ? visitorWithUnusedExpressionResult : visitor, context);
}
- function visitBinaryExpression(node, needsDestructuringValue) {
+ function visitBinaryExpression(node, expressionResultIsUnused) {
if (ts.isDestructuringAssignment(node)) {
- return ts.flattenDestructuringAssignment(node, visitor, context, 0, needsDestructuringValue);
+ return ts.flattenDestructuringAssignment(node, visitor, context, 0, !expressionResultIsUnused);
+ }
+ if (node.operatorToken.kind === 27) {
+ return factory.updateBinaryExpression(node, ts.visitNode(node.left, visitorWithUnusedExpressionResult, ts.isExpression), node.operatorToken, ts.visitNode(node.right, expressionResultIsUnused ? visitorWithUnusedExpressionResult : visitor, ts.isExpression));
}
return ts.visitEachChild(node, visitor, context);
}
+ function visitCommaListExpression(node, expressionResultIsUnused) {
+ if (expressionResultIsUnused) {
+ return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context);
+ }
+ var result;
+ for (var i = 0; i < node.elements.length; i++) {
+ var element = node.elements[i];
+ var visited = ts.visitNode(element, i < node.elements.length - 1 ? visitorWithUnusedExpressionResult : visitor, ts.isExpression);
+ if (result || visited !== element) {
+ result || (result = node.elements.slice(0, i));
+ result.push(visited);
+ }
+ }
+ var elements = result ? ts.setTextRange(factory.createNodeArray(result), node.elements) : node.elements;
+ return factory.updateCommaListExpression(node, elements);
+ }
function isVariableStatementOfTypeScriptClassWrapper(node) {
return node.declarationList.declarations.length === 1
&& !!node.declarationList.declarations[0].initializer
&& !!(ts.getEmitFlags(node.declarationList.declarations[0].initializer) & 33554432);
}
function visitVariableStatement(node) {
- var ancestorFacts = enterSubtree(0, ts.hasModifier(node, 1) ? 32 : 0);
+ var ancestorFacts = enterSubtree(0, ts.hasSyntacticModifier(node, 1) ? 32 : 0);
var updated;
if (convertedLoopState && (node.declarationList.flags & 3) === 0 && !isVariableStatementOfTypeScriptClassWrapper(node)) {
var assignments = void 0;
assignment = ts.flattenDestructuringAssignment(decl, visitor, context, 0);
}
else {
- assignment = ts.createBinary(decl.name, 62, ts.visitNode(decl.initializer, visitor, ts.isExpression));
+ assignment = factory.createBinaryExpression(decl.name, 62, ts.visitNode(decl.initializer, visitor, ts.isExpression));
ts.setTextRange(assignment, decl);
}
assignments = ts.append(assignments, assignment);
}
}
if (assignments) {
- updated = ts.setTextRange(ts.createExpressionStatement(ts.inlineExpressions(assignments)), node);
+ updated = ts.setTextRange(factory.createExpressionStatement(factory.inlineExpressions(assignments)), node);
}
else {
updated = undefined;
var declarations = ts.flatMap(node.declarations, node.flags & 1
? visitVariableDeclarationInLetDeclarationList
: visitVariableDeclaration);
- var declarationList = ts.createVariableDeclarationList(declarations);
+ var declarationList = factory.createVariableDeclarationList(declarations);
ts.setOriginalNode(declarationList, node);
ts.setTextRange(declarationList, node);
ts.setCommentRange(declarationList, node);
return visitVariableDeclaration(node);
}
if (!node.initializer && shouldEmitExplicitInitializerForLetDeclaration(node)) {
- var clone_3 = ts.getMutableClone(node);
- clone_3.initializer = ts.createVoidZero();
- return clone_3;
+ return factory.updateVariableDeclaration(node, node.name, undefined, undefined, factory.createVoidZero());
}
return ts.visitEachChild(node, visitor, context);
}
}
function visitLabeledStatement(node) {
if (convertedLoopState && !convertedLoopState.labels) {
- convertedLoopState.labels = ts.createMap();
+ convertedLoopState.labels = new ts.Map();
}
var statement = ts.unwrapInnermostStatementOfLabel(node, convertedLoopState && recordLabel);
return ts.isIterationStatement(statement, false)
? visitIterationStatement(statement, node)
- : ts.restoreEnclosingLabel(ts.visitNode(statement, visitor, ts.isStatement, ts.liftToBlock), node, convertedLoopState && resetLabel);
+ : factory.restoreEnclosingLabel(ts.visitNode(statement, visitor, ts.isStatement, factory.liftToBlock), node, convertedLoopState && resetLabel);
}
function visitIterationStatement(node, outermostLabeledStatement) {
switch (node.kind) {
- case 228:
- case 229:
+ case 235:
+ case 236:
return visitDoOrWhileStatement(node, outermostLabeledStatement);
- case 230:
+ case 237:
return visitForStatement(node, outermostLabeledStatement);
- case 231:
+ case 238:
return visitForInStatement(node, outermostLabeledStatement);
- case 232:
+ case 239:
return visitForOfStatement(node, outermostLabeledStatement);
}
}
function visitForStatement(node, outermostLabeledStatement) {
return visitIterationStatementWithFacts(5056, 3328, node, outermostLabeledStatement);
}
+ function visitEachChildOfForStatement(node) {
+ return factory.updateForStatement(node, ts.visitNode(node.initializer, visitorWithUnusedExpressionResult, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitorWithUnusedExpressionResult, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock));
+ }
function visitForInStatement(node, outermostLabeledStatement) {
return visitIterationStatementWithFacts(3008, 5376, node, outermostLabeledStatement);
}
var firstOriginalDeclaration = ts.firstOrUndefined(initializer.declarations);
if (firstOriginalDeclaration && ts.isBindingPattern(firstOriginalDeclaration.name)) {
var declarations = ts.flattenDestructuringBinding(firstOriginalDeclaration, visitor, context, 0, boundValue);
- var declarationList = ts.setTextRange(ts.createVariableDeclarationList(declarations), node.initializer);
+ var declarationList = ts.setTextRange(factory.createVariableDeclarationList(declarations), node.initializer);
ts.setOriginalNode(declarationList, node.initializer);
ts.setSourceMapRange(declarationList, ts.createRange(declarations[0].pos, ts.last(declarations).end));
- statements.push(ts.createVariableStatement(undefined, declarationList));
+ statements.push(factory.createVariableStatement(undefined, declarationList));
}
else {
- statements.push(ts.setTextRange(ts.createVariableStatement(undefined, ts.setOriginalNode(ts.setTextRange(ts.createVariableDeclarationList([
- ts.createVariableDeclaration(firstOriginalDeclaration ? firstOriginalDeclaration.name : ts.createTempVariable(undefined), undefined, boundValue)
+ statements.push(ts.setTextRange(factory.createVariableStatement(undefined, ts.setOriginalNode(ts.setTextRange(factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(firstOriginalDeclaration ? firstOriginalDeclaration.name : factory.createTempVariable(undefined), undefined, undefined, boundValue)
]), ts.moveRangePos(initializer, -1)), initializer)), ts.moveRangeEnd(initializer, -1)));
}
}
else {
- var assignment = ts.createAssignment(initializer, boundValue);
+ var assignment = factory.createAssignment(initializer, boundValue);
if (ts.isDestructuringAssignment(assignment)) {
- ts.aggregateTransformFlags(assignment);
- statements.push(ts.createExpressionStatement(visitBinaryExpression(assignment, false)));
+ statements.push(factory.createExpressionStatement(visitBinaryExpression(assignment, true)));
}
else {
- assignment.end = initializer.end;
- statements.push(ts.setTextRange(ts.createExpressionStatement(ts.visitNode(assignment, visitor, ts.isExpression)), ts.moveRangeEnd(initializer, -1)));
+ ts.setTextRangeEnd(assignment, initializer.end);
+ statements.push(ts.setTextRange(factory.createExpressionStatement(ts.visitNode(assignment, visitor, ts.isExpression)), ts.moveRangeEnd(initializer, -1)));
}
}
if (convertedLoopBodyStatements) {
return createSyntheticBlockForConvertedStatements(ts.addRange(statements, convertedLoopBodyStatements));
}
else {
- var statement = ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock);
+ var statement = ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock);
if (ts.isBlock(statement)) {
- return ts.updateBlock(statement, ts.setTextRange(ts.createNodeArray(ts.concatenate(statements, statement.statements)), statement.statements));
+ return factory.updateBlock(statement, ts.setTextRange(factory.createNodeArray(ts.concatenate(statements, statement.statements)), statement.statements));
}
else {
statements.push(statement);
}
}
function createSyntheticBlockForConvertedStatements(statements) {
- return ts.setEmitFlags(ts.createBlock(ts.createNodeArray(statements), true), 48 | 384);
+ return ts.setEmitFlags(factory.createBlock(factory.createNodeArray(statements), true), 48 | 384);
}
function convertForOfStatementForArray(node, outermostLabeledStatement, convertedLoopBodyStatements) {
var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
- var counter = ts.createLoopVariable();
- var rhsReference = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(expression) : ts.createTempVariable(undefined);
+ var counter = factory.createLoopVariable();
+ var rhsReference = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(undefined);
ts.setEmitFlags(expression, 48 | ts.getEmitFlags(expression));
- var forStatement = ts.setTextRange(ts.createFor(ts.setEmitFlags(ts.setTextRange(ts.createVariableDeclarationList([
- ts.setTextRange(ts.createVariableDeclaration(counter, undefined, ts.createLiteral(0)), ts.moveRangePos(node.expression, -1)),
- ts.setTextRange(ts.createVariableDeclaration(rhsReference, undefined, expression), node.expression)
- ]), node.expression), 2097152), ts.setTextRange(ts.createLessThan(counter, ts.createPropertyAccess(rhsReference, "length")), node.expression), ts.setTextRange(ts.createPostfixIncrement(counter), node.expression), convertForOfStatementHead(node, ts.createElementAccess(rhsReference, counter), convertedLoopBodyStatements)), node);
+ var forStatement = ts.setTextRange(factory.createForStatement(ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
+ ts.setTextRange(factory.createVariableDeclaration(counter, undefined, undefined, factory.createNumericLiteral(0)), ts.moveRangePos(node.expression, -1)),
+ ts.setTextRange(factory.createVariableDeclaration(rhsReference, undefined, undefined, expression), node.expression)
+ ]), node.expression), 2097152), ts.setTextRange(factory.createLessThan(counter, factory.createPropertyAccessExpression(rhsReference, "length")), node.expression), ts.setTextRange(factory.createPostfixIncrement(counter), node.expression), convertForOfStatementHead(node, factory.createElementAccessExpression(rhsReference, counter), convertedLoopBodyStatements)), node);
ts.setEmitFlags(forStatement, 256);
ts.setTextRange(forStatement, node);
- return ts.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel);
+ return factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel);
}
function convertForOfStatementForIterable(node, outermostLabeledStatement, convertedLoopBodyStatements, ancestorFacts) {
var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
- var iterator = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(expression) : ts.createTempVariable(undefined);
- var result = ts.isIdentifier(expression) ? ts.getGeneratedNameForNode(iterator) : ts.createTempVariable(undefined);
- var errorRecord = ts.createUniqueName("e");
- var catchVariable = ts.getGeneratedNameForNode(errorRecord);
- var returnMethod = ts.createTempVariable(undefined);
- var values = ts.createValuesHelper(context, expression, node.expression);
- var next = ts.createCall(ts.createPropertyAccess(iterator, "next"), undefined, []);
+ var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(undefined);
+ var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(undefined);
+ var errorRecord = factory.createUniqueName("e");
+ var catchVariable = factory.getGeneratedNameForNode(errorRecord);
+ var returnMethod = factory.createTempVariable(undefined);
+ var values = ts.setTextRange(emitHelpers().createValuesHelper(expression), node.expression);
+ var next = factory.createCallExpression(factory.createPropertyAccessExpression(iterator, "next"), undefined, []);
hoistVariableDeclaration(errorRecord);
hoistVariableDeclaration(returnMethod);
var initializer = ancestorFacts & 1024
- ? ts.inlineExpressions([ts.createAssignment(errorRecord, ts.createVoidZero()), values])
+ ? factory.inlineExpressions([factory.createAssignment(errorRecord, factory.createVoidZero()), values])
: values;
- var forStatement = ts.setEmitFlags(ts.setTextRange(ts.createFor(ts.setEmitFlags(ts.setTextRange(ts.createVariableDeclarationList([
- ts.setTextRange(ts.createVariableDeclaration(iterator, undefined, initializer), node.expression),
- ts.createVariableDeclaration(result, undefined, next)
- ]), node.expression), 2097152), ts.createLogicalNot(ts.createPropertyAccess(result, "done")), ts.createAssignment(result, next), convertForOfStatementHead(node, ts.createPropertyAccess(result, "value"), convertedLoopBodyStatements)), node), 256);
- return ts.createTry(ts.createBlock([
- ts.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel)
- ]), ts.createCatchClause(ts.createVariableDeclaration(catchVariable), ts.setEmitFlags(ts.createBlock([
- ts.createExpressionStatement(ts.createAssignment(errorRecord, ts.createObjectLiteral([
- ts.createPropertyAssignment("error", catchVariable)
+ var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
+ ts.setTextRange(factory.createVariableDeclaration(iterator, undefined, undefined, initializer), node.expression),
+ factory.createVariableDeclaration(result, undefined, undefined, next)
+ ]), node.expression), 2097152), factory.createLogicalNot(factory.createPropertyAccessExpression(result, "done")), factory.createAssignment(result, next), convertForOfStatementHead(node, factory.createPropertyAccessExpression(result, "value"), convertedLoopBodyStatements)), node), 256);
+ return factory.createTryStatement(factory.createBlock([
+ factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel)
+ ]), factory.createCatchClause(factory.createVariableDeclaration(catchVariable), ts.setEmitFlags(factory.createBlock([
+ factory.createExpressionStatement(factory.createAssignment(errorRecord, factory.createObjectLiteralExpression([
+ factory.createPropertyAssignment("error", catchVariable)
])))
- ]), 1)), ts.createBlock([
- ts.createTry(ts.createBlock([
- ts.setEmitFlags(ts.createIf(ts.createLogicalAnd(ts.createLogicalAnd(result, ts.createLogicalNot(ts.createPropertyAccess(result, "done"))), ts.createAssignment(returnMethod, ts.createPropertyAccess(iterator, "return"))), ts.createExpressionStatement(ts.createFunctionCall(returnMethod, iterator, []))), 1),
- ]), undefined, ts.setEmitFlags(ts.createBlock([
- ts.setEmitFlags(ts.createIf(errorRecord, ts.createThrow(ts.createPropertyAccess(errorRecord, "error"))), 1)
+ ]), 1)), factory.createBlock([
+ factory.createTryStatement(factory.createBlock([
+ ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(factory.createPropertyAccessExpression(result, "done"))), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(factory.createFunctionCallCall(returnMethod, iterator, []))), 1),
+ ]), undefined, ts.setEmitFlags(factory.createBlock([
+ ts.setEmitFlags(factory.createIfStatement(errorRecord, factory.createThrowStatement(factory.createPropertyAccessExpression(errorRecord, "error"))), 1)
]), 1))
]));
}
function visitObjectLiteralExpression(node) {
var properties = node.properties;
- var numProperties = properties.length;
- var numInitialProperties = numProperties;
- var numInitialPropertiesWithoutYield = numProperties;
- for (var i = 0; i < numProperties; i++) {
+ var numInitialProperties = -1, hasComputed = false;
+ for (var i = 0; i < properties.length; i++) {
var property = properties[i];
- if ((property.transformFlags & 262144 && hierarchyFacts & 4)
- && i < numInitialPropertiesWithoutYield) {
- numInitialPropertiesWithoutYield = i;
- }
- if (property.name.kind === 154) {
+ if ((property.transformFlags & 262144 &&
+ hierarchyFacts & 4)
+ || (hasComputed = ts.Debug.checkDefined(property.name).kind === 158)) {
numInitialProperties = i;
break;
}
}
- if (numInitialProperties !== numProperties) {
- if (numInitialPropertiesWithoutYield < numInitialProperties) {
- numInitialProperties = numInitialPropertiesWithoutYield;
- }
- var temp = ts.createTempVariable(hoistVariableDeclaration);
- var expressions = [];
- var assignment = ts.createAssignment(temp, ts.setEmitFlags(ts.createObjectLiteral(ts.visitNodes(properties, visitor, ts.isObjectLiteralElementLike, 0, numInitialProperties), node.multiLine), 65536));
- if (node.multiLine) {
- ts.startOnNewLine(assignment);
- }
- expressions.push(assignment);
- addObjectLiteralMembers(expressions, node, temp, numInitialProperties);
- expressions.push(node.multiLine ? ts.startOnNewLine(ts.getMutableClone(temp)) : temp);
- return ts.inlineExpressions(expressions);
+ if (numInitialProperties < 0) {
+ return ts.visitEachChild(node, visitor, context);
}
- return ts.visitEachChild(node, visitor, context);
+ var temp = factory.createTempVariable(hoistVariableDeclaration);
+ var expressions = [];
+ var assignment = factory.createAssignment(temp, ts.setEmitFlags(factory.createObjectLiteralExpression(ts.visitNodes(properties, visitor, ts.isObjectLiteralElementLike, 0, numInitialProperties), node.multiLine), hasComputed ? 65536 : 0));
+ if (node.multiLine) {
+ ts.startOnNewLine(assignment);
+ }
+ expressions.push(assignment);
+ addObjectLiteralMembers(expressions, node, temp, numInitialProperties);
+ expressions.push(node.multiLine ? ts.startOnNewLine(ts.setParent(ts.setTextRange(factory.cloneNode(temp), temp), temp.parent)) : temp);
+ return factory.inlineExpressions(expressions);
}
function shouldConvertPartOfIterationStatement(node) {
return (resolver.getNodeCheckFlags(node) & 131072) !== 0;
}
visit(node.name);
function visit(node) {
- if (node.kind === 75) {
+ if (node.kind === 78) {
state.hoistedLocalVariables.push(node);
}
else {
}
var result = convert
? convert(node, outermostLabeledStatement, undefined, ancestorFacts)
- : ts.restoreEnclosingLabel(ts.visitEachChild(node, visitor, context), outermostLabeledStatement, convertedLoopState && resetLabel);
+ : factory.restoreEnclosingLabel(ts.isForStatement(node) ? visitEachChildOfForStatement(node) : ts.visitEachChild(node, visitor, context), outermostLabeledStatement, convertedLoopState && resetLabel);
if (convertedLoopState) {
convertedLoopState.allowedNonLabeledJumps = saveAllowedNonLabeledJumps;
}
loop = convert(node, outermostLabeledStatement, bodyFunction.part, ancestorFacts);
}
else {
- var clone_4 = convertIterationStatementCore(node, initializerFunction, ts.createBlock(bodyFunction.part, true));
- ts.aggregateTransformFlags(clone_4);
- loop = ts.restoreEnclosingLabel(clone_4, outermostLabeledStatement, convertedLoopState && resetLabel);
+ var clone_3 = convertIterationStatementCore(node, initializerFunction, factory.createBlock(bodyFunction.part, true));
+ loop = factory.restoreEnclosingLabel(clone_3, outermostLabeledStatement, convertedLoopState && resetLabel);
}
}
else {
- var clone_5 = convertIterationStatementCore(node, initializerFunction, ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock));
- ts.aggregateTransformFlags(clone_5);
- loop = ts.restoreEnclosingLabel(clone_5, outermostLabeledStatement, convertedLoopState && resetLabel);
+ var clone_4 = convertIterationStatementCore(node, initializerFunction, ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock));
+ loop = factory.restoreEnclosingLabel(clone_4, outermostLabeledStatement, convertedLoopState && resetLabel);
}
statements.push(loop);
return statements;
}
function convertIterationStatementCore(node, initializerFunction, convertedLoopBody) {
switch (node.kind) {
- case 230: return convertForStatement(node, initializerFunction, convertedLoopBody);
- case 231: return convertForInStatement(node, convertedLoopBody);
- case 232: return convertForOfStatement(node, convertedLoopBody);
- case 228: return convertDoStatement(node, convertedLoopBody);
- case 229: return convertWhileStatement(node, convertedLoopBody);
+ case 237: return convertForStatement(node, initializerFunction, convertedLoopBody);
+ case 238: return convertForInStatement(node, convertedLoopBody);
+ case 239: return convertForOfStatement(node, convertedLoopBody);
+ case 235: return convertDoStatement(node, convertedLoopBody);
+ case 236: return convertWhileStatement(node, convertedLoopBody);
default: return ts.Debug.failBadSyntaxKind(node, "IterationStatement expected");
}
}
function convertForStatement(node, initializerFunction, convertedLoopBody) {
var shouldConvertCondition = node.condition && shouldConvertPartOfIterationStatement(node.condition);
var shouldConvertIncrementor = shouldConvertCondition || node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor);
- return ts.updateFor(node, ts.visitNode(initializerFunction ? initializerFunction.part : node.initializer, visitor, ts.isForInitializer), ts.visitNode(shouldConvertCondition ? undefined : node.condition, visitor, ts.isExpression), ts.visitNode(shouldConvertIncrementor ? undefined : node.incrementor, visitor, ts.isExpression), convertedLoopBody);
+ return factory.updateForStatement(node, ts.visitNode(initializerFunction ? initializerFunction.part : node.initializer, visitorWithUnusedExpressionResult, ts.isForInitializer), ts.visitNode(shouldConvertCondition ? undefined : node.condition, visitor, ts.isExpression), ts.visitNode(shouldConvertIncrementor ? undefined : node.incrementor, visitorWithUnusedExpressionResult, ts.isExpression), convertedLoopBody);
}
function convertForOfStatement(node, convertedLoopBody) {
- return ts.updateForOf(node, undefined, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody);
+ return factory.updateForOfStatement(node, undefined, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody);
}
function convertForInStatement(node, convertedLoopBody) {
- return ts.updateForIn(node, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody);
+ return factory.updateForInStatement(node, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody);
}
function convertDoStatement(node, convertedLoopBody) {
- return ts.updateDo(node, convertedLoopBody, ts.visitNode(node.expression, visitor, ts.isExpression));
+ return factory.updateDoStatement(node, convertedLoopBody, ts.visitNode(node.expression, visitor, ts.isExpression));
}
function convertWhileStatement(node, convertedLoopBody) {
- return ts.updateWhile(node, ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody);
+ return factory.updateWhileStatement(node, ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody);
}
function createConvertedLoopState(node) {
var loopInitializer;
switch (node.kind) {
- case 230:
- case 231:
- case 232:
+ case 237:
+ case 238:
+ case 239:
var initializer = node.initializer;
- if (initializer && initializer.kind === 243) {
+ if (initializer && initializer.kind === 250) {
loopInitializer = initializer;
}
break;
outerState.argumentsName = state.argumentsName;
}
else {
- (extraVariableDeclarations || (extraVariableDeclarations = [])).push(ts.createVariableDeclaration(state.argumentsName, undefined, ts.createIdentifier("arguments")));
+ (extraVariableDeclarations || (extraVariableDeclarations = [])).push(factory.createVariableDeclaration(state.argumentsName, undefined, undefined, factory.createIdentifier("arguments")));
}
}
if (state.thisName) {
outerState.thisName = state.thisName;
}
else {
- (extraVariableDeclarations || (extraVariableDeclarations = [])).push(ts.createVariableDeclaration(state.thisName, undefined, ts.createIdentifier("this")));
+ (extraVariableDeclarations || (extraVariableDeclarations = [])).push(factory.createVariableDeclaration(state.thisName, undefined, undefined, factory.createIdentifier("this")));
}
}
if (state.hoistedLocalVariables) {
}
for (var _i = 0, _a = state.hoistedLocalVariables; _i < _a.length; _i++) {
var identifier = _a[_i];
- extraVariableDeclarations.push(ts.createVariableDeclaration(identifier));
+ extraVariableDeclarations.push(factory.createVariableDeclaration(identifier));
}
}
}
}
for (var _b = 0, _c = state.loopOutParameters; _b < _c.length; _b++) {
var outParam = _c[_b];
- extraVariableDeclarations.push(ts.createVariableDeclaration(outParam.outParamName));
+ extraVariableDeclarations.push(factory.createVariableDeclaration(outParam.outParamName));
}
}
if (state.conditionVariable) {
if (!extraVariableDeclarations) {
extraVariableDeclarations = [];
}
- extraVariableDeclarations.push(ts.createVariableDeclaration(state.conditionVariable, undefined, ts.createFalse()));
+ extraVariableDeclarations.push(factory.createVariableDeclaration(state.conditionVariable, undefined, undefined, factory.createFalse()));
}
if (extraVariableDeclarations) {
- statements.push(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(extraVariableDeclarations)));
+ statements.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList(extraVariableDeclarations)));
}
}
function createOutVariable(p) {
- return ts.createVariableDeclaration(p.originalName, undefined, p.outParamName);
+ return factory.createVariableDeclaration(p.originalName, undefined, undefined, p.outParamName);
}
function createFunctionForInitializerOfForStatement(node, currentState) {
- var functionName = ts.createUniqueName("_loop_init");
+ var functionName = factory.createUniqueName("_loop_init");
var containsYield = (node.initializer.transformFlags & 262144) !== 0;
var emitFlags = 0;
if (currentState.containsLexicalThis)
if (containsYield && hierarchyFacts & 4)
emitFlags |= 262144;
var statements = [];
- statements.push(ts.createVariableStatement(undefined, node.initializer));
+ statements.push(factory.createVariableStatement(undefined, node.initializer));
copyOutParameters(currentState.loopOutParameters, 2, 1, statements);
- var functionDeclaration = ts.createVariableStatement(undefined, ts.setEmitFlags(ts.createVariableDeclarationList([
- ts.createVariableDeclaration(functionName, undefined, ts.setEmitFlags(ts.createFunctionExpression(undefined, containsYield ? ts.createToken(41) : undefined, undefined, undefined, undefined, undefined, ts.visitNode(ts.createBlock(statements, true), visitor, ts.isBlock)), emitFlags))
+ var functionDeclaration = factory.createVariableStatement(undefined, ts.setEmitFlags(factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(functionName, undefined, undefined, ts.setEmitFlags(factory.createFunctionExpression(undefined, containsYield ? factory.createToken(41) : undefined, undefined, undefined, undefined, undefined, ts.visitNode(factory.createBlock(statements, true), visitor, ts.isBlock)), emitFlags))
]), 2097152));
- var part = ts.createVariableDeclarationList(ts.map(currentState.loopOutParameters, createOutVariable));
+ var part = factory.createVariableDeclarationList(ts.map(currentState.loopOutParameters, createOutVariable));
return { functionName: functionName, containsYield: containsYield, functionDeclaration: functionDeclaration, part: part };
}
function createFunctionForBodyOfIterationStatement(node, currentState, outerState) {
- var functionName = ts.createUniqueName("_loop");
+ var functionName = factory.createUniqueName("_loop");
startLexicalEnvironment();
- var statement = ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock);
+ var statement = ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock);
var lexicalEnvironment = endLexicalEnvironment();
var statements = [];
if (shouldConvertConditionOfForStatement(node) || shouldConvertIncrementorOfForStatement(node)) {
- currentState.conditionVariable = ts.createUniqueName("inc");
- statements.push(ts.createIf(currentState.conditionVariable, ts.createStatement(ts.visitNode(node.incrementor, visitor, ts.isExpression)), ts.createStatement(ts.createAssignment(currentState.conditionVariable, ts.createTrue()))));
+ currentState.conditionVariable = factory.createUniqueName("inc");
+ if (node.incrementor) {
+ statements.push(factory.createIfStatement(currentState.conditionVariable, factory.createExpressionStatement(ts.visitNode(node.incrementor, visitor, ts.isExpression)), factory.createExpressionStatement(factory.createAssignment(currentState.conditionVariable, factory.createTrue()))));
+ }
+ else {
+ statements.push(factory.createIfStatement(factory.createLogicalNot(currentState.conditionVariable), factory.createExpressionStatement(factory.createAssignment(currentState.conditionVariable, factory.createTrue()))));
+ }
if (shouldConvertConditionOfForStatement(node)) {
- statements.push(ts.createIf(ts.createPrefix(53, ts.visitNode(node.condition, visitor, ts.isExpression)), ts.visitNode(ts.createBreak(), visitor, ts.isStatement)));
+ statements.push(factory.createIfStatement(factory.createPrefixUnaryExpression(53, ts.visitNode(node.condition, visitor, ts.isExpression)), ts.visitNode(factory.createBreakStatement(), visitor, ts.isStatement)));
}
}
if (ts.isBlock(statement)) {
}
copyOutParameters(currentState.loopOutParameters, 1, 1, statements);
ts.insertStatementsAfterStandardPrologue(statements, lexicalEnvironment);
- var loopBody = ts.createBlock(statements, true);
+ var loopBody = factory.createBlock(statements, true);
if (ts.isBlock(statement))
ts.setOriginalNode(loopBody, statement);
var containsYield = (node.statement.transformFlags & 262144) !== 0;
emitFlags |= 8;
if (containsYield && (hierarchyFacts & 4) !== 0)
emitFlags |= 262144;
- var functionDeclaration = ts.createVariableStatement(undefined, ts.setEmitFlags(ts.createVariableDeclarationList([
- ts.createVariableDeclaration(functionName, undefined, ts.setEmitFlags(ts.createFunctionExpression(undefined, containsYield ? ts.createToken(41) : undefined, undefined, undefined, currentState.loopParameters, undefined, loopBody), emitFlags))
+ var functionDeclaration = factory.createVariableStatement(undefined, ts.setEmitFlags(factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(functionName, undefined, undefined, ts.setEmitFlags(factory.createFunctionExpression(undefined, containsYield ? factory.createToken(41) : undefined, undefined, undefined, currentState.loopParameters, undefined, loopBody), emitFlags))
]), 2097152));
var part = generateCallToConvertedLoop(functionName, currentState, outerState, containsYield);
return { functionName: functionName, containsYield: containsYield, functionDeclaration: functionDeclaration, part: part };
function copyOutParameter(outParam, copyDirection) {
var source = copyDirection === 0 ? outParam.outParamName : outParam.originalName;
var target = copyDirection === 0 ? outParam.originalName : outParam.outParamName;
- return ts.createBinary(target, 62, source);
+ return factory.createBinaryExpression(target, 62, source);
}
function copyOutParameters(outParams, partFlags, copyDirection, statements) {
for (var _i = 0, outParams_1 = outParams; _i < outParams_1.length; _i++) {
var outParam = outParams_1[_i];
if (outParam.flags & partFlags) {
- statements.push(ts.createExpressionStatement(copyOutParameter(outParam, copyDirection)));
+ statements.push(factory.createExpressionStatement(copyOutParameter(outParam, copyDirection)));
}
}
}
function generateCallToConvertedLoopInitializer(initFunctionExpressionName, containsYield) {
- var call = ts.createCall(initFunctionExpressionName, undefined, []);
+ var call = factory.createCallExpression(initFunctionExpressionName, undefined, []);
var callResult = containsYield
- ? ts.createYield(ts.createToken(41), ts.setEmitFlags(call, 8388608))
+ ? factory.createYieldExpression(factory.createToken(41), ts.setEmitFlags(call, 8388608))
: call;
- return ts.createStatement(callResult);
+ return factory.createExpressionStatement(callResult);
}
function generateCallToConvertedLoop(loopFunctionExpressionName, state, outerState, containsYield) {
var statements = [];
var isSimpleLoop = !(state.nonLocalJumps & ~4) &&
!state.labeledNonLocalBreaks &&
!state.labeledNonLocalContinues;
- var call = ts.createCall(loopFunctionExpressionName, undefined, ts.map(state.loopParameters, function (p) { return p.name; }));
+ var call = factory.createCallExpression(loopFunctionExpressionName, undefined, ts.map(state.loopParameters, function (p) { return p.name; }));
var callResult = containsYield
- ? ts.createYield(ts.createToken(41), ts.setEmitFlags(call, 8388608))
+ ? factory.createYieldExpression(factory.createToken(41), ts.setEmitFlags(call, 8388608))
: call;
if (isSimpleLoop) {
- statements.push(ts.createExpressionStatement(callResult));
+ statements.push(factory.createExpressionStatement(callResult));
copyOutParameters(state.loopOutParameters, 1, 0, statements);
}
else {
- var loopResultName = ts.createUniqueName("state");
- var stateVariable = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ts.createVariableDeclaration(loopResultName, undefined, callResult)]));
+ var loopResultName = factory.createUniqueName("state");
+ var stateVariable = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(loopResultName, undefined, undefined, callResult)]));
statements.push(stateVariable);
copyOutParameters(state.loopOutParameters, 1, 0, statements);
if (state.nonLocalJumps & 8) {
var returnStatement = void 0;
if (outerState) {
outerState.nonLocalJumps |= 8;
- returnStatement = ts.createReturn(loopResultName);
+ returnStatement = factory.createReturnStatement(loopResultName);
}
else {
- returnStatement = ts.createReturn(ts.createPropertyAccess(loopResultName, "value"));
+ returnStatement = factory.createReturnStatement(factory.createPropertyAccessExpression(loopResultName, "value"));
}
- statements.push(ts.createIf(ts.createBinary(ts.createTypeOf(loopResultName), 36, ts.createLiteral("object")), returnStatement));
+ statements.push(factory.createIfStatement(factory.createTypeCheck(loopResultName, "object"), returnStatement));
}
if (state.nonLocalJumps & 2) {
- statements.push(ts.createIf(ts.createBinary(loopResultName, 36, ts.createLiteral("break")), ts.createBreak()));
+ statements.push(factory.createIfStatement(factory.createStrictEquality(loopResultName, factory.createStringLiteral("break")), factory.createBreakStatement()));
}
if (state.labeledNonLocalBreaks || state.labeledNonLocalContinues) {
var caseClauses = [];
processLabeledJumps(state.labeledNonLocalBreaks, true, loopResultName, outerState, caseClauses);
processLabeledJumps(state.labeledNonLocalContinues, false, loopResultName, outerState, caseClauses);
- statements.push(ts.createSwitch(loopResultName, ts.createCaseBlock(caseClauses)));
+ statements.push(factory.createSwitchStatement(loopResultName, factory.createCaseBlock(caseClauses)));
}
}
return statements;
function setLabeledJump(state, isBreak, labelText, labelMarker) {
if (isBreak) {
if (!state.labeledNonLocalBreaks) {
- state.labeledNonLocalBreaks = ts.createMap();
+ state.labeledNonLocalBreaks = new ts.Map();
}
state.labeledNonLocalBreaks.set(labelText, labelMarker);
}
else {
if (!state.labeledNonLocalContinues) {
- state.labeledNonLocalContinues = ts.createMap();
+ state.labeledNonLocalContinues = new ts.Map();
}
state.labeledNonLocalContinues.set(labelText, labelMarker);
}
table.forEach(function (labelMarker, labelText) {
var statements = [];
if (!outerLoop || (outerLoop.labels && outerLoop.labels.get(labelText))) {
- var label = ts.createIdentifier(labelText);
- statements.push(isBreak ? ts.createBreak(label) : ts.createContinue(label));
+ var label = factory.createIdentifier(labelText);
+ statements.push(isBreak ? factory.createBreakStatement(label) : factory.createContinueStatement(label));
}
else {
setLabeledJump(outerLoop, isBreak, labelText, labelMarker);
- statements.push(ts.createReturn(loopResultName));
+ statements.push(factory.createReturnStatement(loopResultName));
}
- caseClauses.push(ts.createCaseClause(ts.createLiteral(labelMarker), statements));
+ caseClauses.push(factory.createCaseClause(factory.createStringLiteral(labelMarker), statements));
});
}
function processLoopVariableDeclaration(container, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForInitializer) {
}
}
else {
- loopParameters.push(ts.createParameter(undefined, undefined, undefined, name));
+ loopParameters.push(factory.createParameterDeclaration(undefined, undefined, undefined, name));
var checkFlags = resolver.getNodeCheckFlags(decl);
if (checkFlags & 4194304 || hasCapturedBindingsInForInitializer) {
- var outParamName = ts.createUniqueName("out_" + ts.idText(name));
+ var outParamName = factory.createUniqueName("out_" + ts.idText(name));
var flags = 0;
if (checkFlags & 4194304) {
flags |= 1;
for (var i = start; i < numProperties; i++) {
var property = properties[i];
switch (property.kind) {
- case 163:
- case 164:
+ case 167:
+ case 168:
var accessors = ts.getAllAccessorDeclarations(node.properties, property);
if (property === accessors.firstAccessor) {
expressions.push(transformAccessorsToExpression(receiver, accessors, node, !!node.multiLine));
}
break;
- case 161:
+ case 165:
expressions.push(transformObjectLiteralMethodDeclarationToExpression(property, receiver, node, node.multiLine));
break;
- case 281:
+ case 288:
expressions.push(transformPropertyAssignmentToExpression(property, receiver, node.multiLine));
break;
- case 282:
+ case 289:
expressions.push(transformShorthandPropertyAssignmentToExpression(property, receiver, node.multiLine));
break;
default:
}
}
function transformPropertyAssignmentToExpression(property, receiver, startsOnNewLine) {
- var expression = ts.createAssignment(ts.createMemberAccessForPropertyName(receiver, ts.visitNode(property.name, visitor, ts.isPropertyName)), ts.visitNode(property.initializer, visitor, ts.isExpression));
+ var expression = factory.createAssignment(ts.createMemberAccessForPropertyName(factory, receiver, ts.visitNode(property.name, visitor, ts.isPropertyName)), ts.visitNode(property.initializer, visitor, ts.isExpression));
ts.setTextRange(expression, property);
if (startsOnNewLine) {
ts.startOnNewLine(expression);
return expression;
}
function transformShorthandPropertyAssignmentToExpression(property, receiver, startsOnNewLine) {
- var expression = ts.createAssignment(ts.createMemberAccessForPropertyName(receiver, ts.visitNode(property.name, visitor, ts.isPropertyName)), ts.getSynthesizedClone(property.name));
+ var expression = factory.createAssignment(ts.createMemberAccessForPropertyName(factory, receiver, ts.visitNode(property.name, visitor, ts.isPropertyName)), factory.cloneNode(property.name));
ts.setTextRange(expression, property);
if (startsOnNewLine) {
ts.startOnNewLine(expression);
return expression;
}
function transformObjectLiteralMethodDeclarationToExpression(method, receiver, container, startsOnNewLine) {
- var expression = ts.createAssignment(ts.createMemberAccessForPropertyName(receiver, ts.visitNode(method.name, visitor, ts.isPropertyName)), transformFunctionLikeToExpression(method, method, undefined, container));
+ var expression = factory.createAssignment(ts.createMemberAccessForPropertyName(factory, receiver, ts.visitNode(method.name, visitor, ts.isPropertyName)), transformFunctionLikeToExpression(method, method, undefined, container));
ts.setTextRange(expression, method);
if (startsOnNewLine) {
ts.startOnNewLine(expression);
var updated;
ts.Debug.assert(!!node.variableDeclaration, "Catch clause variable should always be present when downleveling ES2015.");
if (ts.isBindingPattern(node.variableDeclaration.name)) {
- var temp = ts.createTempVariable(undefined);
- var newVariableDeclaration = ts.createVariableDeclaration(temp);
+ var temp = factory.createTempVariable(undefined);
+ var newVariableDeclaration = factory.createVariableDeclaration(temp);
ts.setTextRange(newVariableDeclaration, node.variableDeclaration);
var vars = ts.flattenDestructuringBinding(node.variableDeclaration, visitor, context, 0, temp);
- var list = ts.createVariableDeclarationList(vars);
+ var list = factory.createVariableDeclarationList(vars);
ts.setTextRange(list, node.variableDeclaration);
- var destructure = ts.createVariableStatement(undefined, list);
- updated = ts.updateCatchClause(node, newVariableDeclaration, addStatementToStartOfBlock(node.block, destructure));
+ var destructure = factory.createVariableStatement(undefined, list);
+ updated = factory.updateCatchClause(node, newVariableDeclaration, addStatementToStartOfBlock(node.block, destructure));
}
else {
updated = ts.visitEachChild(node, visitor, context);
}
function addStatementToStartOfBlock(block, statement) {
var transformedStatements = ts.visitNodes(block.statements, visitor, ts.isStatement);
- return ts.updateBlock(block, __spreadArrays([statement], transformedStatements));
+ return factory.updateBlock(block, __spreadArrays([statement], transformedStatements));
}
function visitMethodDeclaration(node) {
ts.Debug.assert(!ts.isComputedPropertyName(node.name));
var functionExpression = transformFunctionLikeToExpression(node, ts.moveRangePos(node, -1), undefined, undefined);
ts.setEmitFlags(functionExpression, 512 | ts.getEmitFlags(functionExpression));
- return ts.setTextRange(ts.createPropertyAssignment(node.name, functionExpression), node);
+ return ts.setTextRange(factory.createPropertyAssignment(node.name, functionExpression), node);
}
function visitAccessorDeclaration(node) {
ts.Debug.assert(!ts.isComputedPropertyName(node.name));
var updated;
var parameters = ts.visitParameterList(node.parameters, visitor, context);
var body = transformFunctionBody(node);
- if (node.kind === 163) {
- updated = ts.updateGetAccessor(node, node.decorators, node.modifiers, node.name, parameters, node.type, body);
+ if (node.kind === 167) {
+ updated = factory.updateGetAccessorDeclaration(node, node.decorators, node.modifiers, node.name, parameters, node.type, body);
}
else {
- updated = ts.updateSetAccessor(node, node.decorators, node.modifiers, node.name, parameters, body);
+ updated = factory.updateSetAccessorDeclaration(node, node.decorators, node.modifiers, node.name, parameters, body);
}
exitSubtree(ancestorFacts, 49152, 0);
convertedLoopState = savedConvertedLoopState;
return updated;
}
function visitShorthandPropertyAssignment(node) {
- return ts.setTextRange(ts.createPropertyAssignment(node.name, ts.getSynthesizedClone(node.name)), node);
+ return ts.setTextRange(factory.createPropertyAssignment(node.name, visitIdentifier(factory.cloneNode(node.name))), node);
}
function visitComputedPropertyName(node) {
return ts.visitEachChild(node, visitor, context);
return visitTypeScriptClassWrapper(node);
}
var expression = ts.skipOuterExpressions(node.expression);
- if (expression.kind === 102 ||
+ if (expression.kind === 105 ||
ts.isSuperProperty(expression) ||
ts.some(node.arguments, ts.isSpreadElement)) {
return visitCallExpressionWithPotentialCapturedThisAssignment(node, true);
}
- return ts.updateCall(node, ts.visitNode(node.expression, callExpressionVisitor, ts.isExpression), undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression));
+ return factory.updateCallExpression(node, ts.visitNode(node.expression, callExpressionVisitor, ts.isExpression), undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression));
}
function visitTypeScriptClassWrapper(node) {
var body = ts.cast(ts.cast(ts.skipOuterExpressions(node.expression), ts.isArrowFunction).body, ts.isBlock);
}
statements.push(funcStatements[classBodyStart]);
classBodyStart++;
- statements.push(ts.createExpressionStatement(ts.createAssignment(aliasAssignment.left, ts.cast(variable.name, ts.isIdentifier))));
+ statements.push(factory.createExpressionStatement(factory.createAssignment(aliasAssignment.left, ts.cast(variable.name, ts.isIdentifier))));
}
while (!ts.isReturnStatement(ts.elementAt(funcStatements, classBodyEnd))) {
classBodyEnd--;
}
ts.addRange(statements, remainingStatements);
ts.addRange(statements, classStatements, 1);
- return ts.recreateOuterExpressions(node.expression, ts.recreateOuterExpressions(variable.initializer, ts.recreateOuterExpressions(aliasAssignment && aliasAssignment.right, ts.updateCall(call, ts.recreateOuterExpressions(call.expression, ts.updateFunctionExpression(func, undefined, undefined, undefined, undefined, func.parameters, undefined, ts.updateBlock(func.body, statements))), undefined, call.arguments))));
+ return factory.restoreOuterExpressions(node.expression, factory.restoreOuterExpressions(variable.initializer, factory.restoreOuterExpressions(aliasAssignment && aliasAssignment.right, factory.updateCallExpression(call, factory.restoreOuterExpressions(call.expression, factory.updateFunctionExpression(func, undefined, undefined, undefined, undefined, func.parameters, undefined, factory.updateBlock(func.body, statements))), undefined, call.arguments))));
}
function visitImmediateSuperCallInBody(node) {
return visitCallExpressionWithPotentialCapturedThisAssignment(node, false);
}
function visitCallExpressionWithPotentialCapturedThisAssignment(node, assignToCapturedThis) {
if (node.transformFlags & 8192 ||
- node.expression.kind === 102 ||
+ node.expression.kind === 105 ||
ts.isSuperProperty(ts.skipOuterExpressions(node.expression))) {
- var _a = ts.createCallBinding(node.expression, hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg;
- if (node.expression.kind === 102) {
+ var _a = factory.createCallBinding(node.expression, hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg;
+ if (node.expression.kind === 105) {
ts.setEmitFlags(thisArg, 4);
}
var resultingCall = void 0;
if (node.transformFlags & 8192) {
- resultingCall = ts.createFunctionApply(ts.visitNode(target, callExpressionVisitor, ts.isExpression), node.expression.kind === 102 ? thisArg : ts.visitNode(thisArg, visitor, ts.isExpression), transformAndSpreadElements(node.arguments, false, false, false));
+ resultingCall = factory.createFunctionApplyCall(ts.visitNode(target, callExpressionVisitor, ts.isExpression), node.expression.kind === 105 ? thisArg : ts.visitNode(thisArg, visitor, ts.isExpression), transformAndSpreadElements(node.arguments, false, false, false));
}
else {
- resultingCall = ts.createFunctionCall(ts.visitNode(target, callExpressionVisitor, ts.isExpression), node.expression.kind === 102 ? thisArg : ts.visitNode(thisArg, visitor, ts.isExpression), ts.visitNodes(node.arguments, visitor, ts.isExpression), node);
+ resultingCall = ts.setTextRange(factory.createFunctionCallCall(ts.visitNode(target, callExpressionVisitor, ts.isExpression), node.expression.kind === 105 ? thisArg : ts.visitNode(thisArg, visitor, ts.isExpression), ts.visitNodes(node.arguments, visitor, ts.isExpression)), node);
}
- if (node.expression.kind === 102) {
- var initializer = ts.createLogicalOr(resultingCall, createActualThis());
+ if (node.expression.kind === 105) {
+ var initializer = factory.createLogicalOr(resultingCall, createActualThis());
resultingCall = assignToCapturedThis
- ? ts.createAssignment(ts.createFileLevelUniqueName("_this"), initializer)
+ ? factory.createAssignment(factory.createUniqueName("_this", 16 | 32), initializer)
: initializer;
}
return ts.setOriginalNode(resultingCall, node);
}
function visitNewExpression(node) {
if (ts.some(node.arguments, ts.isSpreadElement)) {
- var _a = ts.createCallBinding(ts.createPropertyAccess(node.expression, "bind"), hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg;
- return ts.createNew(ts.createFunctionApply(ts.visitNode(target, visitor, ts.isExpression), thisArg, transformAndSpreadElements(ts.createNodeArray(__spreadArrays([ts.createVoidZero()], node.arguments)), false, false, false)), undefined, []);
+ var _a = factory.createCallBinding(factory.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg;
+ return factory.createNewExpression(factory.createFunctionApplyCall(ts.visitNode(target, visitor, ts.isExpression), thisArg, transformAndSpreadElements(factory.createNodeArray(__spreadArrays([factory.createVoidZero()], node.arguments)), false, false, false)), undefined, []);
}
return ts.visitEachChild(node, visitor, context);
}
return segments[0];
}
}
- return ts.createSpreadHelper(context, segments);
+ return emitHelpers().createSpreadHelper(segments);
}
else {
if (segments.length === 1) {
return segments[0];
}
}
- return ts.createSpreadArraysHelper(context, segments);
+ return emitHelpers().createSpreadArraysHelper(segments);
}
}
function isPackedElement(node) {
return ts.map(chunk, visitExpressionOfSpread);
}
function visitSpanOfNonSpreads(chunk, multiLine, hasTrailingComma) {
- return ts.createArrayLiteral(ts.visitNodes(ts.createNodeArray(chunk, hasTrailingComma), visitor, ts.isExpression), multiLine);
+ return factory.createArrayLiteralExpression(ts.visitNodes(factory.createNodeArray(chunk, hasTrailingComma), visitor, ts.isExpression), multiLine);
}
function visitSpreadElement(node) {
return ts.visitNode(node.expression, visitor, ts.isExpression);
return ts.visitNode(node.expression, visitor, ts.isExpression);
}
function visitTemplateLiteral(node) {
- return ts.setTextRange(ts.createLiteral(node.text), node);
+ return ts.setTextRange(factory.createStringLiteral(node.text), node);
}
function visitStringLiteral(node) {
if (node.hasExtendedUnicodeEscape) {
- return ts.setTextRange(ts.createLiteral(node.text), node);
+ return ts.setTextRange(factory.createStringLiteral(node.text), node);
}
return node;
}
function visitNumericLiteral(node) {
if (node.numericLiteralFlags & 384) {
- return ts.setTextRange(ts.createNumericLiteral(node.text), node);
+ return ts.setTextRange(factory.createNumericLiteral(node.text), node);
}
return node;
}
var expressions = [];
addTemplateHead(expressions, node);
addTemplateSpans(expressions, node);
- var expression = ts.reduceLeft(expressions, ts.createAdd);
+ var expression = ts.reduceLeft(expressions, factory.createAdd);
if (ts.nodeIsSynthesized(expression)) {
- expression.pos = node.pos;
- expression.end = node.end;
+ ts.setTextRange(expression, node);
}
return expression;
}
if (!shouldAddTemplateHead(node)) {
return;
}
- expressions.push(ts.createLiteral(node.head.text));
+ expressions.push(factory.createStringLiteral(node.head.text));
}
function addTemplateSpans(expressions, node) {
for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) {
var span = _a[_i];
expressions.push(ts.visitNode(span.expression, visitor, ts.isExpression));
if (span.literal.text.length !== 0) {
- expressions.push(ts.createLiteral(span.literal.text));
+ expressions.push(factory.createStringLiteral(span.literal.text));
}
}
}
function visitSuperKeyword(isExpressionOfCall) {
- return hierarchyFacts & 8 && !isExpressionOfCall ? ts.createPropertyAccess(ts.createFileLevelUniqueName("_super"), "prototype") :
- ts.createFileLevelUniqueName("_super");
+ return hierarchyFacts & 8
+ && !isExpressionOfCall
+ ? factory.createPropertyAccessExpression(factory.createUniqueName("_super", 16 | 32), "prototype")
+ : factory.createUniqueName("_super", 16 | 32);
}
function visitMetaProperty(node) {
- if (node.keywordToken === 99 && node.name.escapedText === "target") {
+ if (node.keywordToken === 102 && node.name.escapedText === "target") {
hierarchyFacts |= 16384;
- return ts.createFileLevelUniqueName("_newTarget");
+ return factory.createUniqueName("_newTarget", 16 | 32);
}
return node;
}
function enableSubstitutionsForBlockScopedBindings() {
if ((enabledSubstitutions & 2) === 0) {
enabledSubstitutions |= 2;
- context.enableSubstitution(75);
+ context.enableSubstitution(78);
}
}
function enableSubstitutionsForCapturedThis() {
if ((enabledSubstitutions & 1) === 0) {
enabledSubstitutions |= 1;
- context.enableSubstitution(104);
- context.enableEmitNotification(162);
- context.enableEmitNotification(161);
- context.enableEmitNotification(163);
- context.enableEmitNotification(164);
- context.enableEmitNotification(202);
- context.enableEmitNotification(201);
- context.enableEmitNotification(244);
+ context.enableSubstitution(107);
+ context.enableEmitNotification(166);
+ context.enableEmitNotification(165);
+ context.enableEmitNotification(167);
+ context.enableEmitNotification(168);
+ context.enableEmitNotification(209);
+ context.enableEmitNotification(208);
+ context.enableEmitNotification(251);
}
}
function onSubstituteNode(hint, node) {
if (enabledSubstitutions & 2 && !ts.isInternalName(node)) {
var original = ts.getParseTreeNode(node, ts.isIdentifier);
if (original && isNameOfDeclarationWithCollidingName(original)) {
- return ts.setTextRange(ts.getGeneratedNameForNode(original), node);
+ return ts.setTextRange(factory.getGeneratedNameForNode(original), node);
}
}
return node;
}
function isNameOfDeclarationWithCollidingName(node) {
switch (node.parent.kind) {
- case 191:
- case 245:
- case 248:
- case 242:
+ case 198:
+ case 252:
+ case 255:
+ case 249:
return node.parent.name === node
&& resolver.isDeclarationWithCollidingName(node.parent);
}
}
function substituteExpression(node) {
switch (node.kind) {
- case 75:
+ case 78:
return substituteExpressionIdentifier(node);
- case 104:
+ case 107:
return substituteThisKeyword(node);
}
return node;
if (enabledSubstitutions & 2 && !ts.isInternalName(node)) {
var declaration = resolver.getReferencedDeclarationWithCollidingName(node);
if (declaration && !(ts.isClassLike(declaration) && isPartOfClassBody(declaration, node))) {
- return ts.setTextRange(ts.getGeneratedNameForNode(ts.getNameOfDeclaration(declaration)), node);
+ return ts.setTextRange(factory.getGeneratedNameForNode(ts.getNameOfDeclaration(declaration)), node);
}
}
return node;
function substituteThisKeyword(node) {
if (enabledSubstitutions & 1
&& hierarchyFacts & 16) {
- return ts.setTextRange(ts.createFileLevelUniqueName("_this"), node);
+ return ts.setTextRange(factory.createUniqueName("_this", 16 | 32), node);
}
return node;
}
function getClassMemberPrefix(node, member) {
- return ts.hasModifier(member, 32)
- ? ts.getInternalName(node)
- : ts.createPropertyAccess(ts.getInternalName(node), "prototype");
+ return ts.hasSyntacticModifier(member, 32)
+ ? factory.getInternalName(node)
+ : factory.createPropertyAccessExpression(factory.getInternalName(node), "prototype");
}
function hasSynthesizedDefaultSuperCall(constructor, hasExtendsClause) {
if (!constructor || !hasExtendsClause) {
return false;
}
var statement = ts.firstOrUndefined(constructor.body.statements);
- if (!statement || !ts.nodeIsSynthesized(statement) || statement.kind !== 226) {
+ if (!statement || !ts.nodeIsSynthesized(statement) || statement.kind !== 233) {
return false;
}
var statementExpression = statement.expression;
- if (!ts.nodeIsSynthesized(statementExpression) || statementExpression.kind !== 196) {
+ if (!ts.nodeIsSynthesized(statementExpression) || statementExpression.kind !== 203) {
return false;
}
var callTarget = statementExpression.expression;
- if (!ts.nodeIsSynthesized(callTarget) || callTarget.kind !== 102) {
+ if (!ts.nodeIsSynthesized(callTarget) || callTarget.kind !== 105) {
return false;
}
var callArgument = ts.singleOrUndefined(statementExpression.arguments);
- if (!callArgument || !ts.nodeIsSynthesized(callArgument) || callArgument.kind !== 213) {
+ if (!callArgument || !ts.nodeIsSynthesized(callArgument) || callArgument.kind !== 220) {
return false;
}
var expression = callArgument.expression;
}
}
ts.transformES2015 = transformES2015;
- function createExtendsHelper(context, name) {
- context.requestEmitHelper(ts.extendsHelper);
- return ts.createCall(ts.getUnscopedHelperName("__extends"), undefined, [
- name,
- ts.createFileLevelUniqueName("_super")
- ]);
- }
- ts.extendsHelper = {
- name: "typescript:extends",
- importName: "__extends",
- scoped: false,
- priority: 0,
- text: "\n var __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n })();"
- };
})(ts || (ts = {}));
var ts;
(function (ts) {
function transformES5(context) {
+ var factory = context.factory;
var compilerOptions = context.getCompilerOptions();
var previousOnEmitNode;
var noSubstitution;
if (compilerOptions.jsx === 1 || compilerOptions.jsx === 3) {
previousOnEmitNode = context.onEmitNode;
context.onEmitNode = onEmitNode;
- context.enableEmitNotification(268);
- context.enableEmitNotification(269);
- context.enableEmitNotification(267);
+ context.enableEmitNotification(275);
+ context.enableEmitNotification(276);
+ context.enableEmitNotification(274);
noSubstitution = [];
}
var previousOnSubstituteNode = context.onSubstituteNode;
context.onSubstituteNode = onSubstituteNode;
- context.enableSubstitution(194);
- context.enableSubstitution(281);
- return ts.chainBundle(transformSourceFile);
+ context.enableSubstitution(201);
+ context.enableSubstitution(288);
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
return node;
}
function onEmitNode(hint, node, emitCallback) {
switch (node.kind) {
- case 268:
- case 269:
- case 267:
+ case 275:
+ case 276:
+ case 274:
var tagName = node.tagName;
noSubstitution[ts.getOriginalNodeId(tagName)] = true;
break;
}
var literalName = trySubstituteReservedName(node.name);
if (literalName) {
- return ts.setTextRange(ts.createElementAccess(node.expression, literalName), node);
+ return ts.setTextRange(factory.createElementAccessExpression(node.expression, literalName), node);
}
return node;
}
function substitutePropertyAssignment(node) {
var literalName = ts.isIdentifier(node.name) && trySubstituteReservedName(node.name);
if (literalName) {
- return ts.updatePropertyAssignment(node, literalName, node.initializer);
+ return factory.updatePropertyAssignment(node, literalName, node.initializer);
}
return node;
}
function trySubstituteReservedName(name) {
var token = name.originalKeywordKind || (ts.nodeIsSynthesized(name) ? ts.stringToToken(ts.idText(name)) : undefined);
- if (token !== undefined && token >= 77 && token <= 112) {
- return ts.setTextRange(ts.createLiteral(name), name);
+ if (token !== undefined && token >= 80 && token <= 115) {
+ return ts.setTextRange(factory.createStringLiteralFromNode(name), name);
}
return undefined;
}
}
}
function transformGenerators(context) {
- var resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistFunctionDeclaration = context.hoistFunctionDeclaration, hoistVariableDeclaration = context.hoistVariableDeclaration;
+ var factory = context.factory, emitHelpers = context.getEmitHelperFactory, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistFunctionDeclaration = context.hoistFunctionDeclaration, hoistVariableDeclaration = context.hoistVariableDeclaration;
var compilerOptions = context.getCompilerOptions();
var languageVersion = ts.getEmitScriptTarget(compilerOptions);
var resolver = context.getEmitResolver();
var exceptionBlockStack;
var currentExceptionBlock;
var withBlockStack;
- return ts.chainBundle(transformSourceFile);
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile || (node.transformFlags & 512) === 0) {
return node;
}
function visitJavaScriptInStatementContainingYield(node) {
switch (node.kind) {
- case 228:
+ case 235:
return visitDoStatement(node);
- case 229:
+ case 236:
return visitWhileStatement(node);
- case 237:
+ case 244:
return visitSwitchStatement(node);
- case 238:
+ case 245:
return visitLabeledStatement(node);
default:
return visitJavaScriptInGeneratorFunctionBody(node);
}
function visitJavaScriptInGeneratorFunctionBody(node) {
switch (node.kind) {
- case 244:
+ case 251:
return visitFunctionDeclaration(node);
- case 201:
+ case 208:
return visitFunctionExpression(node);
- case 163:
- case 164:
+ case 167:
+ case 168:
return visitAccessorDeclaration(node);
- case 225:
+ case 232:
return visitVariableStatement(node);
- case 230:
+ case 237:
return visitForStatement(node);
- case 231:
+ case 238:
return visitForInStatement(node);
- case 234:
+ case 241:
return visitBreakStatement(node);
- case 233:
+ case 240:
return visitContinueStatement(node);
- case 235:
+ case 242:
return visitReturnStatement(node);
default:
if (node.transformFlags & 262144) {
}
function visitJavaScriptContainingYield(node) {
switch (node.kind) {
- case 209:
+ case 216:
return visitBinaryExpression(node);
- case 210:
+ case 337:
+ return visitCommaListExpression(node);
+ case 217:
return visitConditionalExpression(node);
- case 212:
+ case 219:
return visitYieldExpression(node);
- case 192:
+ case 199:
return visitArrayLiteralExpression(node);
- case 193:
+ case 200:
return visitObjectLiteralExpression(node);
- case 195:
+ case 202:
return visitElementAccessExpression(node);
- case 196:
+ case 203:
return visitCallExpression(node);
- case 197:
+ case 204:
return visitNewExpression(node);
default:
return ts.visitEachChild(node, visitor, context);
}
function visitGenerator(node) {
switch (node.kind) {
- case 244:
+ case 251:
return visitFunctionDeclaration(node);
- case 201:
+ case 208:
return visitFunctionExpression(node);
default:
return ts.Debug.failBadSyntaxKind(node);
}
function visitFunctionDeclaration(node) {
if (node.asteriskToken) {
- node = ts.setOriginalNode(ts.setTextRange(ts.createFunctionDeclaration(undefined, node.modifiers, undefined, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, transformGeneratorFunctionBody(node.body)), node), node);
+ node = ts.setOriginalNode(ts.setTextRange(factory.createFunctionDeclaration(undefined, node.modifiers, undefined, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, transformGeneratorFunctionBody(node.body)), node), node);
}
else {
var savedInGeneratorFunctionBody = inGeneratorFunctionBody;
}
function visitFunctionExpression(node) {
if (node.asteriskToken) {
- node = ts.setOriginalNode(ts.setTextRange(ts.createFunctionExpression(undefined, undefined, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, transformGeneratorFunctionBody(node.body)), node), node);
+ node = ts.setOriginalNode(ts.setTextRange(factory.createFunctionExpression(undefined, undefined, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, transformGeneratorFunctionBody(node.body)), node), node);
}
else {
var savedInGeneratorFunctionBody = inGeneratorFunctionBody;
operations = undefined;
operationArguments = undefined;
operationLocations = undefined;
- state = ts.createTempVariable(undefined);
+ state = factory.createTempVariable(undefined);
resumeLexicalEnvironment();
- var statementOffset = ts.addPrologue(statements, body.statements, false, visitor);
+ var statementOffset = factory.copyPrologue(body.statements, statements, false, visitor);
transformAndEmitStatements(body.statements, statementOffset);
var buildResult = build();
ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
- statements.push(ts.createReturn(buildResult));
+ statements.push(factory.createReturnStatement(buildResult));
inGeneratorFunctionBody = savedInGeneratorFunctionBody;
inStatementContainingYield = savedInStatementContainingYield;
blocks = savedBlocks;
operationArguments = savedOperationArguments;
operationLocations = savedOperationLocations;
state = savedState;
- return ts.setTextRange(ts.createBlock(statements, body.multiLine), body);
+ return ts.setTextRange(factory.createBlock(statements, body.multiLine), body);
}
function visitVariableStatement(node) {
if (node.transformFlags & 262144) {
if (variables.length === 0) {
return undefined;
}
- return ts.setSourceMapRange(ts.createExpressionStatement(ts.inlineExpressions(ts.map(variables, transformInitializedVariable))), node);
+ return ts.setSourceMapRange(factory.createExpressionStatement(factory.inlineExpressions(ts.map(variables, transformInitializedVariable))), node);
}
}
function visitBinaryExpression(node) {
if (containsYield(right)) {
var target = void 0;
switch (left.kind) {
- case 194:
- target = ts.updatePropertyAccess(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), left.name);
+ case 201:
+ target = factory.updatePropertyAccessExpression(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), left.name);
break;
- case 195:
- target = ts.updateElementAccess(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), cacheExpression(ts.visitNode(left.argumentExpression, visitor, ts.isExpression)));
+ case 202:
+ target = factory.updateElementAccessExpression(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), cacheExpression(ts.visitNode(left.argumentExpression, visitor, ts.isExpression)));
break;
default:
target = ts.visitNode(left, visitor, ts.isExpression);
}
var operator = node.operatorToken.kind;
if (ts.isCompoundAssignment(operator)) {
- return ts.setTextRange(ts.createAssignment(target, ts.setTextRange(ts.createBinary(cacheExpression(target), ts.getNonAssignmentOperatorForCompoundAssignment(operator), ts.visitNode(right, visitor, ts.isExpression)), node)), node);
+ return ts.setTextRange(factory.createAssignment(target, ts.setTextRange(factory.createBinaryExpression(cacheExpression(target), ts.getNonAssignmentOperatorForCompoundAssignment(operator), ts.visitNode(right, visitor, ts.isExpression)), node)), node);
}
else {
- return ts.updateBinary(node, target, ts.visitNode(right, visitor, ts.isExpression));
+ return factory.updateBinaryExpression(node, target, node.operatorToken, ts.visitNode(right, visitor, ts.isExpression));
}
}
return ts.visitEachChild(node, visitor, context);
else if (node.operatorToken.kind === 27) {
return visitCommaExpression(node);
}
- var clone_6 = ts.getMutableClone(node);
- clone_6.left = cacheExpression(ts.visitNode(node.left, visitor, ts.isExpression));
- clone_6.right = ts.visitNode(node.right, visitor, ts.isExpression);
- return clone_6;
+ return factory.updateBinaryExpression(node, cacheExpression(ts.visitNode(node.left, visitor, ts.isExpression)), node.operatorToken, ts.visitNode(node.right, visitor, ts.isExpression));
}
return ts.visitEachChild(node, visitor, context);
}
- function visitLogicalBinaryExpression(node) {
- var resultLabel = defineLabel();
- var resultLocal = declareLocal();
- emitAssignment(resultLocal, ts.visitNode(node.left, visitor, ts.isExpression), node.left);
- if (node.operatorToken.kind === 55) {
- emitBreakWhenFalse(resultLabel, resultLocal, node.left);
- }
- else {
- emitBreakWhenTrue(resultLabel, resultLocal, node.left);
- }
- emitAssignment(resultLocal, ts.visitNode(node.right, visitor, ts.isExpression), node.right);
- markLabel(resultLabel);
- return resultLocal;
- }
function visitCommaExpression(node) {
var pendingExpressions = [];
visit(node.left);
visit(node.right);
- return ts.inlineExpressions(pendingExpressions);
+ return factory.inlineExpressions(pendingExpressions);
function visit(node) {
if (ts.isBinaryExpression(node) && node.operatorToken.kind === 27) {
visit(node.left);
}
else {
if (containsYield(node) && pendingExpressions.length > 0) {
- emitWorker(1, [ts.createExpressionStatement(ts.inlineExpressions(pendingExpressions))]);
+ emitWorker(1, [factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))]);
pendingExpressions = [];
}
pendingExpressions.push(ts.visitNode(node, visitor, ts.isExpression));
}
}
}
+ function visitCommaListExpression(node) {
+ var pendingExpressions = [];
+ for (var _i = 0, _a = node.elements; _i < _a.length; _i++) {
+ var elem = _a[_i];
+ if (ts.isBinaryExpression(elem) && elem.operatorToken.kind === 27) {
+ pendingExpressions.push(visitCommaExpression(elem));
+ }
+ else {
+ if (containsYield(elem) && pendingExpressions.length > 0) {
+ emitWorker(1, [factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))]);
+ pendingExpressions = [];
+ }
+ pendingExpressions.push(ts.visitNode(elem, visitor, ts.isExpression));
+ }
+ }
+ return factory.inlineExpressions(pendingExpressions);
+ }
+ function visitLogicalBinaryExpression(node) {
+ var resultLabel = defineLabel();
+ var resultLocal = declareLocal();
+ emitAssignment(resultLocal, ts.visitNode(node.left, visitor, ts.isExpression), node.left);
+ if (node.operatorToken.kind === 55) {
+ emitBreakWhenFalse(resultLabel, resultLocal, node.left);
+ }
+ else {
+ emitBreakWhenTrue(resultLabel, resultLocal, node.left);
+ }
+ emitAssignment(resultLocal, ts.visitNode(node.right, visitor, ts.isExpression), node.right);
+ markLabel(resultLabel);
+ return resultLocal;
+ }
function visitConditionalExpression(node) {
if (containsYield(node.whenTrue) || containsYield(node.whenFalse)) {
var whenFalseLabel = defineLabel();
var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
if (node.asteriskToken) {
var iterator = (ts.getEmitFlags(node.expression) & 8388608) === 0
- ? ts.createValuesHelper(context, expression, node)
+ ? ts.setTextRange(emitHelpers().createValuesHelper(expression), node)
: expression;
emitYieldStar(iterator, node);
}
if (numInitialElements > 0) {
temp = declareLocal();
var initialElements = ts.visitNodes(elements, visitor, ts.isExpression, 0, numInitialElements);
- emitAssignment(temp, ts.createArrayLiteral(leadingElement
+ emitAssignment(temp, factory.createArrayLiteralExpression(leadingElement
? __spreadArrays([leadingElement], initialElements) : initialElements));
leadingElement = undefined;
}
var expressions = ts.reduceLeft(elements, reduceElement, [], numInitialElements);
return temp
- ? ts.createArrayConcat(temp, [ts.createArrayLiteral(expressions, multiLine)])
- : ts.setTextRange(ts.createArrayLiteral(leadingElement ? __spreadArrays([leadingElement], expressions) : expressions, multiLine), location);
+ ? factory.createArrayConcatCall(temp, [factory.createArrayLiteralExpression(expressions, multiLine)])
+ : ts.setTextRange(factory.createArrayLiteralExpression(leadingElement ? __spreadArrays([leadingElement], expressions) : expressions, multiLine), location);
function reduceElement(expressions, element) {
if (containsYield(element) && expressions.length > 0) {
var hasAssignedTemp = temp !== undefined;
temp = declareLocal();
}
emitAssignment(temp, hasAssignedTemp
- ? ts.createArrayConcat(temp, [ts.createArrayLiteral(expressions, multiLine)])
- : ts.createArrayLiteral(leadingElement ? __spreadArrays([leadingElement], expressions) : expressions, multiLine));
+ ? factory.createArrayConcatCall(temp, [factory.createArrayLiteralExpression(expressions, multiLine)])
+ : factory.createArrayLiteralExpression(leadingElement ? __spreadArrays([leadingElement], expressions) : expressions, multiLine));
leadingElement = undefined;
expressions = [];
}
var multiLine = node.multiLine;
var numInitialProperties = countInitialNodesWithoutYield(properties);
var temp = declareLocal();
- emitAssignment(temp, ts.createObjectLiteral(ts.visitNodes(properties, visitor, ts.isObjectLiteralElementLike, 0, numInitialProperties), multiLine));
+ emitAssignment(temp, factory.createObjectLiteralExpression(ts.visitNodes(properties, visitor, ts.isObjectLiteralElementLike, 0, numInitialProperties), multiLine));
var expressions = ts.reduceLeft(properties, reduceProperty, [], numInitialProperties);
- expressions.push(multiLine ? ts.startOnNewLine(ts.getMutableClone(temp)) : temp);
- return ts.inlineExpressions(expressions);
+ expressions.push(multiLine ? ts.startOnNewLine(ts.setParent(ts.setTextRange(factory.cloneNode(temp), temp), temp.parent)) : temp);
+ return factory.inlineExpressions(expressions);
function reduceProperty(expressions, property) {
if (containsYield(property) && expressions.length > 0) {
- emitStatement(ts.createExpressionStatement(ts.inlineExpressions(expressions)));
+ emitStatement(factory.createExpressionStatement(factory.inlineExpressions(expressions)));
expressions = [];
}
- var expression = ts.createExpressionForObjectLiteralElementLike(node, property, temp);
+ var expression = ts.createExpressionForObjectLiteralElementLike(factory, node, property, temp);
var visited = ts.visitNode(expression, visitor, ts.isExpression);
if (visited) {
if (multiLine) {
}
function visitElementAccessExpression(node) {
if (containsYield(node.argumentExpression)) {
- var clone_7 = ts.getMutableClone(node);
- clone_7.expression = cacheExpression(ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression));
- clone_7.argumentExpression = ts.visitNode(node.argumentExpression, visitor, ts.isExpression);
- return clone_7;
+ return factory.updateElementAccessExpression(node, cacheExpression(ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression)), ts.visitNode(node.argumentExpression, visitor, ts.isExpression));
}
return ts.visitEachChild(node, visitor, context);
}
function visitCallExpression(node) {
if (!ts.isImportCall(node) && ts.forEach(node.arguments, containsYield)) {
- var _a = ts.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, true), target = _a.target, thisArg = _a.thisArg;
- return ts.setOriginalNode(ts.createFunctionApply(cacheExpression(ts.visitNode(target, visitor, ts.isLeftHandSideExpression)), thisArg, visitElements(node.arguments), node), node);
+ var _a = factory.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, true), target = _a.target, thisArg = _a.thisArg;
+ return ts.setOriginalNode(ts.setTextRange(factory.createFunctionApplyCall(cacheExpression(ts.visitNode(target, visitor, ts.isLeftHandSideExpression)), thisArg, visitElements(node.arguments)), node), node);
}
return ts.visitEachChild(node, visitor, context);
}
function visitNewExpression(node) {
if (ts.forEach(node.arguments, containsYield)) {
- var _a = ts.createCallBinding(ts.createPropertyAccess(node.expression, "bind"), hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg;
- return ts.setOriginalNode(ts.setTextRange(ts.createNew(ts.createFunctionApply(cacheExpression(ts.visitNode(target, visitor, ts.isExpression)), thisArg, visitElements(node.arguments, ts.createVoidZero())), undefined, []), node), node);
+ var _a = factory.createCallBinding(factory.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg;
+ return ts.setOriginalNode(ts.setTextRange(factory.createNewExpression(factory.createFunctionApplyCall(cacheExpression(ts.visitNode(target, visitor, ts.isExpression)), thisArg, visitElements(node.arguments, factory.createVoidZero())), undefined, []), node), node);
}
return ts.visitEachChild(node, visitor, context);
}
}
function transformAndEmitStatementWorker(node) {
switch (node.kind) {
- case 223:
+ case 230:
return transformAndEmitBlock(node);
- case 226:
+ case 233:
return transformAndEmitExpressionStatement(node);
- case 227:
+ case 234:
return transformAndEmitIfStatement(node);
- case 228:
+ case 235:
return transformAndEmitDoStatement(node);
- case 229:
+ case 236:
return transformAndEmitWhileStatement(node);
- case 230:
+ case 237:
return transformAndEmitForStatement(node);
- case 231:
+ case 238:
return transformAndEmitForInStatement(node);
- case 233:
+ case 240:
return transformAndEmitContinueStatement(node);
- case 234:
+ case 241:
return transformAndEmitBreakStatement(node);
- case 235:
+ case 242:
return transformAndEmitReturnStatement(node);
- case 236:
+ case 243:
return transformAndEmitWithStatement(node);
- case 237:
+ case 244:
return transformAndEmitSwitchStatement(node);
- case 238:
+ case 245:
return transformAndEmitLabeledStatement(node);
- case 239:
+ case 246:
return transformAndEmitThrowStatement(node);
- case 240:
+ case 247:
return transformAndEmitTryStatement(node);
default:
return emitStatement(ts.visitNode(node, visitor, ts.isStatement));
function transformAndEmitVariableDeclarationList(node) {
for (var _i = 0, _a = node.declarations; _i < _a.length; _i++) {
var variable = _a[_i];
- var name = ts.getSynthesizedClone(variable.name);
+ var name = factory.cloneNode(variable.name);
ts.setCommentRange(name, variable.name);
hoistVariableDeclaration(name);
}
pendingExpressions.push(transformInitializedVariable(variable));
}
if (pendingExpressions.length) {
- emitStatement(ts.createExpressionStatement(ts.inlineExpressions(pendingExpressions)));
+ emitStatement(factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions)));
variablesWritten += pendingExpressions.length;
pendingExpressions = [];
}
return undefined;
}
function transformInitializedVariable(node) {
- return ts.setSourceMapRange(ts.createAssignment(ts.setSourceMapRange(ts.getSynthesizedClone(node.name), node.name), ts.visitNode(node.initializer, visitor, ts.isExpression)), node);
+ return ts.setSourceMapRange(factory.createAssignment(ts.setSourceMapRange(factory.cloneNode(node.name), node.name), ts.visitNode(node.initializer, visitor, ts.isExpression)), node);
}
function transformAndEmitIfStatement(node) {
if (containsYield(node)) {
transformAndEmitVariableDeclarationList(initializer);
}
else {
- emitStatement(ts.setTextRange(ts.createExpressionStatement(ts.visitNode(initializer, visitor, ts.isExpression)), initializer));
+ emitStatement(ts.setTextRange(factory.createExpressionStatement(ts.visitNode(initializer, visitor, ts.isExpression)), initializer));
}
}
markLabel(conditionLabel);
transformAndEmitEmbeddedStatement(node.statement);
markLabel(incrementLabel);
if (node.incrementor) {
- emitStatement(ts.setTextRange(ts.createExpressionStatement(ts.visitNode(node.incrementor, visitor, ts.isExpression)), node.incrementor));
+ emitStatement(ts.setTextRange(factory.createExpressionStatement(ts.visitNode(node.incrementor, visitor, ts.isExpression)), node.incrementor));
}
emitBreak(conditionLabel);
endLoopBlock();
hoistVariableDeclaration(variable.name);
}
var variables = ts.getInitializedVariables(initializer);
- node = ts.updateFor(node, variables.length > 0
- ? ts.inlineExpressions(ts.map(variables, transformInitializedVariable))
- : undefined, ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock));
+ node = factory.updateForStatement(node, variables.length > 0
+ ? factory.inlineExpressions(ts.map(variables, transformInitializedVariable))
+ : undefined, ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock));
}
else {
node = ts.visitEachChild(node, visitor, context);
if (containsYield(node)) {
var keysArray = declareLocal();
var key = declareLocal();
- var keysIndex = ts.createLoopVariable();
+ var keysIndex = factory.createLoopVariable();
var initializer = node.initializer;
hoistVariableDeclaration(keysIndex);
- emitAssignment(keysArray, ts.createArrayLiteral());
- emitStatement(ts.createForIn(key, ts.visitNode(node.expression, visitor, ts.isExpression), ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(keysArray, "push"), undefined, [key]))));
- emitAssignment(keysIndex, ts.createLiteral(0));
+ emitAssignment(keysArray, factory.createArrayLiteralExpression());
+ emitStatement(factory.createForInStatement(key, ts.visitNode(node.expression, visitor, ts.isExpression), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"), undefined, [key]))));
+ emitAssignment(keysIndex, factory.createNumericLiteral(0));
var conditionLabel = defineLabel();
var incrementLabel = defineLabel();
var endLabel = beginLoopBlock(incrementLabel);
markLabel(conditionLabel);
- emitBreakWhenFalse(endLabel, ts.createLessThan(keysIndex, ts.createPropertyAccess(keysArray, "length")));
+ emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
var variable = void 0;
if (ts.isVariableDeclarationList(initializer)) {
for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
var variable_1 = _a[_i];
hoistVariableDeclaration(variable_1.name);
}
- variable = ts.getSynthesizedClone(initializer.declarations[0].name);
+ variable = factory.cloneNode(initializer.declarations[0].name);
}
else {
variable = ts.visitNode(initializer, visitor, ts.isExpression);
ts.Debug.assert(ts.isLeftHandSideExpression(variable));
}
- emitAssignment(variable, ts.createElementAccess(keysArray, keysIndex));
+ emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
transformAndEmitEmbeddedStatement(node.statement);
markLabel(incrementLabel);
- emitStatement(ts.createExpressionStatement(ts.createPostfixIncrement(keysIndex)));
+ emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
emitBreak(conditionLabel);
endLoopBlock();
}
var variable = _a[_i];
hoistVariableDeclaration(variable.name);
}
- node = ts.updateForIn(node, initializer.declarations[0].name, ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement, ts.liftToBlock));
+ node = factory.updateForInStatement(node, initializer.declarations[0].name, ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock));
}
else {
node = ts.visitEachChild(node, visitor, context);
for (var i = 0; i < numClauses; i++) {
var clause = caseBlock.clauses[i];
clauseLabels.push(defineLabel());
- if (clause.kind === 278 && defaultClauseIndex === -1) {
+ if (clause.kind === 285 && defaultClauseIndex === -1) {
defaultClauseIndex = i;
}
}
var defaultClausesSkipped = 0;
for (var i = clausesWritten; i < numClauses; i++) {
var clause = caseBlock.clauses[i];
- if (clause.kind === 277) {
+ if (clause.kind === 284) {
if (containsYield(clause.expression) && pendingClauses.length > 0) {
break;
}
- pendingClauses.push(ts.createCaseClause(ts.visitNode(clause.expression, visitor, ts.isExpression), [
+ pendingClauses.push(factory.createCaseClause(ts.visitNode(clause.expression, visitor, ts.isExpression), [
createInlineBreak(clauseLabels[i], clause.expression)
]));
}
}
}
if (pendingClauses.length) {
- emitStatement(ts.createSwitch(expression, ts.createCaseBlock(pendingClauses)));
+ emitStatement(factory.createSwitchStatement(expression, factory.createCaseBlock(pendingClauses)));
clausesWritten += pendingClauses.length;
pendingClauses = [];
}
return node;
}
function transformAndEmitThrowStatement(node) {
- emitThrow(ts.visitNode(node.expression, visitor, ts.isExpression), node);
+ var _a;
+ emitThrow(ts.visitNode((_a = node.expression) !== null && _a !== void 0 ? _a : factory.createVoidZero(), visitor, ts.isExpression), node);
}
function transformAndEmitTryStatement(node) {
if (containsYield(node)) {
if (declaration) {
var name = renamedCatchVariableDeclarations[ts.getOriginalNodeId(declaration)];
if (name) {
- var clone_8 = ts.getMutableClone(name);
- ts.setSourceMapRange(clone_8, node);
- ts.setCommentRange(clone_8, node);
- return clone_8;
+ var clone_5 = ts.setParent(ts.setTextRange(factory.cloneNode(name), name), name.parent);
+ ts.setSourceMapRange(clone_5, node);
+ ts.setCommentRange(clone_5, node);
+ return clone_5;
}
}
}
if (ts.isGeneratedIdentifier(node) || ts.getEmitFlags(node) & 4096) {
return node;
}
- var temp = ts.createTempVariable(hoistVariableDeclaration);
+ var temp = factory.createTempVariable(hoistVariableDeclaration);
emitAssignment(temp, node, node);
return temp;
}
function declareLocal(name) {
var temp = name
- ? ts.createUniqueName(name)
- : ts.createTempVariable(undefined);
+ ? factory.createUniqueName(name)
+ : factory.createTempVariable(undefined);
hoistVariableDeclaration(temp);
return temp;
}
var text = ts.idText(variable.name);
name = declareLocal(text);
if (!renamedCatchVariables) {
- renamedCatchVariables = ts.createMap();
+ renamedCatchVariables = new ts.Map();
renamedCatchVariableDeclarations = [];
- context.enableSubstitution(75);
+ context.enableSubstitution(78);
}
renamedCatchVariables.set(text, true);
renamedCatchVariableDeclarations[ts.getOriginalNodeId(variable)] = name;
exception.state = 1;
exception.catchVariable = name;
exception.catchLabel = catchLabel;
- emitAssignment(name, ts.createCall(ts.createPropertyAccess(state, "sent"), undefined, []));
+ emitAssignment(name, factory.createCallExpression(factory.createPropertyAccessExpression(state, "sent"), undefined, []));
emitNop();
}
function beginFinallyBlock() {
if (labelExpressions === undefined) {
labelExpressions = [];
}
- var expression = ts.createLiteral(-1);
+ var expression = factory.createNumericLiteral(-1);
if (labelExpressions[label] === undefined) {
labelExpressions[label] = [expression];
}
}
return expression;
}
- return ts.createOmittedExpression();
+ return factory.createOmittedExpression();
}
function createInstruction(instruction) {
- var literal = ts.createLiteral(instruction);
+ var literal = factory.createNumericLiteral(instruction);
ts.addSyntheticTrailingComment(literal, 3, getInstructionName(instruction));
return literal;
}
function createInlineBreak(label, location) {
ts.Debug.assertLessThan(0, label, "Invalid label");
- return ts.setTextRange(ts.createReturn(ts.createArrayLiteral([
+ return ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([
createInstruction(3),
createLabel(label)
])), location);
}
function createInlineReturn(expression, location) {
- return ts.setTextRange(ts.createReturn(ts.createArrayLiteral(expression
+ return ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression(expression
? [createInstruction(2), expression]
: [createInstruction(2)])), location);
}
function createGeneratorResume(location) {
- return ts.setTextRange(ts.createCall(ts.createPropertyAccess(state, "sent"), undefined, []), location);
+ return ts.setTextRange(factory.createCallExpression(factory.createPropertyAccessExpression(state, "sent"), undefined, []), location);
}
function emitNop() {
emitWorker(0);
currentExceptionBlock = undefined;
withBlockStack = undefined;
var buildResult = buildStatements();
- return createGeneratorHelper(context, ts.setEmitFlags(ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, state)], undefined, ts.createBlock(buildResult, buildResult.length > 0)), 524288));
+ return emitHelpers().createGeneratorHelper(ts.setEmitFlags(factory.createFunctionExpression(undefined, undefined, undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, state)], undefined, factory.createBlock(buildResult, buildResult.length > 0)), 524288));
}
function buildStatements() {
if (operations) {
flushFinalLabel(0);
}
if (clauses) {
- var labelExpression = ts.createPropertyAccess(state, "label");
- var switchStatement = ts.createSwitch(labelExpression, ts.createCaseBlock(clauses));
+ var labelExpression = factory.createPropertyAccessExpression(state, "label");
+ var switchStatement = factory.createSwitchStatement(labelExpression, factory.createCaseBlock(clauses));
return [ts.startOnNewLine(switchStatement)];
}
if (statements) {
if (withBlockStack) {
for (var i = withBlockStack.length - 1; i >= 0; i--) {
var withBlock = withBlockStack[i];
- statements = [ts.createWith(withBlock.expression, ts.createBlock(statements))];
+ statements = [factory.createWithStatement(withBlock.expression, factory.createBlock(statements))];
}
}
if (currentExceptionBlock) {
var startLabel = currentExceptionBlock.startLabel, catchLabel = currentExceptionBlock.catchLabel, finallyLabel = currentExceptionBlock.finallyLabel, endLabel = currentExceptionBlock.endLabel;
- statements.unshift(ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(ts.createPropertyAccess(state, "trys"), "push"), undefined, [
- ts.createArrayLiteral([
+ statements.unshift(factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(state, "trys"), "push"), undefined, [
+ factory.createArrayLiteralExpression([
createLabel(startLabel),
createLabel(catchLabel),
createLabel(finallyLabel),
currentExceptionBlock = undefined;
}
if (markLabelEnd) {
- statements.push(ts.createExpressionStatement(ts.createAssignment(ts.createPropertyAccess(state, "label"), ts.createLiteral(labelNumber + 1))));
+ statements.push(factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(state, "label"), factory.createNumericLiteral(labelNumber + 1))));
}
}
- clauses.push(ts.createCaseClause(ts.createLiteral(labelNumber), statements || []));
+ clauses.push(factory.createCaseClause(factory.createNumericLiteral(labelNumber), statements || []));
statements = undefined;
}
function tryEnterLabel(operationIndex) {
}
}
function writeAssign(left, right, operationLocation) {
- writeStatement(ts.setTextRange(ts.createExpressionStatement(ts.createAssignment(left, right)), operationLocation));
+ writeStatement(ts.setTextRange(factory.createExpressionStatement(factory.createAssignment(left, right)), operationLocation));
}
function writeThrow(expression, operationLocation) {
lastOperationWasAbrupt = true;
lastOperationWasCompletion = true;
- writeStatement(ts.setTextRange(ts.createThrow(expression), operationLocation));
+ writeStatement(ts.setTextRange(factory.createThrowStatement(expression), operationLocation));
}
function writeReturn(expression, operationLocation) {
lastOperationWasAbrupt = true;
lastOperationWasCompletion = true;
- writeStatement(ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral(expression
+ writeStatement(ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression(expression
? [createInstruction(2), expression]
: [createInstruction(2)])), operationLocation), 384));
}
function writeBreak(label, operationLocation) {
lastOperationWasAbrupt = true;
- writeStatement(ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral([
+ writeStatement(ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([
createInstruction(3),
createLabel(label)
])), operationLocation), 384));
}
function writeBreakWhenTrue(label, condition, operationLocation) {
- writeStatement(ts.setEmitFlags(ts.createIf(condition, ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral([
+ writeStatement(ts.setEmitFlags(factory.createIfStatement(condition, ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([
createInstruction(3),
createLabel(label)
])), operationLocation), 384)), 1));
}
function writeBreakWhenFalse(label, condition, operationLocation) {
- writeStatement(ts.setEmitFlags(ts.createIf(ts.createLogicalNot(condition), ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral([
+ writeStatement(ts.setEmitFlags(factory.createIfStatement(factory.createLogicalNot(condition), ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([
createInstruction(3),
createLabel(label)
])), operationLocation), 384)), 1));
}
function writeYield(expression, operationLocation) {
lastOperationWasAbrupt = true;
- writeStatement(ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral(expression
+ writeStatement(ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression(expression
? [createInstruction(4), expression]
: [createInstruction(4)])), operationLocation), 384));
}
function writeYieldStar(expression, operationLocation) {
lastOperationWasAbrupt = true;
- writeStatement(ts.setEmitFlags(ts.setTextRange(ts.createReturn(ts.createArrayLiteral([
+ writeStatement(ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([
createInstruction(5),
expression
])), operationLocation), 384));
}
function writeEndfinally() {
lastOperationWasAbrupt = true;
- writeStatement(ts.createReturn(ts.createArrayLiteral([
+ writeStatement(factory.createReturnStatement(factory.createArrayLiteralExpression([
createInstruction(7)
])));
}
}
ts.transformGenerators = transformGenerators;
- function createGeneratorHelper(context, body) {
- context.requestEmitHelper(ts.generatorHelper);
- return ts.createCall(ts.getUnscopedHelperName("__generator"), undefined, [ts.createThis(), body]);
- }
- ts.generatorHelper = {
- name: "typescript:generator",
- importName: "__generator",
- scoped: false,
- priority: 6,
- text: "\n var __generator = (this && this.__generator) || function (thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (_) try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n };"
- };
})(ts || (ts = {}));
var ts;
(function (ts) {
default: return transformCommonJSModule;
}
}
- var startLexicalEnvironment = context.startLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
+ var factory = context.factory, emitHelpers = context.getEmitHelperFactory, startLexicalEnvironment = context.startLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
var compilerOptions = context.getCompilerOptions();
var resolver = context.getEmitResolver();
var host = context.getEmitHost();
var previousOnEmitNode = context.onEmitNode;
context.onSubstituteNode = onSubstituteNode;
context.onEmitNode = onEmitNode;
- context.enableSubstitution(75);
- context.enableSubstitution(209);
- context.enableSubstitution(207);
- context.enableSubstitution(208);
- context.enableSubstitution(282);
- context.enableEmitNotification(290);
+ context.enableSubstitution(78);
+ context.enableSubstitution(216);
+ context.enableSubstitution(214);
+ context.enableSubstitution(215);
+ context.enableSubstitution(289);
+ context.enableEmitNotification(297);
var moduleInfoMap = [];
var deferredExports = [];
var currentSourceFile;
var currentModuleInfo;
var noSubstitution;
var needUMDDynamicImportHelper;
- return ts.chainBundle(transformSourceFile);
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile ||
!(ts.isEffectiveExternalModule(node, compilerOptions) ||
node.transformFlags & 2097152 ||
- (ts.isJsonSourceFile(node) && ts.hasJsonModuleEmitEnabled(compilerOptions) && (compilerOptions.out || compilerOptions.outFile)))) {
+ (ts.isJsonSourceFile(node) && ts.hasJsonModuleEmitEnabled(compilerOptions) && ts.outFile(compilerOptions)))) {
return node;
}
currentSourceFile = node;
- currentModuleInfo = ts.collectExternalModuleInfo(node, resolver, compilerOptions);
+ currentModuleInfo = ts.collectExternalModuleInfo(context, node, resolver, compilerOptions);
moduleInfoMap[ts.getOriginalNodeId(node)] = currentModuleInfo;
var transformModule = getTransformModuleDelegate(moduleKind);
var updated = transformModule(node);
currentSourceFile = undefined;
currentModuleInfo = undefined;
needUMDDynamicImportHelper = false;
- return ts.aggregateTransformFlags(updated);
+ return updated;
}
function shouldEmitUnderscoreUnderscoreESModule() {
if (!currentModuleInfo.exportEquals && ts.isExternalModule(currentSourceFile)) {
startLexicalEnvironment();
var statements = [];
var ensureUseStrict = ts.getStrictOptionValue(compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && ts.isExternalModule(currentSourceFile));
- var statementOffset = ts.addPrologue(statements, node.statements, ensureUseStrict && !ts.isJsonSourceFile(node), sourceElementVisitor);
+ var statementOffset = factory.copyPrologue(node.statements, statements, ensureUseStrict && !ts.isJsonSourceFile(node), sourceElementVisitor);
if (shouldEmitUnderscoreUnderscoreESModule()) {
ts.append(statements, createUnderscoreUnderscoreESModule());
}
if (ts.length(currentModuleInfo.exportedNames)) {
- ts.append(statements, ts.createExpressionStatement(ts.reduceLeft(currentModuleInfo.exportedNames, function (prev, nextId) { return ts.createAssignment(ts.createPropertyAccess(ts.createIdentifier("exports"), ts.createIdentifier(ts.idText(nextId))), prev); }, ts.createVoidZero())));
+ var chunkSize = 50;
+ for (var i = 0; i < currentModuleInfo.exportedNames.length; i += chunkSize) {
+ ts.append(statements, factory.createExpressionStatement(ts.reduceLeft(currentModuleInfo.exportedNames.slice(i, i + chunkSize), function (prev, nextId) { return factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(ts.idText(nextId))), prev); }, factory.createVoidZero())));
+ }
}
ts.append(statements, ts.visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, ts.isStatement));
ts.addRange(statements, ts.visitNodes(node.statements, sourceElementVisitor, ts.isStatement, statementOffset));
addExportEqualsIfNeeded(statements, false);
ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
- var updated = ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray(statements), node.statements));
+ var updated = factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray(statements), node.statements));
ts.addEmitHelpers(updated, context.readEmitHelpers());
return updated;
}
function transformAMDModule(node) {
- var define = ts.createIdentifier("define");
- var moduleName = ts.tryGetModuleNameFromFile(node, host, compilerOptions);
+ var define = factory.createIdentifier("define");
+ var moduleName = ts.tryGetModuleNameFromFile(factory, node, host, compilerOptions);
var jsonSourceFile = ts.isJsonSourceFile(node) && node;
var _a = collectAsynchronousDependencies(node, true), aliasedModuleNames = _a.aliasedModuleNames, unaliasedModuleNames = _a.unaliasedModuleNames, importAliasNames = _a.importAliasNames;
- var updated = ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray([
- ts.createExpressionStatement(ts.createCall(define, undefined, __spreadArrays((moduleName ? [moduleName] : []), [
- ts.createArrayLiteral(jsonSourceFile ? ts.emptyArray : __spreadArrays([
- ts.createLiteral("require"),
- ts.createLiteral("exports")
+ var updated = factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray([
+ factory.createExpressionStatement(factory.createCallExpression(define, undefined, __spreadArrays((moduleName ? [moduleName] : []), [
+ factory.createArrayLiteralExpression(jsonSourceFile ? ts.emptyArray : __spreadArrays([
+ factory.createStringLiteral("require"),
+ factory.createStringLiteral("exports")
], aliasedModuleNames, unaliasedModuleNames)),
jsonSourceFile ?
- jsonSourceFile.statements.length ? jsonSourceFile.statements[0].expression : ts.createObjectLiteral() :
- ts.createFunctionExpression(undefined, undefined, undefined, undefined, __spreadArrays([
- ts.createParameter(undefined, undefined, undefined, "require"),
- ts.createParameter(undefined, undefined, undefined, "exports")
+ jsonSourceFile.statements.length ? jsonSourceFile.statements[0].expression : factory.createObjectLiteralExpression() :
+ factory.createFunctionExpression(undefined, undefined, undefined, undefined, __spreadArrays([
+ factory.createParameterDeclaration(undefined, undefined, undefined, "require"),
+ factory.createParameterDeclaration(undefined, undefined, undefined, "exports")
], importAliasNames), undefined, transformAsynchronousModuleBody(node))
])))
]), node.statements));
}
function transformUMDModule(node) {
var _a = collectAsynchronousDependencies(node, false), aliasedModuleNames = _a.aliasedModuleNames, unaliasedModuleNames = _a.unaliasedModuleNames, importAliasNames = _a.importAliasNames;
- var moduleName = ts.tryGetModuleNameFromFile(node, host, compilerOptions);
- var umdHeader = ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, "factory")], undefined, ts.setTextRange(ts.createBlock([
- ts.createIf(ts.createLogicalAnd(ts.createTypeCheck(ts.createIdentifier("module"), "object"), ts.createTypeCheck(ts.createPropertyAccess(ts.createIdentifier("module"), "exports"), "object")), ts.createBlock([
- ts.createVariableStatement(undefined, [
- ts.createVariableDeclaration("v", undefined, ts.createCall(ts.createIdentifier("factory"), undefined, [
- ts.createIdentifier("require"),
- ts.createIdentifier("exports")
+ var moduleName = ts.tryGetModuleNameFromFile(factory, node, host, compilerOptions);
+ var umdHeader = factory.createFunctionExpression(undefined, undefined, undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, "factory")], undefined, ts.setTextRange(factory.createBlock([
+ factory.createIfStatement(factory.createLogicalAnd(factory.createTypeCheck(factory.createIdentifier("module"), "object"), factory.createTypeCheck(factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), "object")), factory.createBlock([
+ factory.createVariableStatement(undefined, [
+ factory.createVariableDeclaration("v", undefined, undefined, factory.createCallExpression(factory.createIdentifier("factory"), undefined, [
+ factory.createIdentifier("require"),
+ factory.createIdentifier("exports")
]))
]),
- ts.setEmitFlags(ts.createIf(ts.createStrictInequality(ts.createIdentifier("v"), ts.createIdentifier("undefined")), ts.createExpressionStatement(ts.createAssignment(ts.createPropertyAccess(ts.createIdentifier("module"), "exports"), ts.createIdentifier("v")))), 1)
- ]), ts.createIf(ts.createLogicalAnd(ts.createTypeCheck(ts.createIdentifier("define"), "function"), ts.createPropertyAccess(ts.createIdentifier("define"), "amd")), ts.createBlock([
- ts.createExpressionStatement(ts.createCall(ts.createIdentifier("define"), undefined, __spreadArrays((moduleName ? [moduleName] : []), [
- ts.createArrayLiteral(__spreadArrays([
- ts.createLiteral("require"),
- ts.createLiteral("exports")
+ ts.setEmitFlags(factory.createIfStatement(factory.createStrictInequality(factory.createIdentifier("v"), factory.createIdentifier("undefined")), factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), factory.createIdentifier("v")))), 1)
+ ]), factory.createIfStatement(factory.createLogicalAnd(factory.createTypeCheck(factory.createIdentifier("define"), "function"), factory.createPropertyAccessExpression(factory.createIdentifier("define"), "amd")), factory.createBlock([
+ factory.createExpressionStatement(factory.createCallExpression(factory.createIdentifier("define"), undefined, __spreadArrays((moduleName ? [moduleName] : []), [
+ factory.createArrayLiteralExpression(__spreadArrays([
+ factory.createStringLiteral("require"),
+ factory.createStringLiteral("exports")
], aliasedModuleNames, unaliasedModuleNames)),
- ts.createIdentifier("factory")
+ factory.createIdentifier("factory")
])))
])))
], true), undefined));
- var updated = ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray([
- ts.createExpressionStatement(ts.createCall(umdHeader, undefined, [
- ts.createFunctionExpression(undefined, undefined, undefined, undefined, __spreadArrays([
- ts.createParameter(undefined, undefined, undefined, "require"),
- ts.createParameter(undefined, undefined, undefined, "exports")
+ var updated = factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray([
+ factory.createExpressionStatement(factory.createCallExpression(umdHeader, undefined, [
+ factory.createFunctionExpression(undefined, undefined, undefined, undefined, __spreadArrays([
+ factory.createParameterDeclaration(undefined, undefined, undefined, "require"),
+ factory.createParameterDeclaration(undefined, undefined, undefined, "exports")
], importAliasNames), undefined, transformAsynchronousModuleBody(node))
]))
]), node.statements));
for (var _i = 0, _a = node.amdDependencies; _i < _a.length; _i++) {
var amdDependency = _a[_i];
if (amdDependency.name) {
- aliasedModuleNames.push(ts.createLiteral(amdDependency.path));
- importAliasNames.push(ts.createParameter(undefined, undefined, undefined, amdDependency.name));
+ aliasedModuleNames.push(factory.createStringLiteral(amdDependency.path));
+ importAliasNames.push(factory.createParameterDeclaration(undefined, undefined, undefined, amdDependency.name));
}
else {
- unaliasedModuleNames.push(ts.createLiteral(amdDependency.path));
+ unaliasedModuleNames.push(factory.createStringLiteral(amdDependency.path));
}
}
for (var _b = 0, _c = currentModuleInfo.externalImports; _b < _c.length; _b++) {
var importNode = _c[_b];
- var externalModuleName = ts.getExternalModuleNameLiteral(importNode, currentSourceFile, host, resolver, compilerOptions);
- var importAliasName = ts.getLocalNameForExternalImport(importNode, currentSourceFile);
+ var externalModuleName = ts.getExternalModuleNameLiteral(factory, importNode, currentSourceFile, host, resolver, compilerOptions);
+ var importAliasName = ts.getLocalNameForExternalImport(factory, importNode, currentSourceFile);
if (externalModuleName) {
if (includeNonAmdDependencies && importAliasName) {
ts.setEmitFlags(importAliasName, 4);
aliasedModuleNames.push(externalModuleName);
- importAliasNames.push(ts.createParameter(undefined, undefined, undefined, importAliasName));
+ importAliasNames.push(factory.createParameterDeclaration(undefined, undefined, undefined, importAliasName));
}
else {
unaliasedModuleNames.push(externalModuleName);
return { aliasedModuleNames: aliasedModuleNames, unaliasedModuleNames: unaliasedModuleNames, importAliasNames: importAliasNames };
}
function getAMDImportExpressionForImport(node) {
- if (ts.isImportEqualsDeclaration(node) || ts.isExportDeclaration(node) || !ts.getExternalModuleNameLiteral(node, currentSourceFile, host, resolver, compilerOptions)) {
+ if (ts.isImportEqualsDeclaration(node) || ts.isExportDeclaration(node) || !ts.getExternalModuleNameLiteral(factory, node, currentSourceFile, host, resolver, compilerOptions)) {
return undefined;
}
- var name = ts.getLocalNameForExternalImport(node, currentSourceFile);
+ var name = ts.getLocalNameForExternalImport(factory, node, currentSourceFile);
var expr = getHelperExpressionForImport(node, name);
if (expr === name) {
return undefined;
}
- return ts.createExpressionStatement(ts.createAssignment(name, expr));
+ return factory.createExpressionStatement(factory.createAssignment(name, expr));
}
function transformAsynchronousModuleBody(node) {
startLexicalEnvironment();
var statements = [];
- var statementOffset = ts.addPrologue(statements, node.statements, !compilerOptions.noImplicitUseStrict, sourceElementVisitor);
+ var statementOffset = factory.copyPrologue(node.statements, statements, !compilerOptions.noImplicitUseStrict, sourceElementVisitor);
if (shouldEmitUnderscoreUnderscoreESModule()) {
ts.append(statements, createUnderscoreUnderscoreESModule());
}
if (ts.length(currentModuleInfo.exportedNames)) {
- ts.append(statements, ts.createExpressionStatement(ts.reduceLeft(currentModuleInfo.exportedNames, function (prev, nextId) { return ts.createAssignment(ts.createPropertyAccess(ts.createIdentifier("exports"), ts.createIdentifier(ts.idText(nextId))), prev); }, ts.createVoidZero())));
+ ts.append(statements, factory.createExpressionStatement(ts.reduceLeft(currentModuleInfo.exportedNames, function (prev, nextId) { return factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(ts.idText(nextId))), prev); }, factory.createVoidZero())));
}
ts.append(statements, ts.visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, ts.isStatement));
if (moduleKind === ts.ModuleKind.AMD) {
ts.addRange(statements, ts.visitNodes(node.statements, sourceElementVisitor, ts.isStatement, statementOffset));
addExportEqualsIfNeeded(statements, true);
ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
- var body = ts.createBlock(statements, true);
+ var body = factory.createBlock(statements, true);
if (needUMDDynamicImportHelper) {
ts.addEmitHelper(body, dynamicImportUMDHelper);
}
var expressionResult = ts.visitNode(currentModuleInfo.exportEquals.expression, moduleExpressionElementVisitor);
if (expressionResult) {
if (emitAsReturn) {
- var statement = ts.createReturn(expressionResult);
+ var statement = factory.createReturnStatement(expressionResult);
ts.setTextRange(statement, currentModuleInfo.exportEquals);
ts.setEmitFlags(statement, 384 | 1536);
statements.push(statement);
}
else {
- var statement = ts.createExpressionStatement(ts.createAssignment(ts.createPropertyAccess(ts.createIdentifier("module"), "exports"), expressionResult));
+ var statement = factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), expressionResult));
ts.setTextRange(statement, currentModuleInfo.exportEquals);
ts.setEmitFlags(statement, 1536);
statements.push(statement);
}
function sourceElementVisitor(node) {
switch (node.kind) {
- case 254:
+ case 261:
return visitImportDeclaration(node);
- case 253:
- return visitImportEqualsDeclaration(node);
case 260:
+ return visitImportEqualsDeclaration(node);
+ case 267:
return visitExportDeclaration(node);
- case 259:
+ case 266:
return visitExportAssignment(node);
- case 225:
+ case 232:
return visitVariableStatement(node);
- case 244:
+ case 251:
return visitFunctionDeclaration(node);
- case 245:
+ case 252:
return visitClassDeclaration(node);
- case 328:
+ case 338:
return visitMergeDeclarationMarker(node);
- case 329:
+ case 339:
return visitEndOfDeclarationMarker(node);
default:
return ts.visitEachChild(node, moduleExpressionElementVisitor, context);
for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
var elem = _a[_i];
switch (elem.kind) {
- case 281:
+ case 288:
if (destructuringNeedsFlattening(elem.initializer)) {
return true;
}
break;
- case 282:
+ case 289:
if (destructuringNeedsFlattening(elem.name)) {
return true;
}
break;
- case 283:
+ case 290:
if (destructuringNeedsFlattening(elem.expression)) {
return true;
}
break;
- case 161:
- case 163:
- case 164:
+ case 165:
+ case 167:
+ case 168:
return false;
default: ts.Debug.assertNever(elem, "Unhandled object member kind");
}
case ts.ModuleKind.AMD:
return createImportCallExpressionAMD(argument, containsLexicalThis);
case ts.ModuleKind.UMD:
- return createImportCallExpressionUMD(argument, containsLexicalThis);
+ return createImportCallExpressionUMD(argument !== null && argument !== void 0 ? argument : factory.createVoidZero(), containsLexicalThis);
case ts.ModuleKind.CommonJS:
default:
return createImportCallExpressionCommonJS(argument, containsLexicalThis);
function createImportCallExpressionUMD(arg, containsLexicalThis) {
needUMDDynamicImportHelper = true;
if (ts.isSimpleCopiableExpression(arg)) {
- var argClone = ts.isGeneratedIdentifier(arg) ? arg : ts.isStringLiteral(arg) ? ts.createLiteral(arg) : ts.setEmitFlags(ts.setTextRange(ts.getSynthesizedClone(arg), arg), 1536);
- return ts.createConditional(ts.createIdentifier("__syncRequire"), createImportCallExpressionCommonJS(arg, containsLexicalThis), createImportCallExpressionAMD(argClone, containsLexicalThis));
+ var argClone = ts.isGeneratedIdentifier(arg) ? arg : ts.isStringLiteral(arg) ? factory.createStringLiteralFromNode(arg) : ts.setEmitFlags(ts.setTextRange(factory.cloneNode(arg), arg), 1536);
+ return factory.createConditionalExpression(factory.createIdentifier("__syncRequire"), undefined, createImportCallExpressionCommonJS(arg, containsLexicalThis), undefined, createImportCallExpressionAMD(argClone, containsLexicalThis));
}
else {
- var temp = ts.createTempVariable(hoistVariableDeclaration);
- return ts.createComma(ts.createAssignment(temp, arg), ts.createConditional(ts.createIdentifier("__syncRequire"), createImportCallExpressionCommonJS(temp, containsLexicalThis), createImportCallExpressionAMD(temp, containsLexicalThis)));
+ var temp = factory.createTempVariable(hoistVariableDeclaration);
+ return factory.createComma(factory.createAssignment(temp, arg), factory.createConditionalExpression(factory.createIdentifier("__syncRequire"), undefined, createImportCallExpressionCommonJS(temp, containsLexicalThis), undefined, createImportCallExpressionAMD(temp, containsLexicalThis)));
}
}
function createImportCallExpressionAMD(arg, containsLexicalThis) {
- var resolve = ts.createUniqueName("resolve");
- var reject = ts.createUniqueName("reject");
+ var resolve = factory.createUniqueName("resolve");
+ var reject = factory.createUniqueName("reject");
var parameters = [
- ts.createParameter(undefined, undefined, undefined, resolve),
- ts.createParameter(undefined, undefined, undefined, reject)
+ factory.createParameterDeclaration(undefined, undefined, undefined, resolve),
+ factory.createParameterDeclaration(undefined, undefined, undefined, reject)
];
- var body = ts.createBlock([
- ts.createExpressionStatement(ts.createCall(ts.createIdentifier("require"), undefined, [ts.createArrayLiteral([arg || ts.createOmittedExpression()]), resolve, reject]))
+ var body = factory.createBlock([
+ factory.createExpressionStatement(factory.createCallExpression(factory.createIdentifier("require"), undefined, [factory.createArrayLiteralExpression([arg || factory.createOmittedExpression()]), resolve, reject]))
]);
var func;
if (languageVersion >= 2) {
- func = ts.createArrowFunction(undefined, undefined, parameters, undefined, undefined, body);
+ func = factory.createArrowFunction(undefined, undefined, parameters, undefined, undefined, body);
}
else {
- func = ts.createFunctionExpression(undefined, undefined, undefined, undefined, parameters, undefined, body);
+ func = factory.createFunctionExpression(undefined, undefined, undefined, undefined, parameters, undefined, body);
if (containsLexicalThis) {
ts.setEmitFlags(func, 8);
}
}
- var promise = ts.createNew(ts.createIdentifier("Promise"), undefined, [func]);
+ var promise = factory.createNewExpression(factory.createIdentifier("Promise"), undefined, [func]);
if (compilerOptions.esModuleInterop) {
- context.requestEmitHelper(ts.importStarHelper);
- return ts.createCall(ts.createPropertyAccess(promise, ts.createIdentifier("then")), undefined, [ts.getUnscopedHelperName("__importStar")]);
+ return factory.createCallExpression(factory.createPropertyAccessExpression(promise, factory.createIdentifier("then")), undefined, [emitHelpers().createImportStarCallbackHelper()]);
}
return promise;
}
function createImportCallExpressionCommonJS(arg, containsLexicalThis) {
- var promiseResolveCall = ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Promise"), "resolve"), undefined, []);
- var requireCall = ts.createCall(ts.createIdentifier("require"), undefined, arg ? [arg] : []);
+ var promiseResolveCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Promise"), "resolve"), undefined, []);
+ var requireCall = factory.createCallExpression(factory.createIdentifier("require"), undefined, arg ? [arg] : []);
if (compilerOptions.esModuleInterop) {
- context.requestEmitHelper(ts.importStarHelper);
- requireCall = ts.createCall(ts.getUnscopedHelperName("__importStar"), undefined, [requireCall]);
+ requireCall = emitHelpers().createImportStarHelper(requireCall);
}
var func;
if (languageVersion >= 2) {
- func = ts.createArrowFunction(undefined, undefined, [], undefined, undefined, requireCall);
+ func = factory.createArrowFunction(undefined, undefined, [], undefined, undefined, requireCall);
}
else {
- func = ts.createFunctionExpression(undefined, undefined, undefined, undefined, [], undefined, ts.createBlock([ts.createReturn(requireCall)]));
+ func = factory.createFunctionExpression(undefined, undefined, undefined, undefined, [], undefined, factory.createBlock([factory.createReturnStatement(requireCall)]));
if (containsLexicalThis) {
ts.setEmitFlags(func, 8);
}
}
- return ts.createCall(ts.createPropertyAccess(promiseResolveCall, "then"), undefined, [func]);
+ return factory.createCallExpression(factory.createPropertyAccessExpression(promiseResolveCall, "then"), undefined, [func]);
}
function getHelperExpressionForExport(node, innerExpr) {
if (!compilerOptions.esModuleInterop || ts.getEmitFlags(node) & 67108864) {
return innerExpr;
}
if (ts.getExportNeedsImportStarHelper(node)) {
- context.requestEmitHelper(ts.importStarHelper);
- return ts.createCall(ts.getUnscopedHelperName("__importStar"), undefined, [innerExpr]);
+ return emitHelpers().createImportStarHelper(innerExpr);
}
return innerExpr;
}
return innerExpr;
}
if (ts.getImportNeedsImportStarHelper(node)) {
- context.requestEmitHelper(ts.importStarHelper);
- return ts.createCall(ts.getUnscopedHelperName("__importStar"), undefined, [innerExpr]);
+ return emitHelpers().createImportStarHelper(innerExpr);
}
if (ts.getImportNeedsImportDefaultHelper(node)) {
- context.requestEmitHelper(ts.importDefaultHelper);
- return ts.createCall(ts.getUnscopedHelperName("__importDefault"), undefined, [innerExpr]);
+ return emitHelpers().createImportDefaultHelper(innerExpr);
}
return innerExpr;
}
var namespaceDeclaration = ts.getNamespaceDeclarationNode(node);
if (moduleKind !== ts.ModuleKind.AMD) {
if (!node.importClause) {
- return ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createRequireCall(node)), node), node);
+ return ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createRequireCall(node)), node), node);
}
else {
var variables = [];
if (namespaceDeclaration && !ts.isDefaultImport(node)) {
- variables.push(ts.createVariableDeclaration(ts.getSynthesizedClone(namespaceDeclaration.name), undefined, getHelperExpressionForImport(node, createRequireCall(node))));
+ variables.push(factory.createVariableDeclaration(factory.cloneNode(namespaceDeclaration.name), undefined, undefined, getHelperExpressionForImport(node, createRequireCall(node))));
}
else {
- variables.push(ts.createVariableDeclaration(ts.getGeneratedNameForNode(node), undefined, getHelperExpressionForImport(node, createRequireCall(node))));
+ variables.push(factory.createVariableDeclaration(factory.getGeneratedNameForNode(node), undefined, undefined, getHelperExpressionForImport(node, createRequireCall(node))));
if (namespaceDeclaration && ts.isDefaultImport(node)) {
- variables.push(ts.createVariableDeclaration(ts.getSynthesizedClone(namespaceDeclaration.name), undefined, ts.getGeneratedNameForNode(node)));
+ variables.push(factory.createVariableDeclaration(factory.cloneNode(namespaceDeclaration.name), undefined, undefined, factory.getGeneratedNameForNode(node)));
}
}
- statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList(variables, languageVersion >= 2 ? 2 : 0)), node), node));
+ statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement(undefined, factory.createVariableDeclarationList(variables, languageVersion >= 2 ? 2 : 0)), node), node));
}
}
else if (namespaceDeclaration && ts.isDefaultImport(node)) {
- statements = ts.append(statements, ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.setOriginalNode(ts.setTextRange(ts.createVariableDeclaration(ts.getSynthesizedClone(namespaceDeclaration.name), undefined, ts.getGeneratedNameForNode(node)), node), node)
+ statements = ts.append(statements, factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ ts.setOriginalNode(ts.setTextRange(factory.createVariableDeclaration(factory.cloneNode(namespaceDeclaration.name), undefined, undefined, factory.getGeneratedNameForNode(node)), node), node)
], languageVersion >= 2 ? 2 : 0)));
}
if (hasAssociatedEndOfDeclarationMarker(node)) {
return ts.singleOrMany(statements);
}
function createRequireCall(importNode) {
- var moduleName = ts.getExternalModuleNameLiteral(importNode, currentSourceFile, host, resolver, compilerOptions);
+ var moduleName = ts.getExternalModuleNameLiteral(factory, importNode, currentSourceFile, host, resolver, compilerOptions);
var args = [];
if (moduleName) {
args.push(moduleName);
}
- return ts.createCall(ts.createIdentifier("require"), undefined, args);
+ return factory.createCallExpression(factory.createIdentifier("require"), undefined, args);
}
function visitImportEqualsDeclaration(node) {
ts.Debug.assert(ts.isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
var statements;
if (moduleKind !== ts.ModuleKind.AMD) {
- if (ts.hasModifier(node, 1)) {
- statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportExpression(node.name, createRequireCall(node))), node), node));
+ if (ts.hasSyntacticModifier(node, 1)) {
+ statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createExportExpression(node.name, createRequireCall(node))), node), node));
}
else {
- statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(ts.getSynthesizedClone(node.name), undefined, createRequireCall(node))
+ statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(factory.cloneNode(node.name), undefined, undefined, createRequireCall(node))
], languageVersion >= 2 ? 2 : 0)), node), node));
}
}
else {
- if (ts.hasModifier(node, 1)) {
- statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportExpression(ts.getExportName(node), ts.getLocalName(node))), node), node));
+ if (ts.hasSyntacticModifier(node, 1)) {
+ statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createExportExpression(factory.getExportName(node), factory.getLocalName(node))), node), node));
}
}
if (hasAssociatedEndOfDeclarationMarker(node)) {
if (!node.moduleSpecifier) {
return undefined;
}
- var generatedName = ts.getGeneratedNameForNode(node);
+ var generatedName = factory.getGeneratedNameForNode(node);
if (node.exportClause && ts.isNamedExports(node.exportClause)) {
var statements = [];
if (moduleKind !== ts.ModuleKind.AMD) {
- statements.push(ts.setOriginalNode(ts.setTextRange(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(generatedName, undefined, createRequireCall(node))
+ statements.push(ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(generatedName, undefined, undefined, createRequireCall(node))
])), node), node));
}
for (var _i = 0, _a = node.exportClause.elements; _i < _a.length; _i++) {
var specifier = _a[_i];
if (languageVersion === 0) {
- statements.push(ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createCreateBindingHelper(context, generatedName, ts.createLiteral(specifier.propertyName || specifier.name), specifier.propertyName ? ts.createLiteral(specifier.name) : undefined)), specifier), specifier));
+ statements.push(ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(emitHelpers().createCreateBindingHelper(generatedName, factory.createStringLiteralFromNode(specifier.propertyName || specifier.name), specifier.propertyName ? factory.createStringLiteralFromNode(specifier.name) : undefined)), specifier), specifier));
}
else {
- var exportedValue = ts.createPropertyAccess(generatedName, specifier.propertyName || specifier.name);
- statements.push(ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportExpression(ts.getExportName(specifier), exportedValue, undefined, true)), specifier), specifier));
+ var exportNeedsImportDefault = !!compilerOptions.esModuleInterop &&
+ !(ts.getEmitFlags(node) & 67108864) &&
+ ts.idText(specifier.propertyName || specifier.name) === "default";
+ var exportedValue = factory.createPropertyAccessExpression(exportNeedsImportDefault ? emitHelpers().createImportDefaultHelper(generatedName) : generatedName, specifier.propertyName || specifier.name);
+ statements.push(ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createExportExpression(factory.getExportName(specifier), exportedValue, undefined, true)), specifier), specifier));
}
}
return ts.singleOrMany(statements);
}
else if (node.exportClause) {
var statements = [];
- statements.push(ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportExpression(ts.getSynthesizedClone(node.exportClause.name), moduleKind !== ts.ModuleKind.AMD ?
- getHelperExpressionForExport(node, createRequireCall(node)) :
- ts.createIdentifier(ts.idText(node.exportClause.name)))), node), node));
+ statements.push(ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createExportExpression(factory.cloneNode(node.exportClause.name), getHelperExpressionForExport(node, moduleKind !== ts.ModuleKind.AMD ?
+ createRequireCall(node) :
+ ts.isExportNamespaceAsDefaultDeclaration(node) ? generatedName :
+ factory.createIdentifier(ts.idText(node.exportClause.name))))), node), node));
return ts.singleOrMany(statements);
}
else {
- return ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(createExportStarHelper(context, moduleKind !== ts.ModuleKind.AMD ? createRequireCall(node) : generatedName)), node), node);
+ return ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(emitHelpers().createExportStarHelper(moduleKind !== ts.ModuleKind.AMD ? createRequireCall(node) : generatedName)), node), node);
}
}
function visitExportAssignment(node) {
var original = node.original;
if (original && hasAssociatedEndOfDeclarationMarker(original)) {
var id = ts.getOriginalNodeId(node);
- deferredExports[id] = appendExportStatement(deferredExports[id], ts.createIdentifier("default"), ts.visitNode(node.expression, moduleExpressionElementVisitor), node, true);
+ deferredExports[id] = appendExportStatement(deferredExports[id], factory.createIdentifier("default"), ts.visitNode(node.expression, moduleExpressionElementVisitor), node, true);
}
else {
- statements = appendExportStatement(statements, ts.createIdentifier("default"), ts.visitNode(node.expression, moduleExpressionElementVisitor), node, true);
+ statements = appendExportStatement(statements, factory.createIdentifier("default"), ts.visitNode(node.expression, moduleExpressionElementVisitor), node, true);
}
return ts.singleOrMany(statements);
}
function visitFunctionDeclaration(node) {
var statements;
- if (ts.hasModifier(node, 1)) {
- statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createFunctionDeclaration(undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, ts.getDeclarationName(node, true, true), undefined, ts.visitNodes(node.parameters, moduleExpressionElementVisitor), undefined, ts.visitEachChild(node.body, moduleExpressionElementVisitor, context)), node), node));
+ if (ts.hasSyntacticModifier(node, 1)) {
+ statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createFunctionDeclaration(undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, factory.getDeclarationName(node, true, true), undefined, ts.visitNodes(node.parameters, moduleExpressionElementVisitor), undefined, ts.visitEachChild(node.body, moduleExpressionElementVisitor, context)), node), node));
}
else {
statements = ts.append(statements, ts.visitEachChild(node, moduleExpressionElementVisitor, context));
}
function visitClassDeclaration(node) {
var statements;
- if (ts.hasModifier(node, 1)) {
- statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createClassDeclaration(undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.getDeclarationName(node, true, true), undefined, ts.visitNodes(node.heritageClauses, moduleExpressionElementVisitor), ts.visitNodes(node.members, moduleExpressionElementVisitor)), node), node));
+ if (ts.hasSyntacticModifier(node, 1)) {
+ statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createClassDeclaration(undefined, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), factory.getDeclarationName(node, true, true), undefined, ts.visitNodes(node.heritageClauses, moduleExpressionElementVisitor), ts.visitNodes(node.members, moduleExpressionElementVisitor)), node), node));
}
else {
statements = ts.append(statements, ts.visitEachChild(node, moduleExpressionElementVisitor, context));
var statements;
var variables;
var expressions;
- if (ts.hasModifier(node, 1)) {
+ if (ts.hasSyntacticModifier(node, 1)) {
var modifiers = void 0;
+ var removeCommentsOnExpressions = false;
for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) {
var variable = _a[_i];
if (ts.isIdentifier(variable.name) && ts.isLocalName(variable.name)) {
variables = ts.append(variables, variable);
}
else if (variable.initializer) {
- expressions = ts.append(expressions, transformInitializedVariable(variable));
+ if (!ts.isBindingPattern(variable.name) && (ts.isArrowFunction(variable.initializer) || ts.isFunctionExpression(variable.initializer) || ts.isClassExpression(variable.initializer))) {
+ var expression = factory.createAssignment(ts.setTextRange(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), variable.name), variable.name), factory.createIdentifier(ts.getTextOfIdentifierOrLiteral(variable.name)));
+ var updatedVariable = factory.createVariableDeclaration(variable.name, variable.exclamationToken, variable.type, ts.visitNode(variable.initializer, moduleExpressionElementVisitor));
+ variables = ts.append(variables, updatedVariable);
+ expressions = ts.append(expressions, expression);
+ removeCommentsOnExpressions = true;
+ }
+ else {
+ expressions = ts.append(expressions, transformInitializedVariable(variable));
+ }
}
}
if (variables) {
- statements = ts.append(statements, ts.updateVariableStatement(node, modifiers, ts.updateVariableDeclarationList(node.declarationList, variables)));
+ statements = ts.append(statements, factory.updateVariableStatement(node, modifiers, factory.updateVariableDeclarationList(node.declarationList, variables)));
}
if (expressions) {
- statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(ts.createExpressionStatement(ts.inlineExpressions(expressions)), node), node));
+ var statement = ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(factory.inlineExpressions(expressions)), node), node);
+ if (removeCommentsOnExpressions) {
+ ts.removeAllComments(statement);
+ }
+ statements = ts.append(statements, statement);
}
}
else {
function createAllExportExpressions(name, value, location) {
var exportedNames = getExports(name);
if (exportedNames) {
- var expression = ts.isExportName(name) ? value : ts.createAssignment(name, value);
+ var expression = ts.isExportName(name) ? value : factory.createAssignment(name, value);
for (var _i = 0, exportedNames_1 = exportedNames; _i < exportedNames_1.length; _i++) {
var exportName = exportedNames_1[_i];
ts.setEmitFlags(expression, 4);
}
return expression;
}
- return ts.createAssignment(name, value);
+ return factory.createAssignment(name, value);
}
function transformInitializedVariable(node) {
if (ts.isBindingPattern(node.name)) {
return ts.flattenDestructuringAssignment(ts.visitNode(node, moduleExpressionElementVisitor), undefined, context, 0, false, createAllExportExpressions);
}
else {
- return ts.createAssignment(ts.setTextRange(ts.createPropertyAccess(ts.createIdentifier("exports"), node.name), node.name), node.initializer ? ts.visitNode(node.initializer, moduleExpressionElementVisitor) : ts.createVoidZero());
+ return factory.createAssignment(ts.setTextRange(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), node.name), node.name), node.initializer ? ts.visitNode(node.initializer, moduleExpressionElementVisitor) : factory.createVoidZero());
}
}
function visitMergeDeclarationMarker(node) {
- if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 225) {
+ if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 232) {
var id = ts.getOriginalNodeId(node);
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original);
}
var namedBindings = importClause.namedBindings;
if (namedBindings) {
switch (namedBindings.kind) {
- case 256:
+ case 263:
statements = appendExportsOfDeclaration(statements, namedBindings);
break;
- case 257:
+ case 264:
for (var _i = 0, _a = namedBindings.elements; _i < _a.length; _i++) {
var importBinding = _a[_i];
statements = appendExportsOfDeclaration(statements, importBinding, true);
if (currentModuleInfo.exportEquals) {
return statements;
}
- if (ts.hasModifier(decl, 1)) {
- var exportName = ts.hasModifier(decl, 512) ? ts.createIdentifier("default") : ts.getDeclarationName(decl);
- statements = appendExportStatement(statements, exportName, ts.getLocalName(decl), decl);
+ if (ts.hasSyntacticModifier(decl, 1)) {
+ var exportName = ts.hasSyntacticModifier(decl, 512) ? factory.createIdentifier("default") : factory.getDeclarationName(decl);
+ statements = appendExportStatement(statements, exportName, factory.getLocalName(decl), decl);
}
if (decl.name) {
statements = appendExportsOfDeclaration(statements, decl);
return statements;
}
function appendExportsOfDeclaration(statements, decl, liveBinding) {
- var name = ts.getDeclarationName(decl);
+ var name = factory.getDeclarationName(decl);
var exportSpecifiers = currentModuleInfo.exportSpecifiers.get(ts.idText(name));
if (exportSpecifiers) {
for (var _i = 0, exportSpecifiers_1 = exportSpecifiers; _i < exportSpecifiers_1.length; _i++) {
function createUnderscoreUnderscoreESModule() {
var statement;
if (languageVersion === 0) {
- statement = ts.createExpressionStatement(createExportExpression(ts.createIdentifier("__esModule"), ts.createLiteral(true)));
+ statement = factory.createExpressionStatement(createExportExpression(factory.createIdentifier("__esModule"), factory.createTrue()));
}
else {
- statement = ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"), undefined, [
- ts.createIdentifier("exports"),
- ts.createLiteral("__esModule"),
- ts.createObjectLiteral([
- ts.createPropertyAssignment("value", ts.createLiteral(true))
+ statement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "defineProperty"), undefined, [
+ factory.createIdentifier("exports"),
+ factory.createStringLiteral("__esModule"),
+ factory.createObjectLiteralExpression([
+ factory.createPropertyAssignment("value", factory.createTrue())
])
]));
}
return statement;
}
function createExportStatement(name, value, location, allowComments, liveBinding) {
- var statement = ts.setTextRange(ts.createExpressionStatement(createExportExpression(name, value, undefined, liveBinding)), location);
+ var statement = ts.setTextRange(factory.createExpressionStatement(createExportExpression(name, value, undefined, liveBinding)), location);
ts.startOnNewLine(statement);
if (!allowComments) {
ts.setEmitFlags(statement, 1536);
return statement;
}
function createExportExpression(name, value, location, liveBinding) {
- return ts.setTextRange(liveBinding && languageVersion !== 0 ? ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"), undefined, [
- ts.createIdentifier("exports"),
- ts.createLiteral(name),
- ts.createObjectLiteral([
- ts.createPropertyAssignment("enumerable", ts.createLiteral(true)),
- ts.createPropertyAssignment("get", ts.createFunctionExpression(undefined, undefined, undefined, undefined, [], undefined, ts.createBlock([ts.createReturn(value)])))
+ return ts.setTextRange(liveBinding && languageVersion !== 0 ? factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "defineProperty"), undefined, [
+ factory.createIdentifier("exports"),
+ factory.createStringLiteralFromNode(name),
+ factory.createObjectLiteralExpression([
+ factory.createPropertyAssignment("enumerable", factory.createTrue()),
+ factory.createPropertyAssignment("get", factory.createFunctionExpression(undefined, undefined, undefined, undefined, [], undefined, factory.createBlock([factory.createReturnStatement(value)])))
])
- ]) : ts.createAssignment(ts.createPropertyAccess(ts.createIdentifier("exports"), ts.getSynthesizedClone(name)), value), location);
+ ]) : factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.cloneNode(name)), value), location);
}
function modifierVisitor(node) {
switch (node.kind) {
- case 89:
- case 84:
+ case 92:
+ case 87:
return undefined;
}
return node;
}
function onEmitNode(hint, node, emitCallback) {
- if (node.kind === 290) {
+ if (node.kind === 297) {
currentSourceFile = node;
currentModuleInfo = moduleInfoMap[ts.getOriginalNodeId(currentSourceFile)];
noSubstitution = [];
var exportedOrImportedName = substituteExpressionIdentifier(name);
if (exportedOrImportedName !== name) {
if (node.objectAssignmentInitializer) {
- var initializer = ts.createAssignment(exportedOrImportedName, node.objectAssignmentInitializer);
- return ts.setTextRange(ts.createPropertyAssignment(name, initializer), node);
+ var initializer = factory.createAssignment(exportedOrImportedName, node.objectAssignmentInitializer);
+ return ts.setTextRange(factory.createPropertyAssignment(name, initializer), node);
}
- return ts.setTextRange(ts.createPropertyAssignment(name, exportedOrImportedName), node);
+ return ts.setTextRange(factory.createPropertyAssignment(name, exportedOrImportedName), node);
}
return node;
}
function substituteExpression(node) {
switch (node.kind) {
- case 75:
+ case 78:
return substituteExpressionIdentifier(node);
- case 209:
+ case 216:
return substituteBinaryExpression(node);
- case 208:
- case 207:
+ case 215:
+ case 214:
return substituteUnaryExpression(node);
}
return node;
if (ts.getEmitFlags(node) & 4096) {
var externalHelpersModuleName = ts.getExternalHelpersModuleName(currentSourceFile);
if (externalHelpersModuleName) {
- return ts.createPropertyAccess(externalHelpersModuleName, node);
+ return factory.createPropertyAccessExpression(externalHelpersModuleName, node);
}
return node;
}
- if (!ts.isGeneratedIdentifier(node) && !ts.isLocalName(node)) {
+ if (!(ts.isGeneratedIdentifier(node) && !(node.autoGenerateFlags & 64)) && !ts.isLocalName(node)) {
var exportContainer = resolver.getReferencedExportContainer(node, ts.isExportName(node));
- if (exportContainer && exportContainer.kind === 290) {
- return ts.setTextRange(ts.createPropertyAccess(ts.createIdentifier("exports"), ts.getSynthesizedClone(node)), node);
+ if (exportContainer && exportContainer.kind === 297) {
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.cloneNode(node)), node);
}
var importDeclaration = resolver.getReferencedImportDeclaration(node);
if (importDeclaration) {
if (ts.isImportClause(importDeclaration)) {
- return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent), ts.createIdentifier("default")), node);
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent), factory.createIdentifier("default")), node);
}
else if (ts.isImportSpecifier(importDeclaration)) {
var name = importDeclaration.propertyName || importDeclaration.name;
- return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent.parent.parent), ts.getSynthesizedClone(name)), node);
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent.parent.parent), factory.cloneNode(name)), node);
}
}
}
&& !ts.isDeclarationNameOfEnumOrNamespace(node.operand)) {
var exportedNames = getExports(node.operand);
if (exportedNames) {
- var expression = node.kind === 208
- ? ts.setTextRange(ts.createBinary(node.operand, ts.createToken(node.operator === 45 ? 63 : 64), ts.createLiteral(1)), node)
+ var expression = node.kind === 215
+ ? ts.setTextRange(factory.createBinaryExpression(node.operand, factory.createToken(node.operator === 45 ? 63 : 64), factory.createNumericLiteral(1)), node)
: node;
for (var _i = 0, exportedNames_3 = exportedNames; _i < exportedNames_3.length; _i++) {
var exportName = exportedNames_3[_i];
}
}
ts.transformModule = transformModule;
- ts.createBindingHelper = {
- name: "typescript:commonjscreatebinding",
- importName: "__createBinding",
- scoped: false,
- priority: 1,
- text: "\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n}));"
- };
- function createCreateBindingHelper(context, module, inputName, outputName) {
- context.requestEmitHelper(ts.createBindingHelper);
- return ts.createCall(ts.getUnscopedHelperName("__createBinding"), undefined, __spreadArrays([ts.createIdentifier("exports"), module, inputName], (outputName ? [outputName] : [])));
- }
- ts.setModuleDefaultHelper = {
- name: "typescript:commonjscreatevalue",
- importName: "__setModuleDefault",
- scoped: false,
- priority: 1,
- text: "\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n o[\"default\"] = v;\n});"
- };
- var exportStarHelper = {
- name: "typescript:export-star",
- importName: "__exportStar",
- scoped: false,
- dependencies: [ts.createBindingHelper],
- priority: 2,
- text: "\n var __exportStar = (this && this.__exportStar) || function(m, exports) {\n for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);\n };"
- };
- function createExportStarHelper(context, module) {
- context.requestEmitHelper(exportStarHelper);
- return ts.createCall(ts.getUnscopedHelperName("__exportStar"), undefined, [module, ts.createIdentifier("exports")]);
- }
var dynamicImportUMDHelper = {
name: "typescript:dynamicimport-sync-require",
scoped: true,
text: "\n var __syncRequire = typeof module === \"object\" && typeof module.exports === \"object\";"
};
- ts.importStarHelper = {
- name: "typescript:commonjsimportstar",
- importName: "__importStar",
- scoped: false,
- dependencies: [ts.createBindingHelper, ts.setModuleDefaultHelper],
- priority: 2,
- text: "\nvar __importStar = (this && this.__importStar) || function (mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n __setModuleDefault(result, mod);\n return result;\n};"
- };
- ts.importDefaultHelper = {
- name: "typescript:commonjsimportdefault",
- importName: "__importDefault",
- scoped: false,
- text: "\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};"
- };
})(ts || (ts = {}));
var ts;
(function (ts) {
function transformSystemModule(context) {
- var startLexicalEnvironment = context.startLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
+ var factory = context.factory, startLexicalEnvironment = context.startLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration;
var compilerOptions = context.getCompilerOptions();
var resolver = context.getEmitResolver();
var host = context.getEmitHost();
var previousOnEmitNode = context.onEmitNode;
context.onSubstituteNode = onSubstituteNode;
context.onEmitNode = onEmitNode;
- context.enableSubstitution(75);
- context.enableSubstitution(282);
- context.enableSubstitution(209);
- context.enableSubstitution(207);
- context.enableSubstitution(208);
- context.enableSubstitution(219);
- context.enableEmitNotification(290);
+ context.enableSubstitution(78);
+ context.enableSubstitution(289);
+ context.enableSubstitution(216);
+ context.enableSubstitution(214);
+ context.enableSubstitution(215);
+ context.enableSubstitution(226);
+ context.enableEmitNotification(297);
var moduleInfoMap = [];
var deferredExports = [];
var exportFunctionsMap = [];
var hoistedStatements;
var enclosingBlockScopedContainer;
var noSubstitution;
- return ts.chainBundle(transformSourceFile);
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile || !(ts.isEffectiveExternalModule(node, compilerOptions) || node.transformFlags & 2097152)) {
return node;
var id = ts.getOriginalNodeId(node);
currentSourceFile = node;
enclosingBlockScopedContainer = node;
- moduleInfo = moduleInfoMap[id] = ts.collectExternalModuleInfo(node, resolver, compilerOptions);
- exportFunction = ts.createUniqueName("exports");
+ moduleInfo = moduleInfoMap[id] = ts.collectExternalModuleInfo(context, node, resolver, compilerOptions);
+ exportFunction = factory.createUniqueName("exports");
exportFunctionsMap[id] = exportFunction;
- contextObject = contextObjectMap[id] = ts.createUniqueName("context");
+ contextObject = contextObjectMap[id] = factory.createUniqueName("context");
var dependencyGroups = collectDependencyGroups(moduleInfo.externalImports);
var moduleBodyBlock = createSystemModuleBody(node, dependencyGroups);
- var moduleBodyFunction = ts.createFunctionExpression(undefined, undefined, undefined, undefined, [
- ts.createParameter(undefined, undefined, undefined, exportFunction),
- ts.createParameter(undefined, undefined, undefined, contextObject)
+ var moduleBodyFunction = factory.createFunctionExpression(undefined, undefined, undefined, undefined, [
+ factory.createParameterDeclaration(undefined, undefined, undefined, exportFunction),
+ factory.createParameterDeclaration(undefined, undefined, undefined, contextObject)
], undefined, moduleBodyBlock);
- var moduleName = ts.tryGetModuleNameFromFile(node, host, compilerOptions);
- var dependencies = ts.createArrayLiteral(ts.map(dependencyGroups, function (dependencyGroup) { return dependencyGroup.name; }));
- var updated = ts.setEmitFlags(ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray([
- ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("System"), "register"), undefined, moduleName
+ var moduleName = ts.tryGetModuleNameFromFile(factory, node, host, compilerOptions);
+ var dependencies = factory.createArrayLiteralExpression(ts.map(dependencyGroups, function (dependencyGroup) { return dependencyGroup.name; }));
+ var updated = ts.setEmitFlags(factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray([
+ factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("System"), "register"), undefined, moduleName
? [moduleName, dependencies, moduleBodyFunction]
: [dependencies, moduleBodyFunction]))
]), node.statements)), 1024);
- if (!(compilerOptions.outFile || compilerOptions.out)) {
+ if (!ts.outFile(compilerOptions)) {
ts.moveEmitHelpers(updated, moduleBodyBlock, function (helper) { return !helper.scoped; });
}
if (noSubstitution) {
contextObject = undefined;
hoistedStatements = undefined;
enclosingBlockScopedContainer = undefined;
- return ts.aggregateTransformFlags(updated);
+ return updated;
}
function collectDependencyGroups(externalImports) {
- var groupIndices = ts.createMap();
+ var groupIndices = new ts.Map();
var dependencyGroups = [];
for (var _i = 0, externalImports_1 = externalImports; _i < externalImports_1.length; _i++) {
var externalImport = externalImports_1[_i];
- var externalModuleName = ts.getExternalModuleNameLiteral(externalImport, currentSourceFile, host, resolver, compilerOptions);
+ var externalModuleName = ts.getExternalModuleNameLiteral(factory, externalImport, currentSourceFile, host, resolver, compilerOptions);
if (externalModuleName) {
var text = externalModuleName.text;
var groupIndex = groupIndices.get(text);
var statements = [];
startLexicalEnvironment();
var ensureUseStrict = ts.getStrictOptionValue(compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && ts.isExternalModule(currentSourceFile));
- var statementOffset = ts.addPrologue(statements, node.statements, ensureUseStrict, sourceElementVisitor);
- statements.push(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration("__moduleName", undefined, ts.createLogicalAnd(contextObject, ts.createPropertyAccess(contextObject, "id")))
+ var statementOffset = factory.copyPrologue(node.statements, statements, ensureUseStrict, sourceElementVisitor);
+ statements.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration("__moduleName", undefined, undefined, factory.createLogicalAnd(contextObject, factory.createPropertyAccessExpression(contextObject, "id")))
])));
ts.visitNode(moduleInfo.externalHelpersImportDeclaration, sourceElementVisitor, ts.isStatement);
var executeStatements = ts.visitNodes(node.statements, sourceElementVisitor, ts.isStatement, statementOffset);
ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
var exportStarFunction = addExportStarIfNeeded(statements);
var modifiers = node.transformFlags & 524288 ?
- ts.createModifiersFromModifierFlags(256) :
+ factory.createModifiersFromModifierFlags(256) :
undefined;
- var moduleObject = ts.createObjectLiteral([
- ts.createPropertyAssignment("setters", createSettersArray(exportStarFunction, dependencyGroups)),
- ts.createPropertyAssignment("execute", ts.createFunctionExpression(modifiers, undefined, undefined, undefined, [], undefined, ts.createBlock(executeStatements, true)))
- ]);
- moduleObject.multiLine = true;
- statements.push(ts.createReturn(moduleObject));
- return ts.createBlock(statements, true);
+ var moduleObject = factory.createObjectLiteralExpression([
+ factory.createPropertyAssignment("setters", createSettersArray(exportStarFunction, dependencyGroups)),
+ factory.createPropertyAssignment("execute", factory.createFunctionExpression(modifiers, undefined, undefined, undefined, [], undefined, factory.createBlock(executeStatements, true)))
+ ], true);
+ statements.push(factory.createReturnStatement(moduleObject));
+ return factory.createBlock(statements, true);
}
function addExportStarIfNeeded(statements) {
if (!moduleInfo.hasExportStarsToExportValues) {
var hasExportDeclarationWithExportClause = false;
for (var _i = 0, _a = moduleInfo.externalImports; _i < _a.length; _i++) {
var externalImport = _a[_i];
- if (externalImport.kind === 260 && externalImport.exportClause) {
+ if (externalImport.kind === 267 && externalImport.exportClause) {
hasExportDeclarationWithExportClause = true;
break;
}
if (exportedLocalName.escapedText === "default") {
continue;
}
- exportedNames.push(ts.createPropertyAssignment(ts.createLiteral(exportedLocalName), ts.createTrue()));
- }
- }
- for (var _d = 0, _e = moduleInfo.externalImports; _d < _e.length; _d++) {
- var externalImport = _e[_d];
- if (externalImport.kind !== 260) {
- continue;
- }
- if (!externalImport.exportClause) {
- continue;
- }
- if (ts.isNamedExports(externalImport.exportClause)) {
- for (var _f = 0, _g = externalImport.exportClause.elements; _f < _g.length; _f++) {
- var element = _g[_f];
- exportedNames.push(ts.createPropertyAssignment(ts.createLiteral(ts.idText(element.name || element.propertyName)), ts.createTrue()));
- }
- }
- else {
- exportedNames.push(ts.createPropertyAssignment(ts.createLiteral(ts.idText(externalImport.exportClause.name)), ts.createTrue()));
+ exportedNames.push(factory.createPropertyAssignment(factory.createStringLiteralFromNode(exportedLocalName), factory.createTrue()));
}
}
- var exportedNamesStorageRef = ts.createUniqueName("exportedNames");
- statements.push(ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(exportedNamesStorageRef, undefined, ts.createObjectLiteral(exportedNames, true))
+ var exportedNamesStorageRef = factory.createUniqueName("exportedNames");
+ statements.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(exportedNamesStorageRef, undefined, undefined, factory.createObjectLiteralExpression(exportedNames, true))
])));
var exportStarFunction = createExportStarFunction(exportedNamesStorageRef);
statements.push(exportStarFunction);
return exportStarFunction.name;
}
function createExportStarFunction(localNames) {
- var exportStarFunction = ts.createUniqueName("exportStar");
- var m = ts.createIdentifier("m");
- var n = ts.createIdentifier("n");
- var exports = ts.createIdentifier("exports");
- var condition = ts.createStrictInequality(n, ts.createLiteral("default"));
+ var exportStarFunction = factory.createUniqueName("exportStar");
+ var m = factory.createIdentifier("m");
+ var n = factory.createIdentifier("n");
+ var exports = factory.createIdentifier("exports");
+ var condition = factory.createStrictInequality(n, factory.createStringLiteral("default"));
if (localNames) {
- condition = ts.createLogicalAnd(condition, ts.createLogicalNot(ts.createCall(ts.createPropertyAccess(localNames, "hasOwnProperty"), undefined, [n])));
+ condition = factory.createLogicalAnd(condition, factory.createLogicalNot(factory.createCallExpression(factory.createPropertyAccessExpression(localNames, "hasOwnProperty"), undefined, [n])));
}
- return ts.createFunctionDeclaration(undefined, undefined, undefined, exportStarFunction, undefined, [ts.createParameter(undefined, undefined, undefined, m)], undefined, ts.createBlock([
- ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
- ts.createVariableDeclaration(exports, undefined, ts.createObjectLiteral([]))
+ return factory.createFunctionDeclaration(undefined, undefined, undefined, exportStarFunction, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, m)], undefined, factory.createBlock([
+ factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(exports, undefined, undefined, factory.createObjectLiteralExpression([]))
])),
- ts.createForIn(ts.createVariableDeclarationList([
- ts.createVariableDeclaration(n, undefined)
- ]), m, ts.createBlock([
- ts.setEmitFlags(ts.createIf(condition, ts.createExpressionStatement(ts.createAssignment(ts.createElementAccess(exports, n), ts.createElementAccess(m, n)))), 1)
+ factory.createForInStatement(factory.createVariableDeclarationList([
+ factory.createVariableDeclaration(n)
+ ]), m, factory.createBlock([
+ ts.setEmitFlags(factory.createIfStatement(condition, factory.createExpressionStatement(factory.createAssignment(factory.createElementAccessExpression(exports, n), factory.createElementAccessExpression(m, n)))), 1)
])),
- ts.createExpressionStatement(ts.createCall(exportFunction, undefined, [exports]))
+ factory.createExpressionStatement(factory.createCallExpression(exportFunction, undefined, [exports]))
], true));
}
function createSettersArray(exportStarFunction, dependencyGroups) {
var setters = [];
for (var _i = 0, dependencyGroups_1 = dependencyGroups; _i < dependencyGroups_1.length; _i++) {
var group_2 = dependencyGroups_1[_i];
- var localName = ts.forEach(group_2.externalImports, function (i) { return ts.getLocalNameForExternalImport(i, currentSourceFile); });
- var parameterName = localName ? ts.getGeneratedNameForNode(localName) : ts.createUniqueName("");
+ var localName = ts.forEach(group_2.externalImports, function (i) { return ts.getLocalNameForExternalImport(factory, i, currentSourceFile); });
+ var parameterName = localName ? factory.getGeneratedNameForNode(localName) : factory.createUniqueName("");
var statements = [];
for (var _a = 0, _b = group_2.externalImports; _a < _b.length; _a++) {
var entry = _b[_a];
- var importVariableName = ts.getLocalNameForExternalImport(entry, currentSourceFile);
+ var importVariableName = ts.getLocalNameForExternalImport(factory, entry, currentSourceFile);
switch (entry.kind) {
- case 254:
+ case 261:
if (!entry.importClause) {
break;
}
- case 253:
+ case 260:
ts.Debug.assert(importVariableName !== undefined);
- statements.push(ts.createExpressionStatement(ts.createAssignment(importVariableName, parameterName)));
+ statements.push(factory.createExpressionStatement(factory.createAssignment(importVariableName, parameterName)));
break;
- case 260:
+ case 267:
ts.Debug.assert(importVariableName !== undefined);
if (entry.exportClause) {
if (ts.isNamedExports(entry.exportClause)) {
var properties = [];
for (var _c = 0, _d = entry.exportClause.elements; _c < _d.length; _c++) {
var e = _d[_c];
- properties.push(ts.createPropertyAssignment(ts.createLiteral(ts.idText(e.name)), ts.createElementAccess(parameterName, ts.createLiteral(ts.idText(e.propertyName || e.name)))));
+ properties.push(factory.createPropertyAssignment(factory.createStringLiteral(ts.idText(e.name)), factory.createElementAccessExpression(parameterName, factory.createStringLiteral(ts.idText(e.propertyName || e.name)))));
}
- statements.push(ts.createExpressionStatement(ts.createCall(exportFunction, undefined, [ts.createObjectLiteral(properties, true)])));
+ statements.push(factory.createExpressionStatement(factory.createCallExpression(exportFunction, undefined, [factory.createObjectLiteralExpression(properties, true)])));
}
else {
- statements.push(ts.createExpressionStatement(ts.createCall(exportFunction, undefined, [
- ts.createLiteral(ts.idText(entry.exportClause.name)),
+ statements.push(factory.createExpressionStatement(factory.createCallExpression(exportFunction, undefined, [
+ factory.createStringLiteral(ts.idText(entry.exportClause.name)),
parameterName
])));
}
}
else {
- statements.push(ts.createExpressionStatement(ts.createCall(exportStarFunction, undefined, [parameterName])));
+ statements.push(factory.createExpressionStatement(factory.createCallExpression(exportStarFunction, undefined, [parameterName])));
}
break;
}
}
- setters.push(ts.createFunctionExpression(undefined, undefined, undefined, undefined, [ts.createParameter(undefined, undefined, undefined, parameterName)], undefined, ts.createBlock(statements, true)));
+ setters.push(factory.createFunctionExpression(undefined, undefined, undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, parameterName)], undefined, factory.createBlock(statements, true)));
}
- return ts.createArrayLiteral(setters, true);
+ return factory.createArrayLiteralExpression(setters, true);
}
function sourceElementVisitor(node) {
switch (node.kind) {
- case 254:
+ case 261:
return visitImportDeclaration(node);
- case 253:
- return visitImportEqualsDeclaration(node);
case 260:
+ return visitImportEqualsDeclaration(node);
+ case 267:
return visitExportDeclaration(node);
- case 259:
+ case 266:
return visitExportAssignment(node);
default:
return nestedElementVisitor(node);
function visitImportDeclaration(node) {
var statements;
if (node.importClause) {
- hoistVariableDeclaration(ts.getLocalNameForExternalImport(node, currentSourceFile));
+ hoistVariableDeclaration(ts.getLocalNameForExternalImport(factory, node, currentSourceFile));
}
if (hasAssociatedEndOfDeclarationMarker(node)) {
var id = ts.getOriginalNodeId(node);
function visitImportEqualsDeclaration(node) {
ts.Debug.assert(ts.isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
var statements;
- hoistVariableDeclaration(ts.getLocalNameForExternalImport(node, currentSourceFile));
+ hoistVariableDeclaration(ts.getLocalNameForExternalImport(factory, node, currentSourceFile));
if (hasAssociatedEndOfDeclarationMarker(node)) {
var id = ts.getOriginalNodeId(node);
deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
var original = node.original;
if (original && hasAssociatedEndOfDeclarationMarker(original)) {
var id = ts.getOriginalNodeId(node);
- deferredExports[id] = appendExportStatement(deferredExports[id], ts.createIdentifier("default"), expression, true);
+ deferredExports[id] = appendExportStatement(deferredExports[id], factory.createIdentifier("default"), expression, true);
}
else {
- return createExportStatement(ts.createIdentifier("default"), expression, true);
+ return createExportStatement(factory.createIdentifier("default"), expression, true);
}
}
function visitFunctionDeclaration(node) {
- if (ts.hasModifier(node, 1)) {
- hoistedStatements = ts.append(hoistedStatements, ts.updateFunctionDeclaration(node, node.decorators, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, ts.getDeclarationName(node, true, true), undefined, ts.visitNodes(node.parameters, destructuringAndImportCallVisitor, ts.isParameterDeclaration), undefined, ts.visitNode(node.body, destructuringAndImportCallVisitor, ts.isBlock)));
+ if (ts.hasSyntacticModifier(node, 1)) {
+ hoistedStatements = ts.append(hoistedStatements, factory.updateFunctionDeclaration(node, node.decorators, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, factory.getDeclarationName(node, true, true), undefined, ts.visitNodes(node.parameters, destructuringAndImportCallVisitor, ts.isParameterDeclaration), undefined, ts.visitNode(node.body, destructuringAndImportCallVisitor, ts.isBlock)));
}
else {
hoistedStatements = ts.append(hoistedStatements, ts.visitEachChild(node, destructuringAndImportCallVisitor, context));
}
function visitClassDeclaration(node) {
var statements;
- var name = ts.getLocalName(node);
+ var name = factory.getLocalName(node);
hoistVariableDeclaration(name);
- statements = ts.append(statements, ts.setTextRange(ts.createExpressionStatement(ts.createAssignment(name, ts.setTextRange(ts.createClassExpression(undefined, node.name, undefined, ts.visitNodes(node.heritageClauses, destructuringAndImportCallVisitor, ts.isHeritageClause), ts.visitNodes(node.members, destructuringAndImportCallVisitor, ts.isClassElement)), node))), node));
+ statements = ts.append(statements, ts.setTextRange(factory.createExpressionStatement(factory.createAssignment(name, ts.setTextRange(factory.createClassExpression(ts.visitNodes(node.decorators, destructuringAndImportCallVisitor, ts.isDecorator), undefined, node.name, undefined, ts.visitNodes(node.heritageClauses, destructuringAndImportCallVisitor, ts.isHeritageClause), ts.visitNodes(node.members, destructuringAndImportCallVisitor, ts.isClassElement)), node))), node));
if (hasAssociatedEndOfDeclarationMarker(node)) {
var id = ts.getOriginalNodeId(node);
deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
return ts.visitNode(node, destructuringAndImportCallVisitor, ts.isStatement);
}
var expressions;
- var isExportedDeclaration = ts.hasModifier(node, 1);
+ var isExportedDeclaration = ts.hasSyntacticModifier(node, 1);
var isMarkedDeclaration = hasAssociatedEndOfDeclarationMarker(node);
for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) {
var variable = _a[_i];
}
var statements;
if (expressions) {
- statements = ts.append(statements, ts.setTextRange(ts.createExpressionStatement(ts.inlineExpressions(expressions)), node));
+ statements = ts.append(statements, ts.setTextRange(factory.createExpressionStatement(factory.inlineExpressions(expressions)), node));
}
if (isMarkedDeclaration) {
var id = ts.getOriginalNodeId(node);
}
}
else {
- hoistVariableDeclaration(ts.getSynthesizedClone(node.name));
+ hoistVariableDeclaration(factory.cloneNode(node.name));
}
}
function shouldHoistVariableDeclarationList(node) {
return (ts.getEmitFlags(node) & 2097152) === 0
- && (enclosingBlockScopedContainer.kind === 290
+ && (enclosingBlockScopedContainer.kind === 297
|| (ts.getOriginalNode(node).flags & 3) === 0);
}
function transformInitializedVariable(node, isExportedDeclaration) {
return createVariableAssignment(name, value, location, false);
}
function createVariableAssignment(name, value, location, isExportedDeclaration) {
- hoistVariableDeclaration(ts.getSynthesizedClone(name));
+ hoistVariableDeclaration(factory.cloneNode(name));
return isExportedDeclaration
- ? createExportExpression(name, preventSubstitution(ts.setTextRange(ts.createAssignment(name, value), location)))
- : preventSubstitution(ts.setTextRange(ts.createAssignment(name, value), location));
+ ? createExportExpression(name, preventSubstitution(ts.setTextRange(factory.createAssignment(name, value), location)))
+ : preventSubstitution(ts.setTextRange(factory.createAssignment(name, value), location));
}
function visitMergeDeclarationMarker(node) {
- if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 225) {
+ if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 232) {
var id = ts.getOriginalNodeId(node);
- var isExportedDeclaration = ts.hasModifier(node.original, 1);
+ var isExportedDeclaration = ts.hasSyntacticModifier(node.original, 1);
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original, isExportedDeclaration);
}
return node;
var namedBindings = importClause.namedBindings;
if (namedBindings) {
switch (namedBindings.kind) {
- case 256:
+ case 263:
statements = appendExportsOfDeclaration(statements, namedBindings);
break;
- case 257:
+ case 264:
for (var _i = 0, _a = namedBindings.elements; _i < _a.length; _i++) {
var importBinding = _a[_i];
statements = appendExportsOfDeclaration(statements, importBinding);
else if (!ts.isGeneratedIdentifier(decl.name)) {
var excludeName = void 0;
if (exportSelf) {
- statements = appendExportStatement(statements, decl.name, ts.getLocalName(decl));
+ statements = appendExportStatement(statements, decl.name, factory.getLocalName(decl));
excludeName = ts.idText(decl.name);
}
statements = appendExportsOfDeclaration(statements, decl, excludeName);
return statements;
}
var excludeName;
- if (ts.hasModifier(decl, 1)) {
- var exportName = ts.hasModifier(decl, 512) ? ts.createLiteral("default") : decl.name;
- statements = appendExportStatement(statements, exportName, ts.getLocalName(decl));
+ if (ts.hasSyntacticModifier(decl, 1)) {
+ var exportName = ts.hasSyntacticModifier(decl, 512) ? factory.createStringLiteral("default") : decl.name;
+ statements = appendExportStatement(statements, exportName, factory.getLocalName(decl));
excludeName = ts.getTextOfIdentifierOrLiteral(exportName);
}
if (decl.name) {
if (moduleInfo.exportEquals) {
return statements;
}
- var name = ts.getDeclarationName(decl);
+ var name = factory.getDeclarationName(decl);
var exportSpecifiers = moduleInfo.exportSpecifiers.get(ts.idText(name));
if (exportSpecifiers) {
for (var _i = 0, exportSpecifiers_2 = exportSpecifiers; _i < exportSpecifiers_2.length; _i++) {
return statements;
}
function createExportStatement(name, value, allowComments) {
- var statement = ts.createExpressionStatement(createExportExpression(name, value));
+ var statement = factory.createExpressionStatement(createExportExpression(name, value));
ts.startOnNewLine(statement);
if (!allowComments) {
ts.setEmitFlags(statement, 1536);
return statement;
}
function createExportExpression(name, value) {
- var exportName = ts.isIdentifier(name) ? ts.createLiteral(name) : name;
+ var exportName = ts.isIdentifier(name) ? factory.createStringLiteralFromNode(name) : name;
ts.setEmitFlags(value, ts.getEmitFlags(value) | 1536);
- return ts.setCommentRange(ts.createCall(exportFunction, undefined, [exportName, value]), value);
+ return ts.setCommentRange(factory.createCallExpression(exportFunction, undefined, [exportName, value]), value);
}
function nestedElementVisitor(node) {
switch (node.kind) {
- case 225:
+ case 232:
return visitVariableStatement(node);
- case 244:
+ case 251:
return visitFunctionDeclaration(node);
- case 245:
+ case 252:
return visitClassDeclaration(node);
- case 230:
+ case 237:
return visitForStatement(node);
- case 231:
+ case 238:
return visitForInStatement(node);
- case 232:
+ case 239:
return visitForOfStatement(node);
- case 228:
+ case 235:
return visitDoStatement(node);
- case 229:
+ case 236:
return visitWhileStatement(node);
- case 238:
+ case 245:
return visitLabeledStatement(node);
- case 236:
+ case 243:
return visitWithStatement(node);
- case 237:
+ case 244:
return visitSwitchStatement(node);
- case 251:
+ case 258:
return visitCaseBlock(node);
- case 277:
+ case 284:
return visitCaseClause(node);
- case 278:
+ case 285:
return visitDefaultClause(node);
- case 240:
+ case 247:
return visitTryStatement(node);
- case 280:
+ case 287:
return visitCatchClause(node);
- case 223:
+ case 230:
return visitBlock(node);
- case 328:
+ case 338:
return visitMergeDeclarationMarker(node);
- case 329:
+ case 339:
return visitEndOfDeclarationMarker(node);
default:
return destructuringAndImportCallVisitor(node);
function visitForStatement(node) {
var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
enclosingBlockScopedContainer = node;
- node = ts.updateFor(node, node.initializer && visitForInitializer(node.initializer), ts.visitNode(node.condition, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.incrementor, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement));
+ node = factory.updateForStatement(node, node.initializer && visitForInitializer(node.initializer), ts.visitNode(node.condition, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.incrementor, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement));
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
return node;
}
function visitForInStatement(node) {
var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
enclosingBlockScopedContainer = node;
- node = ts.updateForIn(node, visitForInitializer(node.initializer), ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock));
+ node = factory.updateForInStatement(node, visitForInitializer(node.initializer), ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, factory.liftToBlock));
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
return node;
}
function visitForOfStatement(node) {
var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
enclosingBlockScopedContainer = node;
- node = ts.updateForOf(node, node.awaitModifier, visitForInitializer(node.initializer), ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock));
+ node = factory.updateForOfStatement(node, node.awaitModifier, visitForInitializer(node.initializer), ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, factory.liftToBlock));
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
return node;
}
hoistBindingElement(variable);
}
}
- return expressions ? ts.inlineExpressions(expressions) : ts.createOmittedExpression();
+ return expressions ? factory.inlineExpressions(expressions) : factory.createOmittedExpression();
}
else {
return ts.visitEachChild(node, nestedElementVisitor, context);
}
}
function visitDoStatement(node) {
- return ts.updateDo(node, ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock), ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression));
+ return factory.updateDoStatement(node, ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, factory.liftToBlock), ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression));
}
function visitWhileStatement(node) {
- return ts.updateWhile(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock));
+ return factory.updateWhileStatement(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, factory.liftToBlock));
}
function visitLabeledStatement(node) {
- return ts.updateLabel(node, node.label, ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock));
+ return factory.updateLabeledStatement(node, node.label, ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, factory.liftToBlock));
}
function visitWithStatement(node) {
- return ts.updateWith(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, ts.liftToBlock));
+ return factory.updateWithStatement(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.statement, nestedElementVisitor, ts.isStatement, factory.liftToBlock));
}
function visitSwitchStatement(node) {
- return ts.updateSwitch(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.caseBlock, nestedElementVisitor, ts.isCaseBlock));
+ return factory.updateSwitchStatement(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNode(node.caseBlock, nestedElementVisitor, ts.isCaseBlock));
}
function visitCaseBlock(node) {
var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
enclosingBlockScopedContainer = node;
- node = ts.updateCaseBlock(node, ts.visitNodes(node.clauses, nestedElementVisitor, ts.isCaseOrDefaultClause));
+ node = factory.updateCaseBlock(node, ts.visitNodes(node.clauses, nestedElementVisitor, ts.isCaseOrDefaultClause));
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
return node;
}
function visitCaseClause(node) {
- return ts.updateCaseClause(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNodes(node.statements, nestedElementVisitor, ts.isStatement));
+ return factory.updateCaseClause(node, ts.visitNode(node.expression, destructuringAndImportCallVisitor, ts.isExpression), ts.visitNodes(node.statements, nestedElementVisitor, ts.isStatement));
}
function visitDefaultClause(node) {
return ts.visitEachChild(node, nestedElementVisitor, context);
function visitCatchClause(node) {
var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
enclosingBlockScopedContainer = node;
- node = ts.updateCatchClause(node, node.variableDeclaration, ts.visitNode(node.block, nestedElementVisitor, ts.isBlock));
+ node = factory.updateCatchClause(node, node.variableDeclaration, ts.visitNode(node.block, nestedElementVisitor, ts.isBlock));
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
return node;
}
}
}
function visitImportCallExpression(node) {
- return ts.createCall(ts.createPropertyAccess(contextObject, ts.createIdentifier("import")), undefined, ts.some(node.arguments) ? [ts.visitNode(node.arguments[0], destructuringAndImportCallVisitor)] : []);
+ return factory.createCallExpression(factory.createPropertyAccessExpression(contextObject, factory.createIdentifier("import")), undefined, ts.some(node.arguments) ? [ts.visitNode(node.arguments[0], destructuringAndImportCallVisitor)] : []);
}
function visitDestructuringAssignment(node) {
if (hasExportedReferenceInDestructuringTarget(node.left)) {
}
else if (ts.isIdentifier(node)) {
var container = resolver.getReferencedExportContainer(node);
- return container !== undefined && container.kind === 290;
+ return container !== undefined && container.kind === 297;
}
else {
return false;
}
function modifierVisitor(node) {
switch (node.kind) {
- case 89:
- case 84:
+ case 92:
+ case 87:
return undefined;
}
return node;
}
function onEmitNode(hint, node, emitCallback) {
- if (node.kind === 290) {
+ if (node.kind === 297) {
var id = ts.getOriginalNodeId(node);
currentSourceFile = node;
moduleInfo = moduleInfoMap[id];
}
function substituteUnspecified(node) {
switch (node.kind) {
- case 282:
+ case 289:
return substituteShorthandPropertyAssignment(node);
}
return node;
var importDeclaration = resolver.getReferencedImportDeclaration(name);
if (importDeclaration) {
if (ts.isImportClause(importDeclaration)) {
- return ts.setTextRange(ts.createPropertyAssignment(ts.getSynthesizedClone(name), ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent), ts.createIdentifier("default"))), node);
+ return ts.setTextRange(factory.createPropertyAssignment(factory.cloneNode(name), factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent), factory.createIdentifier("default"))), node);
}
else if (ts.isImportSpecifier(importDeclaration)) {
- return ts.setTextRange(ts.createPropertyAssignment(ts.getSynthesizedClone(name), ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent.parent.parent), ts.getSynthesizedClone(importDeclaration.propertyName || importDeclaration.name))), node);
+ return ts.setTextRange(factory.createPropertyAssignment(factory.cloneNode(name), factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent.parent.parent), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name))), node);
}
}
}
}
function substituteExpression(node) {
switch (node.kind) {
- case 75:
+ case 78:
return substituteExpressionIdentifier(node);
- case 209:
+ case 216:
return substituteBinaryExpression(node);
- case 207:
- case 208:
+ case 214:
+ case 215:
return substituteUnaryExpression(node);
- case 219:
+ case 226:
return substituteMetaProperty(node);
}
return node;
if (ts.getEmitFlags(node) & 4096) {
var externalHelpersModuleName = ts.getExternalHelpersModuleName(currentSourceFile);
if (externalHelpersModuleName) {
- return ts.createPropertyAccess(externalHelpersModuleName, node);
+ return factory.createPropertyAccessExpression(externalHelpersModuleName, node);
}
return node;
}
var importDeclaration = resolver.getReferencedImportDeclaration(node);
if (importDeclaration) {
if (ts.isImportClause(importDeclaration)) {
- return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent), ts.createIdentifier("default")), node);
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent), factory.createIdentifier("default")), node);
}
else if (ts.isImportSpecifier(importDeclaration)) {
- return ts.setTextRange(ts.createPropertyAccess(ts.getGeneratedNameForNode(importDeclaration.parent.parent.parent), ts.getSynthesizedClone(importDeclaration.propertyName || importDeclaration.name)), node);
+ return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent.parent.parent), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name)), node);
}
}
}
&& !ts.isDeclarationNameOfEnumOrNamespace(node.operand)) {
var exportedNames = getExports(node.operand);
if (exportedNames) {
- var expression = node.kind === 208
- ? ts.setTextRange(ts.createPrefix(node.operator, node.operand), node)
+ var expression = node.kind === 215
+ ? ts.setTextRange(factory.createPrefixUnaryExpression(node.operator, node.operand), node)
: node;
for (var _i = 0, exportedNames_5 = exportedNames; _i < exportedNames_5.length; _i++) {
var exportName = exportedNames_5[_i];
expression = createExportExpression(exportName, preventSubstitution(expression));
}
- if (node.kind === 208) {
+ if (node.kind === 215) {
expression = node.operator === 45
- ? ts.createSubtract(preventSubstitution(expression), ts.createLiteral(1))
- : ts.createAdd(preventSubstitution(expression), ts.createLiteral(1));
+ ? factory.createSubtract(preventSubstitution(expression), factory.createNumericLiteral(1))
+ : factory.createAdd(preventSubstitution(expression), factory.createNumericLiteral(1));
}
return expression;
}
}
function substituteMetaProperty(node) {
if (ts.isImportMeta(node)) {
- return ts.createPropertyAccess(contextObject, ts.createIdentifier("meta"));
+ return factory.createPropertyAccessExpression(contextObject, factory.createIdentifier("meta"));
}
return node;
}
|| resolver.getReferencedValueDeclaration(name);
if (valueDeclaration) {
var exportContainer = resolver.getReferencedExportContainer(name, false);
- if (exportContainer && exportContainer.kind === 290) {
- exportedNames = ts.append(exportedNames, ts.getDeclarationName(valueDeclaration));
+ if (exportContainer && exportContainer.kind === 297) {
+ exportedNames = ts.append(exportedNames, factory.getDeclarationName(valueDeclaration));
}
exportedNames = ts.addRange(exportedNames, moduleInfo && moduleInfo.exportedBindings[ts.getOriginalNodeId(valueDeclaration)]);
}
var ts;
(function (ts) {
function transformECMAScriptModule(context) {
+ var factory = context.factory, emitHelpers = context.getEmitHelperFactory;
var compilerOptions = context.getCompilerOptions();
var previousOnEmitNode = context.onEmitNode;
var previousOnSubstituteNode = context.onSubstituteNode;
context.onEmitNode = onEmitNode;
context.onSubstituteNode = onSubstituteNode;
- context.enableEmitNotification(290);
- context.enableSubstitution(75);
+ context.enableEmitNotification(297);
+ context.enableSubstitution(78);
var helperNameSubstitutions;
- return ts.chainBundle(transformSourceFile);
+ return ts.chainBundle(context, transformSourceFile);
function transformSourceFile(node) {
if (node.isDeclarationFile) {
return node;
}
if (ts.isExternalModule(node) || compilerOptions.isolatedModules) {
- var externalHelpersImportDeclaration = ts.createExternalHelpersImportDeclarationIfNeeded(node, compilerOptions);
- if (externalHelpersImportDeclaration) {
- var statements = [];
- var statementOffset = ts.addPrologue(statements, node.statements);
- ts.append(statements, externalHelpersImportDeclaration);
- ts.addRange(statements, ts.visitNodes(node.statements, visitor, ts.isStatement, statementOffset));
- return ts.updateSourceFileNode(node, ts.setTextRange(ts.createNodeArray(statements), node.statements));
- }
- else {
- return ts.visitEachChild(node, visitor, context);
+ var result = updateExternalModule(node);
+ if (!ts.isExternalModule(node) || ts.some(result.statements, ts.isExternalModuleIndicator)) {
+ return result;
}
+ return factory.updateSourceFile(result, ts.setTextRange(factory.createNodeArray(__spreadArrays(result.statements, [ts.createEmptyExports(factory)])), result.statements));
}
return node;
}
+ function updateExternalModule(node) {
+ var externalHelpersImportDeclaration = ts.createExternalHelpersImportDeclarationIfNeeded(factory, emitHelpers(), node, compilerOptions);
+ if (externalHelpersImportDeclaration) {
+ var statements = [];
+ var statementOffset = factory.copyPrologue(node.statements, statements);
+ ts.append(statements, externalHelpersImportDeclaration);
+ ts.addRange(statements, ts.visitNodes(node.statements, visitor, ts.isStatement, statementOffset));
+ return factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray(statements), node.statements));
+ }
+ else {
+ return ts.visitEachChild(node, visitor, context);
+ }
+ }
function visitor(node) {
switch (node.kind) {
- case 253:
+ case 260:
return undefined;
- case 259:
+ case 266:
return visitExportAssignment(node);
- case 260:
+ case 267:
var exportDecl = node;
return visitExportDeclaration(exportDecl);
}
return node;
}
var oldIdentifier = node.exportClause.name;
- var synthName = ts.getGeneratedNameForNode(oldIdentifier);
- var importDecl = ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamespaceImport(synthName)), node.moduleSpecifier);
+ var synthName = factory.getGeneratedNameForNode(oldIdentifier);
+ var importDecl = factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamespaceImport(synthName)), node.moduleSpecifier);
ts.setOriginalNode(importDecl, node.exportClause);
- var exportDecl = ts.createExportDeclaration(undefined, undefined, ts.createNamedExports([ts.createExportSpecifier(synthName, oldIdentifier)]));
+ var exportDecl = ts.isExportNamespaceAsDefaultDeclaration(node) ? factory.createExportDefault(synthName) : factory.createExportDeclaration(undefined, undefined, false, factory.createNamedExports([factory.createExportSpecifier(synthName, oldIdentifier)]));
ts.setOriginalNode(exportDecl, node);
return [importDecl, exportDecl];
}
function onEmitNode(hint, node, emitCallback) {
if (ts.isSourceFile(node)) {
if ((ts.isExternalModule(node) || compilerOptions.isolatedModules) && compilerOptions.importHelpers) {
- helperNameSubstitutions = ts.createMap();
+ helperNameSubstitutions = new ts.Map();
}
previousOnEmitNode(hint, node, emitCallback);
helperNameSubstitutions = undefined;
var name = ts.idText(node);
var substitution = helperNameSubstitutions.get(name);
if (!substitution) {
- helperNameSubstitutions.set(name, substitution = ts.createFileLevelUniqueName(name));
+ helperNameSubstitutions.set(name, substitution = factory.createUniqueName(name, 16 | 32));
}
return substitution;
}
} : undefined;
}
function getAccessorNameVisibilityDiagnosticMessage(symbolAccessibilityResult) {
- if (ts.hasModifier(node, 32)) {
+ if (ts.hasSyntacticModifier(node, 32)) {
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
}
- else if (node.parent.kind === 245) {
+ else if (node.parent.kind === 252) {
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
} : undefined;
}
function getMethodNameVisibilityDiagnosticMessage(symbolAccessibilityResult) {
- if (ts.hasModifier(node, 32)) {
+ if (ts.hasSyntacticModifier(node, 32)) {
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
ts.Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_private_name_1;
}
- else if (node.parent.kind === 245) {
+ else if (node.parent.kind === 252) {
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
return getReturnTypeVisibilityError;
}
else if (ts.isParameter(node)) {
- if (ts.isParameterPropertyDeclaration(node, node.parent) && ts.hasModifier(node.parent, 8)) {
+ if (ts.isParameterPropertyDeclaration(node, node.parent) && ts.hasSyntacticModifier(node.parent, 8)) {
return getVariableDeclarationTypeVisibilityError;
}
return getParameterDeclarationTypeVisibilityError;
return ts.Debug.assertNever(node, "Attempted to set a declaration diagnostic context for unhandled node kind: " + ts.SyntaxKind[node.kind]);
}
function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
- if (node.kind === 242 || node.kind === 191) {
+ if (node.kind === 249 || node.kind === 198) {
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
}
- else if (node.kind === 159 || node.kind === 194 || node.kind === 158 ||
- (node.kind === 156 && ts.hasModifier(node.parent, 8))) {
- if (ts.hasModifier(node, 32)) {
+ else if (node.kind === 163 || node.kind === 201 || node.kind === 162 ||
+ (node.kind === 160 && ts.hasSyntacticModifier(node.parent, 8))) {
+ if (ts.hasSyntacticModifier(node, 32)) {
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
}
- else if (node.parent.kind === 245 || node.kind === 156) {
+ else if (node.parent.kind === 252 || node.kind === 160) {
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
}
function getAccessorDeclarationTypeVisibilityError(symbolAccessibilityResult) {
var diagnosticMessage;
- if (node.kind === 164) {
- if (ts.hasModifier(node, 32)) {
+ if (node.kind === 168) {
+ if (ts.hasSyntacticModifier(node, 32)) {
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
ts.Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1;
}
}
else {
- if (ts.hasModifier(node, 32)) {
+ if (ts.hasSyntacticModifier(node, 32)) {
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
function getReturnTypeVisibilityError(symbolAccessibilityResult) {
var diagnosticMessage;
switch (node.kind) {
- case 166:
+ case 170:
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0;
break;
- case 165:
+ case 169:
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0;
break;
- case 167:
+ case 171:
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0;
break;
- case 161:
- case 160:
- if (ts.hasModifier(node, 32)) {
+ case 165:
+ case 164:
+ if (ts.hasSyntacticModifier(node, 32)) {
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 :
ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0;
}
- else if (node.parent.kind === 245) {
+ else if (node.parent.kind === 252) {
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0;
}
break;
- case 244:
+ case 251:
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
}
function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
switch (node.parent.kind) {
- case 162:
+ case 166:
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1;
- case 166:
- case 171:
+ case 170:
+ case 175:
return symbolAccessibilityResult.errorModuleName ?
ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
- case 165:
+ case 169:
return symbolAccessibilityResult.errorModuleName ?
ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
- case 167:
+ case 171:
return symbolAccessibilityResult.errorModuleName ?
ts.Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1;
- case 161:
- case 160:
- if (ts.hasModifier(node.parent, 32)) {
+ case 165:
+ case 164:
+ if (ts.hasSyntacticModifier(node.parent, 32)) {
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
}
- else if (node.parent.parent.kind === 245) {
+ else if (node.parent.parent.kind === 252) {
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
}
- case 244:
- case 170:
+ case 251:
+ case 174:
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 :
ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1;
- case 164:
- case 163:
+ case 168:
+ case 167:
return symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === 2 ?
ts.Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
function getTypeParameterConstraintVisibilityError() {
var diagnosticMessage;
switch (node.parent.kind) {
- case 245:
+ case 252:
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1;
break;
- case 246:
+ case 253:
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1;
break;
- case 186:
+ case 190:
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1;
break;
- case 171:
- case 166:
+ case 175:
+ case 170:
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
break;
- case 165:
+ case 169:
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
break;
- case 161:
- case 160:
- if (ts.hasModifier(node.parent, 32)) {
+ case 165:
+ case 164:
+ if (ts.hasSyntacticModifier(node.parent, 32)) {
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
}
- else if (node.parent.parent.kind === 245) {
+ else if (node.parent.parent.kind === 252) {
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;
}
else {
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
}
break;
- case 170:
- case 244:
+ case 174:
+ case 251:
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1;
break;
- case 247:
+ case 254:
diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1;
break;
default:
}
function getHeritageClauseVisibilityError() {
var diagnosticMessage;
- if (node.parent.parent.kind === 245) {
- diagnosticMessage = ts.isHeritageClause(node.parent) && node.parent.token === 113 ?
+ if (ts.isClassDeclaration(node.parent.parent)) {
+ diagnosticMessage = ts.isHeritageClause(node.parent) && node.parent.token === 116 ?
ts.Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 :
- ts.Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1;
+ node.parent.parent.name ? ts.Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1 :
+ ts.Diagnostics.extends_clause_of_exported_class_has_or_is_using_private_name_0;
}
else {
diagnosticMessage = ts.Diagnostics.extends_clause_of_exported_interface_0_has_or_is_using_private_name_1;
var ts;
(function (ts) {
function getDeclarationDiagnostics(host, resolver, file) {
- if (file && ts.isJsonSourceFile(file)) {
- return [];
- }
var compilerOptions = host.getCompilerOptions();
- var result = ts.transformNodes(resolver, host, compilerOptions, file ? [file] : ts.filter(host.getSourceFiles(), ts.isSourceFileNotJson), [transformDeclarations], false);
+ var result = ts.transformNodes(resolver, host, ts.factory, compilerOptions, file ? [file] : ts.filter(host.getSourceFiles(), ts.isSourceFileNotJson), [transformDeclarations], false);
return result.diagnostics;
}
ts.getDeclarationDiagnostics = getDeclarationDiagnostics;
}
function isInternalDeclaration(node, currentSourceFile) {
var parseTreeNode = ts.getParseTreeNode(node);
- if (parseTreeNode && parseTreeNode.kind === 156) {
+ if (parseTreeNode && parseTreeNode.kind === 160) {
var paramIdx = parseTreeNode.parent.parameters.indexOf(parseTreeNode);
var previousSibling = paramIdx > 0 ? parseTreeNode.parent.parameters[paramIdx - 1] : undefined;
var text = currentSourceFile.text;
var lateStatementReplacementMap;
var suppressNewDiagnosticContexts;
var exportedModulesFromDeclarationEmit;
+ var factory = context.factory;
var host = context.getEmitHost();
var symbolTracker = {
trackSymbol: trackSymbol,
reportInaccessibleThisError: reportInaccessibleThisError,
reportInaccessibleUniqueSymbolError: reportInaccessibleUniqueSymbolError,
+ reportCyclicStructureError: reportCyclicStructureError,
reportPrivateInBaseOfClassExpression: reportPrivateInBaseOfClassExpression,
reportLikelyUnsafeImportRequiredError: reportLikelyUnsafeImportRequiredError,
+ reportTruncationError: reportTruncationError,
moduleResolverHost: host,
trackReferencedAmbientModule: trackReferencedAmbientModule,
trackExternalModuleSymbolOfImportTypeNode: trackExternalModuleSymbolOfImportTypeNode,
if (!typeReferenceDirectives) {
return;
}
- necessaryTypeReferences = necessaryTypeReferences || ts.createMap();
+ necessaryTypeReferences = necessaryTypeReferences || new ts.Set();
for (var _i = 0, typeReferenceDirectives_2 = typeReferenceDirectives; _i < typeReferenceDirectives_2.length; _i++) {
var ref = typeReferenceDirectives_2[_i];
- necessaryTypeReferences.set(ref, true);
+ necessaryTypeReferences.add(ref);
}
}
function trackReferencedAmbientModule(node, symbol) {
return recordTypeReferenceDirectivesIfNecessary(directives);
}
var container = ts.getSourceFileOfNode(node);
- refs.set("" + ts.getOriginalNodeId(container), container);
+ refs.set(ts.getOriginalNodeId(container), container);
}
function handleSymbolAccessibilityError(symbolAccessibilityResult) {
if (symbolAccessibilityResult.accessibility === 0) {
context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary, ts.declarationNameToString(errorNameNode), "unique symbol"));
}
}
+ function reportCyclicStructureError() {
+ if (errorNameNode) {
+ context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary, ts.declarationNameToString(errorNameNode)));
+ }
+ }
function reportInaccessibleThisError() {
if (errorNameNode) {
context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary, ts.declarationNameToString(errorNameNode), "this"));
context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary, ts.declarationNameToString(errorNameNode), specifier));
}
}
+ function reportTruncationError() {
+ if (errorNameNode) {
+ context.addDiagnostic(ts.createDiagnosticForNode(errorNameNode, ts.Diagnostics.The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed));
+ }
+ }
function reportNonlocalAugmentation(containingFile, parentSymbol, symbol) {
var primaryDeclaration = ts.find(parentSymbol.declarations, function (d) { return ts.getSourceFileOfNode(d) === containingFile; });
var augmentingDeclarations = ts.filter(symbol.declarations, function (d) { return ts.getSourceFileOfNode(d) !== containingFile; });
return result;
}
function transformRoot(node) {
- if (node.kind === 290 && node.isDeclarationFile) {
+ if (node.kind === 297 && node.isDeclarationFile) {
return node;
}
- if (node.kind === 291) {
+ if (node.kind === 298) {
isBundledEmit = true;
- refs = ts.createMap();
- libs = ts.createMap();
+ refs = new ts.Map();
+ libs = new ts.Map();
var hasNoDefaultLib_1 = false;
- var bundle = ts.createBundle(ts.map(node.sourceFiles, function (sourceFile) {
+ var bundle = factory.createBundle(ts.map(node.sourceFiles, function (sourceFile) {
if (sourceFile.isDeclarationFile)
return undefined;
hasNoDefaultLib_1 = hasNoDefaultLib_1 || sourceFile.hasNoDefaultLib;
enclosingDeclaration = sourceFile;
lateMarkedStatements = undefined;
suppressNewDiagnosticContexts = false;
- lateStatementReplacementMap = ts.createMap();
+ lateStatementReplacementMap = new ts.Map();
getSymbolAccessibilityDiagnostic = throwDiagnostic;
needsScopeFixMarker = false;
resultHasScopeMarker = false;
if (ts.isExternalOrCommonJsModule(sourceFile) || ts.isJsonSourceFile(sourceFile)) {
resultHasExternalModuleIndicator = false;
needsDeclare = false;
- var statements = ts.isSourceFileJS(sourceFile) ? ts.createNodeArray(transformDeclarationsForJS(sourceFile, true)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements);
- var newFile = ts.updateSourceFileNode(sourceFile, [ts.createModuleDeclaration([], [ts.createModifier(130)], ts.createLiteral(ts.getResolvedExternalModuleName(context.getEmitHost(), sourceFile)), ts.createModuleBlock(ts.setTextRange(ts.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), sourceFile.statements)))], true, [], [], false, []);
+ var statements = ts.isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile, true)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements);
+ var newFile = factory.updateSourceFile(sourceFile, [factory.createModuleDeclaration([], [factory.createModifier(133)], factory.createStringLiteral(ts.getResolvedExternalModuleName(context.getEmitHost(), sourceFile)), factory.createModuleBlock(ts.setTextRange(factory.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), sourceFile.statements)))], true, [], [], false, []);
return newFile;
}
needsDeclare = true;
- var updated = ts.isSourceFileJS(sourceFile) ? ts.createNodeArray(transformDeclarationsForJS(sourceFile)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements);
- return ts.updateSourceFileNode(sourceFile, transformAndReplaceLatePaintedStatements(updated), true, [], [], false, []);
+ var updated = ts.isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements);
+ return factory.updateSourceFile(sourceFile, transformAndReplaceLatePaintedStatements(updated), true, [], [], false, []);
}), ts.mapDefined(node.prepends, function (prepend) {
- if (prepend.kind === 293) {
+ if (prepend.kind === 300) {
var sourceFile = ts.createUnparsedSourceFile(prepend, "dts", stripInternal);
hasNoDefaultLib_1 = hasNoDefaultLib_1 || !!sourceFile.hasNoDefaultLib;
collectReferences(sourceFile, refs);
resultHasExternalModuleIndicator = false;
suppressNewDiagnosticContexts = false;
lateMarkedStatements = undefined;
- lateStatementReplacementMap = ts.createMap();
+ lateStatementReplacementMap = new ts.Map();
necessaryTypeReferences = undefined;
- refs = collectReferences(currentSourceFile, ts.createMap());
- libs = collectLibs(currentSourceFile, ts.createMap());
+ refs = collectReferences(currentSourceFile, new ts.Map());
+ libs = collectLibs(currentSourceFile, new ts.Map());
var references = [];
var outputFilePath = ts.getDirectoryPath(ts.normalizeSlashes(ts.getOutputPathsFor(node, host, true).declarationFilePath));
var referenceVisitor = mapReferencesIntoArray(references, outputFilePath);
var combinedStatements;
if (ts.isSourceFileJS(currentSourceFile)) {
- combinedStatements = ts.createNodeArray(transformDeclarationsForJS(node));
+ combinedStatements = factory.createNodeArray(transformDeclarationsForJS(node));
refs.forEach(referenceVisitor);
emittedImports = ts.filter(combinedStatements, ts.isAnyImportSyntax);
}
else {
var statements = ts.visitNodes(node.statements, visitDeclarationStatements);
- combinedStatements = ts.setTextRange(ts.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), node.statements);
+ combinedStatements = ts.setTextRange(factory.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), node.statements);
refs.forEach(referenceVisitor);
emittedImports = ts.filter(combinedStatements, ts.isAnyImportSyntax);
if (ts.isExternalModule(node) && (!resultHasExternalModuleIndicator || (needsScopeFixMarker && !resultHasScopeMarker))) {
- combinedStatements = ts.setTextRange(ts.createNodeArray(__spreadArrays(combinedStatements, [ts.createEmptyExports()])), combinedStatements);
+ combinedStatements = ts.setTextRange(factory.createNodeArray(__spreadArrays(combinedStatements, [ts.createEmptyExports(factory)])), combinedStatements);
}
}
- var updated = ts.updateSourceFileNode(node, combinedStatements, true, references, getFileReferencesForUsedTypeReferences(), node.hasNoDefaultLib, getLibReferences());
+ var updated = factory.updateSourceFile(node, combinedStatements, true, references, getFileReferencesForUsedTypeReferences(), node.hasNoDefaultLib, getLibReferences());
updated.exportedModulesFromDeclarationEmit = exportedModulesFromDeclarationEmit;
return updated;
function getLibReferences() {
ts.forEach(sourceFile.referencedFiles, function (f) {
var elem = host.getSourceFileFromReference(sourceFile, f);
if (elem) {
- ret.set("" + ts.getOriginalNodeId(elem), elem);
+ ret.set(ts.getOriginalNodeId(elem), elem);
}
});
return ret;
return ret;
}
function filterBindingPatternInitializers(name) {
- if (name.kind === 75) {
+ if (name.kind === 78) {
return name;
}
else {
- if (name.kind === 190) {
- return ts.updateArrayBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement));
+ if (name.kind === 197) {
+ return factory.updateArrayBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement));
}
else {
- return ts.updateObjectBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement));
+ return factory.updateObjectBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement));
}
}
function visitBindingElement(elem) {
- if (elem.kind === 215) {
+ if (elem.kind === 222) {
return elem;
}
- return ts.updateBindingElement(elem, elem.dotDotDotToken, elem.propertyName, filterBindingPatternInitializers(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined);
+ return factory.updateBindingElement(elem, elem.dotDotDotToken, elem.propertyName, filterBindingPatternInitializers(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined);
}
}
function ensureParameter(p, modifierMask, type) {
oldDiag = getSymbolAccessibilityDiagnostic;
getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(p);
}
- var newParam = ts.updateParameter(p, undefined, maskModifiers(p, modifierMask), p.dotDotDotToken, filterBindingPatternInitializers(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || ts.createToken(57)) : undefined, ensureType(p, type || p.type, true), ensureNoInitializer(p));
+ var newParam = factory.updateParameterDeclaration(p, undefined, maskModifiers(p, modifierMask), p.dotDotDotToken, filterBindingPatternInitializers(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || factory.createToken(57)) : undefined, ensureType(p, type || p.type, true), ensureNoInitializer(p));
if (!suppressNewDiagnosticContexts) {
getSymbolAccessibilityDiagnostic = oldDiag;
}
return undefined;
}
function ensureType(node, type, ignorePrivate) {
- if (!ignorePrivate && ts.hasModifier(node, 8)) {
+ if (!ignorePrivate && ts.hasEffectiveModifier(node, 8)) {
return;
}
if (shouldPrintWithInitializer(node)) {
return;
}
- var shouldUseResolverType = node.kind === 156 &&
+ var shouldUseResolverType = node.kind === 160 &&
(resolver.isRequiredInitializedParameter(node) ||
resolver.isOptionalUninitializedParameterProperty(node));
if (type && !shouldUseResolverType) {
return ts.visitNode(type, visitDeclarationSubtree);
}
if (!ts.getParseTreeNode(node)) {
- return type ? ts.visitNode(type, visitDeclarationSubtree) : ts.createKeywordTypeNode(125);
+ return type ? ts.visitNode(type, visitDeclarationSubtree) : factory.createKeywordTypeNode(128);
}
- if (node.kind === 164) {
- return ts.createKeywordTypeNode(125);
+ if (node.kind === 168) {
+ return factory.createKeywordTypeNode(128);
}
errorNameNode = node.name;
var oldDiag;
oldDiag = getSymbolAccessibilityDiagnostic;
getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(node);
}
- if (node.kind === 242 || node.kind === 191) {
+ if (node.kind === 249 || node.kind === 198) {
return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
}
- if (node.kind === 156
- || node.kind === 159
- || node.kind === 158) {
+ if (node.kind === 160
+ || node.kind === 163
+ || node.kind === 162) {
if (!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));
if (!suppressNewDiagnosticContexts) {
getSymbolAccessibilityDiagnostic = oldDiag;
}
- return returnValue || ts.createKeywordTypeNode(125);
+ return returnValue || factory.createKeywordTypeNode(128);
}
}
function isDeclarationAndNotVisible(node) {
node = ts.getParseTreeNode(node);
switch (node.kind) {
- case 244:
- case 249:
- case 246:
- case 245:
- case 247:
- case 248:
- return !resolver.isDeclarationVisible(node);
- case 242:
- return !getBindingNameVisible(node);
+ case 251:
+ case 256:
case 253:
+ case 252:
case 254:
+ case 255:
+ return !resolver.isDeclarationVisible(node);
+ case 249:
+ return !getBindingNameVisible(node);
case 260:
- case 259:
+ case 261:
+ case 267:
+ case 266:
return false;
}
return false;
}
}
function updateParamsList(node, params, modifierMask) {
- if (ts.hasModifier(node, 8)) {
+ if (ts.hasEffectiveModifier(node, 8)) {
return undefined;
}
var newParams = ts.map(params, function (p) { return ensureParameter(p, modifierMask); });
if (!newParams) {
return undefined;
}
- return ts.createNodeArray(newParams, params.hasTrailingComma);
+ return factory.createNodeArray(newParams, params.hasTrailingComma);
}
function updateAccessorParamsList(input, isPrivate) {
var newParams;
}
}
if (!newValueParameter) {
- newValueParameter = ts.createParameter(undefined, undefined, undefined, "value");
+ newValueParameter = factory.createParameterDeclaration(undefined, undefined, undefined, "value");
}
newParams = ts.append(newParams, newValueParameter);
}
- return ts.createNodeArray(newParams || ts.emptyArray);
+ return factory.createNodeArray(newParams || ts.emptyArray);
}
function ensureTypeParams(node, params) {
- return ts.hasModifier(node, 8) ? undefined : ts.visitNodes(params, visitDeclarationSubtree);
+ return ts.hasEffectiveModifier(node, 8) ? undefined : ts.visitNodes(params, visitDeclarationSubtree);
}
function isEnclosingDeclaration(node) {
return ts.isSourceFile(node)
function rewriteModuleSpecifier(parent, input) {
if (!input)
return undefined;
- resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || (parent.kind !== 249 && parent.kind !== 188);
+ resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || (parent.kind !== 256 && parent.kind !== 195);
if (ts.isStringLiteralLike(input)) {
if (isBundledEmit) {
var newName = ts.getExternalModuleNameFromDeclaration(context.getEmitHost(), resolver, parent);
if (newName) {
- return ts.createLiteral(newName);
+ return factory.createStringLiteral(newName);
}
}
else {
function transformImportEqualsDeclaration(decl) {
if (!resolver.isDeclarationVisible(decl))
return;
- if (decl.moduleReference.kind === 265) {
+ if (decl.moduleReference.kind === 272) {
var specifier = ts.getExternalModuleImportEqualsDeclarationExpression(decl);
- return ts.updateImportEqualsDeclaration(decl, undefined, decl.modifiers, decl.name, ts.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier)));
+ return factory.updateImportEqualsDeclaration(decl, undefined, decl.modifiers, decl.name, factory.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier)));
}
else {
var oldDiag = getSymbolAccessibilityDiagnostic;
}
function transformImportDeclaration(decl) {
if (!decl.importClause) {
- return ts.updateImportDeclaration(decl, undefined, decl.modifiers, decl.importClause, rewriteModuleSpecifier(decl, decl.moduleSpecifier));
+ return factory.updateImportDeclaration(decl, undefined, decl.modifiers, decl.importClause, rewriteModuleSpecifier(decl, decl.moduleSpecifier));
}
var visibleDefaultBinding = decl.importClause && decl.importClause.name && resolver.isDeclarationVisible(decl.importClause) ? decl.importClause.name : undefined;
if (!decl.importClause.namedBindings) {
- return visibleDefaultBinding && ts.updateImportDeclaration(decl, undefined, decl.modifiers, ts.updateImportClause(decl.importClause, visibleDefaultBinding, undefined, decl.importClause.isTypeOnly), rewriteModuleSpecifier(decl, decl.moduleSpecifier));
+ return visibleDefaultBinding && factory.updateImportDeclaration(decl, undefined, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, undefined), rewriteModuleSpecifier(decl, decl.moduleSpecifier));
}
- if (decl.importClause.namedBindings.kind === 256) {
+ if (decl.importClause.namedBindings.kind === 263) {
var namedBindings = resolver.isDeclarationVisible(decl.importClause.namedBindings) ? decl.importClause.namedBindings : undefined;
- return visibleDefaultBinding || namedBindings ? ts.updateImportDeclaration(decl, undefined, decl.modifiers, ts.updateImportClause(decl.importClause, visibleDefaultBinding, namedBindings, decl.importClause.isTypeOnly), rewriteModuleSpecifier(decl, decl.moduleSpecifier)) : undefined;
+ return visibleDefaultBinding || namedBindings ? factory.updateImportDeclaration(decl, undefined, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, namedBindings), rewriteModuleSpecifier(decl, decl.moduleSpecifier)) : undefined;
}
var bindingList = ts.mapDefined(decl.importClause.namedBindings.elements, function (b) { return resolver.isDeclarationVisible(b) ? b : undefined; });
if ((bindingList && bindingList.length) || visibleDefaultBinding) {
- return ts.updateImportDeclaration(decl, undefined, decl.modifiers, ts.updateImportClause(decl.importClause, visibleDefaultBinding, bindingList && bindingList.length ? ts.updateNamedImports(decl.importClause.namedBindings, bindingList) : undefined, decl.importClause.isTypeOnly), rewriteModuleSpecifier(decl, decl.moduleSpecifier));
+ return factory.updateImportDeclaration(decl, undefined, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, bindingList && bindingList.length ? factory.updateNamedImports(decl.importClause.namedBindings, bindingList) : undefined), rewriteModuleSpecifier(decl, decl.moduleSpecifier));
}
if (resolver.isImportRequiredByAugmentation(decl)) {
- return ts.updateImportDeclaration(decl, undefined, decl.modifiers, undefined, rewriteModuleSpecifier(decl, decl.moduleSpecifier));
+ return factory.updateImportDeclaration(decl, undefined, decl.modifiers, undefined, rewriteModuleSpecifier(decl, decl.moduleSpecifier));
}
}
function transformAndReplaceLatePaintedStatements(statements) {
needsDeclare = i.parent && ts.isSourceFile(i.parent) && !(ts.isExternalModule(i.parent) && isBundledEmit);
var result = transformTopLevelDeclaration(i);
needsDeclare = priorNeedsDeclare;
- lateStatementReplacementMap.set("" + ts.getOriginalNodeId(i), result);
+ lateStatementReplacementMap.set(ts.getOriginalNodeId(i), result);
}
return ts.visitNodes(statements, visitLateVisibilityMarkedStatements);
function visitLateVisibilityMarkedStatements(statement) {
if (ts.isLateVisibilityPaintedStatement(statement)) {
- var key = "" + ts.getOriginalNodeId(statement);
+ var key = ts.getOriginalNodeId(statement);
if (lateStatementReplacementMap.has(key)) {
var result = lateStatementReplacementMap.get(key);
lateStatementReplacementMap.delete(key);
var oldDiag = getSymbolAccessibilityDiagnostic;
var canProduceDiagnostic = ts.canProduceDiagnostics(input);
var oldWithinObjectLiteralType = suppressNewDiagnosticContexts;
- var shouldEnterSuppressNewDiagnosticsContextContext = ((input.kind === 173 || input.kind === 186) && input.parent.kind !== 247);
+ var shouldEnterSuppressNewDiagnosticsContextContext = ((input.kind === 177 || input.kind === 190) && input.parent.kind !== 254);
if (ts.isMethodDeclaration(input) || ts.isMethodSignature(input)) {
- if (ts.hasModifier(input, 8)) {
+ if (ts.hasEffectiveModifier(input, 8)) {
if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input)
return;
- return cleanup(ts.createProperty(undefined, ensureModifiers(input), input.name, undefined, undefined, undefined));
+ return cleanup(factory.createPropertyDeclaration(undefined, ensureModifiers(input), input.name, undefined, undefined, undefined));
}
}
if (canProduceDiagnostic && !suppressNewDiagnosticContexts) {
}
if (isProcessedComponent(input)) {
switch (input.kind) {
- case 216: {
+ case 223: {
if ((ts.isEntityName(input.expression) || ts.isEntityNameExpression(input.expression))) {
checkEntityNameVisibility(input.expression, enclosingDeclaration);
}
var node = ts.visitEachChild(input, visitDeclarationSubtree, context);
- return cleanup(ts.updateExpressionWithTypeArguments(node, ts.parenthesizeTypeParameters(node.typeArguments), node.expression));
+ return cleanup(factory.updateExpressionWithTypeArguments(node, node.expression, node.typeArguments));
}
- case 169: {
+ case 173: {
checkEntityNameVisibility(input.typeName, enclosingDeclaration);
var node = ts.visitEachChild(input, visitDeclarationSubtree, context);
- return cleanup(ts.updateTypeReferenceNode(node, node.typeName, ts.parenthesizeTypeParameters(node.typeArguments)));
+ return cleanup(factory.updateTypeReferenceNode(node, node.typeName, node.typeArguments));
}
- case 166:
- return cleanup(ts.updateConstructSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type)));
- case 162: {
- var ctor = ts.createSignatureDeclaration(162, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters, 0), undefined);
- ctor.modifiers = ts.createNodeArray(ensureModifiers(input));
+ case 170:
+ return cleanup(factory.updateConstructSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type)));
+ case 166: {
+ var ctor = factory.createConstructorDeclaration(undefined, ensureModifiers(input), updateParamsList(input, input.parameters, 0), undefined);
return cleanup(ctor);
}
- case 161: {
+ case 165: {
if (ts.isPrivateIdentifier(input.name)) {
return cleanup(undefined);
}
- var sig = ts.createSignatureDeclaration(160, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type));
- sig.name = input.name;
- sig.modifiers = ts.createNodeArray(ensureModifiers(input));
- sig.questionToken = input.questionToken;
+ var sig = factory.createMethodDeclaration(undefined, ensureModifiers(input), undefined, input.name, input.questionToken, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), undefined);
return cleanup(sig);
}
- case 163: {
+ case 167: {
if (ts.isPrivateIdentifier(input.name)) {
return cleanup(undefined);
}
var accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
- return cleanup(ts.updateGetAccessor(input, undefined, ensureModifiers(input), input.name, updateAccessorParamsList(input, ts.hasModifier(input, 8)), ensureType(input, accessorType), undefined));
+ return cleanup(factory.updateGetAccessorDeclaration(input, undefined, ensureModifiers(input), input.name, updateAccessorParamsList(input, ts.hasEffectiveModifier(input, 8)), ensureType(input, accessorType), undefined));
}
- case 164: {
+ case 168: {
if (ts.isPrivateIdentifier(input.name)) {
return cleanup(undefined);
}
- return cleanup(ts.updateSetAccessor(input, undefined, ensureModifiers(input), input.name, updateAccessorParamsList(input, ts.hasModifier(input, 8)), undefined));
+ return cleanup(factory.updateSetAccessorDeclaration(input, undefined, ensureModifiers(input), input.name, updateAccessorParamsList(input, ts.hasEffectiveModifier(input, 8)), undefined));
}
- case 159:
+ case 163:
if (ts.isPrivateIdentifier(input.name)) {
return cleanup(undefined);
}
- return cleanup(ts.updateProperty(input, undefined, ensureModifiers(input), input.name, input.questionToken, ensureType(input, input.type), ensureNoInitializer(input)));
- case 158:
+ return cleanup(factory.updatePropertyDeclaration(input, undefined, ensureModifiers(input), input.name, input.questionToken, ensureType(input, input.type), ensureNoInitializer(input)));
+ case 162:
if (ts.isPrivateIdentifier(input.name)) {
return cleanup(undefined);
}
- return cleanup(ts.updatePropertySignature(input, ensureModifiers(input), input.name, input.questionToken, ensureType(input, input.type), ensureNoInitializer(input)));
- case 160: {
+ return cleanup(factory.updatePropertySignature(input, ensureModifiers(input), input.name, input.questionToken, ensureType(input, input.type)));
+ case 164: {
if (ts.isPrivateIdentifier(input.name)) {
return cleanup(undefined);
}
- return cleanup(ts.updateMethodSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), input.name, input.questionToken));
+ return cleanup(factory.updateMethodSignature(input, ensureModifiers(input), input.name, input.questionToken, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type)));
}
- case 165: {
- return cleanup(ts.updateCallSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type)));
+ case 169: {
+ return cleanup(factory.updateCallSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type)));
}
- case 167: {
- return cleanup(ts.updateIndexSignature(input, undefined, ensureModifiers(input), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree) || ts.createKeywordTypeNode(125)));
+ case 171: {
+ return cleanup(factory.updateIndexSignature(input, undefined, ensureModifiers(input), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree) || factory.createKeywordTypeNode(128)));
}
- case 242: {
+ case 249: {
if (ts.isBindingPattern(input.name)) {
return recreateBindingPattern(input.name);
}
shouldEnterSuppressNewDiagnosticsContextContext = true;
suppressNewDiagnosticContexts = true;
- return cleanup(ts.updateTypeScriptVariableDeclaration(input, input.name, undefined, ensureType(input, input.type), ensureNoInitializer(input)));
+ return cleanup(factory.updateVariableDeclaration(input, input.name, undefined, ensureType(input, input.type), ensureNoInitializer(input)));
}
- case 155: {
+ case 159: {
if (isPrivateMethodTypeParameter(input) && (input.default || input.constraint)) {
- return cleanup(ts.updateTypeParameterDeclaration(input, input.name, undefined, undefined));
+ return cleanup(factory.updateTypeParameterDeclaration(input, input.name, undefined, undefined));
}
return cleanup(ts.visitEachChild(input, visitDeclarationSubtree, context));
}
- case 180: {
+ case 184: {
var checkType = ts.visitNode(input.checkType, visitDeclarationSubtree);
var extendsType = ts.visitNode(input.extendsType, visitDeclarationSubtree);
var oldEnclosingDecl = enclosingDeclaration;
var trueType = ts.visitNode(input.trueType, visitDeclarationSubtree);
enclosingDeclaration = oldEnclosingDecl;
var falseType = ts.visitNode(input.falseType, visitDeclarationSubtree);
- return cleanup(ts.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
+ return cleanup(factory.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
}
- case 170: {
- return cleanup(ts.updateFunctionTypeNode(input, ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree)));
+ case 174: {
+ return cleanup(factory.updateFunctionTypeNode(input, ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree)));
}
- case 171: {
- return cleanup(ts.updateConstructorTypeNode(input, ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree)));
+ case 175: {
+ return cleanup(factory.updateConstructorTypeNode(input, ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree)));
}
- case 188: {
+ case 195: {
if (!ts.isLiteralImportTypeNode(input))
return cleanup(input);
- return cleanup(ts.updateImportTypeNode(input, ts.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)), input.qualifier, ts.visitNodes(input.typeArguments, visitDeclarationSubtree, ts.isTypeNode), input.isTypeOf));
+ return cleanup(factory.updateImportTypeNode(input, factory.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)), input.qualifier, ts.visitNodes(input.typeArguments, visitDeclarationSubtree, ts.isTypeNode), input.isTypeOf));
}
default: ts.Debug.assertNever(input, "Attempted to process unhandled node kind: " + ts.SyntaxKind[input.kind]);
}
}
+ if (ts.isTupleTypeNode(input) && (ts.getLineAndCharacterOfPosition(currentSourceFile, input.pos).line === ts.getLineAndCharacterOfPosition(currentSourceFile, input.end).line)) {
+ ts.setEmitFlags(input, 1);
+ }
return cleanup(ts.visitEachChild(input, visitDeclarationSubtree, context));
function cleanup(returnValue) {
if (returnValue && canProduceDiagnostic && ts.hasDynamicName(input)) {
}
}
function isPrivateMethodTypeParameter(node) {
- return node.parent.kind === 161 && ts.hasModifier(node.parent, 8);
+ return node.parent.kind === 165 && ts.hasEffectiveModifier(node.parent, 8);
}
function visitDeclarationStatements(input) {
if (!isPreservedDeclarationStatement(input)) {
if (shouldStripInternal(input))
return;
switch (input.kind) {
- case 260: {
+ case 267: {
if (ts.isSourceFile(input.parent)) {
resultHasExternalModuleIndicator = true;
}
resultHasScopeMarker = true;
- return ts.updateExportDeclaration(input, undefined, input.modifiers, input.exportClause, rewriteModuleSpecifier(input, input.moduleSpecifier), input.isTypeOnly);
+ return factory.updateExportDeclaration(input, undefined, input.modifiers, input.isTypeOnly, input.exportClause, rewriteModuleSpecifier(input, input.moduleSpecifier));
}
- case 259: {
+ case 266: {
if (ts.isSourceFile(input.parent)) {
resultHasExternalModuleIndicator = true;
}
resultHasScopeMarker = true;
- if (input.expression.kind === 75) {
+ if (input.expression.kind === 78) {
return input;
}
else {
- var newId = ts.createOptimisticUniqueName("_default");
+ var newId = factory.createUniqueName("_default", 16);
getSymbolAccessibilityDiagnostic = function () { return ({
diagnosticMessage: ts.Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
errorNode: input
}); };
- var varDecl = ts.createVariableDeclaration(newId, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), undefined);
- var statement = ts.createVariableStatement(needsDeclare ? [ts.createModifier(130)] : [], ts.createVariableDeclarationList([varDecl], 2));
- return [statement, ts.updateExportAssignment(input, input.decorators, input.modifiers, newId)];
+ var varDecl = factory.createVariableDeclaration(newId, undefined, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), undefined);
+ var statement = factory.createVariableStatement(needsDeclare ? [factory.createModifier(133)] : [], factory.createVariableDeclarationList([varDecl], 2));
+ return [statement, factory.updateExportAssignment(input, input.decorators, input.modifiers, newId)];
}
}
}
var result = transformTopLevelDeclaration(input);
- lateStatementReplacementMap.set("" + ts.getOriginalNodeId(input), result);
+ lateStatementReplacementMap.set(ts.getOriginalNodeId(input), result);
return input;
}
function stripExportModifiers(statement) {
- if (ts.isImportEqualsDeclaration(statement) || ts.hasModifier(statement, 512)) {
+ if (ts.isImportEqualsDeclaration(statement) || ts.hasEffectiveModifier(statement, 512) || !ts.canHaveModifiers(statement)) {
return statement;
}
- var clone = ts.getMutableClone(statement);
- var modifiers = ts.createModifiersFromModifierFlags(ts.getModifierFlags(statement) & (3071 ^ 1));
- clone.modifiers = modifiers.length ? ts.createNodeArray(modifiers) : undefined;
- return clone;
+ var modifiers = factory.createModifiersFromModifierFlags(ts.getEffectiveModifierFlags(statement) & (11263 ^ 1));
+ return factory.updateModifiers(statement, modifiers);
}
function transformTopLevelDeclaration(input) {
if (shouldStripInternal(input))
return;
switch (input.kind) {
- case 253: {
+ case 260: {
return transformImportEqualsDeclaration(input);
}
- case 254: {
+ case 261: {
return transformImportDeclaration(input);
}
}
}
var previousNeedsDeclare = needsDeclare;
switch (input.kind) {
- case 247:
- return cleanup(ts.updateTypeAliasDeclaration(input, undefined, ensureModifiers(input), input.name, ts.visitNodes(input.typeParameters, visitDeclarationSubtree, ts.isTypeParameterDeclaration), ts.visitNode(input.type, visitDeclarationSubtree, ts.isTypeNode)));
- case 246: {
- return cleanup(ts.updateInterfaceDeclaration(input, undefined, ensureModifiers(input), input.name, ensureTypeParams(input, input.typeParameters), transformHeritageClauses(input.heritageClauses), ts.visitNodes(input.members, visitDeclarationSubtree)));
+ case 254:
+ return cleanup(factory.updateTypeAliasDeclaration(input, undefined, ensureModifiers(input), input.name, ts.visitNodes(input.typeParameters, visitDeclarationSubtree, ts.isTypeParameterDeclaration), ts.visitNode(input.type, visitDeclarationSubtree, ts.isTypeNode)));
+ case 253: {
+ return cleanup(factory.updateInterfaceDeclaration(input, undefined, ensureModifiers(input), input.name, ensureTypeParams(input, input.typeParameters), transformHeritageClauses(input.heritageClauses), ts.visitNodes(input.members, visitDeclarationSubtree)));
}
- case 244: {
- var clean = cleanup(ts.updateFunctionDeclaration(input, undefined, ensureModifiers(input), undefined, input.name, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), undefined));
+ case 251: {
+ var clean = cleanup(factory.updateFunctionDeclaration(input, undefined, ensureModifiers(input), undefined, input.name, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), undefined));
if (clean && resolver.isExpandoFunctionDeclaration(input)) {
var props = resolver.getPropertiesOfContainerFunction(input);
- var fakespace_1 = ts.createModuleDeclaration(undefined, undefined, clean.name || ts.createIdentifier("_default"), ts.createModuleBlock([]), 16);
- fakespace_1.flags ^= 8;
- fakespace_1.parent = enclosingDeclaration;
+ var fakespace_1 = ts.parseNodeFactory.createModuleDeclaration(undefined, undefined, clean.name || factory.createIdentifier("_default"), factory.createModuleBlock([]), 16);
+ ts.setParent(fakespace_1, enclosingDeclaration);
fakespace_1.locals = ts.createSymbolTable(props);
fakespace_1.symbol = props[0].parent;
+ var exportMappings_1 = [];
var declarations = ts.mapDefined(props, function (p) {
if (!ts.isPropertyAccessExpression(p.valueDeclaration)) {
return undefined;
getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
var type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace_1, declarationEmitNodeBuilderFlags, symbolTracker);
getSymbolAccessibilityDiagnostic = oldDiag;
- var varDecl = ts.createVariableDeclaration(ts.unescapeLeadingUnderscores(p.escapedName), type, undefined);
- return ts.createVariableStatement(undefined, ts.createVariableDeclarationList([varDecl]));
+ var nameStr = ts.unescapeLeadingUnderscores(p.escapedName);
+ var isNonContextualKeywordName = ts.isStringANonContextualKeyword(nameStr);
+ var name = isNonContextualKeywordName ? factory.getGeneratedNameForNode(p.valueDeclaration) : factory.createIdentifier(nameStr);
+ if (isNonContextualKeywordName) {
+ exportMappings_1.push([name, nameStr]);
+ }
+ var varDecl = factory.createVariableDeclaration(name, undefined, type, undefined);
+ return factory.createVariableStatement(isNonContextualKeywordName ? undefined : [factory.createToken(92)], factory.createVariableDeclarationList([varDecl]));
});
- var namespaceDecl = ts.createModuleDeclaration(undefined, ensureModifiers(input), input.name, ts.createModuleBlock(declarations), 16);
- if (!ts.hasModifier(clean, 512)) {
+ if (!exportMappings_1.length) {
+ declarations = ts.mapDefined(declarations, function (declaration) { return factory.updateModifiers(declaration, 0); });
+ }
+ else {
+ declarations.push(factory.createExportDeclaration(undefined, undefined, false, factory.createNamedExports(ts.map(exportMappings_1, function (_a) {
+ var gen = _a[0], exp = _a[1];
+ return factory.createExportSpecifier(gen, exp);
+ }))));
+ }
+ var namespaceDecl = factory.createModuleDeclaration(undefined, ensureModifiers(input), input.name, factory.createModuleBlock(declarations), 16);
+ if (!ts.hasEffectiveModifier(clean, 512)) {
return [clean, namespaceDecl];
}
- var modifiers = ts.createModifiersFromModifierFlags((ts.getModifierFlags(clean) & ~513) | 2);
- var cleanDeclaration = ts.updateFunctionDeclaration(clean, undefined, modifiers, undefined, clean.name, clean.typeParameters, clean.parameters, clean.type, undefined);
- var namespaceDeclaration = ts.updateModuleDeclaration(namespaceDecl, undefined, modifiers, namespaceDecl.name, namespaceDecl.body);
- var exportDefaultDeclaration = ts.createExportAssignment(undefined, undefined, false, namespaceDecl.name);
+ var modifiers = factory.createModifiersFromModifierFlags((ts.getEffectiveModifierFlags(clean) & ~513) | 2);
+ var cleanDeclaration = factory.updateFunctionDeclaration(clean, undefined, modifiers, undefined, clean.name, clean.typeParameters, clean.parameters, clean.type, undefined);
+ var namespaceDeclaration = factory.updateModuleDeclaration(namespaceDecl, undefined, modifiers, namespaceDecl.name, namespaceDecl.body);
+ var exportDefaultDeclaration = factory.createExportAssignment(undefined, undefined, false, namespaceDecl.name);
if (ts.isSourceFile(input.parent)) {
resultHasExternalModuleIndicator = true;
}
return clean;
}
}
- case 249: {
+ case 256: {
needsDeclare = false;
var inner = input.body;
- if (inner && inner.kind === 250) {
+ if (inner && inner.kind === 257) {
var oldNeedsScopeFix = needsScopeFixMarker;
var oldHasScopeFix = resultHasScopeMarker;
resultHasScopeMarker = false;
}
if (!ts.isGlobalScopeAugmentation(input) && !hasScopeMarker(lateStatements) && !resultHasScopeMarker) {
if (needsScopeFixMarker) {
- lateStatements = ts.createNodeArray(__spreadArrays(lateStatements, [ts.createEmptyExports()]));
+ lateStatements = factory.createNodeArray(__spreadArrays(lateStatements, [ts.createEmptyExports(factory)]));
}
else {
lateStatements = ts.visitNodes(lateStatements, stripExportModifiers);
}
}
- var body = ts.updateModuleBlock(inner, lateStatements);
+ var body = factory.updateModuleBlock(inner, lateStatements);
needsDeclare = previousNeedsDeclare;
needsScopeFixMarker = oldNeedsScopeFix;
resultHasScopeMarker = oldHasScopeFix;
var mods = ensureModifiers(input);
- return cleanup(ts.updateModuleDeclaration(input, undefined, mods, ts.isExternalModuleAugmentation(input) ? rewriteModuleSpecifier(input, input.name) : input.name, body));
+ return cleanup(factory.updateModuleDeclaration(input, undefined, mods, ts.isExternalModuleAugmentation(input) ? rewriteModuleSpecifier(input, input.name) : input.name, body));
}
else {
needsDeclare = previousNeedsDeclare;
var mods = ensureModifiers(input);
needsDeclare = false;
ts.visitNode(inner, visitDeclarationStatements);
- var id = "" + ts.getOriginalNodeId(inner);
+ var id = ts.getOriginalNodeId(inner);
var body = lateStatementReplacementMap.get(id);
lateStatementReplacementMap.delete(id);
- return cleanup(ts.updateModuleDeclaration(input, undefined, mods, input.name, body));
+ return cleanup(factory.updateModuleDeclaration(input, undefined, mods, input.name, body));
}
}
- case 245: {
- var modifiers = ts.createNodeArray(ensureModifiers(input));
+ case 252: {
+ var modifiers = factory.createNodeArray(ensureModifiers(input));
var typeParameters = ensureTypeParams(input, input.typeParameters);
var ctor = ts.getFirstConstructorWithBody(input);
var parameterProperties = void 0;
if (ctor) {
var oldDiag_1 = getSymbolAccessibilityDiagnostic;
parameterProperties = ts.compact(ts.flatMap(ctor.parameters, function (param) {
- if (!ts.hasModifier(param, 92) || shouldStripInternal(param))
+ if (!ts.hasSyntacticModifier(param, 92) || shouldStripInternal(param))
return;
getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(param);
- if (param.name.kind === 75) {
- return preserveJsDoc(ts.createProperty(undefined, ensureModifiers(param), param.name, param.questionToken, ensureType(param, param.type), ensureNoInitializer(param)), param);
+ if (param.name.kind === 78) {
+ return preserveJsDoc(factory.createPropertyDeclaration(undefined, ensureModifiers(param), param.name, param.questionToken, ensureType(param, param.type), ensureNoInitializer(param)), param);
}
else {
return walkBindingPattern(param.name);
elems = ts.concatenate(elems, walkBindingPattern(elem.name));
}
elems = elems || [];
- elems.push(ts.createProperty(undefined, ensureModifiers(param), elem.name, undefined, ensureType(elem, undefined), undefined));
+ elems.push(factory.createPropertyDeclaration(undefined, ensureModifiers(param), elem.name, undefined, ensureType(elem, undefined), undefined));
}
return elems;
}
}
var hasPrivateIdentifier = ts.some(input.members, function (member) { return !!member.name && ts.isPrivateIdentifier(member.name); });
var privateIdentifier = hasPrivateIdentifier ? [
- ts.createProperty(undefined, undefined, ts.createPrivateIdentifier("#private"), undefined, undefined, undefined)
+ factory.createPropertyDeclaration(undefined, undefined, factory.createPrivateIdentifier("#private"), undefined, undefined, undefined)
] : undefined;
var memberNodes = ts.concatenate(ts.concatenate(privateIdentifier, parameterProperties), ts.visitNodes(input.members, visitDeclarationSubtree));
- var members = ts.createNodeArray(memberNodes);
+ var members = factory.createNodeArray(memberNodes);
var extendsClause_1 = ts.getEffectiveBaseTypeNode(input);
- if (extendsClause_1 && !ts.isEntityNameExpression(extendsClause_1.expression) && extendsClause_1.expression.kind !== 100) {
+ if (extendsClause_1 && !ts.isEntityNameExpression(extendsClause_1.expression) && extendsClause_1.expression.kind !== 103) {
var oldId = input.name ? ts.unescapeLeadingUnderscores(input.name.escapedText) : "default";
- var newId_1 = ts.createOptimisticUniqueName(oldId + "_base");
+ var newId_1 = factory.createUniqueName(oldId + "_base", 16);
getSymbolAccessibilityDiagnostic = function () { return ({
diagnosticMessage: ts.Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1,
errorNode: extendsClause_1,
typeName: input.name
}); };
- var varDecl = ts.createVariableDeclaration(newId_1, resolver.createTypeOfExpression(extendsClause_1.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), undefined);
- var statement = ts.createVariableStatement(needsDeclare ? [ts.createModifier(130)] : [], ts.createVariableDeclarationList([varDecl], 2));
- var heritageClauses = ts.createNodeArray(ts.map(input.heritageClauses, function (clause) {
- if (clause.token === 90) {
+ var varDecl = factory.createVariableDeclaration(newId_1, undefined, resolver.createTypeOfExpression(extendsClause_1.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), undefined);
+ var statement = factory.createVariableStatement(needsDeclare ? [factory.createModifier(133)] : [], factory.createVariableDeclarationList([varDecl], 2));
+ var heritageClauses = factory.createNodeArray(ts.map(input.heritageClauses, function (clause) {
+ if (clause.token === 93) {
var oldDiag_2 = getSymbolAccessibilityDiagnostic;
getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(clause.types[0]);
- var newClause = ts.updateHeritageClause(clause, ts.map(clause.types, function (t) { return ts.updateExpressionWithTypeArguments(t, ts.visitNodes(t.typeArguments, visitDeclarationSubtree), newId_1); }));
+ var newClause = factory.updateHeritageClause(clause, ts.map(clause.types, function (t) { return factory.updateExpressionWithTypeArguments(t, newId_1, ts.visitNodes(t.typeArguments, visitDeclarationSubtree)); }));
getSymbolAccessibilityDiagnostic = oldDiag_2;
return newClause;
}
- return ts.updateHeritageClause(clause, ts.visitNodes(ts.createNodeArray(ts.filter(clause.types, function (t) { return ts.isEntityNameExpression(t.expression) || t.expression.kind === 100; })), visitDeclarationSubtree));
+ return factory.updateHeritageClause(clause, ts.visitNodes(factory.createNodeArray(ts.filter(clause.types, function (t) { return ts.isEntityNameExpression(t.expression) || t.expression.kind === 103; })), visitDeclarationSubtree));
}));
- return [statement, cleanup(ts.updateClassDeclaration(input, undefined, modifiers, input.name, typeParameters, heritageClauses, members))];
+ return [statement, cleanup(factory.updateClassDeclaration(input, undefined, modifiers, input.name, typeParameters, heritageClauses, members))];
}
else {
var heritageClauses = transformHeritageClauses(input.heritageClauses);
- return cleanup(ts.updateClassDeclaration(input, undefined, modifiers, input.name, typeParameters, heritageClauses, members));
+ return cleanup(factory.updateClassDeclaration(input, undefined, modifiers, input.name, typeParameters, heritageClauses, members));
}
}
- case 225: {
+ case 232: {
return cleanup(transformVariableStatement(input));
}
- case 248: {
- return cleanup(ts.updateEnumDeclaration(input, undefined, ts.createNodeArray(ensureModifiers(input)), input.name, ts.createNodeArray(ts.mapDefined(input.members, function (m) {
+ case 255: {
+ return cleanup(factory.updateEnumDeclaration(input, undefined, factory.createNodeArray(ensureModifiers(input)), input.name, factory.createNodeArray(ts.mapDefined(input.members, function (m) {
if (shouldStripInternal(m))
return;
var constValue = resolver.getConstantValue(m);
- return preserveJsDoc(ts.updateEnumMember(m, m.name, constValue !== undefined ? ts.createLiteral(constValue) : undefined), m);
+ return preserveJsDoc(factory.updateEnumMember(m, m.name, constValue !== undefined ? typeof constValue === "string" ? factory.createStringLiteral(constValue) : factory.createNumericLiteral(constValue) : undefined), m);
}))));
}
}
if (canProdiceDiagnostic) {
getSymbolAccessibilityDiagnostic = oldDiag;
}
- if (input.kind === 249) {
+ if (input.kind === 256) {
needsDeclare = previousNeedsDeclare;
}
if (node === input) {
var nodes = ts.visitNodes(input.declarationList.declarations, visitDeclarationSubtree);
if (!ts.length(nodes))
return;
- return ts.updateVariableStatement(input, ts.createNodeArray(ensureModifiers(input)), ts.updateVariableDeclarationList(input.declarationList, nodes));
+ return factory.updateVariableStatement(input, factory.createNodeArray(ensureModifiers(input)), factory.updateVariableDeclarationList(input.declarationList, nodes));
}
function recreateBindingPattern(d) {
return ts.flatten(ts.mapDefined(d.elements, function (e) { return recreateBindingElement(e); }));
}
function recreateBindingElement(e) {
- if (e.kind === 215) {
+ if (e.kind === 222) {
return;
}
if (e.name) {
return recreateBindingPattern(e.name);
}
else {
- return ts.createVariableDeclaration(e.name, ensureType(e, undefined), undefined);
+ return factory.createVariableDeclaration(e.name, undefined, ensureType(e, undefined), undefined);
}
}
}
return ts.some(statements, isScopeMarker);
}
function ensureModifiers(node) {
- var currentFlags = ts.getModifierFlags(node);
+ var currentFlags = ts.getEffectiveModifierFlags(node);
var newFlags = ensureModifierFlags(node);
if (currentFlags === newFlags) {
return node.modifiers;
}
- return ts.createModifiersFromModifierFlags(newFlags);
+ return factory.createModifiersFromModifierFlags(newFlags);
}
function ensureModifierFlags(node) {
- var mask = 3071 ^ (4 | 256);
+ var mask = 11263 ^ (4 | 256);
var additions = (needsDeclare && !isAlwaysType(node)) ? 2 : 0;
- var parentIsFile = node.parent.kind === 290;
+ var parentIsFile = node.parent.kind === 297;
if (!parentIsFile || (isBundledEmit && parentIsFile && ts.isExternalModule(node.parent))) {
mask ^= 2;
additions = 0;
return accessorType;
}
function transformHeritageClauses(nodes) {
- return ts.createNodeArray(ts.filter(ts.map(nodes, function (clause) { return ts.updateHeritageClause(clause, ts.visitNodes(ts.createNodeArray(ts.filter(clause.types, function (t) {
- return ts.isEntityNameExpression(t.expression) || (clause.token === 90 && t.expression.kind === 100);
+ return factory.createNodeArray(ts.filter(ts.map(nodes, function (clause) { return factory.updateHeritageClause(clause, ts.visitNodes(factory.createNodeArray(ts.filter(clause.types, function (t) {
+ return ts.isEntityNameExpression(t.expression) || (clause.token === 93 && t.expression.kind === 103);
})), visitDeclarationSubtree)); }), function (clause) { return clause.types && !!clause.types.length; }));
}
}
ts.transformDeclarations = transformDeclarations;
function isAlwaysType(node) {
- if (node.kind === 246) {
+ if (node.kind === 253) {
return true;
}
return false;
}
function maskModifiers(node, modifierMask, modifierAdditions) {
- return ts.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
+ return ts.factory.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
}
function maskModifierFlags(node, modifierMask, modifierAdditions) {
- if (modifierMask === void 0) { modifierMask = 3071 ^ 4; }
+ if (modifierMask === void 0) { modifierMask = 11263 ^ 4; }
if (modifierAdditions === void 0) { modifierAdditions = 0; }
- var flags = (ts.getModifierFlags(node) & modifierMask) | modifierAdditions;
+ var flags = (ts.getEffectiveModifierFlags(node) & modifierMask) | modifierAdditions;
if (flags & 512 && !(flags & 1)) {
flags ^= 1;
}
}
function getTypeAnnotationFromAccessor(accessor) {
if (accessor) {
- return accessor.kind === 163
+ return accessor.kind === 167
? accessor.type
: accessor.parameters.length > 0
? accessor.parameters[0].type
}
function canHaveLiteralInitializer(node) {
switch (node.kind) {
- case 159:
- case 158:
- return !ts.hasModifier(node, 8);
- case 156:
- case 242:
+ case 163:
+ case 162:
+ return !ts.hasEffectiveModifier(node, 8);
+ case 160:
+ case 249:
return true;
}
return false;
}
function isPreservedDeclarationStatement(node) {
switch (node.kind) {
- case 244:
- case 249:
+ case 251:
+ case 256:
+ case 260:
case 253:
- case 246:
- case 245:
- case 247:
- case 248:
- case 225:
+ case 252:
case 254:
- case 260:
- case 259:
+ case 255:
+ case 232:
+ case 261:
+ case 267:
+ case 266:
return true;
}
return false;
}
function isProcessedComponent(node) {
switch (node.kind) {
+ case 170:
case 166:
- case 162:
- case 161:
- case 163:
- case 164:
- case 159:
- case 158:
- case 160:
case 165:
case 167:
- case 242:
- case 155:
- case 216:
+ case 168:
+ case 163:
+ case 162:
+ case 164:
case 169:
- case 180:
- case 170:
case 171:
- case 188:
+ case 249:
+ case 159:
+ case 223:
+ case 173:
+ case 184:
+ case 174:
+ case 175:
+ case 195:
return true;
}
return false;
function getScriptTransformers(compilerOptions, customTransformers, emitOnlyDtsFiles) {
if (emitOnlyDtsFiles)
return ts.emptyArray;
- var jsx = compilerOptions.jsx;
var languageVersion = ts.getEmitScriptTarget(compilerOptions);
var moduleKind = ts.getEmitModuleKind(compilerOptions);
var transformers = [];
ts.addRange(transformers, customTransformers && ts.map(customTransformers.before, wrapScriptTransformerFactory));
transformers.push(ts.transformTypeScript);
transformers.push(ts.transformClassFields);
- if (jsx === 2) {
+ if (ts.getJSXTransformEnabled(compilerOptions)) {
transformers.push(ts.transformJsx);
}
if (languageVersion < 99) {
return function (context) {
var customTransformer = transformer(context);
return typeof customTransformer === "function"
- ? handleDefault(customTransformer)
+ ? handleDefault(context, customTransformer)
: wrapCustomTransformer(customTransformer);
};
}
return wrapCustomTransformerFactory(transformer, ts.chainBundle);
}
function wrapDeclarationTransformerFactory(transformer) {
- return wrapCustomTransformerFactory(transformer, ts.identity);
+ return wrapCustomTransformerFactory(transformer, function (_, node) { return node; });
}
function noEmitSubstitution(_hint, node) {
return node;
callback(hint, node);
}
ts.noEmitNotification = noEmitNotification;
- function transformNodes(resolver, host, options, nodes, transformers, allowDtsFiles) {
- var enabledSyntaxKindFeatures = new Array(331);
+ function transformNodes(resolver, host, factory, options, nodes, transformers, allowDtsFiles) {
+ var enabledSyntaxKindFeatures = new Array(341);
var lexicalEnvironmentVariableDeclarations;
var lexicalEnvironmentFunctionDeclarations;
var lexicalEnvironmentStatements;
var state = 0;
var diagnostics = [];
var context = {
+ factory: factory,
getCompilerOptions: function () { return options; },
getEmitResolver: function () { return resolver; },
getEmitHost: function () { return host; },
+ getEmitHelperFactory: ts.memoize(function () { return ts.createEmitHelperFactory(context); }),
startLexicalEnvironment: startLexicalEnvironment,
suspendLexicalEnvironment: suspendLexicalEnvironment,
resumeLexicalEnvironment: resumeLexicalEnvironment,
diagnostics.push(diag);
}
};
- for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) {
- var node = nodes_4[_i];
+ for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+ var node = nodes_2[_i];
ts.disposeEmitNodes(ts.getSourceFileOfNode(ts.getParseTreeNode(node)));
}
ts.performance.mark("beforeTransform");
return node;
};
state = 1;
- var transformed = ts.map(nodes, allowDtsFiles ? transformation : transformRoot);
+ var transformed = [];
+ for (var _a = 0, nodes_3 = nodes; _a < nodes_3.length; _a++) {
+ var node = nodes_3[_a];
+ ts.tracing.push("emit", "transformNodes", node.kind === 297 ? { path: node.path } : { kind: node.kind, pos: node.pos, end: node.end });
+ transformed.push((allowDtsFiles ? transformation : transformRoot)(node));
+ ts.tracing.pop();
+ }
state = 2;
ts.performance.mark("afterTransform");
ts.performance.measure("transformTime", "beforeTransform", "afterTransform");
function hoistVariableDeclaration(name) {
ts.Debug.assert(state > 0, "Cannot modify the lexical environment during initialization.");
ts.Debug.assert(state < 2, "Cannot modify the lexical environment after transformation has completed.");
- var decl = ts.setEmitFlags(ts.createVariableDeclaration(name), 64);
+ var decl = ts.setEmitFlags(factory.createVariableDeclaration(name), 64);
if (!lexicalEnvironmentVariableDeclarations) {
lexicalEnvironmentVariableDeclarations = [decl];
}
statements = __spreadArrays(lexicalEnvironmentFunctionDeclarations);
}
if (lexicalEnvironmentVariableDeclarations) {
- var statement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList(lexicalEnvironmentVariableDeclarations));
+ var statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(lexicalEnvironmentVariableDeclarations));
ts.setEmitFlags(statement, 1048576);
if (!statements) {
statements = [statement];
}
function dispose() {
if (state < 3) {
- for (var _i = 0, nodes_5 = nodes; _i < nodes_5.length; _i++) {
- var node = nodes_5[_i];
+ for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) {
+ var node = nodes_4[_i];
ts.disposeEmitNodes(ts.getSourceFileOfNode(ts.getParseTreeNode(node)));
}
lexicalEnvironmentVariableDeclarations = undefined;
}
}
ts.transformNodes = transformNodes;
+ ts.nullTransformationContext = {
+ get factory() { return ts.factory; },
+ enableEmitNotification: ts.noop,
+ enableSubstitution: ts.noop,
+ endLexicalEnvironment: ts.returnUndefined,
+ getCompilerOptions: function () { return ({}); },
+ getEmitHost: ts.notImplemented,
+ getEmitResolver: ts.notImplemented,
+ getEmitHelperFactory: ts.notImplemented,
+ setLexicalEnvironmentFlags: ts.noop,
+ getLexicalEnvironmentFlags: function () { return 0; },
+ hoistFunctionDeclaration: ts.noop,
+ hoistVariableDeclaration: ts.noop,
+ addInitializationStatement: ts.noop,
+ isEmitNotificationEnabled: ts.notImplemented,
+ isSubstitutionEnabled: ts.notImplemented,
+ onEmitNode: ts.noop,
+ onSubstituteNode: ts.notImplemented,
+ readEmitHelpers: ts.notImplemented,
+ requestEmitHelper: ts.noop,
+ resumeLexicalEnvironment: ts.noop,
+ startLexicalEnvironment: ts.noop,
+ suspendLexicalEnvironment: ts.noop,
+ addDiagnostic: ts.noop,
+ };
})(ts || (ts = {}));
var ts;
(function (ts) {
if (forceDtsEmit === void 0) { forceDtsEmit = false; }
var sourceFiles = ts.isArray(sourceFilesOrTargetSourceFile) ? sourceFilesOrTargetSourceFile : ts.getSourceFilesToEmit(host, sourceFilesOrTargetSourceFile, forceDtsEmit);
var options = host.getCompilerOptions();
- if (options.outFile || options.out) {
+ if (ts.outFile(options)) {
var prepends = host.getPrependNodes();
if (sourceFiles.length || prepends.length) {
- var bundle = ts.createBundle(sourceFiles, prepends);
+ var bundle = ts.factory.createBundle(sourceFiles, prepends);
var result = action(getOutputPathsFor(bundle, host, forceDtsEmit), bundle);
if (result) {
return result;
}
}
if (includeBuildInfo) {
- var buildInfoPath = getTsBuildInfoEmitOutputFilePath(host.getCompilerOptions());
+ var buildInfoPath = getTsBuildInfoEmitOutputFilePath(options);
if (buildInfoPath)
return action({ buildInfoPath: buildInfoPath }, undefined);
}
return undefined;
if (options.tsBuildInfoFile)
return options.tsBuildInfoFile;
- var outPath = options.outFile || options.out;
+ var outPath = ts.outFile(options);
var buildInfoExtensionLess;
if (outPath) {
buildInfoExtensionLess = ts.removeFileExtension(outPath);
}
ts.getTsBuildInfoEmitOutputFilePath = getTsBuildInfoEmitOutputFilePath;
function getOutputPathsForBundle(options, forceDtsPaths) {
- var outPath = options.outFile || options.out;
+ var outPath = ts.outFile(options);
var jsFilePath = options.emitDeclarationOnly ? undefined : outPath;
var sourceMapFilePath = jsFilePath && getSourceMapFilePath(jsFilePath, options);
var declarationFilePath = (forceDtsPaths || ts.getEmitDeclarations(options)) ? ts.removeFileExtension(outPath) + ".d.ts" : undefined;
ts.getOutputPathsForBundle = getOutputPathsForBundle;
function getOutputPathsFor(sourceFile, host, forceDtsPaths) {
var options = host.getCompilerOptions();
- if (sourceFile.kind === 291) {
+ if (sourceFile.kind === 298) {
return getOutputPathsForBundle(options, forceDtsPaths);
}
else {
}
function getAllProjectOutputs(configFile, ignoreCase) {
var _a = createAddOutput(), addOutput = _a.addOutput, getOutputs = _a.getOutputs;
- if (configFile.options.outFile || configFile.options.out) {
+ if (ts.outFile(configFile.options)) {
getSingleOutputFileNames(configFile, addOutput);
}
else {
inputFileName = ts.normalizePath(inputFileName);
ts.Debug.assert(ts.contains(commandLine.fileNames, inputFileName), "Expected fileName to be present in command line");
var _a = createAddOutput(), addOutput = _a.addOutput, getOutputs = _a.getOutputs;
- if (commandLine.options.outFile || commandLine.options.out) {
+ if (ts.outFile(commandLine.options)) {
getSingleOutputFileNames(commandLine, addOutput);
}
else {
}
ts.getOutputFileNames = getOutputFileNames;
function getFirstProjectOutput(configFile, ignoreCase) {
- if (configFile.options.outFile || configFile.options.out) {
+ if (ts.outFile(configFile.options)) {
var jsFilePath = getOutputPathsForBundle(configFile.options, false).jsFilePath;
return ts.Debug.checkDefined(jsFilePath, "project " + configFile.options.configFilePath + " expected to have at least one output");
}
sourceFiles: sourceFileOrBundle.sourceFiles.map(function (file) { return relativeToBuildInfo(ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory())); })
};
}
+ ts.tracing.push("emit", "emitJsFileOrBundle", { jsFilePath: jsFilePath });
emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo);
+ ts.tracing.pop();
+ ts.tracing.push("emit", "emitDeclarationFileOrBundle", { declarationFilePath: declarationFilePath });
emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo);
+ ts.tracing.pop();
+ ts.tracing.push("emit", "emitBuildInfo", { buildInfoPath: buildInfoPath });
emitBuildInfo(bundleBuildInfo, buildInfoPath);
+ ts.tracing.pop();
if (!emitSkipped && emittedFilesList) {
if (!emitOnlyDtsFiles) {
if (jsFilePath) {
if (!buildInfoPath || targetSourceFile || emitSkipped)
return;
var program = host.getProgramBuildInfo();
- if (host.isEmitBlocked(buildInfoPath) || compilerOptions.noEmit) {
+ if (host.isEmitBlocked(buildInfoPath)) {
emitSkipped = true;
return;
}
emitSkipped = true;
return;
}
- var transform = ts.transformNodes(resolver, host, compilerOptions, [sourceFileOrBundle], scriptTransformers, false);
+ var transform = ts.transformNodes(resolver, host, ts.factory, compilerOptions, [sourceFileOrBundle], scriptTransformers, false);
var printerOptions = {
removeComments: compilerOptions.removeComments,
newLine: compilerOptions.newLine,
}
var sourceFiles = ts.isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : sourceFileOrBundle.sourceFiles;
var filesForEmit = forceDtsEmit ? sourceFiles : ts.filter(sourceFiles, ts.isSourceFileNotJson);
- var inputListOrBundle = (compilerOptions.outFile || compilerOptions.out) ? [ts.createBundle(filesForEmit, !ts.isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.prepends : undefined)] : filesForEmit;
+ var inputListOrBundle = ts.outFile(compilerOptions) ? [ts.factory.createBundle(filesForEmit, !ts.isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.prepends : undefined)] : filesForEmit;
if (emitOnlyDtsFiles && !ts.getEmitDeclarations(compilerOptions)) {
filesForEmit.forEach(collectLinkedAliases);
}
- var declarationTransform = ts.transformNodes(resolver, host, compilerOptions, inputListOrBundle, declarationTransformers, false);
+ var declarationTransform = ts.transformNodes(resolver, host, ts.factory, compilerOptions, inputListOrBundle, declarationTransformers, false);
if (ts.length(declarationTransform.diagnostics)) {
for (var _a = 0, _b = declarationTransform.diagnostics; _a < _b.length; _a++) {
var diagnostic = _b[_a];
mapRoot: compilerOptions.mapRoot,
extendedDiagnostics: compilerOptions.extendedDiagnostics,
});
- if (forceDtsEmit && declarationTransform.transformed[0].kind === 290) {
+ if (forceDtsEmit && declarationTransform.transformed[0].kind === 297) {
var sourceFile = declarationTransform.transformed[0];
exportedModulesFromDeclarationEmit = sourceFile.exportedModulesFromDeclarationEmit;
}
}
function collectLinkedAliases(node) {
if (ts.isExportAssignment(node)) {
- if (node.expression.kind === 75) {
+ if (node.expression.kind === 78) {
resolver.collectLinkedAliases(node.expression, true);
}
return;
ts.forEachChild(node, collectLinkedAliases);
}
function printSourceFileOrBundle(jsFilePath, sourceMapFilePath, sourceFileOrBundle, printer, mapOptions) {
- var bundle = sourceFileOrBundle.kind === 291 ? sourceFileOrBundle : undefined;
- var sourceFile = sourceFileOrBundle.kind === 290 ? sourceFileOrBundle : undefined;
+ var bundle = sourceFileOrBundle.kind === 298 ? sourceFileOrBundle : undefined;
+ var sourceFile = sourceFileOrBundle.kind === 297 ? sourceFileOrBundle : undefined;
var sourceFiles = bundle ? bundle.sourceFiles : [sourceFile];
var sourceMapGenerator;
if (shouldEmitSourceMaps(mapOptions, sourceFileOrBundle)) {
}
function shouldEmitSourceMaps(mapOptions, sourceFileOrBundle) {
return (mapOptions.sourceMap || mapOptions.inlineSourceMap)
- && (sourceFileOrBundle.kind !== 290 || !ts.fileExtensionIs(sourceFileOrBundle.fileName, ".json"));
+ && (sourceFileOrBundle.kind !== 297 || !ts.fileExtensionIs(sourceFileOrBundle.fileName, ".json"));
}
function getSourceRoot(mapOptions) {
var sourceRoot = ts.normalizeSlashes(mapOptions.sourceRoot || "");
}
if (ts.getRootLength(sourceMapDir) === 0) {
sourceMapDir = ts.combinePaths(host.getCommonSourceDirectory(), sourceMapDir);
- return ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizePath(filePath)), ts.combinePaths(sourceMapDir, sourceMapFile), host.getCurrentDirectory(), host.getCanonicalFileName, true);
+ return encodeURI(ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizePath(filePath)), ts.combinePaths(sourceMapDir, sourceMapFile), host.getCurrentDirectory(), host.getCanonicalFileName, true));
}
else {
- return ts.combinePaths(sourceMapDir, sourceMapFile);
+ return encodeURI(ts.combinePaths(sourceMapDir, sourceMapFile));
}
}
- return sourceMapFile;
+ return encodeURI(sourceMapFile);
}
}
ts.emitFiles = emitFiles;
getTypeReferenceDirectivesForSymbol: ts.notImplemented,
isLiteralConstDeclaration: ts.notImplemented,
getJsxFactoryEntity: ts.notImplemented,
+ getJsxFragmentFactoryEntity: ts.notImplemented,
getAllAccessorDeclarations: ts.notImplemented,
getSymbolOfExternalModuleSpecifier: ts.notImplemented,
isBindingCapturedByNode: ts.notImplemented,
isImportRequiredByAugmentation: ts.notImplemented,
};
function createSourceFilesFromBundleBuildInfo(bundle, buildInfoDirectory, host) {
- var sourceFiles = bundle.sourceFiles.map(function (fileName) {
- var sourceFile = ts.createNode(290, 0, 0);
- sourceFile.fileName = ts.getRelativePathFromDirectory(host.getCurrentDirectory(), ts.getNormalizedAbsolutePath(fileName, buildInfoDirectory), !host.useCaseSensitiveFileNames());
- sourceFile.text = "";
- sourceFile.statements = ts.createNodeArray();
- return sourceFile;
- });
+ var _a;
var jsBundle = ts.Debug.checkDefined(bundle.js);
- ts.forEach(jsBundle.sources && jsBundle.sources.prologues, function (prologueInfo) {
- var sourceFile = sourceFiles[prologueInfo.file];
- sourceFile.text = prologueInfo.text;
- sourceFile.end = prologueInfo.text.length;
- sourceFile.statements = ts.createNodeArray(prologueInfo.directives.map(function (directive) {
- var statement = ts.createNode(226, directive.pos, directive.end);
- statement.expression = ts.createNode(10, directive.expression.pos, directive.expression.end);
- statement.expression.text = directive.expression.text;
+ var prologueMap = ((_a = jsBundle.sources) === null || _a === void 0 ? void 0 : _a.prologues) && ts.arrayToMap(jsBundle.sources.prologues, function (prologueInfo) { return prologueInfo.file; });
+ return bundle.sourceFiles.map(function (fileName, index) {
+ var _a, _b;
+ var prologueInfo = prologueMap === null || prologueMap === void 0 ? void 0 : prologueMap.get(index);
+ var statements = prologueInfo === null || prologueInfo === void 0 ? void 0 : prologueInfo.directives.map(function (directive) {
+ var literal = ts.setTextRange(ts.factory.createStringLiteral(directive.expression.text), directive.expression);
+ var statement = ts.setTextRange(ts.factory.createExpressionStatement(literal), directive);
+ ts.setParent(literal, statement);
return statement;
- }));
+ });
+ var eofToken = ts.factory.createToken(1);
+ var sourceFile = ts.factory.createSourceFile(statements !== null && statements !== void 0 ? statements : [], eofToken, 0);
+ sourceFile.fileName = ts.getRelativePathFromDirectory(host.getCurrentDirectory(), ts.getNormalizedAbsolutePath(fileName, buildInfoDirectory), !host.useCaseSensitiveFileNames());
+ sourceFile.text = (_a = prologueInfo === null || prologueInfo === void 0 ? void 0 : prologueInfo.text) !== null && _a !== void 0 ? _a : "";
+ ts.setTextRangePosWidth(sourceFile, 0, (_b = prologueInfo === null || prologueInfo === void 0 ? void 0 : prologueInfo.text.length) !== null && _b !== void 0 ? _b : 0);
+ ts.setEachParent(sourceFile.statements, sourceFile);
+ ts.setTextRangePosWidth(eofToken, sourceFile.end, 0);
+ ts.setParent(eofToken, sourceFile);
+ return sourceFile;
});
- return sourceFiles;
}
function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
var _a = getOutputPathsForBundle(config.options, false), buildInfoPath = _a.buildInfoPath, jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath;
var extendedDiagnostics = !!printerOptions.extendedDiagnostics;
var newLine = ts.getNewLineCharacter(printerOptions);
var moduleKind = ts.getEmitModuleKind(printerOptions);
- var bundledHelpers = ts.createMap();
+ var bundledHelpers = new ts.Map();
var currentSourceFile;
var nodeIdToGeneratedName;
var autoGeneratedIdToGeneratedName;
var reservedNamesStack;
var reservedNames;
var preserveSourceNewlines = printerOptions.preserveSourceNewlines;
+ var nextListElementPos;
var writer;
var ownWriter;
var write = writeBase;
var sourceMapGenerator;
var sourceMapSource;
var sourceMapSourceIndex = -1;
+ var mostRecentlyAddedSourceMapSource;
+ var mostRecentlyAddedSourceMapSourceIndex = -1;
var containerPos = -1;
var containerEnd = -1;
var declarationListContainerEnd = -1;
break;
}
switch (node.kind) {
- case 290: return printFile(node);
- case 291: return printBundle(node);
- case 292: return printUnparsedSource(node);
+ case 297: return printFile(node);
+ case 298: return printBundle(node);
+ case 299: return printUnparsedSource(node);
}
writeNode(hint, node, sourceFile, beginPrint());
return endPrint();
function reset() {
nodeIdToGeneratedName = [];
autoGeneratedIdToGeneratedName = [];
- generatedNames = ts.createMap();
+ generatedNames = new ts.Set();
tempFlagsStack = [];
tempFlags = 0;
reservedNamesStack = [];
return pipelineEmitWithSubstitution;
}
case 2:
- if (!commentsDisabled && node.kind !== 290) {
+ if (!commentsDisabled && node.kind !== 297) {
return pipelineEmitWithComments;
}
case 3:
- if (!sourceMapsDisabled && node.kind !== 290 && !ts.isInJsonFile(node)) {
+ if (!sourceMapsDisabled && node.kind !== 297 && !ts.isInJsonFile(node)) {
return pipelineEmitWithSourceMap;
}
case 4:
case 16:
case 17:
return emitLiteral(node, false);
- case 292:
- case 286:
+ case 299:
+ case 293:
return emitUnparsedSourceOrPrepend(node);
- case 285:
+ case 292:
return writeUnparsedNode(node);
- case 287:
- case 288:
+ case 294:
+ case 295:
return emitUnparsedTextLike(node);
- case 289:
+ case 296:
return emitUnparsedSyntheticReference(node);
- case 75:
+ case 78:
return emitIdentifier(node);
- case 76:
+ case 79:
return emitPrivateIdentifier(node);
- case 153:
+ case 157:
return emitQualifiedName(node);
- case 154:
+ case 158:
return emitComputedPropertyName(node);
- case 155:
+ case 159:
return emitTypeParameter(node);
- case 156:
+ case 160:
return emitParameter(node);
- case 157:
+ case 161:
return emitDecorator(node);
- case 158:
+ case 162:
return emitPropertySignature(node);
- case 159:
+ case 163:
return emitPropertyDeclaration(node);
- case 160:
+ case 164:
return emitMethodSignature(node);
- case 161:
+ case 165:
return emitMethodDeclaration(node);
- case 162:
+ case 166:
return emitConstructor(node);
- case 163:
- case 164:
+ case 167:
+ case 168:
return emitAccessorDeclaration(node);
- case 165:
+ case 169:
return emitCallSignature(node);
- case 166:
+ case 170:
return emitConstructSignature(node);
- case 167:
+ case 171:
return emitIndexSignature(node);
- case 168:
+ case 194:
+ return emitTemplateTypeSpan(node);
+ case 172:
return emitTypePredicate(node);
- case 169:
+ case 173:
return emitTypeReference(node);
- case 170:
+ case 174:
return emitFunctionType(node);
- case 300:
+ case 308:
return emitJSDocFunctionType(node);
- case 171:
+ case 175:
return emitConstructorType(node);
- case 172:
+ case 176:
return emitTypeQuery(node);
- case 173:
+ case 177:
return emitTypeLiteral(node);
- case 174:
+ case 178:
return emitArrayType(node);
- case 175:
+ case 179:
return emitTupleType(node);
- case 176:
+ case 180:
return emitOptionalType(node);
- case 178:
+ case 182:
return emitUnionType(node);
- case 179:
+ case 183:
return emitIntersectionType(node);
- case 180:
+ case 184:
return emitConditionalType(node);
- case 181:
+ case 185:
return emitInferType(node);
- case 182:
+ case 186:
return emitParenthesizedType(node);
- case 216:
+ case 223:
return emitExpressionWithTypeArguments(node);
- case 183:
+ case 187:
return emitThisType();
- case 184:
+ case 188:
return emitTypeOperator(node);
- case 185:
+ case 189:
return emitIndexedAccessType(node);
- case 186:
+ case 190:
return emitMappedType(node);
- case 187:
+ case 191:
return emitLiteralType(node);
- case 188:
+ case 193:
+ return emitTemplateType(node);
+ case 195:
return emitImportTypeNode(node);
- case 295:
+ case 303:
writePunctuation("*");
return;
- case 296:
+ case 304:
writePunctuation("?");
return;
- case 297:
+ case 305:
return emitJSDocNullableType(node);
- case 298:
+ case 306:
return emitJSDocNonNullableType(node);
- case 299:
+ case 307:
return emitJSDocOptionalType(node);
- case 177:
- case 301:
+ case 181:
+ case 309:
return emitRestOrJSDocVariadicType(node);
- case 189:
+ case 192:
+ return emitNamedTupleMember(node);
+ case 196:
return emitObjectBindingPattern(node);
- case 190:
+ case 197:
return emitArrayBindingPattern(node);
- case 191:
+ case 198:
return emitBindingElement(node);
- case 221:
+ case 228:
return emitTemplateSpan(node);
- case 222:
+ case 229:
return emitSemicolonClassElement();
- case 223:
+ case 230:
return emitBlock(node);
- case 225:
+ case 232:
return emitVariableStatement(node);
- case 224:
+ case 231:
return emitEmptyStatement(false);
- case 226:
+ case 233:
return emitExpressionStatement(node);
- case 227:
+ case 234:
return emitIfStatement(node);
- case 228:
+ case 235:
return emitDoStatement(node);
- case 229:
+ case 236:
return emitWhileStatement(node);
- case 230:
+ case 237:
return emitForStatement(node);
- case 231:
+ case 238:
return emitForInStatement(node);
- case 232:
+ case 239:
return emitForOfStatement(node);
- case 233:
+ case 240:
return emitContinueStatement(node);
- case 234:
+ case 241:
return emitBreakStatement(node);
- case 235:
+ case 242:
return emitReturnStatement(node);
- case 236:
+ case 243:
return emitWithStatement(node);
- case 237:
+ case 244:
return emitSwitchStatement(node);
- case 238:
+ case 245:
return emitLabeledStatement(node);
- case 239:
+ case 246:
return emitThrowStatement(node);
- case 240:
+ case 247:
return emitTryStatement(node);
- case 241:
+ case 248:
return emitDebuggerStatement(node);
- case 242:
+ case 249:
return emitVariableDeclaration(node);
- case 243:
+ case 250:
return emitVariableDeclarationList(node);
- case 244:
+ case 251:
return emitFunctionDeclaration(node);
- case 245:
+ case 252:
return emitClassDeclaration(node);
- case 246:
+ case 253:
return emitInterfaceDeclaration(node);
- case 247:
+ case 254:
return emitTypeAliasDeclaration(node);
- case 248:
+ case 255:
return emitEnumDeclaration(node);
- case 249:
+ case 256:
return emitModuleDeclaration(node);
- case 250:
+ case 257:
return emitModuleBlock(node);
- case 251:
+ case 258:
return emitCaseBlock(node);
- case 252:
+ case 259:
return emitNamespaceExportDeclaration(node);
- case 253:
+ case 260:
return emitImportEqualsDeclaration(node);
- case 254:
+ case 261:
return emitImportDeclaration(node);
- case 255:
+ case 262:
return emitImportClause(node);
- case 256:
+ case 263:
return emitNamespaceImport(node);
- case 262:
+ case 269:
return emitNamespaceExport(node);
- case 257:
+ case 264:
return emitNamedImports(node);
- case 258:
+ case 265:
return emitImportSpecifier(node);
- case 259:
+ case 266:
return emitExportAssignment(node);
- case 260:
+ case 267:
return emitExportDeclaration(node);
- case 261:
+ case 268:
return emitNamedExports(node);
- case 263:
+ case 270:
return emitExportSpecifier(node);
- case 264:
+ case 271:
return;
- case 265:
+ case 272:
return emitExternalModuleReference(node);
case 11:
return emitJsxText(node);
- case 268:
- case 271:
+ case 275:
+ case 278:
return emitJsxOpeningElementOrFragment(node);
- case 269:
- case 272:
+ case 276:
+ case 279:
return emitJsxClosingElementOrFragment(node);
- case 273:
+ case 280:
return emitJsxAttribute(node);
- case 274:
+ case 281:
return emitJsxAttributes(node);
- case 275:
+ case 282:
return emitJsxSpreadAttribute(node);
- case 276:
+ case 283:
return emitJsxExpression(node);
- case 277:
+ case 284:
return emitCaseClause(node);
- case 278:
+ case 285:
return emitDefaultClause(node);
- case 279:
+ case 286:
return emitHeritageClause(node);
- case 280:
+ case 287:
return emitCatchClause(node);
- case 281:
+ case 288:
return emitPropertyAssignment(node);
- case 282:
+ case 289:
return emitShorthandPropertyAssignment(node);
- case 283:
+ case 290:
return emitSpreadAssignment(node);
- case 284:
+ case 291:
return emitEnumMember(node);
- case 317:
- case 323:
+ case 326:
+ case 333:
return emitJSDocPropertyLikeTag(node);
- case 318:
- case 320:
- case 319:
- case 316:
+ case 327:
+ case 329:
+ case 328:
+ case 325:
return emitJSDocSimpleTypedTag(node);
- case 308:
- case 307:
+ case 316:
+ case 315:
return emitJSDocHeritageTag(node);
- case 321:
+ case 330:
return emitJSDocTemplateTag(node);
- case 322:
+ case 331:
return emitJSDocTypedefTag(node);
- case 315:
+ case 324:
return emitJSDocCallbackTag(node);
- case 305:
+ case 313:
return emitJSDocSignature(node);
- case 304:
+ case 312:
return emitJSDocTypeLiteral(node);
- case 310:
- case 306:
+ case 319:
+ case 314:
return emitJSDocSimpleTag(node);
- case 303:
+ case 332:
+ return emitJSDocSeeTag(node);
+ case 302:
+ return emitJSDocNameReference(node);
+ case 311:
return emitJSDoc(node);
}
if (ts.isExpression(node)) {
case 13:
case 14:
return emitLiteral(node, false);
- case 75:
+ case 78:
return emitIdentifier(node);
- case 91:
- case 100:
- case 102:
- case 106:
- case 104:
- case 96:
+ case 94:
+ case 103:
+ case 105:
+ case 109:
+ case 107:
+ case 99:
writeTokenNode(node, writeKeyword);
return;
- case 192:
+ case 199:
return emitArrayLiteralExpression(node);
- case 193:
+ case 200:
return emitObjectLiteralExpression(node);
- case 194:
+ case 201:
return emitPropertyAccessExpression(node);
- case 195:
+ case 202:
return emitElementAccessExpression(node);
- case 196:
+ case 203:
return emitCallExpression(node);
- case 197:
+ case 204:
return emitNewExpression(node);
- case 198:
+ case 205:
return emitTaggedTemplateExpression(node);
- case 199:
+ case 206:
return emitTypeAssertionExpression(node);
- case 200:
+ case 207:
return emitParenthesizedExpression(node);
- case 201:
+ case 208:
return emitFunctionExpression(node);
- case 202:
+ case 209:
return emitArrowFunction(node);
- case 203:
+ case 210:
return emitDeleteExpression(node);
- case 204:
+ case 211:
return emitTypeOfExpression(node);
- case 205:
+ case 212:
return emitVoidExpression(node);
- case 206:
+ case 213:
return emitAwaitExpression(node);
- case 207:
+ case 214:
return emitPrefixUnaryExpression(node);
- case 208:
+ case 215:
return emitPostfixUnaryExpression(node);
- case 209:
+ case 216:
return emitBinaryExpression(node);
- case 210:
+ case 217:
return emitConditionalExpression(node);
- case 211:
+ case 218:
return emitTemplateExpression(node);
- case 212:
+ case 219:
return emitYieldExpression(node);
- case 213:
+ case 220:
return emitSpreadExpression(node);
- case 214:
+ case 221:
return emitClassExpression(node);
- case 215:
+ case 222:
return;
- case 217:
+ case 224:
return emitAsExpression(node);
- case 218:
+ case 225:
return emitNonNullExpression(node);
- case 219:
+ case 226:
return emitMetaProperty(node);
- case 266:
+ case 273:
return emitJsxElement(node);
- case 267:
+ case 274:
return emitJsxSelfClosingElement(node);
- case 270:
+ case 277:
return emitJsxFragment(node);
- case 326:
+ case 336:
return emitPartiallyEmittedExpression(node);
- case 327:
+ case 337:
return emitCommaList(node);
}
}
if (moduleKind === ts.ModuleKind.None || printerOptions.noEmitHelpers) {
return undefined;
}
- var bundledHelpers = ts.createMap();
+ var bundledHelpers = new ts.Map();
for (var _a = 0, _b = bundle.sourceFiles; _a < _b.length; _a++) {
var sourceFile = _b[_a];
var shouldSkip = ts.getExternalHelpersModuleName(sourceFile) !== undefined;
var helpers = getSortedEmitHelpers(sourceFile);
if (!helpers)
continue;
- for (var _c = 0, helpers_4 = helpers; _c < helpers_4.length; _c++) {
- var helper = helpers_4[_c];
+ for (var _c = 0, helpers_5 = helpers; _c < helpers_5.length; _c++) {
+ var helper = helpers_5[_c];
if (!helper.scoped && !shouldSkip && !bundledHelpers.get(helper.name)) {
bundledHelpers.set(helper.name, true);
(result || (result = [])).push(helper.name);
}
function emitHelpers(node) {
var helpersEmitted = false;
- var bundle = node.kind === 291 ? node : undefined;
+ var bundle = node.kind === 298 ? node : undefined;
if (bundle && moduleKind === ts.ModuleKind.None) {
return;
}
var shouldBundle = (ts.isSourceFile(currentNode) || ts.isUnparsedSource(currentNode)) && !isOwnFileEmit;
var helpers = ts.isUnparsedSource(currentNode) ? currentNode.helpers : getSortedEmitHelpers(currentNode);
if (helpers) {
- for (var _a = 0, helpers_5 = helpers; _a < helpers_5.length; _a++) {
- var helper = helpers_5[_a];
+ for (var _a = 0, helpers_6 = helpers; _a < helpers_6.length; _a++) {
+ var helper = helpers_6[_a];
if (!helper.scoped) {
if (shouldSkip)
continue;
var pos = getTextPosWithWriteLine();
writeUnparsedNode(unparsed);
if (bundleFileInfo) {
- updateOrPushBundleFileTextLike(pos, writer.getTextPos(), unparsed.kind === 287 ?
+ updateOrPushBundleFileTextLike(pos, writer.getTextPos(), unparsed.kind === 294 ?
"text" :
"internal");
}
emit(node.right);
}
function emitEntityName(node) {
- if (node.kind === 75) {
+ if (node.kind === 78) {
emitExpression(node);
}
else {
emit(node.dotDotDotToken);
emitNodeWithWriter(node.name, writeParameter);
emit(node.questionToken);
- if (node.parent && node.parent.kind === 300 && !node.name) {
+ if (node.parent && node.parent.kind === 308 && !node.name) {
emit(node.type);
}
else {
function emitAccessorDeclaration(node) {
emitDecorators(node, node.decorators);
emitModifiers(node, node.modifiers);
- writeKeyword(node.kind === 163 ? "get" : "set");
+ writeKeyword(node.kind === 167 ? "get" : "set");
writeSpace();
emit(node.name);
emitSignatureAndBody(node, emitSignatureHead);
emitTypeAnnotation(node.type);
writeTrailingSemicolon();
}
+ function emitTemplateTypeSpan(node) {
+ emit(node.type);
+ emit(node.literal);
+ }
function emitSemicolonClassElement() {
writeTrailingSemicolon();
}
emit(node.type);
}
function emitTupleType(node) {
- writePunctuation("[");
- emitList(node, node.elementTypes, 528);
- writePunctuation("]");
+ emitTokenWithComment(22, node.pos, writePunctuation, node);
+ var flags = ts.getEmitFlags(node) & 1 ? 528 : 657;
+ emitList(node, node.elements, flags | 524288);
+ emitTokenWithComment(23, node.elements.end, writePunctuation, node);
+ }
+ function emitNamedTupleMember(node) {
+ emit(node.dotDotDotToken);
+ emit(node.name);
+ emit(node.questionToken);
+ emitTokenWithComment(58, node.name.end, writePunctuation, node);
+ writeSpace();
+ emit(node.type);
}
function emitOptionalType(node) {
emit(node.type);
}
if (node.readonlyToken) {
emit(node.readonlyToken);
- if (node.readonlyToken.kind !== 138) {
+ if (node.readonlyToken.kind !== 142) {
writeKeyword("readonly");
}
writeSpace();
}
writePunctuation("[");
pipelineEmit(3, node.typeParameter);
+ if (node.nameType) {
+ writeSpace();
+ writeKeyword("as");
+ writeSpace();
+ emit(node.nameType);
+ }
writePunctuation("]");
if (node.questionToken) {
emit(node.questionToken);
function emitLiteralType(node) {
emitExpression(node.literal);
}
+ function emitTemplateType(node) {
+ emit(node.head);
+ emitList(node, node.templateSpans, 262144);
+ }
function emitImportTypeNode(node) {
if (node.isTypeOf) {
writeKeyword("typeof");
}
function emitPropertyAccessExpression(node) {
var expression = ts.cast(emitExpression(node.expression), ts.isExpression);
- var token = node.questionDotToken || ts.createNode(24, node.expression.end, node.name.pos);
+ var token = node.questionDotToken || ts.setTextRangePosEnd(ts.factory.createToken(24), node.expression.end, node.name.pos);
var linesBeforeDot = getLinesBetweenNodes(node, node.expression, token);
var linesAfterDot = getLinesBetweenNodes(node, token, node.name);
writeLinesAndIndent(linesBeforeDot, false);
emitExpressionList(node, node.arguments, 2576);
}
function emitNewExpression(node) {
- emitTokenWithComment(99, node.pos, writeKeyword, node);
+ emitTokenWithComment(102, node.pos, writeKeyword, node);
writeSpace();
emitExpression(node.expression);
emitTypeArguments(node, node.typeArguments);
emit(node.equalsGreaterThanToken);
}
function emitDeleteExpression(node) {
- emitTokenWithComment(85, node.pos, writeKeyword, node);
+ emitTokenWithComment(88, node.pos, writeKeyword, node);
writeSpace();
emitExpression(node.expression);
}
function emitTypeOfExpression(node) {
- emitTokenWithComment(108, node.pos, writeKeyword, node);
+ emitTokenWithComment(111, node.pos, writeKeyword, node);
writeSpace();
emitExpression(node.expression);
}
function emitVoidExpression(node) {
- emitTokenWithComment(110, node.pos, writeKeyword, node);
+ emitTokenWithComment(113, node.pos, writeKeyword, node);
writeSpace();
emitExpression(node.expression);
}
function emitAwaitExpression(node) {
- emitTokenWithComment(127, node.pos, writeKeyword, node);
+ emitTokenWithComment(130, node.pos, writeKeyword, node);
writeSpace();
emitExpression(node.expression);
}
}
function shouldEmitWhitespaceBeforeOperand(node) {
var operand = node.operand;
- return operand.kind === 207
+ return operand.kind === 214
&& ((node.operator === 39 && (operand.operator === 39 || operand.operator === 45))
|| (node.operator === 40 && (operand.operator === 40 || operand.operator === 46)));
}
var linesAfterOperator = getLinesBetweenNodes(node, node.operatorToken, node.right);
writeLinesAndIndent(linesBeforeOperator, isCommaOperator);
emitLeadingCommentsOfPosition(node.operatorToken.pos);
- writeTokenNode(node.operatorToken, node.operatorToken.kind === 97 ? writeKeyword : writeOperator);
+ writeTokenNode(node.operatorToken, node.operatorToken.kind === 100 ? writeKeyword : writeOperator);
emitTrailingCommentsOfPosition(node.operatorToken.end, true);
writeLinesAndIndent(linesAfterOperator, true);
maybePipelineEmitExpression(node.right);
emitList(node, node.templateSpans, 262144);
}
function emitYieldExpression(node) {
- emitTokenWithComment(121, node.pos, writeKeyword, node);
+ emitTokenWithComment(124, node.pos, writeKeyword, node);
emit(node.asteriskToken);
emitExpressionWithLeadingSpace(node.expression);
}
}
}
function emitIfStatement(node) {
- var openParenPos = emitTokenWithComment(95, node.pos, writeKeyword, node);
+ var openParenPos = emitTokenWithComment(98, node.pos, writeKeyword, node);
writeSpace();
emitTokenWithComment(20, openParenPos, writePunctuation, node);
emitExpression(node.expression);
emitTokenWithComment(21, node.expression.end, writePunctuation, node);
emitEmbeddedStatement(node, node.thenStatement);
if (node.elseStatement) {
- writeLineOrSpace(node);
- emitTokenWithComment(87, node.thenStatement.end, writeKeyword, node);
- if (node.elseStatement.kind === 227) {
+ writeLineOrSpace(node, node.thenStatement, node.elseStatement);
+ emitTokenWithComment(90, node.thenStatement.end, writeKeyword, node);
+ if (node.elseStatement.kind === 234) {
writeSpace();
emit(node.elseStatement);
}
}
}
function emitWhileClause(node, startPos) {
- var openParenPos = emitTokenWithComment(111, startPos, writeKeyword, node);
+ var openParenPos = emitTokenWithComment(114, startPos, writeKeyword, node);
writeSpace();
emitTokenWithComment(20, openParenPos, writePunctuation, node);
emitExpression(node.expression);
emitTokenWithComment(21, node.expression.end, writePunctuation, node);
}
function emitDoStatement(node) {
- emitTokenWithComment(86, node.pos, writeKeyword, node);
+ emitTokenWithComment(89, node.pos, writeKeyword, node);
emitEmbeddedStatement(node, node.statement);
- if (ts.isBlock(node.statement)) {
+ if (ts.isBlock(node.statement) && !preserveSourceNewlines) {
writeSpace();
}
else {
- writeLineOrSpace(node);
+ writeLineOrSpace(node, node.statement, node.expression);
}
emitWhileClause(node, node.statement.end);
writeTrailingSemicolon();
emitEmbeddedStatement(node, node.statement);
}
function emitForStatement(node) {
- var openParenPos = emitTokenWithComment(93, node.pos, writeKeyword, node);
+ var openParenPos = emitTokenWithComment(96, node.pos, writeKeyword, node);
writeSpace();
var pos = emitTokenWithComment(20, openParenPos, writePunctuation, node);
emitForBinding(node.initializer);
emitEmbeddedStatement(node, node.statement);
}
function emitForInStatement(node) {
- var openParenPos = emitTokenWithComment(93, node.pos, writeKeyword, node);
+ var openParenPos = emitTokenWithComment(96, node.pos, writeKeyword, node);
writeSpace();
emitTokenWithComment(20, openParenPos, writePunctuation, node);
emitForBinding(node.initializer);
writeSpace();
- emitTokenWithComment(97, node.initializer.end, writeKeyword, node);
+ emitTokenWithComment(100, node.initializer.end, writeKeyword, node);
writeSpace();
emitExpression(node.expression);
emitTokenWithComment(21, node.expression.end, writePunctuation, node);
emitEmbeddedStatement(node, node.statement);
}
function emitForOfStatement(node) {
- var openParenPos = emitTokenWithComment(93, node.pos, writeKeyword, node);
+ var openParenPos = emitTokenWithComment(96, node.pos, writeKeyword, node);
writeSpace();
emitWithTrailingSpace(node.awaitModifier);
emitTokenWithComment(20, openParenPos, writePunctuation, node);
emitForBinding(node.initializer);
writeSpace();
- emitTokenWithComment(152, node.initializer.end, writeKeyword, node);
+ emitTokenWithComment(156, node.initializer.end, writeKeyword, node);
writeSpace();
emitExpression(node.expression);
emitTokenWithComment(21, node.expression.end, writePunctuation, node);
}
function emitForBinding(node) {
if (node !== undefined) {
- if (node.kind === 243) {
+ if (node.kind === 250) {
emit(node);
}
else {
}
}
function emitContinueStatement(node) {
- emitTokenWithComment(82, node.pos, writeKeyword, node);
+ emitTokenWithComment(85, node.pos, writeKeyword, node);
emitWithLeadingSpace(node.label);
writeTrailingSemicolon();
}
function emitBreakStatement(node) {
- emitTokenWithComment(77, node.pos, writeKeyword, node);
+ emitTokenWithComment(80, node.pos, writeKeyword, node);
emitWithLeadingSpace(node.label);
writeTrailingSemicolon();
}
return pos;
}
function emitReturnStatement(node) {
- emitTokenWithComment(101, node.pos, writeKeyword, node);
+ emitTokenWithComment(104, node.pos, writeKeyword, node);
emitExpressionWithLeadingSpace(node.expression);
writeTrailingSemicolon();
}
function emitWithStatement(node) {
- var openParenPos = emitTokenWithComment(112, node.pos, writeKeyword, node);
+ var openParenPos = emitTokenWithComment(115, node.pos, writeKeyword, node);
writeSpace();
emitTokenWithComment(20, openParenPos, writePunctuation, node);
emitExpression(node.expression);
emitEmbeddedStatement(node, node.statement);
}
function emitSwitchStatement(node) {
- var openParenPos = emitTokenWithComment(103, node.pos, writeKeyword, node);
+ var openParenPos = emitTokenWithComment(106, node.pos, writeKeyword, node);
writeSpace();
emitTokenWithComment(20, openParenPos, writePunctuation, node);
emitExpression(node.expression);
emit(node.statement);
}
function emitThrowStatement(node) {
- emitTokenWithComment(105, node.pos, writeKeyword, node);
+ emitTokenWithComment(108, node.pos, writeKeyword, node);
emitExpressionWithLeadingSpace(node.expression);
writeTrailingSemicolon();
}
function emitTryStatement(node) {
- emitTokenWithComment(107, node.pos, writeKeyword, node);
+ emitTokenWithComment(110, node.pos, writeKeyword, node);
writeSpace();
emit(node.tryBlock);
if (node.catchClause) {
- writeLineOrSpace(node);
+ writeLineOrSpace(node, node.tryBlock, node.catchClause);
emit(node.catchClause);
}
if (node.finallyBlock) {
- writeLineOrSpace(node);
- emitTokenWithComment(92, (node.catchClause || node.tryBlock).end, writeKeyword, node);
+ writeLineOrSpace(node, node.catchClause || node.tryBlock, node.finallyBlock);
+ emitTokenWithComment(95, (node.catchClause || node.tryBlock).end, writeKeyword, node);
writeSpace();
emit(node.finallyBlock);
}
}
function emitDebuggerStatement(node) {
- writeToken(83, node.pos, writeKeyword);
+ writeToken(86, node.pos, writeKeyword);
writeTrailingSemicolon();
}
function emitVariableDeclaration(node) {
var body = node.body;
if (!body)
return writeTrailingSemicolon();
- while (body.kind === 249) {
+ while (body.kind === 256) {
writePunctuation(".");
emit(body.name);
body = body.body;
}
function emitImportEqualsDeclaration(node) {
emitModifiers(node, node.modifiers);
- emitTokenWithComment(96, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node);
+ emitTokenWithComment(99, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node);
writeSpace();
emit(node.name);
writeSpace();
writeTrailingSemicolon();
}
function emitModuleReference(node) {
- if (node.kind === 75) {
+ if (node.kind === 78) {
emitExpression(node);
}
else {
}
function emitImportDeclaration(node) {
emitModifiers(node, node.modifiers);
- emitTokenWithComment(96, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node);
+ emitTokenWithComment(99, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node);
writeSpace();
if (node.importClause) {
emit(node.importClause);
writeSpace();
- emitTokenWithComment(149, node.importClause.end, writeKeyword, node);
+ emitTokenWithComment(153, node.importClause.end, writeKeyword, node);
writeSpace();
}
emitExpression(node.moduleSpecifier);
}
function emitImportClause(node) {
if (node.isTypeOnly) {
- emitTokenWithComment(145, node.pos, writeKeyword, node);
+ emitTokenWithComment(149, node.pos, writeKeyword, node);
writeSpace();
}
emit(node.name);
function emitNamespaceImport(node) {
var asPos = emitTokenWithComment(41, node.pos, writePunctuation, node);
writeSpace();
- emitTokenWithComment(123, asPos, writeKeyword, node);
+ emitTokenWithComment(126, asPos, writeKeyword, node);
writeSpace();
emit(node.name);
}
emitImportOrExportSpecifier(node);
}
function emitExportAssignment(node) {
- var nextPos = emitTokenWithComment(89, node.pos, writeKeyword, node);
+ var nextPos = emitTokenWithComment(92, node.pos, writeKeyword, node);
writeSpace();
if (node.isExportEquals) {
emitTokenWithComment(62, nextPos, writeOperator, node);
}
else {
- emitTokenWithComment(84, nextPos, writeKeyword, node);
+ emitTokenWithComment(87, nextPos, writeKeyword, node);
}
writeSpace();
emitExpression(node.expression);
writeTrailingSemicolon();
}
function emitExportDeclaration(node) {
- var nextPos = emitTokenWithComment(89, node.pos, writeKeyword, node);
+ var nextPos = emitTokenWithComment(92, node.pos, writeKeyword, node);
writeSpace();
if (node.isTypeOnly) {
- nextPos = emitTokenWithComment(145, nextPos, writeKeyword, node);
+ nextPos = emitTokenWithComment(149, nextPos, writeKeyword, node);
writeSpace();
}
if (node.exportClause) {
if (node.moduleSpecifier) {
writeSpace();
var fromPos = node.exportClause ? node.exportClause.end : nextPos;
- emitTokenWithComment(149, fromPos, writeKeyword, node);
+ emitTokenWithComment(153, fromPos, writeKeyword, node);
writeSpace();
emitExpression(node.moduleSpecifier);
}
writeTrailingSemicolon();
}
function emitNamespaceExportDeclaration(node) {
- var nextPos = emitTokenWithComment(89, node.pos, writeKeyword, node);
+ var nextPos = emitTokenWithComment(92, node.pos, writeKeyword, node);
writeSpace();
- nextPos = emitTokenWithComment(123, nextPos, writeKeyword, node);
+ nextPos = emitTokenWithComment(126, nextPos, writeKeyword, node);
writeSpace();
- nextPos = emitTokenWithComment(136, nextPos, writeKeyword, node);
+ nextPos = emitTokenWithComment(140, nextPos, writeKeyword, node);
writeSpace();
emit(node.name);
writeTrailingSemicolon();
function emitNamespaceExport(node) {
var asPos = emitTokenWithComment(41, node.pos, writePunctuation, node);
writeSpace();
- emitTokenWithComment(123, asPos, writeKeyword, node);
+ emitTokenWithComment(126, asPos, writeKeyword, node);
writeSpace();
emit(node.name);
}
if (node.propertyName) {
emit(node.propertyName);
writeSpace();
- emitTokenWithComment(123, node.propertyName.end, writeKeyword, node);
+ emitTokenWithComment(126, node.propertyName.end, writeKeyword, node);
writeSpace();
}
emit(node.name);
}
}
function emitJsxTagName(node) {
- if (node.kind === 75) {
+ if (node.kind === 78) {
emitExpression(node);
}
else {
}
}
function emitCaseClause(node) {
- emitTokenWithComment(78, node.pos, writeKeyword, node);
+ emitTokenWithComment(81, node.pos, writeKeyword, node);
writeSpace();
emitExpression(node.expression);
emitCaseOrDefaultClauseRest(node, node.statements, node.expression.end);
}
function emitDefaultClause(node) {
- var pos = emitTokenWithComment(84, node.pos, writeKeyword, node);
+ var pos = emitTokenWithComment(87, node.pos, writeKeyword, node);
emitCaseOrDefaultClauseRest(node, node.statements, pos);
}
function emitCaseOrDefaultClauseRest(parentNode, statements, colonPos) {
emitList(node, node.types, 528);
}
function emitCatchClause(node) {
- var openParenPos = emitTokenWithComment(79, node.pos, writeKeyword, node);
+ var openParenPos = emitTokenWithComment(82, node.pos, writeKeyword, node);
writeSpace();
if (node.variableDeclaration) {
emitTokenWithComment(20, openParenPos, writePunctuation, node);
}
}
if (node.tags) {
- if (node.tags.length === 1 && node.tags[0].kind === 320 && !node.comment) {
+ if (node.tags.length === 1 && node.tags[0].kind === 329 && !node.comment) {
writeSpace();
emit(node.tags[0]);
}
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();
function emitJSDocTypedefTag(tag) {
emitJSDocTagName(tag.tagName);
if (tag.typeExpression) {
- if (tag.typeExpression.kind === 294) {
+ if (tag.typeExpression.kind === 301) {
emitJSDocTypeExpression(tag.typeExpression);
}
else {
emit(tag.fullName);
}
emitJSDocComment(tag.comment);
- if (tag.typeExpression && tag.typeExpression.kind === 304) {
+ if (tag.typeExpression && tag.typeExpression.kind === 312) {
emitJSDocTypeLiteral(tag.typeExpression);
}
}
emitJSDocComment(tag.comment);
}
function emitJSDocTypeLiteral(lit) {
- emitList(lit, ts.createNodeArray(lit.jsDocPropertyTags), 33);
+ emitList(lit, ts.factory.createNodeArray(lit.jsDocPropertyTags), 33);
}
function emitJSDocSignature(sig) {
if (sig.typeParameters) {
- emitList(sig, ts.createNodeArray(sig.typeParameters), 33);
+ emitList(sig, ts.factory.createNodeArray(sig.typeParameters), 33);
}
if (sig.parameters) {
- emitList(sig, ts.createNodeArray(sig.parameters), 33);
+ emitList(sig, ts.factory.createNodeArray(sig.parameters), 33);
}
if (sig.type) {
writeLine();
bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "reference", data: directive.fileName });
writeLine();
}
- for (var _d = 0, types_22 = types; _d < types_22.length; _d++) {
- var directive = types_22[_d];
+ for (var _d = 0, types_23 = types; _d < types_23.length; _d++) {
+ var directive = types_23[_d];
var pos = writer.getTextPos();
writeComment("/// <reference types=\"" + directive.fileName + "\" />");
if (bundleFileInfo)
if (recordBundleFileSection && bundleFileInfo)
bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "prologue", data: statement.expression.text });
if (seenPrologueDirectives) {
- seenPrologueDirectives.set(statement.expression.text, true);
+ seenPrologueDirectives.add(statement.expression.text);
}
}
}
if (bundleFileInfo)
bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "prologue", data: prologue.data });
if (seenPrologueDirectives) {
- seenPrologueDirectives.set(prologue.data, true);
+ seenPrologueDirectives.add(prologue.data);
}
}
}
emitPrologueDirectives(sourceFileOrBundle.statements, sourceFileOrBundle);
}
else {
- var seenPrologueDirectives = ts.createMap();
+ var seenPrologueDirectives = new ts.Set();
for (var _a = 0, _b = sourceFileOrBundle.prepends; _a < _b.length; _a++) {
var prepend = _b[_a];
emitUnparsedPrologues(prepend.prologues, seenPrologueDirectives);
}
}
function getPrologueDirectivesFromBundledSourceFiles(bundle) {
- var seenPrologueDirectives = ts.createMap();
+ var seenPrologueDirectives = new ts.Set();
var prologues;
for (var index = 0; index < bundle.sourceFiles.length; index++) {
var sourceFile = bundle.sourceFiles[index];
break;
if (seenPrologueDirectives.has(statement.expression.text))
continue;
- seenPrologueDirectives.set(statement.expression.text, true);
+ seenPrologueDirectives.add(statement.expression.text);
(directives || (directives = [])).push({
pos: statement.pos,
end: statement.end,
else {
shouldEmitInterveningComments = mayEmitInterveningComments;
}
+ nextListElementPos = child.pos;
emit(child);
if (shouldDecreaseIndentAfterEmit) {
decreaseIndent();
writer(tokenString);
return pos < 0 ? pos : pos + tokenString.length;
}
- function writeLineOrSpace(node) {
- if (ts.getEmitFlags(node) & 1) {
+ function writeLineOrSpace(parentNode, prevChildNode, nextChildNode) {
+ if (ts.getEmitFlags(parentNode) & 1) {
writeSpace();
}
+ else if (preserveSourceNewlines) {
+ var lines = getLinesBetweenNodes(parentNode, prevChildNode, nextChildNode);
+ if (lines) {
+ writeLine(lines);
+ }
+ else {
+ writeSpace();
+ }
+ }
else {
writeLine();
}
if (firstChild_1 === undefined) {
return ts.rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1;
}
+ if (firstChild_1.pos === nextListElementPos) {
+ return 0;
+ }
if (firstChild_1.kind === 11) {
return 0;
}
- if (!ts.positionIsSynthesized(parentNode.pos) && !ts.nodeIsSynthesized(firstChild_1) && (!firstChild_1.parent || firstChild_1.parent === parentNode)) {
+ if (!ts.positionIsSynthesized(parentNode.pos) &&
+ !ts.nodeIsSynthesized(firstChild_1) &&
+ (!firstChild_1.parent || ts.getOriginalNode(firstChild_1.parent) === ts.getOriginalNode(parentNode))) {
if (preserveSourceNewlines) {
return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(firstChild_1.pos, parentNode.pos, currentSourceFile, includeComments); });
}
if (format & 65536) {
return 1;
}
- var lastChild_1 = ts.lastOrUndefined(children);
- if (lastChild_1 === undefined) {
+ var lastChild = ts.lastOrUndefined(children);
+ if (lastChild === undefined) {
return ts.rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1;
}
- if (!ts.positionIsSynthesized(parentNode.pos) && !ts.nodeIsSynthesized(lastChild_1) && (!lastChild_1.parent || lastChild_1.parent === parentNode)) {
+ if (!ts.positionIsSynthesized(parentNode.pos) && !ts.nodeIsSynthesized(lastChild) && (!lastChild.parent || lastChild.parent === parentNode)) {
if (preserveSourceNewlines) {
- return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenPositionAndNextNonWhitespaceCharacter(lastChild_1.end, parentNode.end, currentSourceFile, includeComments); });
+ var end_2 = ts.isNodeArray(children) && !ts.positionIsSynthesized(children.end) ? children.end : lastChild.end;
+ return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenPositionAndNextNonWhitespaceCharacter(end_2, parentNode.end, currentSourceFile, includeComments); });
}
- return ts.rangeEndPositionsAreOnSameLine(parentNode, lastChild_1, currentSourceFile) ? 0 : 1;
+ return ts.rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile) ? 0 : 1;
}
- if (synthesizedNodeStartsOnNewLine(lastChild_1, format)) {
+ if (synthesizedNodeStartsOnNewLine(lastChild, format)) {
return 1;
}
}
&& ts.rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile);
}
function skipSynthesizedParentheses(node) {
- while (node.kind === 200 && ts.nodeIsSynthesized(node)) {
+ while (node.kind === 207 && ts.nodeIsSynthesized(node)) {
node = node.expression;
}
return node;
function getLiteralTextOfNode(node, neverAsciiEscape, jsxAttributeEscape) {
if (node.kind === 10 && node.textSourceNode) {
var textSourceNode = node.textSourceNode;
- if (ts.isIdentifier(textSourceNode)) {
- return jsxAttributeEscape ? "\"" + ts.escapeJsxAttributeString(getTextOfNode(textSourceNode)) + "\"" :
- neverAsciiEscape || (ts.getEmitFlags(node) & 16777216) ? "\"" + ts.escapeString(getTextOfNode(textSourceNode)) + "\"" :
- "\"" + ts.escapeNonAsciiString(getTextOfNode(textSourceNode)) + "\"";
+ if (ts.isIdentifier(textSourceNode) || ts.isNumericLiteral(textSourceNode)) {
+ var text = ts.isNumericLiteral(textSourceNode) ? textSourceNode.text : getTextOfNode(textSourceNode);
+ return jsxAttributeEscape ? "\"" + ts.escapeJsxAttributeString(text) + "\"" :
+ neverAsciiEscape || (ts.getEmitFlags(node) & 16777216) ? "\"" + ts.escapeString(text) + "\"" :
+ "\"" + ts.escapeNonAsciiString(text) + "\"";
}
else {
return getLiteralTextOfNode(textSourceNode, neverAsciiEscape, jsxAttributeEscape);
}
}
- return ts.getLiteralText(node, currentSourceFile, neverAsciiEscape, jsxAttributeEscape);
+ var flags = (neverAsciiEscape ? 1 : 0)
+ | (jsxAttributeEscape ? 2 : 0)
+ | (printerOptions.terminateUnterminatedLiterals ? 4 : 0);
+ return ts.getLiteralText(node, currentSourceFile, flags);
}
function pushNameGenerationScope(node) {
if (node && ts.getEmitFlags(node) & 524288) {
}
function reserveNameInNestedScopes(name) {
if (!reservedNames || reservedNames === ts.lastOrUndefined(reservedNamesStack)) {
- reservedNames = ts.createMap();
+ reservedNames = new ts.Set();
}
- reservedNames.set(name, true);
+ reservedNames.add(name);
}
function generateNames(node) {
if (!node)
return;
switch (node.kind) {
- case 223:
+ case 230:
ts.forEach(node.statements, generateNames);
break;
- case 238:
+ case 245:
+ case 243:
+ case 235:
case 236:
- case 228:
- case 229:
generateNames(node.statement);
break;
- case 227:
+ case 234:
generateNames(node.thenStatement);
generateNames(node.elseStatement);
break;
- case 230:
- case 232:
- case 231:
+ case 237:
+ case 239:
+ case 238:
generateNames(node.initializer);
generateNames(node.statement);
break;
- case 237:
+ case 244:
generateNames(node.caseBlock);
break;
- case 251:
+ case 258:
ts.forEach(node.clauses, generateNames);
break;
- case 277:
- case 278:
+ case 284:
+ case 285:
ts.forEach(node.statements, generateNames);
break;
- case 240:
+ case 247:
generateNames(node.tryBlock);
generateNames(node.catchClause);
generateNames(node.finallyBlock);
break;
- case 280:
+ case 287:
generateNames(node.variableDeclaration);
generateNames(node.block);
break;
- case 225:
+ case 232:
generateNames(node.declarationList);
break;
- case 243:
+ case 250:
ts.forEach(node.declarations, generateNames);
break;
- case 242:
- case 156:
- case 191:
- case 245:
+ case 249:
+ case 160:
+ case 198:
+ case 252:
generateNameIfNeeded(node.name);
break;
- case 244:
+ case 251:
generateNameIfNeeded(node.name);
if (ts.getEmitFlags(node) & 524288) {
ts.forEach(node.parameters, generateNames);
generateNames(node.body);
}
break;
- case 189:
- case 190:
+ case 196:
+ case 197:
ts.forEach(node.elements, generateNames);
break;
- case 254:
+ case 261:
generateNames(node.importClause);
break;
- case 255:
+ case 262:
generateNameIfNeeded(node.name);
generateNames(node.namedBindings);
break;
- case 256:
+ case 263:
generateNameIfNeeded(node.name);
break;
- case 262:
+ case 269:
generateNameIfNeeded(node.name);
break;
- case 257:
+ case 264:
ts.forEach(node.elements, generateNames);
break;
- case 258:
+ case 265:
generateNameIfNeeded(node.propertyName || node.name);
break;
}
if (!node)
return;
switch (node.kind) {
- case 281:
- case 282:
- case 159:
- case 161:
+ case 288:
+ case 289:
case 163:
- case 164:
+ case 165:
+ case 167:
+ case 168:
generateNameIfNeeded(node.name);
break;
}
reserveNameInNestedScopes(baseName);
}
else {
- generatedNames.set(baseName, true);
+ generatedNames.add(baseName);
}
return baseName;
}
reserveNameInNestedScopes(generatedName);
}
else {
- generatedNames.set(generatedName, true);
+ generatedNames.add(generatedName);
}
return generatedName;
}
}
function generateNameForNode(node, flags) {
switch (node.kind) {
- case 75:
+ case 78:
return makeUniqueName(getTextOfNode(node), isUniqueName, !!(flags & 16), !!(flags & 8));
- case 249:
- case 248:
+ case 256:
+ case 255:
return generateNameForModuleOrEnum(node);
- case 254:
- case 260:
+ case 261:
+ case 267:
return generateNameForImportOrExportDeclaration(node);
- case 244:
- case 245:
- case 259:
+ case 251:
+ case 252:
+ case 266:
return generateNameForExportDefault();
- case 214:
+ case 221:
return generateNameForClassExpression();
- case 161:
- case 163:
- case 164:
+ case 165:
+ case 167:
+ case 168:
return generateNameForMethodOrAccessor(node);
- case 154:
+ case 158:
return makeTempVariableName(0, true);
default:
return makeTempVariableName(0);
hasWrittenComment = false;
var emitFlags = ts.getEmitFlags(node);
var _a = ts.getCommentRange(node), pos = _a.pos, end = _a.end;
- var isEmittedNode = node.kind !== 325;
+ var isEmittedNode = node.kind !== 335;
var skipLeadingComments = pos < 0 || (emitFlags & 512) !== 0 || node.kind === 11;
var skipTrailingComments = end < 0 || (emitFlags & 1024) !== 0 || node.kind === 11;
var savedContainerPos = containerPos;
}
if (!skipTrailingComments || (end >= 0 && (emitFlags & 1024) !== 0)) {
containerEnd = end;
- if (node.kind === 243) {
+ if (node.kind === 250) {
declarationListContainerEnd = end;
}
}
ts.Debug.assert(lastNode === node || lastSubstitution === node);
}
function emitLeadingSynthesizedComment(comment) {
- if (comment.kind === 2) {
+ if (comment.hasLeadingNewline || comment.kind === 2) {
writer.writeLine();
}
writeSynthesizedComment(comment);
function emitLeadingComments(pos, isEmittedNode) {
hasWrittenComment = false;
if (isEmittedNode) {
- forEachLeadingCommentToEmit(pos, emitLeadingComment);
+ if (pos === 0 && (currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.isDeclarationFile)) {
+ forEachLeadingCommentToEmit(pos, emitNonTripleSlashLeadingComment);
+ }
+ else {
+ forEachLeadingCommentToEmit(pos, emitLeadingComment);
+ }
}
else if (pos === 0) {
forEachLeadingCommentToEmit(pos, emitTripleSlashLeadingComment);
emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos);
}
}
+ function emitNonTripleSlashLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) {
+ if (!isTripleSlashComment(commentPos, commentEnd)) {
+ emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos);
+ }
+ }
function shouldWriteComment(text, pos) {
if (printerOptions.onlyPrintJsDocStyle) {
return (ts.isJSDocLikeText(text, pos) || ts.isPinnedComment(text, pos));
else {
var _a = ts.getSourceMapRange(node), pos = _a.pos, end = _a.end, _b = _a.source, source = _b === void 0 ? sourceMapSource : _b;
var emitFlags = ts.getEmitFlags(node);
- if (node.kind !== 325
+ if (node.kind !== 335
&& (emitFlags & 16) === 0
&& pos >= 0) {
emitSourcePos(source, skipSourceTrivia(source, pos));
else {
pipelinePhase(hint, node);
}
- if (node.kind !== 325
+ if (node.kind !== 335
&& (emitFlags & 32) === 0
&& end >= 0) {
emitSourcePos(source, end);
function emitSourcePos(source, pos) {
if (source !== sourceMapSource) {
var savedSourceMapSource = sourceMapSource;
+ var savedSourceMapSourceIndex = sourceMapSourceIndex;
setSourceMapSource(source);
emitPos(pos);
- setSourceMapSource(savedSourceMapSource);
+ resetSourceMapSource(savedSourceMapSource, savedSourceMapSourceIndex);
}
else {
emitPos(pos);
return;
}
sourceMapSource = source;
+ if (source === mostRecentlyAddedSourceMapSource) {
+ sourceMapSourceIndex = mostRecentlyAddedSourceMapSourceIndex;
+ return;
+ }
if (isJsonSourceMapSource(source)) {
return;
}
if (printerOptions.inlineSources) {
sourceMapGenerator.setSourceContent(sourceMapSourceIndex, source.text);
}
+ mostRecentlyAddedSourceMapSource = source;
+ mostRecentlyAddedSourceMapSourceIndex = sourceMapSourceIndex;
+ }
+ function resetSourceMapSource(source, sourceIndex) {
+ sourceMapSource = source;
+ sourceMapSourceIndex = sourceIndex;
}
function isJsonSourceMapSource(sourceFile) {
return ts.fileExtensionIs(sourceFile.fileName, ".json");
if (!host.getDirectories || !host.readDirectory) {
return undefined;
}
- var cachedReadDirectoryResult = ts.createMap();
+ var cachedReadDirectoryResult = new ts.Map();
var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
return {
useCaseSensitiveFileNames: useCaseSensitiveFileNames,
})(ConfigFileProgramReloadLevel = ts.ConfigFileProgramReloadLevel || (ts.ConfigFileProgramReloadLevel = {}));
function updateMissingFilePathsWatch(program, missingFileWatches, createMissingFileWatch) {
var missingFilePaths = program.getMissingFilePaths();
- var newMissingFilePathMap = ts.arrayToSet(missingFilePaths);
+ var newMissingFilePathMap = ts.arrayToMap(missingFilePaths, ts.identity, ts.returnTrue);
ts.mutateMap(missingFileWatches, newMissingFilePathMap, {
createNewValue: createMissingFileWatch,
onDeleteValue: ts.closeFileWatcher
}
}
ts.updateWatchingWildcardDirectories = updateWatchingWildcardDirectories;
+ function isIgnoredFileFromWildCardWatching(_a) {
+ var watchedDirPath = _a.watchedDirPath, fileOrDirectory = _a.fileOrDirectory, fileOrDirectoryPath = _a.fileOrDirectoryPath, configFileName = _a.configFileName, options = _a.options, configFileSpecs = _a.configFileSpecs, program = _a.program, extraFileExtensions = _a.extraFileExtensions, currentDirectory = _a.currentDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, writeLog = _a.writeLog;
+ var newPath = ts.removeIgnoredPath(fileOrDirectoryPath);
+ if (!newPath) {
+ writeLog("Project: " + configFileName + " Detected ignored path: " + fileOrDirectory);
+ return true;
+ }
+ fileOrDirectoryPath = newPath;
+ if (fileOrDirectoryPath === watchedDirPath)
+ return false;
+ if (ts.hasExtension(fileOrDirectoryPath) && !ts.isSupportedSourceFileName(fileOrDirectory, options, extraFileExtensions)) {
+ writeLog("Project: " + configFileName + " Detected file add/remove of non supported extension: " + fileOrDirectory);
+ return true;
+ }
+ if (ts.isExcludedFile(fileOrDirectory, configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), useCaseSensitiveFileNames, currentDirectory)) {
+ writeLog("Project: " + configFileName + " Detected excluded file: " + fileOrDirectory);
+ return true;
+ }
+ if (!program)
+ return false;
+ if (options.outFile || options.outDir)
+ return false;
+ if (ts.fileExtensionIs(fileOrDirectoryPath, ".d.ts")) {
+ if (options.declarationDir)
+ return false;
+ }
+ else if (!ts.fileExtensionIsOneOf(fileOrDirectoryPath, ts.supportedJSExtensions)) {
+ return false;
+ }
+ var filePathWithoutExtension = ts.removeFileExtension(fileOrDirectoryPath);
+ var realProgram = isBuilderProgram(program) ? program.getProgramOrUndefined() : program;
+ if (hasSourceFile((filePathWithoutExtension + ".ts")) ||
+ hasSourceFile((filePathWithoutExtension + ".tsx"))) {
+ writeLog("Project: " + configFileName + " Detected output file: " + fileOrDirectory);
+ return true;
+ }
+ return false;
+ function hasSourceFile(file) {
+ return realProgram ?
+ !!realProgram.getSourceFileByPath(file) :
+ program.getState().fileInfos.has(file);
+ }
+ }
+ ts.isIgnoredFileFromWildCardWatching = isIgnoredFileFromWildCardWatching;
+ function isBuilderProgram(program) {
+ return !!program.getState;
+ }
function isEmittedFileOfProgram(program, file) {
if (!program) {
return false;
ts.createCompilerHost = createCompilerHost;
function createCompilerHostWorker(options, setParentNodes, system) {
if (system === void 0) { system = ts.sys; }
- var existingDirectories = ts.createMap();
+ var existingDirectories = new ts.Map();
var getCanonicalFileName = ts.createGetCanonicalFileName(system.useCaseSensitiveFileNames);
+ var computeHash = ts.maybeBind(system, system.createHash) || ts.generateDjb2Hash;
function getSourceFile(fileName, languageVersion, onError) {
var text;
try {
}
var outputFingerprints;
function writeFileWorker(fileName, data, writeByteOrderMark) {
- if (!ts.isWatchSet(options) || !system.createHash || !system.getModifiedTime) {
+ if (!ts.isWatchSet(options) || !system.getModifiedTime) {
system.writeFile(fileName, data, writeByteOrderMark);
return;
}
if (!outputFingerprints) {
- outputFingerprints = ts.createMap();
+ outputFingerprints = new ts.Map();
}
- var hash = system.createHash(data);
+ var hash = computeHash(data);
var mtimeBefore = system.getModifiedTime(fileName);
if (mtimeBefore) {
var fingerprint = outputFingerprints.get(fileName);
var originalDirectoryExists = host.directoryExists;
var originalCreateDirectory = host.createDirectory;
var originalWriteFile = host.writeFile;
- var readFileCache = ts.createMap();
- var fileExistsCache = ts.createMap();
- var directoryExistsCache = ts.createMap();
- var sourceFileCache = ts.createMap();
+ var readFileCache = new ts.Map();
+ var fileExistsCache = new ts.Map();
+ var directoryExistsCache = new ts.Map();
+ var sourceFileCache = new ts.Map();
var readFileWithCache = function (fileName) {
var key = toPath(fileName);
var value = readFileCache.get(key);
ts.getPreEmitDiagnostics = getPreEmitDiagnostics;
function formatDiagnostics(diagnostics, host) {
var output = "";
- for (var _i = 0, diagnostics_2 = diagnostics; _i < diagnostics_2.length; _i++) {
- var diagnostic = diagnostics_2[_i];
+ for (var _i = 0, diagnostics_3 = diagnostics; _i < diagnostics_3.length; _i++) {
+ var diagnostic = diagnostics_3[_i];
output += formatDiagnostic(diagnostic, host);
}
return output;
ts.formatLocation = formatLocation;
function formatDiagnosticsWithColorAndContext(diagnostics, host) {
var output = "";
- for (var _i = 0, diagnostics_3 = diagnostics; _i < diagnostics_3.length; _i++) {
- var diagnostic = diagnostics_3[_i];
+ for (var _i = 0, diagnostics_4 = diagnostics; _i < diagnostics_4.length; _i++) {
+ var diagnostic = diagnostics_4[_i];
if (diagnostic.file) {
var file = diagnostic.file, start = diagnostic.start;
output += formatLocation(file, start, host);
return [];
}
var resolutions = [];
- var cache = ts.createMap();
+ var cache = new ts.Map();
for (var _i = 0, names_2 = names; _i < names_2.length; _i++) {
var name = names_2[_i];
var result = void 0;
return resolutions;
}
ts.loadWithLocalCache = loadWithLocalCache;
+ function forEachResolvedProjectReference(resolvedProjectReferences, cb) {
+ return forEachProjectReference(undefined, resolvedProjectReferences, function (resolvedRef, parent) { return resolvedRef && cb(resolvedRef, parent); });
+ }
+ ts.forEachResolvedProjectReference = forEachResolvedProjectReference;
+ function forEachProjectReference(projectReferences, resolvedProjectReferences, cbResolvedRef, cbRef) {
+ var seenResolvedRefs;
+ return worker(projectReferences, resolvedProjectReferences, undefined);
+ function worker(projectReferences, resolvedProjectReferences, parent) {
+ if (cbRef) {
+ var result = cbRef(projectReferences, parent);
+ if (result) {
+ return result;
+ }
+ }
+ return ts.forEach(resolvedProjectReferences, function (resolvedRef, index) {
+ if (resolvedRef && (seenResolvedRefs === null || seenResolvedRefs === void 0 ? void 0 : seenResolvedRefs.has(resolvedRef.sourceFile.path))) {
+ return undefined;
+ }
+ var result = cbResolvedRef(resolvedRef, parent, index);
+ if (result || !resolvedRef)
+ return result;
+ (seenResolvedRefs || (seenResolvedRefs = new ts.Set())).add(resolvedRef.sourceFile.path);
+ return worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef);
+ });
+ }
+ }
ts.inferredTypesContainingFile = "__inferred type names__.ts";
function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, projectReferences) {
- if (!program || hasChangedAutomaticTypeDirectiveNames) {
+ if (!program || (hasChangedAutomaticTypeDirectiveNames === null || hasChangedAutomaticTypeDirectiveNames === void 0 ? void 0 : hasChangedAutomaticTypeDirectiveNames())) {
return false;
}
if (!ts.arrayIsEqualTo(program.getRootFileNames(), rootFileNames)) {
};
}
function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
- var _a;
+ var _a, _b;
var createProgramOptions = ts.isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions;
var rootNames = createProgramOptions.rootNames, options = createProgramOptions.options, configFileParsingDiagnostics = createProgramOptions.configFileParsingDiagnostics, projectReferences = createProgramOptions.projectReferences;
var oldProgram = createProgramOptions.oldProgram;
var diagnosticsProducingTypeChecker;
var noDiagnosticsTypeChecker;
var classifiableNames;
- var ambientModuleNameToUnmodifiedFileName = ts.createMap();
+ var ambientModuleNameToUnmodifiedFileName = new ts.Map();
var refFileMap;
var cachedBindAndCheckDiagnosticsForFile = {};
var cachedDeclarationDiagnosticsForFile = {};
- var resolvedTypeReferenceDirectives = ts.createMap();
+ var resolvedTypeReferenceDirectives = new ts.Map();
var fileProcessingDiagnostics = ts.createDiagnosticCollection();
var maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;
var currentNodeModulesDepth = 0;
- var modulesWithElidedImports = ts.createMap();
- var sourceFilesFoundSearchingNodeModules = ts.createMap();
+ var modulesWithElidedImports = new ts.Map();
+ var sourceFilesFoundSearchingNodeModules = new ts.Map();
+ var tracingData = ["program", "createProgram"];
+ ts.tracing.begin.apply(ts.tracing, tracingData);
ts.performance.mark("beforeProgram");
var host = createProgramOptions.host || createCompilerHost(options);
var configParsingHost = parseConfigHostFromCompilerHostLike(host);
var currentDirectory = host.getCurrentDirectory();
var supportedExtensions = ts.getSupportedExtensions(options);
var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
- var hasEmitBlockingDiagnostics = ts.createMap();
+ var hasEmitBlockingDiagnostics = new ts.Map();
var _compilerOptionsObjectLiteralSyntax;
var moduleResolutionCache;
var actualResolveModuleNamesWorker;
var loader_2 = function (typesRef, containingFile, redirectedReference) { return ts.resolveTypeReferenceDirective(typesRef, containingFile, options, host, redirectedReference).resolvedTypeReferenceDirective; };
actualResolveTypeReferenceDirectiveNamesWorker = function (typeReferenceDirectiveNames, containingFile, redirectedReference) { return loadWithLocalCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, loader_2); };
}
- var packageIdToSourceFile = ts.createMap();
- var sourceFileToPackageName = ts.createMap();
+ var packageIdToSourceFile = new ts.Map();
+ var sourceFileToPackageName = new ts.Map();
var redirectTargetsMap = ts.createMultiMap();
- var filesByName = ts.createMap();
+ var filesByName = new ts.Map();
var missingFilePaths;
- var filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? ts.createMap() : undefined;
+ var filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? new ts.Map() : undefined;
var resolvedProjectReferences;
var projectReferenceRedirects;
var mapFromFileToProjectReferenceRedirects;
var mapFromToProjectReferenceRedirectSource;
var useSourceOfProjectReferenceRedirect = !!((_a = host.useSourceOfProjectReferenceRedirect) === null || _a === void 0 ? void 0 : _a.call(host)) &&
!options.disableSourceOfProjectReferenceRedirect;
- var _b = updateHostForUseSourceOfProjectReferenceRedirect({
+ var _c = updateHostForUseSourceOfProjectReferenceRedirect({
compilerHost: host,
+ getSymlinkCache: getSymlinkCache,
useSourceOfProjectReferenceRedirect: useSourceOfProjectReferenceRedirect,
toPath: toPath,
getResolvedProjectReferences: getResolvedProjectReferences,
getSourceOfProjectReferenceRedirect: getSourceOfProjectReferenceRedirect,
forEachResolvedProjectReference: forEachResolvedProjectReference
- }), onProgramCreateComplete = _b.onProgramCreateComplete, fileExists = _b.fileExists;
+ }), onProgramCreateComplete = _c.onProgramCreateComplete, fileExists = _c.fileExists, directoryExists = _c.directoryExists;
+ ts.tracing.push("program", "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
var shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
- var structuralIsReused;
- structuralIsReused = tryReuseStructureFromOldProgram();
- if (structuralIsReused !== 2) {
+ ts.tracing.pop();
+ var structureIsReused;
+ ts.tracing.push("program", "tryReuseStructureFromOldProgram", {});
+ structureIsReused = tryReuseStructureFromOldProgram();
+ ts.tracing.pop();
+ if (structureIsReused !== 2) {
processingDefaultLibFiles = [];
processingOtherFiles = [];
if (projectReferences) {
var parsedRef = resolvedProjectReferences_1[_i];
if (!parsedRef)
continue;
- var out = parsedRef.commandLine.options.outFile || parsedRef.commandLine.options.out;
+ var out = ts.outFile(parsedRef.commandLine.options);
if (useSourceOfProjectReferenceRedirect) {
if (out || ts.getEmitModuleKind(parsedRef.commandLine.options) === ts.ModuleKind.None) {
- for (var _c = 0, _d = parsedRef.commandLine.fileNames; _c < _d.length; _c++) {
- var fileName = _d[_c];
+ for (var _d = 0, _e = parsedRef.commandLine.fileNames; _d < _e.length; _d++) {
+ var fileName = _e[_d];
processSourceFile(fileName, false, false, undefined);
}
}
processSourceFile(ts.changeExtension(out, ".d.ts"), false, false, undefined);
}
else if (ts.getEmitModuleKind(parsedRef.commandLine.options) === ts.ModuleKind.None) {
- for (var _e = 0, _f = parsedRef.commandLine.fileNames; _e < _f.length; _e++) {
- var fileName = _f[_e];
+ for (var _f = 0, _g = parsedRef.commandLine.fileNames; _f < _g.length; _f++) {
+ var fileName = _g[_f];
if (!ts.fileExtensionIs(fileName, ".d.ts") && !ts.fileExtensionIs(fileName, ".json")) {
processSourceFile(ts.getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames()), false, false, undefined);
}
}
}
}
+ ts.tracing.push("program", "processRootFiles", { count: rootNames.length });
ts.forEach(rootNames, function (name) { return processRootFile(name, false, false); });
+ ts.tracing.pop();
var typeReferences = rootNames.length ? ts.getAutomaticTypeDirectiveNames(options, host) : ts.emptyArray;
if (typeReferences.length) {
+ ts.tracing.push("program", "processTypeReferences", { count: typeReferences.length });
var containingDirectory = options.configFilePath ? ts.getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
var containingFilename = ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile);
var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);
for (var i = 0; i < typeReferences.length; i++) {
processTypeReferenceDirective(typeReferences[i], resolutions[i]);
}
+ ts.tracing.pop();
}
if (rootNames.length && !skipDefaultLib) {
var defaultLibraryFileName = getDefaultLibraryFileName();
ts.Debug.assert(!!missingFilePaths);
if (oldProgram && host.onReleaseOldSourceFile) {
var oldSourceFiles = oldProgram.getSourceFiles();
- for (var _g = 0, oldSourceFiles_1 = oldSourceFiles; _g < oldSourceFiles_1.length; _g++) {
- var oldSourceFile = oldSourceFiles_1[_g];
+ for (var _h = 0, oldSourceFiles_1 = oldSourceFiles; _h < oldSourceFiles_1.length; _h++) {
+ var oldSourceFile = oldSourceFiles_1[_h];
var newFile = getSourceFileByPath(oldSourceFile.resolvedPath);
if (shouldCreateNewSourceFile || !newFile ||
(oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path)) {
host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));
}
}
- oldProgram.forEachResolvedProjectReference(function (resolvedProjectReference, resolvedProjectReferencePath) {
- if (resolvedProjectReference && !getResolvedProjectReferenceByPath(resolvedProjectReferencePath)) {
+ oldProgram.forEachResolvedProjectReference(function (resolvedProjectReference) {
+ if (!getResolvedProjectReferenceByPath(resolvedProjectReference.sourceFile.path)) {
host.onReleaseOldSourceFile(resolvedProjectReference.sourceFile, oldProgram.getCompilerOptions(), false);
}
});
getOptionsDiagnostics: getOptionsDiagnostics,
getGlobalDiagnostics: getGlobalDiagnostics,
getSemanticDiagnostics: getSemanticDiagnostics,
+ getCachedSemanticDiagnostics: getCachedSemanticDiagnostics,
getSuggestionDiagnostics: getSuggestionDiagnostics,
getDeclarationDiagnostics: getDeclarationDiagnostics,
getBindAndCheckDiagnostics: getBindAndCheckDiagnostics,
getNodeCount: function () { return getDiagnosticsProducingTypeChecker().getNodeCount(); },
getIdentifierCount: function () { return getDiagnosticsProducingTypeChecker().getIdentifierCount(); },
getSymbolCount: function () { return getDiagnosticsProducingTypeChecker().getSymbolCount(); },
+ getTypeCatalog: function () { return getDiagnosticsProducingTypeChecker().getTypeCatalog(); },
getTypeCount: function () { return getDiagnosticsProducingTypeChecker().getTypeCount(); },
getInstantiationCount: function () { return getDiagnosticsProducingTypeChecker().getInstantiationCount(); },
getRelationCacheSizes: function () { return getDiagnosticsProducingTypeChecker().getRelationCacheSizes(); },
isSourceOfProjectReferenceRedirect: isSourceOfProjectReferenceRedirect,
emitBuildInfo: emitBuildInfo,
fileExists: fileExists,
- getProbableSymlinks: getProbableSymlinks,
+ directoryExists: directoryExists,
+ getSymlinkCache: getSymlinkCache,
+ realpath: (_b = host.realpath) === null || _b === void 0 ? void 0 : _b.bind(host),
useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); },
+ structureIsReused: structureIsReused,
};
onProgramCreateComplete();
verifyCompilerOptions();
ts.performance.mark("afterProgram");
ts.performance.measure("Program", "beforeProgram", "afterProgram");
+ ts.tracing.end.apply(ts.tracing, tracingData);
return program;
- function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames, redirectedReference) {
+ function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
+ if (!moduleNames.length)
+ return ts.emptyArray;
+ var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
+ var redirectedReference = getRedirectReferenceForResolution(containingFile);
+ ts.tracing.push("program", "resolveModuleNamesWorker", { containingFileName: containingFileName });
ts.performance.mark("beforeResolveModule");
- var result = actualResolveModuleNamesWorker(moduleNames, containingFile, reusedNames, redirectedReference);
+ var result = actualResolveModuleNamesWorker(moduleNames, containingFileName, reusedNames, redirectedReference);
ts.performance.mark("afterResolveModule");
ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
+ ts.tracing.pop();
return result;
}
- function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, redirectedReference) {
+ function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile) {
+ if (!typeDirectiveNames.length)
+ return [];
+ var containingFileName = !ts.isString(containingFile) ? ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
+ var redirectedReference = !ts.isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : undefined;
+ ts.tracing.push("program", "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: containingFileName });
ts.performance.mark("beforeResolveTypeReference");
- var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, redirectedReference);
+ var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference);
ts.performance.mark("afterResolveTypeReference");
ts.performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
+ ts.tracing.pop();
return result;
}
+ function getRedirectReferenceForResolution(file) {
+ var redirect = getResolvedProjectReferenceToRedirect(file.originalFileName);
+ if (redirect || !ts.fileExtensionIs(file.originalFileName, ".d.ts"))
+ return redirect;
+ var resultFromDts = getRedirectReferenceForResolutionFromSourceOfProject(file.originalFileName, file.path);
+ if (resultFromDts)
+ return resultFromDts;
+ if (!host.realpath || !options.preserveSymlinks || !ts.stringContains(file.originalFileName, ts.nodeModulesPathPart))
+ return undefined;
+ var realDeclarationFileName = host.realpath(file.originalFileName);
+ var realDeclarationPath = toPath(realDeclarationFileName);
+ return realDeclarationPath === file.path ? undefined : getRedirectReferenceForResolutionFromSourceOfProject(realDeclarationFileName, realDeclarationPath);
+ }
+ function getRedirectReferenceForResolutionFromSourceOfProject(fileName, filePath) {
+ var source = getSourceOfProjectReferenceRedirect(fileName);
+ if (ts.isString(source))
+ return getResolvedProjectReferenceToRedirect(source);
+ if (!source)
+ return undefined;
+ return forEachResolvedProjectReference(function (resolvedRef) {
+ var out = ts.outFile(resolvedRef.commandLine.options);
+ if (!out)
+ return undefined;
+ return toPath(out) === filePath ? resolvedRef : undefined;
+ });
+ }
function compareDefaultLibFiles(a, b) {
return ts.compareValues(getDefaultLibFilePriority(a), getDefaultLibFilePriority(b));
}
return commonSourceDirectory;
}
function getClassifiableNames() {
+ var _a;
if (!classifiableNames) {
getTypeChecker();
- classifiableNames = ts.createUnderscoreEscapedMap();
+ classifiableNames = new ts.Set();
for (var _i = 0, files_2 = files; _i < files_2.length; _i++) {
var sourceFile = files_2[_i];
- ts.copyEntries(sourceFile.classifiableNames, classifiableNames);
+ (_a = sourceFile.classifiableNames) === null || _a === void 0 ? void 0 : _a.forEach(function (value) { return classifiableNames.add(value); });
}
}
return classifiableNames;
}
- function resolveModuleNamesReusingOldState(moduleNames, containingFile, file) {
- if (structuralIsReused === 0 && !file.ambientModuleNames.length) {
- return resolveModuleNamesWorker(moduleNames, containingFile, undefined, getResolvedProjectReferenceToRedirect(file.originalFileName));
+ function resolveModuleNamesReusingOldState(moduleNames, file) {
+ if (structureIsReused === 0 && !file.ambientModuleNames.length) {
+ return resolveModuleNamesWorker(moduleNames, file, undefined);
}
- var oldSourceFile = oldProgram && oldProgram.getSourceFile(containingFile);
+ var oldSourceFile = oldProgram && oldProgram.getSourceFile(file.fileName);
if (oldSourceFile !== file && file.resolvedModules) {
- var result_11 = [];
+ var result_14 = [];
for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) {
var moduleName = moduleNames_1[_i];
var resolvedModule = file.resolvedModules.get(moduleName);
- result_11.push(resolvedModule);
+ result_14.push(resolvedModule);
}
- return result_11;
+ return result_14;
}
var unknownModuleNames;
var result;
for (var i = 0; i < moduleNames.length; i++) {
var moduleName = moduleNames[i];
if (file === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path)) {
- var oldResolvedModule = oldSourceFile && oldSourceFile.resolvedModules.get(moduleName);
+ var oldResolvedModule = ts.getResolvedModule(oldSourceFile, moduleName);
if (oldResolvedModule) {
if (ts.isTraceEnabled(options, host)) {
- ts.trace(host, ts.Diagnostics.Reusing_resolution_of_module_0_to_file_1_from_old_program, moduleName, containingFile);
+ ts.trace(host, ts.Diagnostics.Reusing_resolution_of_module_0_to_file_1_from_old_program, moduleName, ts.getNormalizedAbsolutePath(file.originalFileName, currentDirectory));
}
(result || (result = new Array(moduleNames.length)))[i] = oldResolvedModule;
(reusedNames || (reusedNames = [])).push(moduleName);
if (ts.contains(file.ambientModuleNames, moduleName)) {
resolvesToAmbientModuleInNonModifiedFile = true;
if (ts.isTraceEnabled(options, host)) {
- ts.trace(host, ts.Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName, containingFile);
+ ts.trace(host, ts.Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName, ts.getNormalizedAbsolutePath(file.originalFileName, currentDirectory));
}
}
else {
}
}
var resolutions = unknownModuleNames && unknownModuleNames.length
- ? resolveModuleNamesWorker(unknownModuleNames, containingFile, reusedNames, getResolvedProjectReferenceToRedirect(file.originalFileName))
+ ? resolveModuleNamesWorker(unknownModuleNames, file, reusedNames)
: ts.emptyArray;
if (!result) {
ts.Debug.assert(resolutions.length === moduleNames.length);
}
}
function canReuseProjectReferences() {
- return !forEachProjectReference(oldProgram.getProjectReferences(), oldProgram.getResolvedProjectReferences(), function (oldResolvedRef, index, parent) {
+ return !forEachProjectReference(oldProgram.getProjectReferences(), oldProgram.getResolvedProjectReferences(), function (oldResolvedRef, parent, index) {
var newRef = (parent ? parent.commandLine.projectReferences : projectReferences)[index];
var newResolvedRef = parseProjectReferenceConfigFile(newRef);
if (oldResolvedRef) {
});
}
function tryReuseStructureFromOldProgram() {
+ var _a;
if (!oldProgram) {
return 0;
}
var oldOptions = oldProgram.getCompilerOptions();
if (ts.changesAffectModuleResolution(oldOptions, options)) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
- ts.Debug.assert(!(oldProgram.structureIsReused & (2 | 1)));
var oldRootNames = oldProgram.getRootFileNames();
if (!ts.arrayIsEqualTo(oldRootNames, rootNames)) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
if (!ts.arrayIsEqualTo(options.types, oldOptions.types)) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
if (!canReuseProjectReferences()) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
if (projectReferences) {
resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile);
}
var newSourceFiles = [];
var modifiedSourceFiles = [];
- oldProgram.structureIsReused = 2;
+ structureIsReused = 2;
if (oldProgram.getMissingFilePaths().some(function (missingFilePath) { return host.fileExists(missingFilePath); })) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
var oldSourceFiles = oldProgram.getSourceFiles();
- var seenPackageNames = ts.createMap();
+ var seenPackageNames = new ts.Map();
for (var _i = 0, oldSourceFiles_2 = oldSourceFiles; _i < oldSourceFiles_2.length; _i++) {
var oldSourceFile = oldSourceFiles_2[_i];
var newSourceFile = host.getSourceFileByPath
? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, options.target, undefined, shouldCreateNewSourceFile)
: host.getSourceFile(oldSourceFile.fileName, options.target, undefined, shouldCreateNewSourceFile);
if (!newSourceFile) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
ts.Debug.assert(!newSourceFile.redirectInfo, "Host should not return a redirect source file from `getSourceFile`");
var fileChanged = void 0;
if (oldSourceFile.redirectInfo) {
if (newSourceFile !== oldSourceFile.redirectInfo.unredirected) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
fileChanged = false;
newSourceFile = oldSourceFile;
}
else if (oldProgram.redirectTargetsMap.has(oldSourceFile.path)) {
if (newSourceFile !== oldSourceFile) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
fileChanged = false;
}
var prevKind = seenPackageNames.get(packageName);
var newKind = fileChanged ? 1 : 0;
if ((prevKind !== undefined && newKind === 1) || prevKind === 1) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
seenPackageNames.set(packageName, newKind);
}
if (fileChanged) {
if (!ts.arrayIsEqualTo(oldSourceFile.libReferenceDirectives, newSourceFile.libReferenceDirectives, fileReferenceIsEqualTo)) {
- return oldProgram.structureIsReused = 0;
+ return 0;
}
if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
- oldProgram.structureIsReused = 1;
+ structureIsReused = 1;
}
if (!ts.arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {
- oldProgram.structureIsReused = 1;
+ structureIsReused = 1;
}
collectExternalModuleReferences(newSourceFile);
if (!ts.arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {
- oldProgram.structureIsReused = 1;
+ structureIsReused = 1;
}
if (!ts.arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) {
- oldProgram.structureIsReused = 1;
+ structureIsReused = 1;
}
if ((oldSourceFile.flags & 3145728) !== (newSourceFile.flags & 3145728)) {
- oldProgram.structureIsReused = 1;
+ structureIsReused = 1;
}
if (!ts.arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) {
- oldProgram.structureIsReused = 1;
+ structureIsReused = 1;
}
modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
}
else if (hasInvalidatedResolution(oldSourceFile.path)) {
- oldProgram.structureIsReused = 1;
+ structureIsReused = 1;
modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
}
newSourceFiles.push(newSourceFile);
}
- if (oldProgram.structureIsReused !== 2) {
- return oldProgram.structureIsReused;
+ if (structureIsReused !== 2) {
+ return structureIsReused;
}
var modifiedFiles = modifiedSourceFiles.map(function (f) { return f.oldFile; });
- for (var _a = 0, oldSourceFiles_3 = oldSourceFiles; _a < oldSourceFiles_3.length; _a++) {
- var oldFile = oldSourceFiles_3[_a];
+ for (var _b = 0, oldSourceFiles_3 = oldSourceFiles; _b < oldSourceFiles_3.length; _b++) {
+ var oldFile = oldSourceFiles_3[_b];
if (!ts.contains(modifiedFiles, oldFile)) {
- for (var _b = 0, _c = oldFile.ambientModuleNames; _b < _c.length; _b++) {
- var moduleName = _c[_b];
+ for (var _c = 0, _d = oldFile.ambientModuleNames; _c < _d.length; _c++) {
+ var moduleName = _d[_c];
ambientModuleNameToUnmodifiedFileName.set(moduleName, oldFile.fileName);
}
}
}
- for (var _d = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _d < modifiedSourceFiles_1.length; _d++) {
- var _e = modifiedSourceFiles_1[_d], oldSourceFile = _e.oldFile, newSourceFile = _e.newFile;
- var newSourceFilePath = ts.getNormalizedAbsolutePath(newSourceFile.originalFileName, currentDirectory);
+ for (var _e = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _e < modifiedSourceFiles_1.length; _e++) {
+ var _f = modifiedSourceFiles_1[_e], oldSourceFile = _f.oldFile, newSourceFile = _f.newFile;
var moduleNames = getModuleNames(newSourceFile);
- var resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFilePath, newSourceFile);
+ var resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
var resolutionsChanged = ts.hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, ts.moduleResolutionIsEqualTo);
if (resolutionsChanged) {
- oldProgram.structureIsReused = 1;
+ structureIsReused = 1;
newSourceFile.resolvedModules = ts.zipToMap(moduleNames, resolutions);
}
else {
newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
}
- if (resolveTypeReferenceDirectiveNamesWorker) {
- var typesReferenceDirectives = ts.map(newSourceFile.typeReferenceDirectives, function (ref) { return ts.toFileNameLowerCase(ref.fileName); });
- var resolutions_1 = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFilePath, getResolvedProjectReferenceToRedirect(newSourceFile.originalFileName));
- var resolutionsChanged_1 = ts.hasChangesInResolutions(typesReferenceDirectives, resolutions_1, oldSourceFile.resolvedTypeReferenceDirectiveNames, ts.typeDirectiveIsEqualTo);
- if (resolutionsChanged_1) {
- oldProgram.structureIsReused = 1;
- newSourceFile.resolvedTypeReferenceDirectiveNames = ts.zipToMap(typesReferenceDirectives, resolutions_1);
- }
- else {
- newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
- }
+ var typesReferenceDirectives = ts.map(newSourceFile.typeReferenceDirectives, function (ref) { return ts.toFileNameLowerCase(ref.fileName); });
+ var typeReferenceResolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFile);
+ var typeReferenceEesolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, ts.typeDirectiveIsEqualTo);
+ if (typeReferenceEesolutionsChanged) {
+ structureIsReused = 1;
+ newSourceFile.resolvedTypeReferenceDirectiveNames = ts.zipToMap(typesReferenceDirectives, typeReferenceResolutions);
+ }
+ else {
+ newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
}
}
- if (oldProgram.structureIsReused !== 2) {
- return oldProgram.structureIsReused;
+ if (structureIsReused !== 2) {
+ return structureIsReused;
}
- if (host.hasChangedAutomaticTypeDirectiveNames) {
- return oldProgram.structureIsReused = 1;
+ if ((_a = host.hasChangedAutomaticTypeDirectiveNames) === null || _a === void 0 ? void 0 : _a.call(host)) {
+ return 1;
}
missingFilePaths = oldProgram.getMissingFilePaths();
refFileMap = oldProgram.getRefFileMap();
ts.Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length);
- for (var _f = 0, newSourceFiles_1 = newSourceFiles; _f < newSourceFiles_1.length; _f++) {
- var newSourceFile = newSourceFiles_1[_f];
+ for (var _g = 0, newSourceFiles_1 = newSourceFiles; _g < newSourceFiles_1.length; _g++) {
+ var newSourceFile = newSourceFiles_1[_g];
filesByName.set(newSourceFile.path, newSourceFile);
}
var oldFilesByNameMap = oldProgram.getFilesByNameMap();
});
files = newSourceFiles;
fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
- for (var _g = 0, modifiedSourceFiles_2 = modifiedSourceFiles; _g < modifiedSourceFiles_2.length; _g++) {
- var modifiedFile = modifiedSourceFiles_2[_g];
+ for (var _h = 0, modifiedSourceFiles_2 = modifiedSourceFiles; _h < modifiedSourceFiles_2.length; _h++) {
+ var modifiedFile = modifiedSourceFiles_2[_h];
fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile.newFile);
}
resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();
sourceFileToPackageName = oldProgram.sourceFileToPackageName;
redirectTargetsMap = oldProgram.redirectTargetsMap;
- return oldProgram.structureIsReused = 2;
+ return 2;
}
function getEmitHost(writeFileCallback) {
return {
getResolvedProjectReferenceToRedirect: getResolvedProjectReferenceToRedirect,
getProjectReferenceRedirect: getProjectReferenceRedirect,
isSourceOfProjectReferenceRedirect: isSourceOfProjectReferenceRedirect,
- getProbableSymlinks: getProbableSymlinks,
+ getSymlinkCache: getSymlinkCache,
writeFile: writeFileCallback || (function (fileName, data, writeByteOrderMark, onError, sourceFiles) { return host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles); }),
isEmitBlocked: isEmitBlocked,
readFile: function (f) { return host.readFile(f); },
};
}
function emitBuildInfo(writeFileCallback) {
- ts.Debug.assert(!options.out && !options.outFile);
+ ts.Debug.assert(!ts.outFile(options));
+ var tracingData = ["emit", "emitBuildInfo"];
+ ts.tracing.begin.apply(ts.tracing, tracingData);
ts.performance.mark("beforeEmit");
var emitResult = ts.emitFiles(ts.notImplementedResolver, getEmitHost(writeFileCallback), undefined, ts.noTransformers, false, true);
ts.performance.mark("afterEmit");
ts.performance.measure("Emit", "beforeEmit", "afterEmit");
+ ts.tracing.end.apply(ts.tracing, tracingData);
return emitResult;
}
function getResolvedProjectReferences() {
return projectReferences;
}
function getPrependNodes() {
- return createPrependNodes(projectReferences, function (_ref, index) { return resolvedProjectReferences[index].commandLine; }, function (fileName) {
+ return createPrependNodes(projectReferences, function (_ref, index) { var _a; return (_a = resolvedProjectReferences[index]) === null || _a === void 0 ? void 0 : _a.commandLine; }, function (fileName) {
var path = toPath(fileName);
var sourceFile = getSourceFileByPath(path);
return sourceFile ? sourceFile.text : filesByName.has(path) ? undefined : host.readFile(path);
return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = ts.createTypeChecker(program, false));
}
function emit(sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit) {
- return runWithCancellationToken(function () { return emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit); });
+ var tracingData = ["emit", "emit", { path: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.path }];
+ ts.tracing.begin.apply(ts.tracing, tracingData);
+ var result = runWithCancellationToken(function () { return emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit); });
+ ts.tracing.end.apply(ts.tracing, tracingData);
+ return result;
}
function isEmitBlocked(emitFileName) {
return hasEmitBlockingDiagnostics.has(toPath(emitFileName));
}
function emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit) {
if (!forceDtsEmit) {
- var result = handleNoEmitOptions(program, sourceFile, cancellationToken);
+ var result = handleNoEmitOptions(program, sourceFile, writeFileCallback, cancellationToken);
if (result)
return result;
}
- var emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile, cancellationToken);
+ var emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver(ts.outFile(options) ? undefined : sourceFile, cancellationToken);
ts.performance.mark("beforeEmit");
var emitResult = ts.emitFiles(emitResolver, getEmitHost(writeFileCallback), sourceFile, ts.getTransformers(options, customTransformers, emitOnlyDtsFiles), emitOnlyDtsFiles, false, forceDtsEmit);
ts.performance.mark("afterEmit");
function getSemanticDiagnostics(sourceFile, cancellationToken) {
return getDiagnosticsHelper(sourceFile, getSemanticDiagnosticsForFile, cancellationToken);
}
+ function getCachedSemanticDiagnostics(sourceFile) {
+ var _a;
+ return sourceFile
+ ? (_a = cachedBindAndCheckDiagnosticsForFile.perFile) === null || _a === void 0 ? void 0 : _a.get(sourceFile.path) : cachedBindAndCheckDiagnosticsForFile.allDiagnostics;
+ }
function getBindAndCheckDiagnostics(sourceFile, cancellationToken) {
return getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken);
}
}
function getDeclarationDiagnostics(sourceFile, cancellationToken) {
var options = program.getCompilerOptions();
- if (!sourceFile || options.out || options.outFile) {
+ if (!sourceFile || ts.outFile(options)) {
return getDeclarationDiagnosticsWorker(sourceFile, cancellationToken);
}
else {
}
}
function getSemanticDiagnosticsForFile(sourceFile, cancellationToken) {
- return ts.concatenate(getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken), getProgramDiagnostics(sourceFile));
+ return ts.concatenate(filterSemanticDiagnotics(getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken), options), getProgramDiagnostics(sourceFile));
}
function getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken) {
return getAndCacheDiagnostics(sourceFile, cancellationToken, cachedBindAndCheckDiagnosticsForFile, getBindAndCheckDiagnosticsForFileNoCache);
sourceFile.scriptKind === 5 || isCheckJs || sourceFile.scriptKind === 7);
var bindDiagnostics = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : ts.emptyArray;
var checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : ts.emptyArray;
- return getMergedBindAndCheckDiagnostics(sourceFile, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : undefined);
+ return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : undefined);
});
}
- function getMergedBindAndCheckDiagnostics(sourceFile) {
+ function getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics) {
var _a;
var allDiagnostics = [];
- for (var _i = 1; _i < arguments.length; _i++) {
- allDiagnostics[_i - 1] = arguments[_i];
+ for (var _i = 2; _i < arguments.length; _i++) {
+ allDiagnostics[_i - 2] = arguments[_i];
}
var flatDiagnostics = ts.flatten(allDiagnostics);
- if (!((_a = sourceFile.commentDirectives) === null || _a === void 0 ? void 0 : _a.length)) {
+ if (!includeBindAndCheckDiagnostics || !((_a = sourceFile.commentDirectives) === null || _a === void 0 ? void 0 : _a.length)) {
return flatDiagnostics;
}
var _b = getDiagnosticsWithPrecedingDirectives(sourceFile, sourceFile.commentDirectives, flatDiagnostics), diagnostics = _b.diagnostics, directives = _b.directives;
return diagnostics;
function walk(node, parent) {
switch (parent.kind) {
- case 156:
- case 159:
- case 161:
+ case 160:
+ case 163:
+ case 165:
if (parent.questionToken === node) {
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?"));
return "skip";
}
- case 160:
- case 162:
- case 163:
case 164:
- case 201:
- case 244:
- case 202:
- case 242:
+ case 166:
+ case 167:
+ case 168:
+ case 208:
+ case 251:
+ case 209:
+ case 249:
if (parent.type === node) {
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Type_annotations_can_only_be_used_in_TypeScript_files));
return "skip";
}
}
switch (node.kind) {
- case 255:
+ case 262:
if (node.isTypeOnly) {
- diagnostics.push(createDiagnosticForNode(node.parent, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "import type"));
+ diagnostics.push(createDiagnosticForNode(parent, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "import type"));
return "skip";
}
break;
- case 260:
+ case 267:
if (node.isTypeOnly) {
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "export type"));
return "skip";
}
break;
- case 253:
+ case 260:
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_TypeScript_files));
return "skip";
- case 259:
+ case 266:
if (node.isExportEquals) {
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.export_can_only_be_used_in_TypeScript_files));
return "skip";
}
break;
- case 279:
+ case 286:
var heritageClause = node;
- if (heritageClause.token === 113) {
+ if (heritageClause.token === 116) {
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.implements_clauses_can_only_be_used_in_TypeScript_files));
return "skip";
}
break;
- case 246:
- var interfaceKeyword = ts.tokenToString(114);
+ case 253:
+ var interfaceKeyword = ts.tokenToString(117);
ts.Debug.assertIsDefined(interfaceKeyword);
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, interfaceKeyword));
return "skip";
- case 249:
- var moduleKeyword = node.flags & 16 ? ts.tokenToString(136) : ts.tokenToString(135);
+ case 256:
+ var moduleKeyword = node.flags & 16 ? ts.tokenToString(140) : ts.tokenToString(139);
ts.Debug.assertIsDefined(moduleKeyword);
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, moduleKeyword));
return "skip";
- case 247:
+ case 254:
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Type_aliases_can_only_be_used_in_TypeScript_files));
return "skip";
- case 248:
- var enumKeyword = ts.Debug.checkDefined(ts.tokenToString(88));
+ case 255:
+ var enumKeyword = ts.Debug.checkDefined(ts.tokenToString(91));
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, enumKeyword));
return "skip";
- case 218:
+ case 225:
diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Non_null_assertions_can_only_be_used_in_TypeScript_files));
return "skip";
- case 217:
+ case 224:
diagnostics.push(createDiagnosticForNode(node.type, ts.Diagnostics.Type_assertion_expressions_can_only_be_used_in_TypeScript_files));
return "skip";
- case 199:
+ case 206:
ts.Debug.fail();
}
}
diagnostics.push(createDiagnosticForNode(parent, ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning));
}
switch (parent.kind) {
- case 245:
- case 214:
- case 161:
- case 162:
- case 163:
- case 164:
- case 201:
- case 244:
- case 202:
+ case 252:
+ case 221:
+ case 165:
+ case 166:
+ case 167:
+ case 168:
+ case 208:
+ case 251:
+ case 209:
if (nodes === parent.typeParameters) {
diagnostics.push(createDiagnosticForNodeArray(nodes, ts.Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files));
return "skip";
}
- case 225:
+ case 232:
if (nodes === parent.modifiers) {
- checkModifiers(parent.modifiers, parent.kind === 225);
+ checkModifiers(parent.modifiers, parent.kind === 232);
return "skip";
}
break;
- case 159:
+ case 163:
if (nodes === parent.modifiers) {
for (var _i = 0, _a = nodes; _i < _a.length; _i++) {
var modifier = _a[_i];
- if (modifier.kind !== 120) {
+ if (modifier.kind !== 123) {
diagnostics.push(createDiagnosticForNode(modifier, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, ts.tokenToString(modifier.kind)));
}
}
return "skip";
}
break;
- case 156:
+ case 160:
if (nodes === parent.modifiers) {
diagnostics.push(createDiagnosticForNodeArray(nodes, ts.Diagnostics.Parameter_modifiers_can_only_be_used_in_TypeScript_files));
return "skip";
}
break;
- case 196:
- case 197:
- case 216:
- case 267:
- case 268:
- case 198:
+ case 203:
+ case 204:
+ case 223:
+ case 274:
+ case 275:
+ case 205:
if (nodes === parent.typeArguments) {
diagnostics.push(createDiagnosticForNodeArray(nodes, ts.Diagnostics.Type_arguments_can_only_be_used_in_TypeScript_files));
return "skip";
}
}
function checkModifiers(modifiers, isConstValid) {
- for (var _i = 0, modifiers_1 = modifiers; _i < modifiers_1.length; _i++) {
- var modifier = modifiers_1[_i];
+ for (var _i = 0, modifiers_2 = modifiers; _i < modifiers_2.length; _i++) {
+ var modifier = modifiers_2[_i];
switch (modifier.kind) {
- case 81:
+ case 84:
if (isConstValid) {
continue;
}
- case 119:
- case 117:
- case 118:
- case 138:
- case 130:
case 122:
+ case 120:
+ case 121:
+ case 142:
+ case 133:
+ case 125:
diagnostics.push(createDiagnosticForNode(modifier, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, ts.tokenToString(modifier.kind)));
break;
- case 120:
- case 89:
- case 84:
+ case 123:
+ case 92:
+ case 87:
}
}
}
});
}
function getAndCacheDiagnostics(sourceFile, cancellationToken, cache, getDiagnostics) {
+ var _a;
var cachedResult = sourceFile
- ? cache.perFile && cache.perFile.get(sourceFile.path)
- : cache.allDiagnostics;
+ ? (_a = cache.perFile) === null || _a === void 0 ? void 0 : _a.get(sourceFile.path) : cache.allDiagnostics;
if (cachedResult) {
return cachedResult;
}
var result = getDiagnostics(sourceFile, cancellationToken);
if (sourceFile) {
- if (!cache.perFile) {
- cache.perFile = ts.createMap();
- }
- cache.perFile.set(sourceFile.path, result);
+ (cache.perFile || (cache.perFile = new ts.Map())).set(sourceFile.path, result);
}
else {
cache.allDiagnostics = result;
}
var diagnostics = programDiagnostics.getDiagnostics(options.configFile.fileName);
forEachResolvedProjectReference(function (resolvedRef) {
- if (resolvedRef) {
- diagnostics = ts.concatenate(diagnostics, programDiagnostics.getDiagnostics(resolvedRef.sourceFile.fileName));
- }
+ diagnostics = ts.concatenate(diagnostics, programDiagnostics.getDiagnostics(resolvedRef.sourceFile.fileName));
});
return diagnostics;
}
return a.fileName === b.fileName;
}
function moduleNameIsEqualTo(a, b) {
- return a.kind === 75
- ? b.kind === 75 && a.escapedText === b.escapedText
+ return a.kind === 78
+ ? b.kind === 78 && a.escapedText === b.escapedText
: b.kind === 10 && a.text === b.text;
}
+ function createSyntheticImport(text, file) {
+ var externalHelpersModuleReference = ts.factory.createStringLiteral(text);
+ var importDecl = ts.factory.createImportDeclaration(undefined, undefined, undefined, externalHelpersModuleReference);
+ ts.addEmitFlags(importDecl, 67108864);
+ ts.setParent(externalHelpersModuleReference, importDecl);
+ ts.setParent(importDecl, file);
+ externalHelpersModuleReference.flags &= ~8;
+ importDecl.flags &= ~8;
+ return externalHelpersModuleReference;
+ }
function collectExternalModuleReferences(file) {
if (file.imports) {
return;
var imports;
var moduleAugmentations;
var ambientModules;
- if (options.importHelpers
- && (options.isolatedModules || isExternalModuleFile)
+ if ((options.isolatedModules || isExternalModuleFile)
&& !file.isDeclarationFile) {
- var externalHelpersModuleReference = ts.createLiteral(ts.externalHelpersModuleNameText);
- var importDecl = ts.createImportDeclaration(undefined, undefined, undefined, externalHelpersModuleReference);
- ts.addEmitFlags(importDecl, 67108864);
- externalHelpersModuleReference.parent = importDecl;
- importDecl.parent = file;
- imports = [externalHelpersModuleReference];
+ if (options.importHelpers) {
+ imports = [createSyntheticImport(ts.externalHelpersModuleNameText, file)];
+ }
+ var jsxImport = ts.getJSXRuntimeImport(ts.getJSXImplicitImportBase(options, file), options);
+ if (jsxImport) {
+ (imports || (imports = [])).push(createSyntheticImport(jsxImport, file));
+ }
}
for (var _i = 0, _a = file.statements; _i < _a.length; _i++) {
var node = _a[_i];
}
}
else if (ts.isModuleDeclaration(node)) {
- if (ts.isAmbientModule(node) && (inAmbientModule || ts.hasModifier(node, 2) || file.isDeclarationFile)) {
+ if (ts.isAmbientModule(node) && (inAmbientModule || ts.hasSyntacticModifier(node, 2) || file.isDeclarationFile)) {
var nameText = ts.getTextOfIdentifierOrLiteral(node.name);
if (isExternalModuleFile || (inAmbientModule && !ts.isExternalModuleNameRelative(nameText))) {
(moduleAugmentations || (moduleAugmentations = [])).push(node.name);
var r = /import|require/g;
while (r.exec(file.text) !== null) {
var node = getNodeAtPosition(file, r.lastIndex);
- if (ts.isRequireCall(node, true)) {
+ if (isJavaScriptFile && ts.isRequireCall(node, true)) {
imports = ts.append(imports, node.arguments[0]);
}
else if (ts.isImportCall(node) && node.arguments.length === 1 && ts.isStringLiteralLike(node.arguments[0])) {
return redirect;
}
function findSourceFile(fileName, path, isDefaultLib, ignoreNoDefaultLib, refFile, packageId) {
+ ts.tracing.push("program", "findSourceFile", {
+ fileName: fileName,
+ isDefaultLib: isDefaultLib || undefined,
+ refKind: refFile ? ts.RefFileKind[refFile.kind] : undefined,
+ });
+ var result = findSourceFileWorker(fileName, path, isDefaultLib, ignoreNoDefaultLib, refFile, packageId);
+ ts.tracing.pop();
+ return result;
+ }
+ function findSourceFileWorker(fileName, path, isDefaultLib, ignoreNoDefaultLib, refFile, packageId) {
if (useSourceOfProjectReferenceRedirect) {
var source = getSourceOfProjectReferenceRedirect(fileName);
if (!source &&
if (refFile && !useSourceOfProjectReferenceRedirect) {
var redirectProject = getProjectReferenceRedirectProject(fileName);
if (redirectProject) {
- if (redirectProject.commandLine.options.outFile || redirectProject.commandLine.options.out) {
+ if (ts.outFile(redirectProject.commandLine.options)) {
return undefined;
}
var redirect = getProjectReferenceOutputName(redirectProject, fileName);
return getResolvedProjectReferenceToRedirect(fileName);
}
function getProjectReferenceOutputName(referencedProject, fileName) {
- var out = referencedProject.commandLine.options.outFile || referencedProject.commandLine.options.out;
+ var out = ts.outFile(referencedProject.commandLine.options);
return out ?
ts.changeExtension(out, ".d.ts") :
ts.getOutputDeclarationFileName(fileName, referencedProject.commandLine, !host.useCaseSensitiveFileNames());
}
function getResolvedProjectReferenceToRedirect(fileName) {
if (mapFromFileToProjectReferenceRedirects === undefined) {
- mapFromFileToProjectReferenceRedirects = ts.createMap();
- forEachResolvedProjectReference(function (referencedProject, referenceProjectPath) {
- if (referencedProject &&
- toPath(options.configFilePath) !== referenceProjectPath) {
+ mapFromFileToProjectReferenceRedirects = new ts.Map();
+ forEachResolvedProjectReference(function (referencedProject) {
+ if (toPath(options.configFilePath) !== referencedProject.sourceFile.path) {
referencedProject.commandLine.fileNames.forEach(function (f) {
- return mapFromFileToProjectReferenceRedirects.set(toPath(f), referenceProjectPath);
+ return mapFromFileToProjectReferenceRedirects.set(toPath(f), referencedProject.sourceFile.path);
});
}
});
return referencedProjectPath && getResolvedProjectReferenceByPath(referencedProjectPath);
}
function forEachResolvedProjectReference(cb) {
- return forEachProjectReference(projectReferences, resolvedProjectReferences, function (resolvedRef, index, parent) {
- var ref = (parent ? parent.commandLine.projectReferences : projectReferences)[index];
- var resolvedRefPath = toPath(resolveProjectReferencePath(ref));
- return cb(resolvedRef, resolvedRefPath);
- });
+ return ts.forEachResolvedProjectReference(resolvedProjectReferences, cb);
}
function getSourceOfProjectReferenceRedirect(file) {
if (!ts.isDeclarationFileName(file))
return undefined;
if (mapFromToProjectReferenceRedirectSource === undefined) {
- mapFromToProjectReferenceRedirectSource = ts.createMap();
+ mapFromToProjectReferenceRedirectSource = new ts.Map();
forEachResolvedProjectReference(function (resolvedRef) {
- if (resolvedRef) {
- var out = resolvedRef.commandLine.options.outFile || resolvedRef.commandLine.options.out;
- if (out) {
- var outputDts = ts.changeExtension(out, ".d.ts");
- mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), true);
- }
- else {
- ts.forEach(resolvedRef.commandLine.fileNames, function (fileName) {
- if (!ts.fileExtensionIs(fileName, ".d.ts") && !ts.fileExtensionIs(fileName, ".json")) {
- var outputDts = ts.getOutputDeclarationFileName(fileName, resolvedRef.commandLine, host.useCaseSensitiveFileNames());
- mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), fileName);
- }
- });
- }
+ var out = ts.outFile(resolvedRef.commandLine.options);
+ if (out) {
+ var outputDts = ts.changeExtension(out, ".d.ts");
+ mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), true);
+ }
+ else {
+ ts.forEach(resolvedRef.commandLine.fileNames, function (fileName) {
+ if (!ts.fileExtensionIs(fileName, ".d.ts") && !ts.fileExtensionIs(fileName, ".json")) {
+ var outputDts = ts.getOutputDeclarationFileName(fileName, resolvedRef.commandLine, host.useCaseSensitiveFileNames());
+ mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), fileName);
+ }
+ });
}
});
}
function isSourceOfProjectReferenceRedirect(fileName) {
return useSourceOfProjectReferenceRedirect && !!getResolvedProjectReferenceToRedirect(fileName);
}
- function forEachProjectReference(projectReferences, resolvedProjectReferences, cbResolvedRef, cbRef) {
- var seenResolvedRefs;
- return worker(projectReferences, resolvedProjectReferences, undefined, cbResolvedRef, cbRef);
- function worker(projectReferences, resolvedProjectReferences, parent, cbResolvedRef, cbRef) {
- if (cbRef) {
- var result = cbRef(projectReferences, parent);
- if (result) {
- return result;
- }
- }
- return ts.forEach(resolvedProjectReferences, function (resolvedRef, index) {
- if (ts.contains(seenResolvedRefs, resolvedRef)) {
- return undefined;
- }
- var result = cbResolvedRef(resolvedRef, index, parent);
- if (result) {
- return result;
- }
- if (!resolvedRef)
- return undefined;
- (seenResolvedRefs || (seenResolvedRefs = [])).push(resolvedRef);
- return worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef, cbResolvedRef, cbRef);
- });
- }
- }
function getResolvedProjectReferenceByPath(projectReferencePath) {
if (!projectReferenceRedirects) {
return undefined;
}
function processReferencedFiles(file, isDefaultLib) {
ts.forEach(file.referencedFiles, function (ref, index) {
- var referencedFileName = resolveTripleslashReference(ref.fileName, file.originalFileName);
+ var referencedFileName = resolveTripleslashReference(ref.fileName, file.fileName);
processSourceFile(referencedFileName, isDefaultLib, false, undefined, {
kind: ts.RefFileKind.ReferenceFile,
index: index,
if (!typeDirectives) {
return;
}
- var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file.originalFileName, getResolvedProjectReferenceToRedirect(file.originalFileName));
+ var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file);
for (var i = 0; i < typeDirectives.length; i++) {
var ref = file.typeReferenceDirectives[i];
var resolvedTypeReferenceDirective = resolutions[i];
}
}
function processTypeReferenceDirective(typeReferenceDirective, resolvedTypeReferenceDirective, refFile) {
+ ts.tracing.push("program", "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: refFile === null || refFile === void 0 ? void 0 : refFile.kind, refPath: refFile === null || refFile === void 0 ? void 0 : refFile.file.path });
+ processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, refFile);
+ ts.tracing.pop();
+ }
+ function processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, refFile) {
var previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective);
if (previousResolution && previousResolution.primary) {
return;
collectExternalModuleReferences(file);
if (file.imports.length || file.moduleAugmentations.length) {
var moduleNames = getModuleNames(file);
- var resolutions = resolveModuleNamesReusingOldState(moduleNames, ts.getNormalizedAbsolutePath(file.originalFileName, currentDirectory), file);
+ var resolutions = resolveModuleNamesReusingOldState(moduleNames, file);
ts.Debug.assert(resolutions.length === moduleNames.length);
for (var i = 0; i < moduleNames.length; i++) {
var resolution = resolutions[i];
&& !options.noResolve
&& i < file.imports.length
&& !elideImport
- && !(isJsFile && !options.allowJs)
+ && !(isJsFile && !ts.getAllowJSCompilerOption(options))
&& (ts.isInJSFile(file.imports[i]) || !(file.imports[i].flags & 4194304));
if (elideImport) {
modulesWithElidedImports.set(file.path, true);
var absoluteSourceFilePath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
if (!rootPaths)
- rootPaths = ts.arrayToSet(rootNames, toPath);
+ rootPaths = new ts.Set(rootNames.map(toPath));
addProgramDiagnosticAtRefPath(sourceFile, rootPaths, ts.Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files, sourceFile.fileName, rootDirectory);
allFilesBelongToPath = false;
}
}
function parseProjectReferenceConfigFile(ref) {
if (!projectReferenceRedirects) {
- projectReferenceRedirects = ts.createMap();
+ projectReferenceRedirects = new ts.Map();
}
var refPath = resolveProjectReferencePath(ref);
var sourceFilePath = toPath(refPath);
createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "mapRoot", "inlineSourceMap");
}
}
- if (options.paths && options.baseUrl === undefined) {
- createDiagnosticForOptionName(ts.Diagnostics.Option_paths_cannot_be_used_without_specifying_baseUrl_option, "paths");
- }
if (options.composite) {
if (options.declaration === false) {
createDiagnosticForOptionName(ts.Diagnostics.Composite_projects_may_not_disable_declaration_emit, "declaration");
createDiagnosticForOptionName(ts.Diagnostics.Composite_projects_may_not_disable_incremental_compilation, "declaration");
}
}
+ var outputFile = ts.outFile(options);
if (options.tsBuildInfoFile) {
if (!ts.isIncrementalCompilation(options)) {
createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "tsBuildInfoFile", "incremental", "composite");
}
}
- else if (options.incremental && !options.outFile && !options.out && !options.configFilePath) {
+ else if (options.incremental && !outputFile && !options.configFilePath) {
programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified));
}
- if (!options.listFilesOnly && options.noEmit && ts.isIncrementalCompilation(options)) {
- createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "noEmit", options.incremental ? "incremental" : "composite");
- }
verifyProjectReferences();
if (options.composite) {
- var rootPaths = ts.arrayToSet(rootNames, toPath);
+ var rootPaths = new ts.Set(rootNames.map(toPath));
for (var _i = 0, files_3 = files; _i < files_3.length; _i++) {
var file = files_3[_i];
if (ts.sourceFileMayBeEmitted(file, program) && !rootPaths.has(file.path)) {
if (!ts.hasZeroOrOneAsteriskCharacter(subst)) {
createDiagnosticForOptionPathKeyValue(key, i, ts.Diagnostics.Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character, subst, key);
}
+ if (!options.baseUrl && !ts.pathIsRelative(subst) && !ts.pathIsAbsolute(subst)) {
+ createDiagnosticForOptionPathKeyValue(key, i, ts.Diagnostics.Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash);
+ }
}
else {
createDiagnosticForOptionPathKeyValue(key, i, ts.Diagnostics.Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2, subst, key, typeOfSubst);
if (!ts.getEmitDeclarations(options)) {
createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationDir", "declaration", "composite");
}
- if (options.out || options.outFile) {
+ if (outputFile) {
createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "declarationDir", options.out ? "out" : "outFile");
}
}
createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict");
}
var languageVersion = options.target || 0;
- var outFile = options.outFile || options.out;
var firstNonAmbientExternalModuleSourceFile = ts.find(files, function (f) { return ts.isExternalModule(f) && !f.isDeclarationFile; });
if (options.isolatedModules) {
if (options.module === ts.ModuleKind.None && languageVersion < 2) {
var firstNonExternalModuleSourceFile = ts.find(files, function (f) { return !ts.isExternalModule(f) && !ts.isSourceFileJS(f) && !f.isDeclarationFile && f.scriptKind !== 6; });
if (firstNonExternalModuleSourceFile) {
var span = ts.getErrorSpanForNode(firstNonExternalModuleSourceFile, firstNonExternalModuleSourceFile);
- programDiagnostics.add(ts.createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.All_files_must_be_modules_when_the_isolatedModules_flag_is_provided));
+ programDiagnostics.add(ts.createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, ts.Diagnostics._0_cannot_be_compiled_under_isolatedModules_because_it_is_considered_a_global_script_file_Add_an_import_export_or_an_empty_export_statement_to_make_it_a_module, ts.getBaseFileName(firstNonExternalModuleSourceFile.fileName)));
}
}
else if (firstNonAmbientExternalModuleSourceFile && languageVersion < 2 && options.module === ts.ModuleKind.None) {
var span = ts.getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
programDiagnostics.add(ts.createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
}
- if (outFile && !options.emitDeclarationOnly) {
+ if (outputFile && !options.emitDeclarationOnly) {
if (options.module && !(options.module === ts.ModuleKind.AMD || options.module === ts.ModuleKind.System)) {
createDiagnosticForOptionName(ts.Diagnostics.Only_amd_and_system_modules_are_supported_alongside_0, options.out ? "out" : "outFile", "module");
}
if (options.useDefineForClassFields && languageVersion === 0) {
createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_target_is_ES3, "useDefineForClassFields");
}
- if (options.checkJs && !options.allowJs) {
+ if (options.checkJs && !ts.getAllowJSCompilerOption(options)) {
programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "checkJs", "allowJs"));
}
if (options.emitDeclarationOnly) {
if (options.reactNamespace) {
createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "reactNamespace", "jsxFactory");
}
+ if (options.jsx === 4 || options.jsx === 5) {
+ createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFactory", ts.inverseJsxOptionMap.get("" + options.jsx));
+ }
if (!ts.parseIsolatedEntityName(options.jsxFactory, languageVersion)) {
createOptionValueDiagnostic("jsxFactory", ts.Diagnostics.Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name, options.jsxFactory);
}
else if (options.reactNamespace && !ts.isIdentifierText(options.reactNamespace, languageVersion)) {
createOptionValueDiagnostic("reactNamespace", ts.Diagnostics.Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier, options.reactNamespace);
}
+ if (options.jsxFragmentFactory) {
+ if (!options.jsxFactory) {
+ createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "jsxFragmentFactory", "jsxFactory");
+ }
+ if (options.jsx === 4 || options.jsx === 5) {
+ createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFragmentFactory", ts.inverseJsxOptionMap.get("" + options.jsx));
+ }
+ if (!ts.parseIsolatedEntityName(options.jsxFragmentFactory, languageVersion)) {
+ createOptionValueDiagnostic("jsxFragmentFactory", ts.Diagnostics.Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name, options.jsxFragmentFactory);
+ }
+ }
+ if (options.reactNamespace) {
+ if (options.jsx === 4 || options.jsx === 5) {
+ createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "reactNamespace", ts.inverseJsxOptionMap.get("" + options.jsx));
+ }
+ }
+ if (options.jsxImportSource) {
+ if (options.jsx === 2) {
+ createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxImportSource", ts.inverseJsxOptionMap.get("" + options.jsx));
+ }
+ }
if (!options.noEmit && !options.suppressOutputPathCheck) {
var emitHost = getEmitHost();
- var emitFilesSeen_1 = ts.createMap();
+ var emitFilesSeen_1 = new ts.Set();
ts.forEachEmittedFile(emitHost, function (emitFileNames) {
if (!options.emitDeclarationOnly) {
verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen_1);
blockEmittingOfFile(emitFileName, ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files, emitFileName));
}
else {
- emitFilesSeen.set(emitFileKey, true);
+ emitFilesSeen.add(emitFileKey);
}
}
}
for (var _i = 3; _i < arguments.length; _i++) {
args[_i - 3] = arguments[_i];
}
- var refPaths = refFileMap && refFileMap.get(file.path);
+ var refPaths = refFileMap === null || refFileMap === void 0 ? void 0 : refFileMap.get(file.path);
var refPathToReportErrorOn = ts.forEach(refPaths, function (refPath) { return rootPaths.has(refPath.file) ? refPath : undefined; }) ||
ts.elementAt(refPaths, 0);
programDiagnostics.add(refPathToReportErrorOn ? createFileDiagnosticAtReference.apply(void 0, __spreadArrays([refPathToReportErrorOn, message], args)) : ts.createCompilerDiagnostic.apply(void 0, __spreadArrays([message], args)));
}
function verifyProjectReferences() {
- var buildInfoPath = !options.noEmit && !options.suppressOutputPathCheck ? ts.getTsBuildInfoEmitOutputFilePath(options) : undefined;
- forEachProjectReference(projectReferences, resolvedProjectReferences, function (resolvedRef, index, parent) {
+ var buildInfoPath = !options.suppressOutputPathCheck ? ts.getTsBuildInfoEmitOutputFilePath(options) : undefined;
+ forEachProjectReference(projectReferences, resolvedProjectReferences, function (resolvedRef, parent, index) {
var ref = (parent ? parent.commandLine.projectReferences : projectReferences)[index];
var parentFile = parent && parent.sourceFile;
if (!resolvedRef) {
return;
}
var options = resolvedRef.commandLine.options;
- if (!options.composite) {
+ if (!options.composite || options.noEmit) {
var inputs = parent ? parent.commandLine.fileNames : rootNames;
if (inputs.length) {
- createDiagnosticForReference(parentFile, index, ts.Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path);
+ if (!options.composite)
+ createDiagnosticForReference(parentFile, index, ts.Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path);
+ if (options.noEmit)
+ createDiagnosticForReference(parentFile, index, ts.Diagnostics.Referenced_project_0_may_not_disable_emit, ref.path);
}
}
if (ref.prepend) {
- var out = options.outFile || options.out;
+ var out = ts.outFile(options);
if (out) {
if (!host.fileExists(out)) {
createDiagnosticForReference(parentFile, index, ts.Diagnostics.Output_file_0_from_project_1_does_not_exist, out, ref.path);
if (getSourceFileByPath(filePath)) {
return false;
}
- var out = options.outFile || options.out;
+ var out = ts.outFile(options);
if (out) {
return isSameFile(filePath, out) || isSameFile(filePath, ts.removeFileExtension(out) + ".d.ts");
}
function isSameFile(file1, file2) {
return ts.comparePaths(file1, file2, currentDirectory, !host.useCaseSensitiveFileNames()) === 0;
}
- function getProbableSymlinks() {
- if (host.getSymlinks) {
- return host.getSymlinks();
+ function getSymlinkCache() {
+ if (host.getSymlinkCache) {
+ return host.getSymlinkCache();
}
return symlinks || (symlinks = ts.discoverProbableSymlinks(files, getCanonicalFileName, host.getCurrentDirectory()));
}
}
ts.createProgram = createProgram;
function updateHostForUseSourceOfProjectReferenceRedirect(host) {
- var mapOfDeclarationDirectories;
- var symlinkedDirectories;
- var symlinkedFiles;
+ var setOfDeclarationDirectories;
var originalFileExists = host.compilerHost.fileExists;
var originalDirectoryExists = host.compilerHost.directoryExists;
var originalGetDirectories = host.compilerHost.getDirectories;
if (!host.useSourceOfProjectReferenceRedirect)
return { onProgramCreateComplete: ts.noop, fileExists: fileExists };
host.compilerHost.fileExists = fileExists;
+ var directoryExists;
if (originalDirectoryExists) {
- host.compilerHost.directoryExists = function (path) {
+ directoryExists = host.compilerHost.directoryExists = function (path) {
if (originalDirectoryExists.call(host.compilerHost, path)) {
handleDirectoryCouldBeSymlink(path);
return true;
}
if (!host.getResolvedProjectReferences())
return false;
- if (!mapOfDeclarationDirectories) {
- mapOfDeclarationDirectories = ts.createMap();
+ if (!setOfDeclarationDirectories) {
+ setOfDeclarationDirectories = new ts.Set();
host.forEachResolvedProjectReference(function (ref) {
- if (!ref)
- return;
- var out = ref.commandLine.options.outFile || ref.commandLine.options.out;
+ var out = ts.outFile(ref.commandLine.options);
if (out) {
- mapOfDeclarationDirectories.set(ts.getDirectoryPath(host.toPath(out)), true);
+ setOfDeclarationDirectories.add(ts.getDirectoryPath(host.toPath(out)));
}
else {
var declarationDir = ref.commandLine.options.declarationDir || ref.commandLine.options.outDir;
if (declarationDir) {
- mapOfDeclarationDirectories.set(host.toPath(declarationDir), true);
+ setOfDeclarationDirectories.add(host.toPath(declarationDir));
}
}
});
}
if (originalRealpath) {
host.compilerHost.realpath = function (s) {
- return (symlinkedFiles === null || symlinkedFiles === void 0 ? void 0 : symlinkedFiles.get(host.toPath(s))) ||
+ var _a;
+ return ((_a = host.getSymlinkCache().getSymlinkedFiles()) === null || _a === void 0 ? void 0 : _a.get(host.toPath(s))) ||
originalRealpath.call(host.compilerHost, s);
};
}
- return { onProgramCreateComplete: onProgramCreateComplete, fileExists: fileExists };
+ return { onProgramCreateComplete: onProgramCreateComplete, fileExists: fileExists, directoryExists: directoryExists };
function onProgramCreateComplete() {
host.compilerHost.fileExists = originalFileExists;
host.compilerHost.directoryExists = originalDirectoryExists;
function directoryExistsIfProjectReferenceDeclDir(dir) {
var dirPath = host.toPath(dir);
var dirPathWithTrailingDirectorySeparator = "" + dirPath + ts.directorySeparator;
- return ts.forEachKey(mapOfDeclarationDirectories, function (declDirPath) { return dirPath === declDirPath ||
+ return ts.forEachKey(setOfDeclarationDirectories, function (declDirPath) { return dirPath === declDirPath ||
ts.startsWith(declDirPath, dirPathWithTrailingDirectorySeparator) ||
ts.startsWith(dirPath, declDirPath + "/"); });
}
function handleDirectoryCouldBeSymlink(directory) {
+ var _a;
if (!host.getResolvedProjectReferences())
return;
if (!originalRealpath || !ts.stringContains(directory, ts.nodeModulesPathPart))
return;
- if (!symlinkedDirectories)
- symlinkedDirectories = ts.createMap();
+ var symlinkCache = host.getSymlinkCache();
var directoryPath = ts.ensureTrailingDirectorySeparator(host.toPath(directory));
- if (symlinkedDirectories.has(directoryPath))
+ if ((_a = symlinkCache.getSymlinkedDirectories()) === null || _a === void 0 ? void 0 : _a.has(directoryPath))
return;
var real = ts.normalizePath(originalRealpath.call(host.compilerHost, directory));
var realPath;
if (real === directory ||
(realPath = ts.ensureTrailingDirectorySeparator(host.toPath(real))) === directoryPath) {
- symlinkedDirectories.set(directoryPath, false);
+ symlinkCache.setSymlinkedDirectory(directoryPath, false);
return;
}
- symlinkedDirectories.set(directoryPath, {
+ symlinkCache.setSymlinkedDirectory(directoryPath, {
real: ts.ensureTrailingDirectorySeparator(real),
realPath: realPath
});
}
function fileOrDirectoryExistsUsingSource(fileOrDirectory, isFile) {
+ var _a;
var fileOrDirectoryExistsUsingSource = isFile ?
function (file) { return fileExistsIfProjectReferenceDts(file); } :
function (dir) { return directoryExistsIfProjectReferenceDeclDir(dir); };
var result = fileOrDirectoryExistsUsingSource(fileOrDirectory);
if (result !== undefined)
return result;
+ var symlinkCache = host.getSymlinkCache();
+ var symlinkedDirectories = symlinkCache.getSymlinkedDirectories();
if (!symlinkedDirectories)
return false;
var fileOrDirectoryPath = host.toPath(fileOrDirectory);
if (!ts.stringContains(fileOrDirectoryPath, ts.nodeModulesPathPart))
return false;
- if (isFile && symlinkedFiles && symlinkedFiles.has(fileOrDirectoryPath))
+ if (isFile && ((_a = symlinkCache.getSymlinkedFiles()) === null || _a === void 0 ? void 0 : _a.has(fileOrDirectoryPath)))
return true;
return ts.firstDefinedIterator(symlinkedDirectories.entries(), function (_a) {
var directoryPath = _a[0], symlinkedDirectory = _a[1];
return undefined;
var result = fileOrDirectoryExistsUsingSource(fileOrDirectoryPath.replace(directoryPath, symlinkedDirectory.realPath));
if (isFile && result) {
- if (!symlinkedFiles)
- symlinkedFiles = ts.createMap();
var absolutePath = ts.getNormalizedAbsolutePath(fileOrDirectory, host.compilerHost.getCurrentDirectory());
- symlinkedFiles.set(fileOrDirectoryPath, "" + symlinkedDirectory.real + absolutePath.replace(new RegExp(directoryPath, "i"), ""));
+ symlinkCache.setSymlinkedFile(fileOrDirectoryPath, "" + symlinkedDirectory.real + absolutePath.replace(new RegExp(directoryPath, "i"), ""));
}
return result;
}) || false;
}
}
- function handleNoEmitOptions(program, sourceFile, cancellationToken) {
+ ts.emitSkippedWithNoDiagnostics = { diagnostics: ts.emptyArray, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true };
+ function handleNoEmitOptions(program, sourceFile, writeFile, cancellationToken) {
var options = program.getCompilerOptions();
if (options.noEmit) {
- return { diagnostics: ts.emptyArray, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true };
+ program.getSemanticDiagnostics(sourceFile, cancellationToken);
+ return sourceFile || ts.outFile(options) ?
+ ts.emitSkippedWithNoDiagnostics :
+ program.emitBuildInfo(writeFile, cancellationToken);
}
if (!options.noEmitOnError)
return undefined;
if (diagnostics.length === 0 && ts.getEmitDeclarations(program.getCompilerOptions())) {
diagnostics = program.getDeclarationDiagnostics(undefined, cancellationToken);
}
- return diagnostics.length > 0 ?
- { diagnostics: diagnostics, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true } :
- undefined;
+ if (!diagnostics.length)
+ return undefined;
+ var emittedFiles;
+ if (!sourceFile && !ts.outFile(options)) {
+ var emitResult = program.emitBuildInfo(writeFile, cancellationToken);
+ if (emitResult.diagnostics)
+ diagnostics = __spreadArrays(diagnostics, emitResult.diagnostics);
+ emittedFiles = emitResult.emittedFiles;
+ }
+ return { diagnostics: diagnostics, sourceMaps: undefined, emittedFiles: emittedFiles, emitSkipped: true };
}
ts.handleNoEmitOptions = handleNoEmitOptions;
+ function filterSemanticDiagnotics(diagnostic, option) {
+ return ts.filter(diagnostic, function (d) { return !d.skippedOn || !option[d.skippedOn]; });
+ }
+ ts.filterSemanticDiagnotics = filterSemanticDiagnotics;
function parseConfigHostFromCompilerHostLike(host, directoryStructureHost) {
if (directoryStructureHost === void 0) { directoryStructureHost = host; }
return {
var ref = projectReferences[i];
var resolvedRefOpts = getCommandLine(ref, i);
if (ref.prepend && resolvedRefOpts && resolvedRefOpts.options) {
- var out = resolvedRefOpts.options.outFile || resolvedRefOpts.options.out;
+ var out = ts.outFile(resolvedRefOpts.options);
if (!out)
continue;
var _a = ts.getOutputPathsForBundle(resolvedRefOpts.options, true), jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath, buildInfoPath = _a.buildInfoPath;
return options.jsx ? undefined : ts.Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set;
}
function needAllowJs() {
- return options.allowJs || !ts.getStrictOptionValue(options, "noImplicitAny") ? undefined : ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type;
+ return ts.getAllowJSCompilerOption(options) || !ts.getStrictOptionValue(options, "noImplicitAny") ? undefined : ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type;
}
function needResolveJsonModule() {
return options.resolveJsonModule ? undefined : ts.Diagnostics.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used;
}
}
function addReferencedFile(referencedPath) {
- if (!referencedFiles) {
- referencedFiles = ts.createMap();
- }
- referencedFiles.set(referencedPath, true);
+ (referencedFiles || (referencedFiles = new ts.Set())).add(referencedPath);
}
}
function canReuseOldState(newReferencedMap, oldState) {
}
BuilderState.canReuseOldState = canReuseOldState;
function create(newProgram, getCanonicalFileName, oldState) {
- var fileInfos = ts.createMap();
- var referencedMap = newProgram.getCompilerOptions().module !== ts.ModuleKind.None ? ts.createMap() : undefined;
- var exportedModulesMap = referencedMap ? ts.createMap() : undefined;
- var hasCalledUpdateShapeSignature = ts.createMap();
+ var fileInfos = new ts.Map();
+ var referencedMap = newProgram.getCompilerOptions().module !== ts.ModuleKind.None ? new ts.Map() : undefined;
+ var exportedModulesMap = referencedMap ? new ts.Map() : undefined;
+ var hasCalledUpdateShapeSignature = new ts.Set();
var useOldState = canReuseOldState(referencedMap, oldState);
+ newProgram.getTypeChecker();
for (var _i = 0, _a = newProgram.getSourceFiles(); _i < _a.length; _i++) {
var sourceFile = _a[_i];
- var version_1 = ts.Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set");
+ var version_2 = ts.Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set");
var oldInfo = useOldState ? oldState.fileInfos.get(sourceFile.resolvedPath) : undefined;
if (referencedMap) {
var newReferences = getReferencedFiles(newProgram, sourceFile, getCanonicalFileName);
}
}
}
- fileInfos.set(sourceFile.resolvedPath, { version: version_1, signature: oldInfo && oldInfo.signature, affectsGlobalScope: isFileAffectingGlobalScope(sourceFile) });
+ fileInfos.set(sourceFile.resolvedPath, { version: version_2, signature: oldInfo && oldInfo.signature, affectsGlobalScope: isFileAffectingGlobalScope(sourceFile) });
}
return {
fileInfos: fileInfos,
}
BuilderState.releaseCache = releaseCache;
function clone(state) {
- var fileInfos = ts.createMap();
- state.fileInfos.forEach(function (value, key) {
- fileInfos.set(key, __assign({}, value));
- });
return {
- fileInfos: fileInfos,
- referencedMap: cloneMapOrUndefined(state.referencedMap),
- exportedModulesMap: cloneMapOrUndefined(state.exportedModulesMap),
- hasCalledUpdateShapeSignature: ts.cloneMap(state.hasCalledUpdateShapeSignature),
+ fileInfos: new ts.Map(state.fileInfos),
+ referencedMap: state.referencedMap && new ts.Map(state.referencedMap),
+ exportedModulesMap: state.exportedModulesMap && new ts.Map(state.exportedModulesMap),
+ hasCalledUpdateShapeSignature: new ts.Set(state.hasCalledUpdateShapeSignature),
};
}
BuilderState.clone = clone;
function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash, cacheToUpdateSignature, exportedModulesMapCache) {
- var signatureCache = cacheToUpdateSignature || ts.createMap();
+ var signatureCache = cacheToUpdateSignature || new ts.Map();
var sourceFile = programOfThisState.getSourceFileByPath(path);
if (!sourceFile) {
return ts.emptyArray;
BuilderState.updateSignaturesFromCache = updateSignaturesFromCache;
function updateSignatureOfFile(state, signature, path) {
state.fileInfos.get(path).signature = signature;
- state.hasCalledUpdateShapeSignature.set(path, true);
+ state.hasCalledUpdateShapeSignature.add(path);
}
BuilderState.updateSignatureOfFile = updateSignatureOfFile;
function updateShapeSignature(state, programOfThisState, sourceFile, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache) {
emitOutput_1.outputFiles.length > 0 ? emitOutput_1.outputFiles[0] : undefined;
if (firstDts_1) {
ts.Debug.assert(ts.fileExtensionIs(firstDts_1.name, ".d.ts"), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); });
- latestSignature = computeHash(firstDts_1.text);
+ latestSignature = (computeHash || ts.generateDjb2Hash)(firstDts_1.text);
if (exportedModulesMapCache && latestSignature !== prevSignature) {
updateExportedModules(sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
}
function addExportedModule(exportedModulePath) {
if (exportedModulePath) {
if (!exportedModules) {
- exportedModules = ts.createMap();
+ exportedModules = new ts.Set();
}
- exportedModules.set(exportedModulePath, true);
+ exportedModules.add(exportedModulePath);
}
}
}
BuilderState.updateExportedFilesMapFromCache = updateExportedFilesMapFromCache;
function getAllDependencies(state, programOfThisState, sourceFile) {
var compilerOptions = programOfThisState.getCompilerOptions();
- if (compilerOptions.outFile || compilerOptions.out) {
+ if (ts.outFile(compilerOptions)) {
return getAllFileNames(state, programOfThisState);
}
if (!state.referencedMap || isFileAffectingGlobalScope(sourceFile)) {
return getAllFileNames(state, programOfThisState);
}
- var seenMap = ts.createMap();
+ var seenMap = new ts.Set();
var queue = [sourceFile.resolvedPath];
while (queue.length) {
var path = queue.pop();
if (!seenMap.has(path)) {
- seenMap.set(path, true);
+ seenMap.add(path);
var references = state.referencedMap.get(path);
if (references) {
var iterator = references.keys();
}
}
}
- return ts.arrayFrom(ts.mapDefinedIterator(seenMap.keys(), function (path) {
- var file = programOfThisState.getSourceFileByPath(path);
- return file ? file.fileName : path;
- }));
+ return ts.arrayFrom(ts.mapDefinedIterator(seenMap.keys(), function (path) { var _a, _b; return (_b = (_a = programOfThisState.getSourceFileByPath(path)) === null || _a === void 0 ? void 0 : _a.fileName) !== null && _b !== void 0 ? _b : path; }));
}
BuilderState.getAllDependencies = getAllDependencies;
function getAllFileNames(state, programOfThisState) {
BuilderState.getAllFilesExcludingDefaultLibraryFile = getAllFilesExcludingDefaultLibraryFile;
function getFilesAffectedByUpdatedShapeWhenNonModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape) {
var compilerOptions = programOfThisState.getCompilerOptions();
- if (compilerOptions && (compilerOptions.out || compilerOptions.outFile)) {
+ if (compilerOptions && ts.outFile(compilerOptions)) {
return [sourceFileWithUpdatedShape];
}
return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
}
var compilerOptions = programOfThisState.getCompilerOptions();
- if (compilerOptions && (compilerOptions.isolatedModules || compilerOptions.out || compilerOptions.outFile)) {
+ if (compilerOptions && (compilerOptions.isolatedModules || ts.outFile(compilerOptions))) {
return [sourceFileWithUpdatedShape];
}
- var seenFileNamesMap = ts.createMap();
+ var seenFileNamesMap = new ts.Map();
seenFileNamesMap.set(sourceFileWithUpdatedShape.resolvedPath, sourceFileWithUpdatedShape);
var queue = getReferencedByPaths(state, sourceFileWithUpdatedShape.resolvedPath);
while (queue.length > 0) {
return ts.arrayFrom(ts.mapDefinedIterator(seenFileNamesMap.values(), function (value) { return value; }));
}
})(BuilderState = ts.BuilderState || (ts.BuilderState = {}));
- function cloneMapOrUndefined(map) {
- return map ? ts.cloneMap(map) : undefined;
- }
- ts.cloneMapOrUndefined = cloneMapOrUndefined;
})(ts || (ts = {}));
var ts;
(function (ts) {
state.program = newProgram;
var compilerOptions = newProgram.getCompilerOptions();
state.compilerOptions = compilerOptions;
- if (!compilerOptions.outFile && !compilerOptions.out) {
- state.semanticDiagnosticsPerFile = ts.createMap();
+ if (!ts.outFile(compilerOptions)) {
+ state.semanticDiagnosticsPerFile = new ts.Map();
}
- state.changedFilesSet = ts.createMap();
+ state.changedFilesSet = new ts.Set();
var useOldState = ts.BuilderState.canReuseOldState(state.referencedMap, oldState);
var oldCompilerOptions = useOldState ? oldState.compilerOptions : undefined;
var canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile &&
if (canCopySemanticDiagnostics) {
ts.Debug.assert(!changedFilesSet || !ts.forEachKey(changedFilesSet, function (path) { return oldState.semanticDiagnosticsPerFile.has(path); }), "Semantic diagnostics shouldnt be available for changed files");
}
- if (changedFilesSet) {
- ts.copyEntries(changedFilesSet, state.changedFilesSet);
- }
- if (!compilerOptions.outFile && !compilerOptions.out && oldState.affectedFilesPendingEmit) {
+ changedFilesSet === null || changedFilesSet === void 0 ? void 0 : changedFilesSet.forEach(function (value) { return state.changedFilesSet.add(value); });
+ if (!ts.outFile(compilerOptions) && oldState.affectedFilesPendingEmit) {
state.affectedFilesPendingEmit = oldState.affectedFilesPendingEmit.slice();
- state.affectedFilesPendingEmitKind = ts.cloneMapOrUndefined(oldState.affectedFilesPendingEmitKind);
+ state.affectedFilesPendingEmitKind = oldState.affectedFilesPendingEmitKind && new ts.Map(oldState.affectedFilesPendingEmitKind);
state.affectedFilesPendingEmitIndex = oldState.affectedFilesPendingEmitIndex;
- state.seenAffectedFiles = ts.createMap();
+ state.seenAffectedFiles = new ts.Set();
}
}
var referencedMap = state.referencedMap;
oldInfo.version !== info.version ||
!hasSameKeys(newReferences = referencedMap && referencedMap.get(sourceFilePath), oldReferencedMap && oldReferencedMap.get(sourceFilePath)) ||
newReferences && ts.forEachKey(newReferences, function (path) { return !state.fileInfos.has(path) && oldState.fileInfos.has(path); })) {
- state.changedFilesSet.set(sourceFilePath, true);
+ state.changedFilesSet.add(sourceFilePath);
}
else if (canCopySemanticDiagnostics) {
var sourceFile = newProgram.getSourceFileByPath(sourceFilePath);
if (diagnostics) {
state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) : diagnostics);
if (!state.semanticDiagnosticsFromOldState) {
- state.semanticDiagnosticsFromOldState = ts.createMap();
+ state.semanticDiagnosticsFromOldState = new ts.Set();
}
- state.semanticDiagnosticsFromOldState.set(sourceFilePath, true);
+ state.semanticDiagnosticsFromOldState.add(sourceFilePath);
}
}
});
if (useOldState && ts.forEachEntry(oldState.fileInfos, function (info, sourceFilePath) { return info.affectsGlobalScope && !state.fileInfos.has(sourceFilePath); })) {
ts.BuilderState.getAllFilesExcludingDefaultLibraryFile(state, newProgram, undefined)
- .forEach(function (file) { return state.changedFilesSet.set(file.resolvedPath, true); });
+ .forEach(function (file) { return state.changedFilesSet.add(file.resolvedPath); });
}
- else if (oldCompilerOptions && ts.compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {
+ else if (oldCompilerOptions && !ts.outFile(compilerOptions) && ts.compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {
newProgram.getSourceFiles().forEach(function (f) { return addToAffectedFilesPendingEmit(state, f.resolvedPath, 1); });
ts.Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);
- state.seenAffectedFiles = state.seenAffectedFiles || ts.createMap();
+ state.seenAffectedFiles = state.seenAffectedFiles || new ts.Set();
}
- state.emittedBuildInfo = !state.changedFilesSet.size && !state.affectedFilesPendingEmit;
+ state.buildInfoEmitPending = !!state.changedFilesSet.size;
return state;
}
function convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) {
return diagnostics.map(function (diagnostic) {
var result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath);
result.reportsUnnecessary = diagnostic.reportsUnnecessary;
+ result.reportsDeprecated = diagnostic.reportDeprecated;
result.source = diagnostic.source;
+ result.skippedOn = diagnostic.skippedOn;
var relatedInformation = diagnostic.relatedInformation;
result.relatedInformation = relatedInformation ?
relatedInformation.length ?
relatedInformation.map(function (r) { return convertToDiagnosticRelatedInformation(r, newProgram, toPath); }) :
- ts.emptyArray :
+ [] :
undefined;
return result;
});
}
function cloneBuilderProgramState(state) {
var newState = ts.BuilderState.clone(state);
- newState.semanticDiagnosticsPerFile = ts.cloneMapOrUndefined(state.semanticDiagnosticsPerFile);
- newState.changedFilesSet = ts.cloneMap(state.changedFilesSet);
+ newState.semanticDiagnosticsPerFile = state.semanticDiagnosticsPerFile && new ts.Map(state.semanticDiagnosticsPerFile);
+ newState.changedFilesSet = new ts.Set(state.changedFilesSet);
newState.affectedFiles = state.affectedFiles;
newState.affectedFilesIndex = state.affectedFilesIndex;
newState.currentChangedFilePath = state.currentChangedFilePath;
- newState.currentAffectedFilesSignatures = ts.cloneMapOrUndefined(state.currentAffectedFilesSignatures);
- newState.currentAffectedFilesExportedModulesMap = ts.cloneMapOrUndefined(state.currentAffectedFilesExportedModulesMap);
- newState.seenAffectedFiles = ts.cloneMapOrUndefined(state.seenAffectedFiles);
+ newState.currentAffectedFilesSignatures = state.currentAffectedFilesSignatures && new ts.Map(state.currentAffectedFilesSignatures);
+ newState.currentAffectedFilesExportedModulesMap = state.currentAffectedFilesExportedModulesMap && new ts.Map(state.currentAffectedFilesExportedModulesMap);
+ newState.seenAffectedFiles = state.seenAffectedFiles && new ts.Set(state.seenAffectedFiles);
newState.cleanedDiagnosticsOfLibFiles = state.cleanedDiagnosticsOfLibFiles;
- newState.semanticDiagnosticsFromOldState = ts.cloneMapOrUndefined(state.semanticDiagnosticsFromOldState);
+ newState.semanticDiagnosticsFromOldState = state.semanticDiagnosticsFromOldState && new ts.Set(state.semanticDiagnosticsFromOldState);
newState.program = state.program;
newState.compilerOptions = state.compilerOptions;
newState.affectedFilesPendingEmit = state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice();
- newState.affectedFilesPendingEmitKind = ts.cloneMapOrUndefined(state.affectedFilesPendingEmitKind);
+ newState.affectedFilesPendingEmitKind = state.affectedFilesPendingEmitKind && new ts.Map(state.affectedFilesPendingEmitKind);
newState.affectedFilesPendingEmitIndex = state.affectedFilesPendingEmitIndex;
- newState.seenEmittedFiles = ts.cloneMapOrUndefined(state.seenEmittedFiles);
+ newState.seenEmittedFiles = state.seenEmittedFiles && new ts.Map(state.seenEmittedFiles);
newState.programEmitComplete = state.programEmitComplete;
return newState;
}
}
var program = ts.Debug.checkDefined(state.program);
var compilerOptions = program.getCompilerOptions();
- if (compilerOptions.outFile || compilerOptions.out) {
+ if (ts.outFile(compilerOptions)) {
ts.Debug.assert(!state.semanticDiagnosticsPerFile);
return program;
}
- state.currentAffectedFilesSignatures = state.currentAffectedFilesSignatures || ts.createMap();
+ if (!state.currentAffectedFilesSignatures)
+ state.currentAffectedFilesSignatures = new ts.Map();
if (state.exportedModulesMap) {
- state.currentAffectedFilesExportedModulesMap = state.currentAffectedFilesExportedModulesMap || ts.createMap();
+ if (!state.currentAffectedFilesExportedModulesMap)
+ state.currentAffectedFilesExportedModulesMap = new ts.Map();
}
state.affectedFiles = ts.BuilderState.getFilesAffectedBy(state, program, nextKey.value, cancellationToken, computeHash, state.currentAffectedFilesSignatures, state.currentAffectedFilesExportedModulesMap);
state.currentChangedFilePath = nextKey.value;
state.affectedFilesIndex = 0;
- state.seenAffectedFiles = state.seenAffectedFiles || ts.createMap();
+ if (!state.seenAffectedFiles)
+ state.seenAffectedFiles = new ts.Set();
}
}
function getNextAffectedFilePendingEmit(state) {
var affectedFilesPendingEmit = state.affectedFilesPendingEmit;
if (affectedFilesPendingEmit) {
- var seenEmittedFiles = state.seenEmittedFiles || (state.seenEmittedFiles = ts.createMap());
+ var seenEmittedFiles = (state.seenEmittedFiles || (state.seenEmittedFiles = new ts.Map()));
for (var i = state.affectedFilesPendingEmitIndex; i < affectedFilesPendingEmit.length; i++) {
var affectedFile = ts.Debug.checkDefined(state.program).getSourceFileByPath(affectedFilesPendingEmit[i]);
if (affectedFile) {
state.semanticDiagnosticsPerFile.delete(path);
return !state.semanticDiagnosticsFromOldState.size;
}
- function isChangedSignagure(state, path) {
+ function isChangedSignature(state, path) {
var newSignature = ts.Debug.checkDefined(state.currentAffectedFilesSignatures).get(path);
- var oldSignagure = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
- return newSignature !== oldSignagure;
+ var oldSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
+ return newSignature !== oldSignature;
}
function forEachReferencingModulesOfExportOfAffectedFile(state, affectedFile, fn) {
if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath)) {
return;
}
- if (!isChangedSignagure(state, affectedFile.resolvedPath))
+ if (!isChangedSignature(state, affectedFile.resolvedPath))
return;
if (state.compilerOptions.isolatedModules) {
- var seenFileNamesMap = ts.createMap();
+ var seenFileNamesMap = new ts.Map();
seenFileNamesMap.set(affectedFile.resolvedPath, true);
var queue = ts.BuilderState.getReferencedByPaths(state, affectedFile.resolvedPath);
while (queue.length > 0) {
if (!seenFileNamesMap.has(currentPath)) {
seenFileNamesMap.set(currentPath, true);
var result = fn(state, currentPath);
- if (result && isChangedSignagure(state, currentPath)) {
+ if (result && isChangedSignature(state, currentPath)) {
var currentSourceFile = ts.Debug.checkDefined(state.program).getSourceFileByPath(currentPath);
queue.push.apply(queue, ts.BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath));
}
}
}
ts.Debug.assert(!!state.currentAffectedFilesExportedModulesMap);
- var seenFileAndExportsOfFile = ts.createMap();
+ var seenFileAndExportsOfFile = new ts.Set();
if (ts.forEachEntry(state.currentAffectedFilesExportedModulesMap, function (exportedModules, exportedFromPath) {
return exportedModules &&
exportedModules.has(affectedFile.resolvedPath) &&
});
}
function forEachFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, fn) {
- if (!ts.addToSeen(seenFileAndExportsOfFile, filePath)) {
+ if (!ts.tryAddToSet(seenFileAndExportsOfFile, filePath)) {
return false;
}
if (fn(state, filePath)) {
}
function doneWithAffectedFile(state, affected, emitKind, isPendingEmit, isBuildInfoEmit) {
if (isBuildInfoEmit) {
- state.emittedBuildInfo = true;
+ state.buildInfoEmitPending = false;
}
else if (affected === state.program) {
state.changedFilesSet.clear();
state.programEmitComplete = true;
}
else {
- state.seenAffectedFiles.set(affected.resolvedPath, true);
+ state.seenAffectedFiles.add(affected.resolvedPath);
if (emitKind !== undefined) {
- (state.seenEmittedFiles || (state.seenEmittedFiles = ts.createMap())).set(affected.resolvedPath, emitKind);
+ (state.seenEmittedFiles || (state.seenEmittedFiles = new ts.Map())).set(affected.resolvedPath, emitKind);
}
if (isPendingEmit) {
state.affectedFilesPendingEmitIndex++;
+ state.buildInfoEmitPending = true;
}
else {
state.affectedFilesIndex++;
if (state.semanticDiagnosticsPerFile) {
var cachedDiagnostics = state.semanticDiagnosticsPerFile.get(path);
if (cachedDiagnostics) {
- return cachedDiagnostics;
+ return ts.filterSemanticDiagnotics(cachedDiagnostics, state.compilerOptions);
}
}
var diagnostics = ts.Debug.checkDefined(state.program).getBindAndCheckDiagnostics(sourceFile, cancellationToken);
if (state.semanticDiagnosticsPerFile) {
state.semanticDiagnosticsPerFile.set(path, diagnostics);
}
- return diagnostics;
+ return ts.filterSemanticDiagnotics(diagnostics, state.compilerOptions);
}
function getProgramBuildInfo(state, getCanonicalFileName) {
- if (state.compilerOptions.outFile || state.compilerOptions.out)
+ if (ts.outFile(state.compilerOptions))
return undefined;
var currentDirectory = ts.Debug.checkDefined(state.program).getCurrentDirectory();
var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
}
result.semanticDiagnosticsPerFile = semanticDiagnosticsPerFile;
}
+ if (state.affectedFilesPendingEmit) {
+ var affectedFilesPendingEmit = [];
+ var seenFiles = new ts.Set();
+ for (var _f = 0, _g = state.affectedFilesPendingEmit.slice(state.affectedFilesPendingEmitIndex).sort(ts.compareStringsCaseSensitive); _f < _g.length; _f++) {
+ var path = _g[_f];
+ if (ts.tryAddToSet(seenFiles, path)) {
+ affectedFilesPendingEmit.push([relativeToBuildInfo(path), state.affectedFilesPendingEmitKind.get(path)]);
+ }
+ }
+ result.affectedFilesPendingEmit = affectedFilesPendingEmit;
+ }
return result;
function relativeToBuildInfoEnsuringAbsolutePath(path) {
return relativeToBuildInfo(ts.getNormalizedAbsolutePath(path, currentDirectory));
return diagnostics.map(function (diagnostic) {
var result = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo);
result.reportsUnnecessary = diagnostic.reportsUnnecessary;
+ result.reportDeprecated = diagnostic.reportsDeprecated;
result.source = diagnostic.source;
+ result.skippedOn = diagnostic.skippedOn;
var relatedInformation = diagnostic.relatedInformation;
result.relatedInformation = relatedInformation ?
relatedInformation.length ?
relatedInformation.map(function (r) { return convertToReusableDiagnosticRelatedInformation(r, relativeToBuildInfo); }) :
- ts.emptyArray :
+ [] :
undefined;
return result;
});
return oldProgram;
}
var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
- var computeHash = host.createHash || ts.generateDjb2Hash;
+ var computeHash = ts.maybeBind(host, host.createHash);
var state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState);
var backupState;
newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName); };
else if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) {
builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile;
builderProgram.emitNextAffectedFile = emitNextAffectedFile;
+ builderProgram.emitBuildInfo = emitBuildInfo;
}
else {
ts.notImplemented();
}
return builderProgram;
+ function emitBuildInfo(writeFile, cancellationToken) {
+ if (state.buildInfoEmitPending) {
+ var result = ts.Debug.checkDefined(state.program).emitBuildInfo(writeFile || ts.maybeBind(host, host.writeFile), cancellationToken);
+ state.buildInfoEmitPending = false;
+ return result;
+ }
+ return ts.emitSkippedWithNoDiagnostics;
+ }
function emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
var affected = getNextAffectedFile(state, cancellationToken, computeHash);
var emitKind = 1;
var isPendingEmitFile = false;
if (!affected) {
- if (!state.compilerOptions.out && !state.compilerOptions.outFile) {
+ if (!ts.outFile(state.compilerOptions)) {
var pendingAffectedFile = getNextAffectedFilePendingEmit(state);
if (!pendingAffectedFile) {
- if (state.emittedBuildInfo) {
+ if (!state.buildInfoEmitPending) {
return undefined;
}
var affected_1 = ts.Debug.checkDefined(state.program);
return toAffectedFileEmitResult(state, ts.Debug.checkDefined(state.program).emit(affected === state.program ? undefined : affected, writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles || emitKind === 0, customTransformers), affected, emitKind, isPendingEmitFile);
}
function emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
+ var restorePendingEmitOnHandlingNoEmitSuccess = false;
+ var savedAffectedFilesPendingEmit;
+ var savedAffectedFilesPendingEmitKind;
+ var savedAffectedFilesPendingEmitIndex;
+ if (kind !== BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram &&
+ !targetSourceFile &&
+ !ts.outFile(state.compilerOptions) &&
+ !state.compilerOptions.noEmit &&
+ state.compilerOptions.noEmitOnError) {
+ restorePendingEmitOnHandlingNoEmitSuccess = true;
+ savedAffectedFilesPendingEmit = state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice();
+ savedAffectedFilesPendingEmitKind = state.affectedFilesPendingEmitKind && new ts.Map(state.affectedFilesPendingEmitKind);
+ savedAffectedFilesPendingEmitIndex = state.affectedFilesPendingEmitIndex;
+ }
if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) {
assertSourceFileOkWithoutNextAffectedCall(state, targetSourceFile);
- var result = ts.handleNoEmitOptions(builderProgram, targetSourceFile, cancellationToken);
- if (result)
- return result;
- if (!targetSourceFile) {
- var sourceMaps = [];
- var emitSkipped = false;
- var diagnostics = void 0;
- var emittedFiles = [];
- var affectedEmitResult = void 0;
- while (affectedEmitResult = emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers)) {
- emitSkipped = emitSkipped || affectedEmitResult.result.emitSkipped;
- diagnostics = ts.addRange(diagnostics, affectedEmitResult.result.diagnostics);
- emittedFiles = ts.addRange(emittedFiles, affectedEmitResult.result.emittedFiles);
- sourceMaps = ts.addRange(sourceMaps, affectedEmitResult.result.sourceMaps);
- }
- return {
- emitSkipped: emitSkipped,
- diagnostics: diagnostics || ts.emptyArray,
- emittedFiles: emittedFiles,
- sourceMaps: sourceMaps
- };
+ }
+ var result = ts.handleNoEmitOptions(builderProgram, targetSourceFile, writeFile, cancellationToken);
+ if (result)
+ return result;
+ if (restorePendingEmitOnHandlingNoEmitSuccess) {
+ state.affectedFilesPendingEmit = savedAffectedFilesPendingEmit;
+ state.affectedFilesPendingEmitKind = savedAffectedFilesPendingEmitKind;
+ state.affectedFilesPendingEmitIndex = savedAffectedFilesPendingEmitIndex;
+ }
+ if (!targetSourceFile && kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) {
+ var sourceMaps = [];
+ var emitSkipped = false;
+ var diagnostics = void 0;
+ var emittedFiles = [];
+ var affectedEmitResult = void 0;
+ while (affectedEmitResult = emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers)) {
+ emitSkipped = emitSkipped || affectedEmitResult.result.emitSkipped;
+ diagnostics = ts.addRange(diagnostics, affectedEmitResult.result.diagnostics);
+ emittedFiles = ts.addRange(emittedFiles, affectedEmitResult.result.emittedFiles);
+ sourceMaps = ts.addRange(sourceMaps, affectedEmitResult.result.sourceMaps);
}
+ return {
+ emitSkipped: emitSkipped,
+ diagnostics: diagnostics || ts.emptyArray,
+ emittedFiles: emittedFiles,
+ sourceMaps: sourceMaps
+ };
}
return ts.Debug.checkDefined(state.program).emit(targetSourceFile, writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
}
else if (affected === state.program) {
return toAffectedFileResult(state, state.program.getSemanticDiagnostics(undefined, cancellationToken), affected);
}
- if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) {
+ if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram || state.compilerOptions.noEmit || state.compilerOptions.noEmitOnError) {
addToAffectedFilesPendingEmit(state, affected.resolvedPath, 1);
}
if (ignoreSourceFile && ignoreSourceFile(affected)) {
function getSemanticDiagnostics(sourceFile, cancellationToken) {
assertSourceFileOkWithoutNextAffectedCall(state, sourceFile);
var compilerOptions = ts.Debug.checkDefined(state.program).getCompilerOptions();
- if (compilerOptions.outFile || compilerOptions.out) {
+ if (ts.outFile(compilerOptions)) {
ts.Debug.assert(!state.semanticDiagnosticsPerFile);
return ts.Debug.checkDefined(state.program).getSemanticDiagnostics(sourceFile, cancellationToken);
}
if (!state.affectedFilesPendingEmit)
state.affectedFilesPendingEmit = [];
if (!state.affectedFilesPendingEmitKind)
- state.affectedFilesPendingEmitKind = ts.createMap();
+ state.affectedFilesPendingEmitKind = new ts.Map();
var existingKind = state.affectedFilesPendingEmitKind.get(affectedFilePendingEmit);
state.affectedFilesPendingEmit.push(affectedFilePendingEmit);
state.affectedFilesPendingEmitKind.set(affectedFilePendingEmit, existingKind || kind);
function getMapOfReferencedSet(mapLike, toPath) {
if (!mapLike)
return undefined;
- var map = ts.createMap();
+ var map = new ts.Map();
for (var key in mapLike) {
if (ts.hasProperty(mapLike, key)) {
- map.set(toPath(key), ts.arrayToSet(mapLike[key], toPath));
+ map.set(toPath(key), new ts.Set(mapLike[key].map(toPath)));
}
}
return map;
function createBuildProgramUsingProgramBuildInfo(program, buildInfoPath, host) {
var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
- var fileInfos = ts.createMap();
+ var fileInfos = new ts.Map();
for (var key in program.fileInfos) {
if (ts.hasProperty(program.fileInfos, key)) {
fileInfos.set(toPath(key), program.fileInfos[key]);
referencedMap: getMapOfReferencedSet(program.referencedMap, toPath),
exportedModulesMap: getMapOfReferencedSet(program.exportedModulesMap, toPath),
semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && ts.arrayToMap(program.semanticDiagnosticsPerFile, function (value) { return toPath(ts.isString(value) ? value : value[0]); }, function (value) { return ts.isString(value) ? ts.emptyArray : value[1]; }),
- hasReusableDiagnostic: true
+ hasReusableDiagnostic: true,
+ affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toPath(value[0]); }),
+ affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toPath(value[0]); }, function (value) { return value[1]; }),
+ affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
};
return {
getState: function () { return state; },
getCurrentDirectory: ts.notImplemented,
emitNextAffectedFile: ts.notImplemented,
getSemanticDiagnosticsOfNextAffectedFile: ts.notImplemented,
+ emitBuildInfo: ts.notImplemented,
close: ts.noop,
};
function toPath(path) {
getDeclarationDiagnostics: function (sourceFile, cancellationToken) { return getProgram().getDeclarationDiagnostics(sourceFile, cancellationToken); },
getSemanticDiagnostics: function (sourceFile, cancellationToken) { return getProgram().getSemanticDiagnostics(sourceFile, cancellationToken); },
emit: function (sourceFile, writeFile, cancellationToken, emitOnlyDts, customTransformers) { return getProgram().emit(sourceFile, writeFile, cancellationToken, emitOnlyDts, customTransformers); },
+ emitBuildInfo: function (writeFile, cancellationToken) { return getProgram().emitBuildInfo(writeFile, cancellationToken); },
getAllDependencies: ts.notImplemented,
getCurrentDirectory: function () { return getProgram().getCurrentDirectory(); },
close: ts.noop,
var nonRelativeExternalModuleResolutions = ts.createMultiMap();
var resolutionsWithFailedLookups = [];
var resolvedFileToResolution = ts.createMultiMap();
+ var hasChangedAutomaticTypeDirectiveNames = false;
+ var failedLookupChecks = [];
+ var startsWithPathChecks = [];
+ var isInDirectoryChecks = [];
var getCurrentDirectory = ts.memoize(function () { return resolutionHost.getCurrentDirectory(); });
var cachedDirectoryStructureHost = resolutionHost.getCachedDirectoryStructureHost();
- var resolvedModuleNames = ts.createMap();
+ var resolvedModuleNames = new ts.Map();
var perDirectoryResolvedModuleNames = ts.createCacheWithRedirects();
var nonRelativeModuleNameCache = ts.createCacheWithRedirects();
var moduleResolutionCache = ts.createModuleResolutionCacheWithMaps(perDirectoryResolvedModuleNames, nonRelativeModuleNameCache, getCurrentDirectory(), resolutionHost.getCanonicalFileName);
- var resolvedTypeReferenceDirectives = ts.createMap();
+ var resolvedTypeReferenceDirectives = new ts.Map();
var perDirectoryResolvedTypeReferenceDirectives = ts.createCacheWithRedirects();
var failedLookupDefaultExtensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
- var customFailedLookupPaths = ts.createMap();
- var directoryWatchesOfFailedLookups = ts.createMap();
+ var customFailedLookupPaths = new ts.Map();
+ var directoryWatchesOfFailedLookups = new ts.Map();
var rootDir = rootDirForResolution && ts.removeTrailingDirectorySeparator(ts.getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory()));
var rootPath = (rootDir && resolutionHost.toPath(rootDir));
var rootSplitLength = rootPath !== undefined ? rootPath.split(ts.directorySeparator).length : 0;
- var typeRootsWatches = ts.createMap();
+ var typeRootsWatches = new ts.Map();
return {
startRecordingFilesWithChangedResolutions: startRecordingFilesWithChangedResolutions,
finishRecordingFilesWithChangedResolutions: finishRecordingFilesWithChangedResolutions,
resolveTypeReferenceDirectives: resolveTypeReferenceDirectives,
removeResolutionsFromProjectReferenceRedirects: removeResolutionsFromProjectReferenceRedirects,
removeResolutionsOfFile: removeResolutionsOfFile,
+ hasChangedAutomaticTypeDirectiveNames: function () { return hasChangedAutomaticTypeDirectiveNames; },
invalidateResolutionOfFile: invalidateResolutionOfFile,
+ invalidateResolutionsOfFailedLookupLocations: invalidateResolutionsOfFailedLookupLocations,
setFilesWithInvalidatedNonRelativeUnresolvedImports: setFilesWithInvalidatedNonRelativeUnresolvedImports,
createHasInvalidatedResolution: createHasInvalidatedResolution,
updateTypeRootsWatch: updateTypeRootsWatch,
resolvedTypeReferenceDirectives.clear();
resolvedFileToResolution.clear();
resolutionsWithFailedLookups.length = 0;
+ failedLookupChecks.length = 0;
+ startsWithPathChecks.length = 0;
+ isInDirectoryChecks.length = 0;
clearPerDirectoryResolutions();
+ hasChangedAutomaticTypeDirectiveNames = false;
}
function startRecordingFilesWithChangedResolutions() {
filesWithChangedSetOfUnresolvedImports = [];
return !!value && !!value.length;
}
function createHasInvalidatedResolution(forceAllFilesAsInvalidated) {
+ invalidateResolutionsOfFailedLookupLocations();
if (forceAllFilesAsInvalidated) {
filesWithInvalidatedResolutions = undefined;
return ts.returnTrue;
watcher.watcher.close();
}
});
+ hasChangedAutomaticTypeDirectiveNames = false;
}
function resolveModuleName(moduleName, containingFile, compilerOptions, host, redirectedReference) {
var _a;
var _b;
var names = _a.names, containingFile = _a.containingFile, redirectedReference = _a.redirectedReference, cache = _a.cache, perDirectoryCacheWithRedirects = _a.perDirectoryCacheWithRedirects, loader = _a.loader, getResolutionWithResolvedFileName = _a.getResolutionWithResolvedFileName, shouldRetryResolution = _a.shouldRetryResolution, reusedNames = _a.reusedNames, logChanges = _a.logChanges;
var path = resolutionHost.toPath(containingFile);
- var resolutionsInFile = cache.get(path) || cache.set(path, ts.createMap()).get(path);
+ var resolutionsInFile = cache.get(path) || cache.set(path, new ts.Map()).get(path);
var dirPath = ts.getDirectoryPath(path);
var perDirectoryCache = perDirectoryCacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
var perDirectoryResolution = perDirectoryCache.get(dirPath);
if (!perDirectoryResolution) {
- perDirectoryResolution = ts.createMap();
+ perDirectoryResolution = new ts.Map();
perDirectoryCache.set(dirPath, perDirectoryResolution);
}
var resolvedModules = [];
var unmatchedRedirects = oldRedirect ?
!redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path :
!!redirectedReference;
- var seenNamesInFile = ts.createMap();
+ var seenNamesInFile = new ts.Map();
for (var _i = 0, names_3 = names; _i < names_3.length; _i++) {
var name = names_3[_i];
var resolution = resolutionsInFile.get(name);
getResolutionWithResolvedFileName: getResolvedModule,
shouldRetryResolution: function (resolution) { return !resolution.resolvedModule || !ts.resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension); },
reusedNames: reusedNames,
- logChanges: logChangesWhenResolvingModule
+ logChanges: logChangesWhenResolvingModule,
});
}
function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile) {
}
else {
resolution.refCount = 1;
- ts.Debug.assert(resolution.files === undefined);
+ ts.Debug.assert(ts.length(resolution.files) === 0);
if (ts.isExternalModuleNameRelative(name)) {
watchFailedLookupLocationOfResolution(resolution);
}
if (cachedDirectoryStructureHost) {
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
}
- if (invalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath)) {
- resolutionHost.onInvalidatedResolution();
- }
+ scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
}, nonRecursive ? 0 : 1);
}
function removeResolutionsOfFileFromCache(cache, filePath, getResolutionWithResolvedFileName) {
removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModule);
removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective);
}
- function invalidateResolution(resolution) {
- resolution.isInvalidated = true;
- var changedInAutoTypeReferenced = false;
- for (var _i = 0, _a = ts.Debug.assertDefined(resolution.files); _i < _a.length; _i++) {
- var containingFilePath = _a[_i];
- (filesWithInvalidatedResolutions || (filesWithInvalidatedResolutions = ts.createMap())).set(containingFilePath, true);
- changedInAutoTypeReferenced = changedInAutoTypeReferenced || containingFilePath.endsWith(ts.inferredTypesContainingFile);
- }
- if (changedInAutoTypeReferenced) {
- resolutionHost.onChangedAutomaticTypeDirectiveNames();
+ function invalidateResolutions(resolutions, canInvalidate) {
+ if (!resolutions)
+ return false;
+ var invalidated = false;
+ for (var _i = 0, resolutions_1 = resolutions; _i < resolutions_1.length; _i++) {
+ var resolution = resolutions_1[_i];
+ if (resolution.isInvalidated || !canInvalidate(resolution))
+ continue;
+ resolution.isInvalidated = invalidated = true;
+ for (var _a = 0, _b = ts.Debug.assertDefined(resolution.files); _a < _b.length; _a++) {
+ var containingFilePath = _b[_a];
+ (filesWithInvalidatedResolutions || (filesWithInvalidatedResolutions = new ts.Set())).add(containingFilePath);
+ hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || ts.endsWith(containingFilePath, ts.inferredTypesContainingFile);
+ }
}
+ return invalidated;
}
function invalidateResolutionOfFile(filePath) {
removeResolutionsOfFile(filePath);
- ts.forEach(resolvedFileToResolution.get(filePath), invalidateResolution);
+ var prevHasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
+ if (invalidateResolutions(resolvedFileToResolution.get(filePath), ts.returnTrue) &&
+ hasChangedAutomaticTypeDirectiveNames &&
+ !prevHasChangedAutomaticTypeDirectiveNames) {
+ resolutionHost.onChangedAutomaticTypeDirectiveNames();
+ }
}
function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap) {
ts.Debug.assert(filesWithInvalidatedNonRelativeUnresolvedImports === filesMap || filesWithInvalidatedNonRelativeUnresolvedImports === undefined);
filesWithInvalidatedNonRelativeUnresolvedImports = filesMap;
}
- function invalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, isCreatingWatchedDirectory) {
- var isChangedFailedLookupLocation;
+ function scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, isCreatingWatchedDirectory) {
if (isCreatingWatchedDirectory) {
- isChangedFailedLookupLocation = function (location) { return isInDirectoryPath(fileOrDirectoryPath, resolutionHost.toPath(location)); };
+ isInDirectoryChecks.push(fileOrDirectoryPath);
}
else {
var updatedPath = removeIgnoredPath(fileOrDirectoryPath);
var dirOfFileOrDirectory = ts.getDirectoryPath(fileOrDirectoryPath);
if (isNodeModulesAtTypesDirectory(fileOrDirectoryPath) || ts.isNodeModulesDirectory(fileOrDirectoryPath) ||
isNodeModulesAtTypesDirectory(dirOfFileOrDirectory) || ts.isNodeModulesDirectory(dirOfFileOrDirectory)) {
- isChangedFailedLookupLocation = function (location) {
- var locationPath = resolutionHost.toPath(location);
- return locationPath === fileOrDirectoryPath || ts.startsWith(resolutionHost.toPath(location), fileOrDirectoryPath);
- };
+ failedLookupChecks.push(fileOrDirectoryPath);
+ startsWithPathChecks.push(fileOrDirectoryPath);
}
else {
if (!isPathWithDefaultFailedLookupExtension(fileOrDirectoryPath) && !customFailedLookupPaths.has(fileOrDirectoryPath)) {
if (ts.isEmittedFileOfProgram(resolutionHost.getCurrentProgram(), fileOrDirectoryPath)) {
return false;
}
- isChangedFailedLookupLocation = function (location) { return resolutionHost.toPath(location) === fileOrDirectoryPath; };
+ failedLookupChecks.push(fileOrDirectoryPath);
}
}
- var invalidated = false;
- for (var _i = 0, resolutionsWithFailedLookups_1 = resolutionsWithFailedLookups; _i < resolutionsWithFailedLookups_1.length; _i++) {
- var resolution = resolutionsWithFailedLookups_1[_i];
- if (resolution.failedLookupLocations.some(isChangedFailedLookupLocation)) {
- invalidateResolution(resolution);
- invalidated = true;
- }
+ resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
+ }
+ function invalidateResolutionsOfFailedLookupLocations() {
+ if (!failedLookupChecks.length && !startsWithPathChecks.length && !isInDirectoryChecks.length) {
+ return false;
}
+ var invalidated = invalidateResolutions(resolutionsWithFailedLookups, canInvalidateFailedLookupResolution);
+ failedLookupChecks.length = 0;
+ startsWithPathChecks.length = 0;
+ isInDirectoryChecks.length = 0;
return invalidated;
}
+ function canInvalidateFailedLookupResolution(resolution) {
+ return resolution.failedLookupLocations.some(function (location) {
+ var locationPath = resolutionHost.toPath(location);
+ return ts.contains(failedLookupChecks, locationPath) ||
+ startsWithPathChecks.some(function (fileOrDirectoryPath) { return ts.startsWith(locationPath, fileOrDirectoryPath); }) ||
+ isInDirectoryChecks.some(function (fileOrDirectoryPath) { return isInDirectoryPath(fileOrDirectoryPath, locationPath); });
+ });
+ }
function closeTypeRootsWatch() {
ts.clearMap(typeRootsWatches, ts.closeFileWatcher);
}
if (cachedDirectoryStructureHost) {
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
}
+ hasChangedAutomaticTypeDirectiveNames = true;
resolutionHost.onChangedAutomaticTypeDirectiveNames();
var dirPath = getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath);
- if (dirPath && invalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath)) {
- resolutionHost.onInvalidatedResolution();
+ if (dirPath) {
+ scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
}
}, 1);
}
function getNodeModulesPackageName(compilerOptions, importingSourceFileName, nodeModulesFileName, host) {
var info = getInfo(importingSourceFileName, host);
var modulePaths = getAllModulePaths(importingSourceFileName, nodeModulesFileName, host);
- return ts.firstDefined(modulePaths, function (moduleFileName) { return tryGetModuleNameAsNodeModule(moduleFileName, info, host, compilerOptions, true); });
+ return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions, true); });
}
moduleSpecifiers.getNodeModulesPackageName = getNodeModulesPackageName;
function getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, preferences) {
var info = getInfo(importingSourceFileName, host);
var modulePaths = getAllModulePaths(importingSourceFileName, toFileName, host);
- return ts.firstDefined(modulePaths, function (moduleFileName) { return tryGetModuleNameAsNodeModule(moduleFileName, info, host, compilerOptions); }) ||
- getLocalModuleSpecifier(toFileName, info, compilerOptions, preferences);
+ return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions); }) ||
+ getLocalModuleSpecifier(toFileName, info, compilerOptions, host, preferences);
}
function getModuleSpecifiers(moduleSymbol, compilerOptions, importingSourceFile, host, userPreferences) {
var ambient = tryGetModuleNameFromAmbientModule(moduleSymbol);
var moduleSourceFile = ts.getSourceFileOfNode(moduleSymbol.valueDeclaration || ts.getNonAugmentationDeclaration(moduleSymbol));
var modulePaths = getAllModulePaths(importingSourceFile.path, moduleSourceFile.originalFileName, host);
var preferences = getPreferences(userPreferences, compilerOptions, importingSourceFile);
- var global = ts.mapDefined(modulePaths, function (moduleFileName) { return tryGetModuleNameAsNodeModule(moduleFileName, info, host, compilerOptions); });
- return global.length ? global : modulePaths.map(function (moduleFileName) { return getLocalModuleSpecifier(moduleFileName, info, compilerOptions, preferences); });
+ var importedFileIsInNodeModules = ts.some(modulePaths, function (p) { return p.isInNodeModules; });
+ var nodeModulesSpecifiers;
+ var pathsSpecifiers;
+ var relativeSpecifiers;
+ for (var _i = 0, modulePaths_1 = modulePaths; _i < modulePaths_1.length; _i++) {
+ var modulePath = modulePaths_1[_i];
+ var specifier = tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions);
+ nodeModulesSpecifiers = ts.append(nodeModulesSpecifiers, specifier);
+ if (specifier && modulePath.isRedirect) {
+ return nodeModulesSpecifiers;
+ }
+ if (!specifier && !modulePath.isRedirect) {
+ var local = getLocalModuleSpecifier(modulePath.path, info, compilerOptions, host, preferences);
+ if (ts.pathIsBareSpecifier(local)) {
+ pathsSpecifiers = ts.append(pathsSpecifiers, local);
+ }
+ else if (!importedFileIsInNodeModules || modulePath.isInNodeModules) {
+ relativeSpecifiers = ts.append(relativeSpecifiers, local);
+ }
+ }
+ }
+ return (pathsSpecifiers === null || pathsSpecifiers === void 0 ? void 0 : pathsSpecifiers.length) ? pathsSpecifiers :
+ (nodeModulesSpecifiers === null || nodeModulesSpecifiers === void 0 ? void 0 : nodeModulesSpecifiers.length) ? nodeModulesSpecifiers :
+ ts.Debug.checkDefined(relativeSpecifiers);
}
moduleSpecifiers.getModuleSpecifiers = getModuleSpecifiers;
function getInfo(importingSourceFileName, host) {
var sourceDirectory = ts.getDirectoryPath(importingSourceFileName);
return { getCanonicalFileName: getCanonicalFileName, sourceDirectory: sourceDirectory };
}
- function getLocalModuleSpecifier(moduleFileName, _a, compilerOptions, _b) {
+ function getLocalModuleSpecifier(moduleFileName, _a, compilerOptions, host, _b) {
var getCanonicalFileName = _a.getCanonicalFileName, sourceDirectory = _a.sourceDirectory;
var ending = _b.ending, relativePreference = _b.relativePreference;
var baseUrl = compilerOptions.baseUrl, paths = compilerOptions.paths, rootDirs = compilerOptions.rootDirs;
var relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) ||
removeExtensionAndIndexPostFix(ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), ending, compilerOptions);
- if (!baseUrl || relativePreference === 0) {
+ if (!baseUrl && !paths || relativePreference === 0) {
return relativePath;
}
- var relativeToBaseUrl = getRelativePathIfInDirectory(moduleFileName, baseUrl, getCanonicalFileName);
+ var baseDirectory = ts.getPathsBasePath(compilerOptions, host) || baseUrl;
+ var relativeToBaseUrl = getRelativePathIfInDirectory(moduleFileName, baseDirectory, getCanonicalFileName);
if (!relativeToBaseUrl) {
return relativePath;
}
var importRelativeToBaseUrl = removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions);
var fromPaths = paths && tryGetModuleNameFromPaths(ts.removeFileExtension(relativeToBaseUrl), importRelativeToBaseUrl, paths);
- var nonRelative = fromPaths === undefined ? importRelativeToBaseUrl : fromPaths;
+ var nonRelative = fromPaths === undefined && baseUrl !== undefined ? importRelativeToBaseUrl : fromPaths;
+ if (!nonRelative) {
+ return relativePath;
+ }
if (relativePreference === 1) {
return nonRelative;
}
var match = str.match(/\//g);
return match ? match.length : 0;
}
- function comparePathsByNumberOfDirectorySeparators(a, b) {
- return ts.compareValues(numberOfDirectorySeparators(a), numberOfDirectorySeparators(b));
+ function comparePathsByRedirectAndNumberOfDirectorySeparators(a, b) {
+ return ts.compareBooleans(b.isRedirect, a.isRedirect) || ts.compareValues(numberOfDirectorySeparators(a.path), numberOfDirectorySeparators(b.path));
}
function forEachFileNameOfModule(importingFileName, importedFileName, host, preferSymlinks, cb) {
var getCanonicalFileName = ts.hostGetCanonicalFileName(host);
var importedFileNames = __spreadArrays((referenceRedirect ? [referenceRedirect] : ts.emptyArray), [importedFileName], redirects);
var targets = importedFileNames.map(function (f) { return ts.getNormalizedAbsolutePath(f, cwd); });
if (!preferSymlinks) {
- var result_12 = ts.forEach(targets, cb);
- if (result_12)
- return result_12;
+ var result_15 = ts.forEach(targets, function (p) { return cb(p, referenceRedirect === p); });
+ if (result_15)
+ return result_15;
}
- var links = host.getProbableSymlinks
- ? host.getProbableSymlinks(host.getSourceFiles())
+ var links = host.getSymlinkCache
+ ? host.getSymlinkCache()
: ts.discoverProbableSymlinks(host.getSourceFiles(), getCanonicalFileName, cwd);
- var compareStrings = (!host.useCaseSensitiveFileNames || host.useCaseSensitiveFileNames()) ? ts.compareStringsCaseSensitive : ts.compareStringsCaseInsensitive;
- var result = ts.forEachEntry(links, function (resolved, path) {
- if (ts.startsWithDirectory(importingFileName, resolved, getCanonicalFileName)) {
+ var symlinkedDirectories = links.getSymlinkedDirectories();
+ var useCaseSensitiveFileNames = !host.useCaseSensitiveFileNames || host.useCaseSensitiveFileNames();
+ var result = symlinkedDirectories && ts.forEachEntry(symlinkedDirectories, function (resolved, path) {
+ if (resolved === false)
return undefined;
- }
- var target = ts.find(targets, function (t) { return compareStrings(t.slice(0, resolved.length + 1), resolved + "/") === 0; });
- if (target === undefined)
+ if (ts.startsWithDirectory(importingFileName, resolved.realPath, getCanonicalFileName)) {
return undefined;
- var relative = ts.getRelativePathFromDirectory(resolved, target, getCanonicalFileName);
- var option = ts.resolvePath(path, relative);
- if (!host.fileExists || host.fileExists(option)) {
- var result_13 = cb(option);
- if (result_13)
- return result_13;
}
+ return ts.forEach(targets, function (target) {
+ if (!ts.containsPath(resolved.real, target, !useCaseSensitiveFileNames)) {
+ return;
+ }
+ var relative = ts.getRelativePathFromDirectory(resolved.real, target, getCanonicalFileName);
+ var option = ts.resolvePath(path, relative);
+ if (!host.fileExists || host.fileExists(option)) {
+ var result_16 = cb(option, target === referenceRedirect);
+ if (result_16)
+ return result_16;
+ }
+ });
});
return result ||
- (preferSymlinks ? ts.forEach(targets, cb) : undefined);
+ (preferSymlinks ? ts.forEach(targets, function (p) { return cb(p, p === referenceRedirect); }) : undefined);
}
moduleSpecifiers.forEachFileNameOfModule = forEachFileNameOfModule;
function getAllModulePaths(importingFileName, importedFileName, host) {
var cwd = host.getCurrentDirectory();
var getCanonicalFileName = ts.hostGetCanonicalFileName(host);
- var allFileNames = ts.createMap();
+ var allFileNames = new ts.Map();
var importedFileFromNodeModules = false;
- forEachFileNameOfModule(importingFileName, importedFileName, host, true, function (path) {
- allFileNames.set(path, getCanonicalFileName(path));
- importedFileFromNodeModules = importedFileFromNodeModules || ts.pathContainsNodeModules(path);
+ forEachFileNameOfModule(importingFileName, importedFileName, host, true, function (path, isRedirect) {
+ var isInNodeModules = ts.pathContainsNodeModules(path);
+ allFileNames.set(path, { path: getCanonicalFileName(path), isRedirect: isRedirect, isInNodeModules: isInNodeModules });
+ importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules;
});
var sortedPaths = [];
- var _loop_20 = function (directory) {
+ var _loop_24 = function (directory) {
var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
var pathsInDirectory;
- allFileNames.forEach(function (canonicalFileName, fileName) {
- if (ts.startsWith(canonicalFileName, directoryStart)) {
- if (!importedFileFromNodeModules || ts.pathContainsNodeModules(fileName)) {
- (pathsInDirectory || (pathsInDirectory = [])).push(fileName);
- }
+ allFileNames.forEach(function (_a, fileName) {
+ var path = _a.path, isRedirect = _a.isRedirect, isInNodeModules = _a.isInNodeModules;
+ if (ts.startsWith(path, directoryStart)) {
+ (pathsInDirectory || (pathsInDirectory = [])).push({ path: fileName, isRedirect: isRedirect, isInNodeModules: isInNodeModules });
allFileNames.delete(fileName);
}
});
if (pathsInDirectory) {
if (pathsInDirectory.length > 1) {
- pathsInDirectory.sort(comparePathsByNumberOfDirectorySeparators);
+ pathsInDirectory.sort(comparePathsByRedirectAndNumberOfDirectorySeparators);
}
sortedPaths.push.apply(sortedPaths, pathsInDirectory);
}
};
var out_directory_1;
for (var directory = ts.getDirectoryPath(ts.toPath(importingFileName, cwd, getCanonicalFileName)); allFileNames.size !== 0;) {
- var state_8 = _loop_20(directory);
+ var state_8 = _loop_24(directory);
directory = out_directory_1;
if (state_8 === "break")
break;
if (allFileNames.size) {
var remainingPaths = ts.arrayFrom(allFileNames.values());
if (remainingPaths.length > 1)
- remainingPaths.sort(comparePathsByNumberOfDirectorySeparators);
+ remainingPaths.sort(comparePathsByRedirectAndNumberOfDirectorySeparators);
sortedPaths.push.apply(sortedPaths, remainingPaths);
}
return sortedPaths;
? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions)
: ts.removeFileExtension(relativePath);
}
- function tryGetModuleNameAsNodeModule(moduleFileName, _a, host, options, packageNameOnly) {
- var getCanonicalFileName = _a.getCanonicalFileName, sourceDirectory = _a.sourceDirectory;
+ function tryGetModuleNameAsNodeModule(_a, _b, host, options, packageNameOnly) {
+ var path = _a.path, isRedirect = _a.isRedirect;
+ var getCanonicalFileName = _b.getCanonicalFileName, sourceDirectory = _b.sourceDirectory;
if (!host.fileExists || !host.readFile) {
return undefined;
}
- var parts = getNodeModulePathParts(moduleFileName);
+ var parts = getNodeModulePathParts(path);
if (!parts) {
return undefined;
}
- var moduleSpecifier = moduleFileName;
+ var moduleSpecifier = path;
+ var isPackageRootPath = false;
if (!packageNameOnly) {
var packageRootIndex = parts.packageRootIndex;
var moduleFileNameForExtensionless = void 0;
while (true) {
- var _b = tryDirectoryWithPackageJson(packageRootIndex), moduleFileToTry = _b.moduleFileToTry, packageRootPath = _b.packageRootPath;
+ var _c = tryDirectoryWithPackageJson(packageRootIndex), moduleFileToTry = _c.moduleFileToTry, packageRootPath = _c.packageRootPath;
if (packageRootPath) {
moduleSpecifier = packageRootPath;
+ isPackageRootPath = true;
break;
}
if (!moduleFileNameForExtensionless)
moduleFileNameForExtensionless = moduleFileToTry;
- packageRootIndex = moduleFileName.indexOf(ts.directorySeparator, packageRootIndex + 1);
+ packageRootIndex = path.indexOf(ts.directorySeparator, packageRootIndex + 1);
if (packageRootIndex === -1) {
moduleSpecifier = getExtensionlessFileName(moduleFileNameForExtensionless);
break;
}
}
}
+ if (isRedirect && !isPackageRootPath) {
+ return undefined;
+ }
var globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation();
var pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex));
if (!(ts.startsWith(sourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && ts.startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) {
var packageName = ts.getPackageNameFromTypesPackageName(nodeModulesDirectoryName);
return ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs && packageName === nodeModulesDirectoryName ? undefined : packageName;
function tryDirectoryWithPackageJson(packageRootIndex) {
- var packageRootPath = moduleFileName.substring(0, packageRootIndex);
+ var packageRootPath = path.substring(0, packageRootIndex);
var packageJsonPath = ts.combinePaths(packageRootPath, "package.json");
- var moduleFileToTry = moduleFileName;
+ var moduleFileToTry = path;
if (host.fileExists(packageJsonPath)) {
var packageJsonContent = JSON.parse(host.readFile(packageJsonPath));
var versionPaths = packageJsonContent.typesVersions
? ts.getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions)
: undefined;
if (versionPaths) {
- var subModuleName = moduleFileName.slice(packageRootPath.length + 1);
+ var subModuleName = path.slice(packageRootPath.length + 1);
var fromPaths = tryGetModuleNameFromPaths(ts.removeFileExtension(subModuleName), removeExtensionAndIndexPostFix(subModuleName, 0, options), versionPaths.paths);
if (fromPaths !== undefined) {
moduleFileToTry = ts.combinePaths(packageRootPath, fromPaths);
}
ts.emitFilesAndReportErrorsAndGetExitStatus = emitFilesAndReportErrorsAndGetExitStatus;
ts.noopFileWatcher = { close: ts.noop };
+ ts.returnNoopFileWatcher = function () { return ts.noopFileWatcher; };
function createWatchHost(system, reportWatchStatus) {
if (system === void 0) { system = ts.sys; }
var onWatchStatusChange = reportWatchStatus || createWatchStatusReporter(system);
return {
onWatchStatusChange: onWatchStatusChange,
- watchFile: ts.maybeBind(system, system.watchFile) || (function () { return ts.noopFileWatcher; }),
- watchDirectory: ts.maybeBind(system, system.watchDirectory) || (function () { return ts.noopFileWatcher; }),
+ watchFile: ts.maybeBind(system, system.watchFile) || ts.returnNoopFileWatcher,
+ watchDirectory: ts.maybeBind(system, system.watchDirectory) || ts.returnNoopFileWatcher,
setTimeout: ts.maybeBind(system, system.setTimeout) || ts.noop,
clearTimeout: ts.maybeBind(system, system.clearTimeout) || ts.noop
};
ts.createCompilerHostFromProgramHost = createCompilerHostFromProgramHost;
function setGetSourceFileAsHashVersioned(compilerHost, host) {
var originalGetSourceFile = compilerHost.getSourceFile;
- var computeHash = host.createHash || ts.generateDjb2Hash;
+ var computeHash = ts.maybeBind(host, host.createHash) || ts.generateDjb2Hash;
compilerHost.getSourceFile = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
}
var result = originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArrays([compilerHost], args));
if (result) {
- result.version = computeHash.call(host, result.text);
+ result.version = computeHash(result.text);
}
return result;
};
var ts;
(function (ts) {
function readBuilderProgram(compilerOptions, host) {
- if (compilerOptions.out || compilerOptions.outFile)
+ if (ts.outFile(compilerOptions))
return undefined;
var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(compilerOptions);
if (!buildInfoPath)
var missingFilesMap;
var watchedWildcardDirectories;
var timerToUpdateProgram;
- var sourceFilesCache = ts.createMap();
+ var timerToInvalidateFailedLookupResolutions;
+ var sourceFilesCache = new ts.Map();
var missingFilePathsRequestedForRelease;
var hasChangedCompilerOptions = false;
- var hasChangedAutomaticTypeDirectiveNames = false;
var useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
var currentDirectory = host.getCurrentDirectory();
var configFileName = host.configFileName, _a = host.optionsToExtend, optionsToExtendForConfigFile = _a === void 0 ? {} : _a, watchOptionsToExtend = host.watchOptionsToExtend, extraFileExtensions = host.extraFileExtensions, createProgram = host.createProgram;
compilerHost.watchDirectoryOfFailedLookupLocation = function (dir, cb, flags) { return watchDirectory(host, dir, cb, flags, watchOptions, ts.WatchType.FailedLookupLocations); };
compilerHost.watchTypeRootsDirectory = function (dir, cb, flags) { return watchDirectory(host, dir, cb, flags, watchOptions, ts.WatchType.TypeRoots); };
compilerHost.getCachedDirectoryStructureHost = function () { return cachedDirectoryStructureHost; };
+ compilerHost.scheduleInvalidateResolutionsOfFailedLookupLocations = scheduleInvalidateResolutionsOfFailedLookupLocations;
compilerHost.onInvalidatedResolution = scheduleProgramUpdate;
- compilerHost.onChangedAutomaticTypeDirectiveNames = function () {
- hasChangedAutomaticTypeDirectiveNames = true;
- scheduleProgramUpdate();
- };
+ compilerHost.onChangedAutomaticTypeDirectiveNames = scheduleProgramUpdate;
compilerHost.fileIsOpen = ts.returnFalse;
compilerHost.getCurrentProgram = getCurrentProgram;
compilerHost.writeLog = writeLog;
{ getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, close: close } :
{ getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, updateRootFileNames: updateRootFileNames, close: close };
function close() {
+ clearInvalidateResolutionsOfFailedLookupLocations();
resolutionCache.clear();
ts.clearMap(sourceFilesCache, function (value) {
if (value && value.fileWatcher) {
}
function synchronizeProgram() {
writeLog("Synchronizing program");
+ clearInvalidateResolutionsOfFailedLookupLocations();
var program = getCurrentBuilderProgram();
if (hasChangedCompilerOptions) {
newLine = updateNewLine();
resolutionCache.startCachingPerDirectoryResolution();
compilerHost.hasInvalidatedResolution = hasInvalidatedResolution;
compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
- hasChangedAutomaticTypeDirectiveNames = false;
builderProgram = createProgram(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
resolutionCache.finishCachingPerDirectoryResolution();
- ts.updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = ts.createMap()), watchMissingFilePath);
+ ts.updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = new ts.Map()), watchMissingFilePath);
if (needsUpdateInTypeRootWatch) {
resolutionCache.updateTypeRootsWatch();
}
host.onWatchStatusChange(ts.createCompilerDiagnostic(message), newLine, compilerOptions || optionsToExtendForConfigFile);
}
}
+ function hasChangedAutomaticTypeDirectiveNames() {
+ return resolutionCache.hasChangedAutomaticTypeDirectiveNames();
+ }
+ function clearInvalidateResolutionsOfFailedLookupLocations() {
+ if (!timerToInvalidateFailedLookupResolutions)
+ return false;
+ host.clearTimeout(timerToInvalidateFailedLookupResolutions);
+ timerToInvalidateFailedLookupResolutions = undefined;
+ return true;
+ }
+ function scheduleInvalidateResolutionsOfFailedLookupLocations() {
+ if (!host.setTimeout || !host.clearTimeout) {
+ return resolutionCache.invalidateResolutionsOfFailedLookupLocations();
+ }
+ var pending = clearInvalidateResolutionsOfFailedLookupLocations();
+ writeLog("Scheduling invalidateFailedLookup" + (pending ? ", Cancelled earlier one" : ""));
+ timerToInvalidateFailedLookupResolutions = host.setTimeout(invalidateResolutionsOfFailedLookup, 250);
+ }
+ function invalidateResolutionsOfFailedLookup() {
+ timerToInvalidateFailedLookupResolutions = undefined;
+ if (resolutionCache.invalidateResolutionsOfFailedLookupLocations()) {
+ scheduleProgramUpdate();
+ }
+ }
function scheduleProgramUpdate() {
if (!host.setTimeout || !host.clearTimeout) {
return;
}
function reloadFileNamesFromConfigFile() {
writeLog("Reloading new file names and options");
- var result = ts.getFileNamesFromConfigSpecs(configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost);
+ var result = ts.getFileNamesFromConfigSpecs(configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions);
if (ts.updateErrorForNoInputFiles(result, ts.getNormalizedAbsolutePath(configFileName, currentDirectory), configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) {
hasChangedConfigFileParsingErrors = true;
}
configFileSpecs = configFileParseResult.configFileSpecs;
projectReferences = configFileParseResult.projectReferences;
configFileParsingDiagnostics = ts.getConfigFileParsingDiagnostics(configFileParseResult).slice();
- canConfigFileJsonReportNoInputFiles = ts.canJsonReportNoInutFiles(configFileParseResult.raw);
+ canConfigFileJsonReportNoInputFiles = ts.canJsonReportNoInputFiles(configFileParseResult.raw);
hasChangedConfigFileParsingErrors = true;
}
function onSourceFileChange(fileName, eventKind, path) {
}
function watchConfigFileWildCardDirectories() {
if (configFileSpecs) {
- ts.updateWatchingWildcardDirectories(watchedWildcardDirectories || (watchedWildcardDirectories = ts.createMap()), ts.createMapFromTemplate(configFileSpecs.wildcardDirectories), watchWildcardDirectory);
+ ts.updateWatchingWildcardDirectories(watchedWildcardDirectories || (watchedWildcardDirectories = new ts.Map()), new ts.Map(ts.getEntries(configFileSpecs.wildcardDirectories)), watchWildcardDirectory);
}
else if (watchedWildcardDirectories) {
ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf);
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
}
nextSourceFileVersion(fileOrDirectoryPath);
- fileOrDirectoryPath = ts.removeIgnoredPath(fileOrDirectoryPath);
- if (!fileOrDirectoryPath)
- return;
- if (fileOrDirectoryPath !== directory && ts.hasExtension(fileOrDirectoryPath) && !ts.isSupportedSourceFileName(fileOrDirectory, compilerOptions)) {
- writeLog("Project: " + configFileName + " Detected file add/remove of non supported extension: " + fileOrDirectory);
+ if (ts.isIgnoredFileFromWildCardWatching({
+ watchedDirPath: toPath(directory),
+ fileOrDirectory: fileOrDirectory,
+ fileOrDirectoryPath: fileOrDirectoryPath,
+ configFileName: configFileName,
+ configFileSpecs: configFileSpecs,
+ extraFileExtensions: extraFileExtensions,
+ options: compilerOptions,
+ program: getCurrentBuilderProgram(),
+ currentDirectory: currentDirectory,
+ useCaseSensitiveFileNames: useCaseSensitiveFileNames,
+ writeLog: writeLog
+ }))
return;
- }
if (reloadLevel !== ts.ConfigFileProgramReloadLevel.Full) {
reloadLevel = ts.ConfigFileProgramReloadLevel.Partial;
scheduleProgramUpdate();
BuildResultFlags[BuildResultFlags["EmitErrors"] = 64] = "EmitErrors";
BuildResultFlags[BuildResultFlags["AnyErrors"] = 124] = "AnyErrors";
})(BuildResultFlags || (BuildResultFlags = {}));
- function createConfigFileMap() {
- return ts.createMap();
- }
function getOrCreateValueFromConfigFileMap(configFileMap, resolved, createT) {
var existingValue = configFileMap.get(resolved);
var newValue;
return existingValue || newValue;
}
function getOrCreateValueMapFromConfigFileMap(configFileMap, resolved) {
- return getOrCreateValueFromConfigFileMap(configFileMap, resolved, ts.createMap);
+ return getOrCreateValueFromConfigFileMap(configFileMap, resolved, function () { return new ts.Map(); });
}
function newer(date1, date2) {
return date2 > date1 ? date2 : date1;
baseCompilerOptions: baseCompilerOptions,
rootNames: rootNames,
baseWatchOptions: baseWatchOptions,
- resolvedConfigFilePaths: ts.createMap(),
- configFileCache: createConfigFileMap(),
- projectStatus: createConfigFileMap(),
- buildInfoChecked: createConfigFileMap(),
- extendedConfigCache: ts.createMap(),
- builderPrograms: createConfigFileMap(),
- diagnostics: createConfigFileMap(),
- projectPendingBuild: createConfigFileMap(),
- projectErrorsReported: createConfigFileMap(),
+ resolvedConfigFilePaths: new ts.Map(),
+ configFileCache: new ts.Map(),
+ projectStatus: new ts.Map(),
+ buildInfoChecked: new ts.Map(),
+ extendedConfigCache: new ts.Map(),
+ builderPrograms: new ts.Map(),
+ diagnostics: new ts.Map(),
+ projectPendingBuild: new ts.Map(),
+ projectErrorsReported: new ts.Map(),
compilerHost: compilerHost,
moduleResolutionCache: moduleResolutionCache,
buildOrder: undefined,
watchAllProjectsPending: watch,
currentInvalidatedProject: undefined,
watch: watch,
- allWatchedWildcardDirectories: createConfigFileMap(),
- allWatchedInputFiles: createConfigFileMap(),
- allWatchedConfigFiles: createConfigFileMap(),
+ allWatchedWildcardDirectories: new ts.Map(),
+ allWatchedInputFiles: new ts.Map(),
+ allWatchedConfigFiles: new ts.Map(),
timerToBuildInvalidatedProject: undefined,
reportFileChangeDetected: false,
watchFile: watchFile,
return ts.resolveConfigFileProjectName(ts.resolvePath(state.currentDirectory, name));
}
function createBuildOrder(state, roots) {
- var temporaryMarks = ts.createMap();
- var permanentMarks = ts.createMap();
+ var temporaryMarks = new ts.Map();
+ var permanentMarks = new ts.Map();
var circularityReportStack = [];
var buildOrder;
var circularDiagnostics;
function createStateBuildOrder(state) {
var buildOrder = createBuildOrder(state, state.rootNames.map(function (f) { return resolveProjectName(state, f); }));
state.resolvedConfigFilePaths.clear();
- var currentProjects = ts.arrayToSet(getBuildOrderFromAnyBuildOrder(buildOrder), function (resolved) { return toResolvedConfigFilePath(state, resolved); });
+ var currentProjects = new ts.Map(getBuildOrderFromAnyBuildOrder(buildOrder).map(function (resolved) { return [toResolvedConfigFilePath(state, resolved), true]; }));
var noopOnDelete = { onDeleteValue: ts.noop };
ts.mutateMapSkippingNewValues(state.configFileCache, currentProjects, noopOnDelete);
ts.mutateMapSkippingNewValues(state.projectStatus, currentProjects, noopOnDelete);
}
};
}
+ var BuildStep;
+ (function (BuildStep) {
+ BuildStep[BuildStep["CreateProgram"] = 0] = "CreateProgram";
+ BuildStep[BuildStep["SyntaxDiagnostics"] = 1] = "SyntaxDiagnostics";
+ BuildStep[BuildStep["SemanticDiagnostics"] = 2] = "SemanticDiagnostics";
+ BuildStep[BuildStep["Emit"] = 3] = "Emit";
+ BuildStep[BuildStep["EmitBundle"] = 4] = "EmitBundle";
+ BuildStep[BuildStep["EmitBuildInfo"] = 5] = "EmitBuildInfo";
+ BuildStep[BuildStep["BuildInvalidatedProjectOfBundle"] = 6] = "BuildInvalidatedProjectOfBundle";
+ BuildStep[BuildStep["QueueReferencingProjects"] = 7] = "QueueReferencingProjects";
+ BuildStep[BuildStep["Done"] = 8] = "Done";
+ })(BuildStep || (BuildStep = {}));
function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath, projectIndex, config, buildOrder) {
- var Step;
- (function (Step) {
- Step[Step["CreateProgram"] = 0] = "CreateProgram";
- Step[Step["SyntaxDiagnostics"] = 1] = "SyntaxDiagnostics";
- Step[Step["SemanticDiagnostics"] = 2] = "SemanticDiagnostics";
- Step[Step["Emit"] = 3] = "Emit";
- Step[Step["EmitBundle"] = 4] = "EmitBundle";
- Step[Step["BuildInvalidatedProjectOfBundle"] = 5] = "BuildInvalidatedProjectOfBundle";
- Step[Step["QueueReferencingProjects"] = 6] = "QueueReferencingProjects";
- Step[Step["Done"] = 7] = "Done";
- })(Step || (Step = {}));
- var step = kind === InvalidatedProjectKind.Build ? Step.CreateProgram : Step.EmitBundle;
+ var step = kind === InvalidatedProjectKind.Build ? BuildStep.CreateProgram : BuildStep.EmitBundle;
var program;
var buildResult;
var invalidatedProjectOfBundle;
if (targetSourceFile || emitOnlyDtsFiles) {
return withProgramOrUndefined(function (program) { return program.emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers); });
}
- executeSteps(Step.SemanticDiagnostics, cancellationToken);
- if (step !== Step.Emit)
+ executeSteps(BuildStep.SemanticDiagnostics, cancellationToken);
+ if (step === BuildStep.EmitBuildInfo) {
+ return emitBuildInfo(writeFile, cancellationToken);
+ }
+ if (step !== BuildStep.Emit)
return undefined;
return emit(writeFile, cancellationToken, customTransformers);
},
getCompilerOptions: function () { return config.options; },
getCurrentDirectory: function () { return state.currentDirectory; },
emit: function (writeFile, customTransformers) {
- if (step !== Step.EmitBundle)
+ if (step !== BuildStep.EmitBundle)
return invalidatedProjectOfBundle;
return emitBundle(writeFile, customTransformers);
},
done: done,
};
function done(cancellationToken, writeFile, customTransformers) {
- executeSteps(Step.Done, cancellationToken, writeFile, customTransformers);
+ executeSteps(BuildStep.Done, cancellationToken, writeFile, customTransformers);
return doneInvalidatedProject(state, projectPath);
}
function withProgramOrUndefined(action) {
- executeSteps(Step.CreateProgram);
+ executeSteps(BuildStep.CreateProgram);
return program && action(program);
}
function withProgramOrEmptyArray(action) {
if (state.options.dry) {
reportStatus(state, ts.Diagnostics.A_non_dry_build_would_build_project_0, project);
buildResult = BuildResultFlags.Success;
- step = Step.QueueReferencingProjects;
+ step = BuildStep.QueueReferencingProjects;
return;
}
if (state.options.verbose)
if (config.fileNames.length === 0) {
reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
buildResult = BuildResultFlags.None;
- step = Step.QueueReferencingProjects;
+ step = BuildStep.QueueReferencingProjects;
return;
}
var host = state.host, compilerHost = state.compilerHost;
state.projectCompilerOptions = config.options;
updateModuleResolutionCache(state, project, config);
program = host.createProgram(config.fileNames, config.options, compilerHost, getOldProgram(state, projectPath, config), ts.getConfigFileParsingDiagnostics(config), config.projectReferences);
+ if (state.watch) {
+ state.builderPrograms.set(projectPath, program);
+ }
step++;
}
function handleDiagnostics(diagnostics, errorFlags, errorType) {
+ var _a;
if (diagnostics.length) {
- buildResult = buildErrors(state, projectPath, program, config, diagnostics, errorFlags, errorType);
- step = Step.QueueReferencingProjects;
+ (_a = buildErrors(state, projectPath, program, config, diagnostics, errorFlags, errorType), buildResult = _a.buildResult, step = _a.step);
}
else {
step++;
handleDiagnostics(ts.Debug.checkDefined(program).getSemanticDiagnostics(undefined, cancellationToken), BuildResultFlags.TypeErrors, "Semantic");
}
function emit(writeFileCallback, cancellationToken, customTransformers) {
+ var _a;
ts.Debug.assertIsDefined(program);
- ts.Debug.assert(step === Step.Emit);
+ ts.Debug.assert(step === BuildStep.Emit);
program.backupState();
var declDiagnostics;
var reportDeclarationDiagnostics = function (d) { return (declDiagnostics || (declDiagnostics = [])).push(d); };
var emitResult = ts.emitFilesAndReportErrors(program, reportDeclarationDiagnostics, undefined, undefined, function (name, text, writeByteOrderMark) { return outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); }, cancellationToken, false, customTransformers).emitResult;
if (declDiagnostics) {
program.restoreState();
- buildResult = buildErrors(state, projectPath, program, config, declDiagnostics, BuildResultFlags.DeclarationEmitErrors, "Declaration file");
- step = Step.QueueReferencingProjects;
+ (_a = buildErrors(state, projectPath, program, config, declDiagnostics, BuildResultFlags.DeclarationEmitErrors, "Declaration file"), buildResult = _a.buildResult, step = _a.step);
return {
emitSkipped: true,
diagnostics: emitResult.diagnostics
var newestDeclarationFileContentChangedTime = minimumDate;
var anyDtsChanged = false;
var emitterDiagnostics = ts.createDiagnosticCollection();
- var emittedOutputs = ts.createMap();
+ var emittedOutputs = new ts.Map();
outputFiles.forEach(function (_a) {
var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark;
var priorChangeTime;
finishEmit(emitterDiagnostics, emittedOutputs, newestDeclarationFileContentChangedTime, anyDtsChanged, outputFiles.length ? outputFiles[0].name : ts.getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()), resultFlags);
return emitResult;
}
+ function emitBuildInfo(writeFileCallback, cancellationToken) {
+ ts.Debug.assertIsDefined(program);
+ ts.Debug.assert(step === BuildStep.EmitBuildInfo);
+ var emitResult = program.emitBuildInfo(writeFileCallback, cancellationToken);
+ if (emitResult.diagnostics.length) {
+ reportErrors(state, emitResult.diagnostics);
+ state.diagnostics.set(projectPath, __spreadArrays(state.diagnostics.get(projectPath), emitResult.diagnostics));
+ buildResult = BuildResultFlags.EmitErrors & buildResult;
+ }
+ if (emitResult.emittedFiles && state.writeFileName) {
+ emitResult.emittedFiles.forEach(function (name) { return listEmittedFile(state, config, name); });
+ }
+ afterProgramDone(state, program, config);
+ step = BuildStep.QueueReferencingProjects;
+ return emitResult;
+ }
function finishEmit(emitterDiagnostics, emittedOutputs, priorNewestUpdateTime, newestDeclarationFileContentChangedTimeIsMaximumDate, oldestOutputFileName, resultFlags) {
+ var _a;
var emitDiagnostics = emitterDiagnostics.getDiagnostics();
if (emitDiagnostics.length) {
- buildResult = buildErrors(state, projectPath, program, config, emitDiagnostics, BuildResultFlags.EmitErrors, "Emit");
- step = Step.QueueReferencingProjects;
+ (_a = buildErrors(state, projectPath, program, config, emitDiagnostics, BuildResultFlags.EmitErrors, "Emit"), buildResult = _a.buildResult, step = _a.step);
return emitDiagnostics;
}
if (state.writeFileName) {
emittedOutputs.forEach(function (name) { return listEmittedFile(state, config, name); });
- if (program)
- ts.listFiles(program, state.writeFileName);
}
var newestDeclarationFileContentChangedTime = updateOutputTimestampsWorker(state, config, priorNewestUpdateTime, ts.Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs);
state.diagnostics.delete(projectPath);
newestDeclarationFileContentChangedTime,
oldestOutputFileName: oldestOutputFileName
});
- afterProgramDone(state, projectPath, program, config);
- state.projectCompilerOptions = state.baseCompilerOptions;
- step = Step.QueueReferencingProjects;
+ afterProgramDone(state, program, config);
+ step = BuildStep.QueueReferencingProjects;
buildResult = resultFlags;
return emitDiagnostics;
}
if (state.options.dry) {
reportStatus(state, ts.Diagnostics.A_non_dry_build_would_update_output_of_project_0, project);
buildResult = BuildResultFlags.Success;
- step = Step.QueueReferencingProjects;
+ step = BuildStep.QueueReferencingProjects;
return undefined;
}
if (state.options.verbose)
}, customTransformers);
if (ts.isString(outputFiles)) {
reportStatus(state, ts.Diagnostics.Cannot_update_output_of_project_0_because_there_was_error_reading_file_1, project, relName(state, outputFiles));
- step = Step.BuildInvalidatedProjectOfBundle;
+ step = BuildStep.BuildInvalidatedProjectOfBundle;
return invalidatedProjectOfBundle = createBuildOrUpdateInvalidedProject(InvalidatedProjectKind.Build, state, project, projectPath, projectIndex, config, buildOrder);
}
ts.Debug.assert(!!outputFiles.length);
var emitterDiagnostics = ts.createDiagnosticCollection();
- var emittedOutputs = ts.createMap();
+ var emittedOutputs = new ts.Map();
outputFiles.forEach(function (_a) {
var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark;
emittedOutputs.set(toPath(state, name), name);
return { emitSkipped: false, diagnostics: emitDiagnostics };
}
function executeSteps(till, cancellationToken, writeFile, customTransformers) {
- while (step <= till && step < Step.Done) {
+ while (step <= till && step < BuildStep.Done) {
var currentStep = step;
switch (step) {
- case Step.CreateProgram:
+ case BuildStep.CreateProgram:
createProgram();
break;
- case Step.SyntaxDiagnostics:
+ case BuildStep.SyntaxDiagnostics:
getSyntaxDiagnostics(cancellationToken);
break;
- case Step.SemanticDiagnostics:
+ case BuildStep.SemanticDiagnostics:
getSemanticDiagnostics(cancellationToken);
break;
- case Step.Emit:
+ case BuildStep.Emit:
emit(writeFile, cancellationToken, customTransformers);
break;
- case Step.EmitBundle:
+ case BuildStep.EmitBuildInfo:
+ emitBuildInfo(writeFile, cancellationToken);
+ break;
+ case BuildStep.EmitBundle:
emitBundle(writeFile, customTransformers);
break;
- case Step.BuildInvalidatedProjectOfBundle:
+ case BuildStep.BuildInvalidatedProjectOfBundle:
ts.Debug.checkDefined(invalidatedProjectOfBundle).done(cancellationToken);
- step = Step.Done;
+ step = BuildStep.Done;
break;
- case Step.QueueReferencingProjects:
+ case BuildStep.QueueReferencingProjects:
queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, ts.Debug.checkDefined(buildResult));
step++;
break;
- case Step.Done:
+ case BuildStep.Done:
default:
ts.assertType(step);
}
}
else if (reloadLevel === ts.ConfigFileProgramReloadLevel.Partial) {
var result = ts.getFileNamesFromConfigSpecs(config.configFileSpecs, ts.getDirectoryPath(project), config.options, state.parseConfigFileHost);
- ts.updateErrorForNoInputFiles(result, project, config.configFileSpecs, config.errors, ts.canJsonReportNoInutFiles(config.raw));
+ ts.updateErrorForNoInputFiles(result, project, config.configFileSpecs, config.errors, ts.canJsonReportNoInputFiles(config.raw));
config.fileNames = result.fileNames;
watchInputFiles(state, project, projectPath, config);
}
return value;
return ts.readBuilderProgram(parsed.options, compilerHost);
}
- function afterProgramDone(_a, proj, program, config) {
- var host = _a.host, watch = _a.watch, builderPrograms = _a.builderPrograms;
+ function afterProgramDone(state, program, config) {
if (program) {
- if (host.afterProgramEmitAndDiagnostics) {
- host.afterProgramEmitAndDiagnostics(program);
- }
- if (watch) {
- program.releaseProgram();
- builderPrograms.set(proj, program);
+ if (program && state.writeFileName)
+ ts.listFiles(program, state.writeFileName);
+ if (state.host.afterProgramEmitAndDiagnostics) {
+ state.host.afterProgramEmitAndDiagnostics(program);
}
+ program.releaseProgram();
}
- else if (host.afterEmitBundle) {
- host.afterEmitBundle(config);
+ else if (state.host.afterEmitBundle) {
+ state.host.afterEmitBundle(config);
}
+ state.projectCompilerOptions = state.baseCompilerOptions;
}
- function buildErrors(state, resolvedPath, program, config, diagnostics, errorFlags, errorType) {
+ function buildErrors(state, resolvedPath, program, config, diagnostics, buildResult, errorType) {
+ var canEmitBuildInfo = !(buildResult & BuildResultFlags.SyntaxErrors) && program && !ts.outFile(program.getCompilerOptions());
reportAndStoreErrors(state, resolvedPath, diagnostics);
- if (program && state.writeFileName)
- ts.listFiles(program, state.writeFileName);
state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.Unbuildable, reason: errorType + " errors" });
- afterProgramDone(state, resolvedPath, program, config);
- state.projectCompilerOptions = state.baseCompilerOptions;
- return errorFlags;
+ if (canEmitBuildInfo)
+ return { buildResult: buildResult, step: BuildStep.EmitBuildInfo };
+ afterProgramDone(state, program, config);
+ return { buildResult: buildResult, step: BuildStep.QueueReferencingProjects };
}
function updateModuleResolutionCache(state, proj, config) {
if (!state.moduleResolutionCache)
newestInputFileTime = inputTime;
}
}
- if (!project.fileNames.length && !ts.canJsonReportNoInutFiles(project.raw)) {
+ if (!project.fileNames.length && !ts.canJsonReportNoInputFiles(project.raw)) {
return {
type: ts.UpToDateStatusType.ContainerOnly
};
invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full);
}, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ConfigFile, resolved));
}
- function isSameFile(state, file1, file2) {
- return ts.comparePaths(file1, file2, state.currentDirectory, !state.host.useCaseSensitiveFileNames()) === 0;
- }
- function isOutputFile(state, fileName, configFile) {
- if (configFile.options.noEmit)
- return false;
- if (!ts.fileExtensionIs(fileName, ".d.ts") &&
- (ts.fileExtensionIs(fileName, ".ts") || ts.fileExtensionIs(fileName, ".tsx"))) {
- return false;
- }
- var out = configFile.options.outFile || configFile.options.out;
- if (out && (isSameFile(state, fileName, out) || isSameFile(state, fileName, ts.removeFileExtension(out) + ".d.ts"))) {
- return true;
- }
- if (configFile.options.declarationDir && ts.containsPath(configFile.options.declarationDir, fileName, state.currentDirectory, !state.host.useCaseSensitiveFileNames())) {
- return true;
- }
- if (configFile.options.outDir && ts.containsPath(configFile.options.outDir, fileName, state.currentDirectory, !state.host.useCaseSensitiveFileNames())) {
- return true;
- }
- return !ts.forEach(configFile.fileNames, function (inputFile) { return isSameFile(state, fileName, inputFile); });
- }
function watchWildCardDirectories(state, resolved, resolvedPath, parsed) {
if (!state.watch)
return;
- ts.updateWatchingWildcardDirectories(getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath), ts.createMapFromTemplate(parsed.configFileSpecs.wildcardDirectories), function (dir, flags) { return state.watchDirectory(state.hostWithWatch, dir, function (fileOrDirectory) {
- var fileOrDirectoryPath = toPath(state, fileOrDirectory);
- if (fileOrDirectoryPath !== toPath(state, dir) && ts.hasExtension(fileOrDirectoryPath) && !ts.isSupportedSourceFileName(fileOrDirectory, parsed.options)) {
- state.writeLog("Project: " + resolved + " Detected file add/remove of non supported extension: " + fileOrDirectory);
- return;
- }
- if (isOutputFile(state, fileOrDirectory, parsed)) {
- state.writeLog(fileOrDirectory + " is output file");
+ ts.updateWatchingWildcardDirectories(getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath), new ts.Map(ts.getEntries(parsed.configFileSpecs.wildcardDirectories)), function (dir, flags) { return state.watchDirectory(state.hostWithWatch, dir, function (fileOrDirectory) {
+ if (ts.isIgnoredFileFromWildCardWatching({
+ watchedDirPath: toPath(state, dir),
+ fileOrDirectory: fileOrDirectory,
+ fileOrDirectoryPath: toPath(state, fileOrDirectory),
+ configFileName: resolved,
+ configFileSpecs: parsed.configFileSpecs,
+ currentDirectory: state.currentDirectory,
+ options: parsed.options,
+ program: state.builderPrograms.get(resolvedPath),
+ useCaseSensitiveFileNames: state.parseConfigFileHost.useCaseSensitiveFileNames,
+ writeLog: function (s) { return state.writeLog(s); }
+ }))
return;
- }
invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Partial);
}, flags, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.WildcardDirectory, resolved); });
}
marginLength = 0;
var usageColumn = [];
var descriptionColumn = [];
- var optionsDescriptionMap = ts.createMap();
+ var optionsDescriptionMap = new ts.Map();
for (var _i = 0, optionsList_1 = optionsList; _i < optionsList_1.length; _i++) {
var option = optionsList_1[_i];
if (!option.description) {
updateSolutionBuilderHost(sys, cb, buildHost);
var builder = ts.createSolutionBuilder(buildHost, projects, buildOptions);
var exitStatus = buildOptions.clean ? builder.clean() : builder.build();
+ ts.tracing.dumpLegend();
return sys.exit(exitStatus);
}
function createReportErrorSummary(sys, options) {
var currentDirectory = host.getCurrentDirectory();
var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return ts.toPath(fileName, currentDirectory, getCanonicalFileName); });
- enableStatistics(sys, options);
+ enableStatisticsAndTracing(sys, options, false);
var programOptions = {
rootNames: fileNames,
options: options,
}
function performIncrementalCompilation(sys, cb, reportDiagnostic, config) {
var options = config.options, fileNames = config.fileNames, projectReferences = config.projectReferences;
- enableStatistics(sys, options);
+ enableStatisticsAndTracing(sys, options, false);
var host = ts.createIncrementalCompilerHost(options, sys);
var exitStatus = ts.performIncrementalCompilation({
host: host,
host.createProgram = function (rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences) {
ts.Debug.assert(rootNames !== undefined || (options === undefined && !!oldProgram));
if (options !== undefined) {
- enableStatistics(sys, options);
+ enableStatisticsAndTracing(sys, options, true);
}
return compileUsingBuilder(rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences);
};
function canReportDiagnostics(system, compilerOptions) {
return system === ts.sys && (compilerOptions.diagnostics || compilerOptions.extendedDiagnostics);
}
- function enableStatistics(sys, compilerOptions) {
- if (canReportDiagnostics(sys, compilerOptions)) {
+ function canTrace(system, compilerOptions) {
+ return system === ts.sys && compilerOptions.generateTrace;
+ }
+ function enableStatisticsAndTracing(system, compilerOptions, isBuildMode) {
+ if (canReportDiagnostics(system, compilerOptions)) {
ts.performance.enable();
}
+ if (canTrace(system, compilerOptions)) {
+ ts.tracing.startTracing(compilerOptions.configFilePath, compilerOptions.generateTrace, isBuildMode);
+ }
}
function reportStatistics(sys, program) {
- var statistics;
var compilerOptions = program.getCompilerOptions();
+ if (canTrace(sys, compilerOptions)) {
+ ts.tracing.stopTracing(program.getTypeCatalog());
+ }
+ var statistics;
if (canReportDiagnostics(sys, compilerOptions)) {
statistics = [];
var memoryUsed = sys.getMemoryUsage ? sys.getMemoryUsage() : -1;
if (memoryUsed >= 0) {
reportStatisticalValue("Memory used", Math.round(memoryUsed / 1000) + "K");
}
- var programTime = ts.performance.getDuration("Program");
- var bindTime = ts.performance.getDuration("Bind");
- var checkTime = ts.performance.getDuration("Check");
- var emitTime = ts.performance.getDuration("Emit");
+ var isPerformanceEnabled = ts.performance.isEnabled();
+ var programTime = isPerformanceEnabled ? ts.performance.getDuration("Program") : 0;
+ var bindTime = isPerformanceEnabled ? ts.performance.getDuration("Bind") : 0;
+ var checkTime = isPerformanceEnabled ? ts.performance.getDuration("Check") : 0;
+ var emitTime = isPerformanceEnabled ? ts.performance.getDuration("Emit") : 0;
if (compilerOptions.extendedDiagnostics) {
var 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);
- ts.performance.forEachMeasure(function (name, duration) { return reportTimeStatistic(name + " time", duration); });
+ if (isPerformanceEnabled) {
+ ts.performance.forEachMeasure(function (name, duration) { return reportTimeStatistic(name + " time", duration); });
+ }
}
- else {
+ else if (isPerformanceEnabled) {
reportTimeStatistic("I/O read", ts.performance.getDuration("I/O Read"));
reportTimeStatistic("I/O write", ts.performance.getDuration("I/O Write"));
reportTimeStatistic("Parse time", programTime);
reportTimeStatistic("Check time", checkTime);
reportTimeStatistic("Emit time", emitTime);
}
- reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime);
+ if (isPerformanceEnabled) {
+ reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime);
+ }
reportStatistics();
- ts.performance.disable();
+ if (!isPerformanceEnabled) {
+ sys.write(ts.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 {
+ ts.performance.disable();
+ }
}
function reportStatistics() {
var nameSize = 0;
}
})(ts || (ts = {}));
// This file actually uses arguments passed on commandline and executes it
+ts.Debug.loggingHost = {
+ log: function (_level, s) {
+ ts.sys.write("" + (s || "") + ts.sys.newLine);
+ }
+};
if (ts.Debug.isDebugging) {
ts.Debug.enableDebugInfo();
}
projects / dotfiles / .git / blobdiff