Compare commits
47 commits
Author | SHA1 | Date | |
---|---|---|---|
|
90600e1b17 | ||
|
a90389a22d | ||
|
0163a624b7 | ||
|
9766757ee6 | ||
|
868c275fdf | ||
|
6143237376 | ||
|
1ade73df2b | ||
|
de4ba0f208 | ||
|
a75f26e68b | ||
|
f11f14baba | ||
|
009dd487a6 | ||
|
0bf97296d6 | ||
|
fcdbc932bf | ||
|
7615547d42 | ||
|
719ab0b477 | ||
|
fe3e117cb2 | ||
|
1298f498f4 | ||
|
7b86a65f22 | ||
|
b12d5c5dc5 | ||
|
416571ca90 | ||
|
e5a6ae397d | ||
|
4a065f524c | ||
|
e040e8516f | ||
|
a05d851dc3 | ||
|
9713cc1a75 | ||
|
3ef3cdddb3 | ||
|
0a628ff0c9 | ||
|
2d4b243195 | ||
|
4fca1e1fcd | ||
|
ae582a22ee | ||
|
ff75b8a180 | ||
|
d53630fac3 | ||
|
7264cf7db5 | ||
|
e2f47a2db1 | ||
|
831b770b95 | ||
|
de23842e45 | ||
|
b8f8fd7a3e | ||
|
33fe1b6ffc | ||
|
373accf28f | ||
|
56f81075f9 | ||
|
7f8bf0b9c4 | ||
|
7cbcfeea99 | ||
|
2424d0e575 | ||
|
5142e37f2d | ||
|
fa2ad1a35a | ||
|
d89076381e | ||
|
6d33d8797b |
20
package-lock.json
generated
20
package-lock.json
generated
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "typescript",
|
||||
"version": "4.5.0",
|
||||
"version": "4.6.0",
|
||||
"lockfileVersion": 1,
|
||||
"requires": true,
|
||||
"dependencies": {
|
||||
|
@ -676,9 +676,9 @@
|
|||
"dev": true
|
||||
},
|
||||
"@types/node": {
|
||||
"version": "16.11.6",
|
||||
"resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.6.tgz",
|
||||
"integrity": "sha512-ua7PgUoeQFjmWPcoo9khiPum3Pd60k4/2ZGXt18sm2Slk0W0xZTqt5Y0Ny1NyBiN1EVQ/+FaF9NcY4Qe6rwk5w==",
|
||||
"version": "16.11.10",
|
||||
"resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.10.tgz",
|
||||
"integrity": "sha512-3aRnHa1KlOEEhJ6+CvyHKK5vE9BcLGjtUpwvqYLRvYNQKMfabu3BwfJaA/SLW8dxe28LsNDjtHwePTuzn3gmOA==",
|
||||
"dev": true
|
||||
},
|
||||
"@types/node-fetch": {
|
||||
|
@ -6997,9 +6997,9 @@
|
|||
}
|
||||
},
|
||||
"source-map-support": {
|
||||
"version": "0.5.20",
|
||||
"resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.20.tgz",
|
||||
"integrity": "sha512-n1lZZ8Ve4ksRqizaBQgxXDgKwttHDhyfQjA6YZZn8+AroHbsIz+JjwxQDxbp+7y5OYCI8t1Yk7etjD9CRd2hIw==",
|
||||
"version": "0.5.21",
|
||||
"resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
|
||||
"integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
|
||||
"dev": true,
|
||||
"requires": {
|
||||
"buffer-from": "^1.0.0",
|
||||
|
@ -8423,9 +8423,9 @@
|
|||
},
|
||||
"dependencies": {
|
||||
"camelcase": {
|
||||
"version": "6.2.0",
|
||||
"resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz",
|
||||
"integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==",
|
||||
"version": "6.2.1",
|
||||
"resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.1.tgz",
|
||||
"integrity": "sha512-tVI4q5jjFV5CavAU8DXfza/TJcZutVKo/5Foskmsqcm0MsL91moHvwiGNnqaa2o6PF/7yT5ikDRcVcl8Rj6LCA==",
|
||||
"dev": true
|
||||
},
|
||||
"decamelize": {
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
"name": "typescript",
|
||||
"author": "Microsoft Corp.",
|
||||
"homepage": "https://www.typescriptlang.org/",
|
||||
"version": "4.5.0",
|
||||
"version": "4.6.0",
|
||||
"license": "Apache-2.0",
|
||||
"description": "TypeScript is a language for application scale JavaScript development",
|
||||
"keywords": [
|
||||
|
|
|
@ -39,7 +39,7 @@ const execTsc = (lkg, ...args) =>
|
|||
exec(process.execPath,
|
||||
[resolve(findUpRoot(), lkg ? "./lib/tsc" : "./built/local/tsc"),
|
||||
"-b", ...args],
|
||||
{ hidePrompt: true })
|
||||
{ hidePrompt: true });
|
||||
|
||||
const projectBuilder = new ProjectQueue((projects, lkg, force) => execTsc(lkg, ...(force ? ["--force"] : []), ...projects));
|
||||
|
||||
|
|
|
@ -33,9 +33,9 @@ async function main() {
|
|||
|
||||
const inputPR = (await gh.pulls.get({ pull_number: +process.env.SOURCE_ISSUE, owner: "microsoft", repo: "TypeScript" })).data;
|
||||
let remoteName = "origin";
|
||||
if (inputPR.base.repo.git_url !== `git:github.com/microsoft/TypeScript`) {
|
||||
if (inputPR.base.repo.git_url !== `git:github.com/microsoft/TypeScript` && inputPR.base.repo.git_url !== `git://github.com/microsoft/TypeScript`) {
|
||||
runSequence([
|
||||
["git", ["remote", "add", "nonlocal", inputPR.base.repo.git_url]]
|
||||
["git", ["remote", "add", "nonlocal", inputPR.base.repo.git_url.replace(/^git:(?:\/\/)?/, "https://")]]
|
||||
]);
|
||||
remoteName = "nonlocal";
|
||||
}
|
||||
|
|
|
@ -5657,8 +5657,8 @@ namespace ts {
|
|||
const expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
|
||||
// If the expanded parameter list had a variadic in a non-trailing position, don't expand it
|
||||
const parameters = (some(expandedParams, p => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & CheckFlags.RestParameter)) ? signature.parameters : expandedParams).map(parameter => symbolToParameterDeclaration(parameter, context, kind === SyntaxKind.Constructor, options?.privateSymbolVisitor, options?.bundledImports));
|
||||
if (signature.thisParameter) {
|
||||
const thisParameter = symbolToParameterDeclaration(signature.thisParameter, context);
|
||||
const thisParameter = tryGetThisParameterDeclaration(signature, context);
|
||||
if (thisParameter) {
|
||||
parameters.unshift(thisParameter);
|
||||
}
|
||||
|
||||
|
@ -5713,6 +5713,25 @@ namespace ts {
|
|||
return node;
|
||||
}
|
||||
|
||||
function tryGetThisParameterDeclaration(signature: Signature, context: NodeBuilderContext) {
|
||||
if (signature.thisParameter) {
|
||||
return symbolToParameterDeclaration(signature.thisParameter, context);
|
||||
}
|
||||
if (signature.declaration) {
|
||||
const thisTag = getJSDocThisTag(signature.declaration);
|
||||
if (thisTag && thisTag.typeExpression) {
|
||||
return factory.createParameterDeclaration(
|
||||
/* decorators */ undefined,
|
||||
/* modifiers */ undefined,
|
||||
/* dotDotDotToken */ undefined,
|
||||
"this",
|
||||
/* questionToken */ undefined,
|
||||
typeToTypeNodeHelper(getTypeFromTypeNode(thisTag.typeExpression), context)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function typeParameterToDeclarationWithConstraint(type: TypeParameter, context: NodeBuilderContext, constraintNode: TypeNode | undefined): TypeParameterDeclaration {
|
||||
const savedContextFlags = context.flags;
|
||||
context.flags &= ~NodeBuilderFlags.WriteTypeParametersInQualifiedName; // Avoids potential infinite loop when building for a claimspace with a generic
|
||||
|
@ -6204,12 +6223,8 @@ namespace ts {
|
|||
firstChar = symbolName.charCodeAt(0);
|
||||
}
|
||||
let expression: Expression | undefined;
|
||||
if (isSingleOrDoubleQuote(firstChar)) {
|
||||
expression = factory.createStringLiteral(
|
||||
symbolName
|
||||
.substring(1, symbolName.length - 1)
|
||||
.replace(/\\./g, s => s.substring(1)),
|
||||
firstChar === CharacterCodes.singleQuote);
|
||||
if (isSingleOrDoubleQuote(firstChar) && !(symbol.flags & SymbolFlags.EnumMember)) {
|
||||
expression = factory.createStringLiteral(stripQuotes(symbolName).replace(/\\./g, s => s.substring(1)), firstChar === CharacterCodes.singleQuote);
|
||||
}
|
||||
else if (("" + +symbolName) === symbolName) {
|
||||
expression = factory.createNumericLiteral(+symbolName);
|
||||
|
@ -8544,12 +8559,16 @@ namespace ts {
|
|||
|
||||
/** Return the inferred type for a binding element */
|
||||
function getTypeForBindingElement(declaration: BindingElement): Type | undefined {
|
||||
const pattern = declaration.parent;
|
||||
let parentType = getTypeForBindingElementParent(pattern.parent);
|
||||
// If no type or an any type was inferred for parent, infer that for the binding element
|
||||
if (!parentType || isTypeAny(parentType)) {
|
||||
const parentType = getTypeForBindingElementParent(declaration.parent.parent);
|
||||
return parentType && getBindingElementTypeFromParentType(declaration, parentType);
|
||||
}
|
||||
|
||||
function getBindingElementTypeFromParentType(declaration: BindingElement, parentType: Type): Type {
|
||||
// If an any type was inferred for parent, infer that for the binding element
|
||||
if (isTypeAny(parentType)) {
|
||||
return parentType;
|
||||
}
|
||||
const pattern = declaration.parent;
|
||||
// Relax null check on ambient destructuring parameters, since the parameters have no implementation and are just documentation
|
||||
if (strictNullChecks && declaration.flags & NodeFlags.Ambient && isParameterDeclaration(declaration)) {
|
||||
parentType = getNonNullableType(parentType);
|
||||
|
@ -14153,6 +14172,7 @@ namespace ts {
|
|||
// We ignore 'never' types in unions
|
||||
if (!(flags & TypeFlags.Never)) {
|
||||
includes |= flags & TypeFlags.IncludesMask;
|
||||
if (flags & TypeFlags.Instantiable) includes |= TypeFlags.IncludesInstantiable;
|
||||
if (type === wildcardType) includes |= TypeFlags.IncludesWildcard;
|
||||
if (!strictNullChecks && flags & TypeFlags.Nullable) {
|
||||
if (!(getObjectFlags(type) & ObjectFlags.ContainsWideningType)) includes |= TypeFlags.IncludesNonWideningType;
|
||||
|
@ -16008,7 +16028,7 @@ namespace ts {
|
|||
const declarations = concatenate(leftProp.declarations, rightProp.declarations);
|
||||
const flags = SymbolFlags.Property | (leftProp.flags & SymbolFlags.Optional);
|
||||
const result = createSymbol(flags, leftProp.escapedName);
|
||||
result.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)]);
|
||||
result.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)], UnionReduction.Subtype);
|
||||
result.leftSpread = leftProp;
|
||||
result.rightSpread = rightProp;
|
||||
result.declarations = declarations;
|
||||
|
@ -17803,7 +17823,7 @@ namespace ts {
|
|||
if (source.flags & TypeFlags.Singleton) return true;
|
||||
}
|
||||
if (source.flags & TypeFlags.Object && target.flags & TypeFlags.Object) {
|
||||
const related = relation.get(getRelationKey(source, target, IntersectionState.None, relation));
|
||||
const related = relation.get(getRelationKey(source, target, IntersectionState.None, relation, /*ignoreConstraints*/ false));
|
||||
if (related !== undefined) {
|
||||
return !!(related & RelationComparisonResult.Succeeded);
|
||||
}
|
||||
|
@ -18703,7 +18723,8 @@ namespace ts {
|
|||
if (overflow) {
|
||||
return Ternary.False;
|
||||
}
|
||||
const id = getRelationKey(source, target, intersectionState | (inPropertyCheck ? IntersectionState.InPropertyCheck : 0), relation);
|
||||
const keyIntersectionState = intersectionState | (inPropertyCheck ? IntersectionState.InPropertyCheck : 0);
|
||||
const id = getRelationKey(source, target, keyIntersectionState, relation, /*ingnoreConstraints*/ false);
|
||||
const entry = relation.get(id);
|
||||
if (entry !== undefined) {
|
||||
if (reportErrors && entry & RelationComparisonResult.Failed && !(entry & RelationComparisonResult.Reported)) {
|
||||
|
@ -18730,16 +18751,13 @@ namespace ts {
|
|||
targetStack = [];
|
||||
}
|
||||
else {
|
||||
// generate a key where all type parameter id positions are replaced with unconstrained type parameter ids
|
||||
// this isn't perfect - nested type references passed as type arguments will muck up the indexes and thus
|
||||
// prevent finding matches- but it should hit up the common cases
|
||||
const broadestEquivalentId = id.split(",").map(i => i.replace(/-\d+/g, (_match, offset: number) => {
|
||||
const index = length(id.slice(0, offset).match(/[-=]/g) || undefined);
|
||||
return `=${index}`;
|
||||
})).join(",");
|
||||
// A key that starts with "*" is an indication that we have type references that reference constrained
|
||||
// type parameters. For such keys we also check against the key we would have gotten if all type parameters
|
||||
// were unconstrained.
|
||||
const broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, keyIntersectionState, relation, /*ignoreConstraints*/ true) : undefined;
|
||||
for (let i = 0; i < maybeCount; i++) {
|
||||
// If source and target are already being compared, consider them related with assumptions
|
||||
if (id === maybeKeys[i] || broadestEquivalentId === maybeKeys[i]) {
|
||||
if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) {
|
||||
return Ternary.Maybe;
|
||||
}
|
||||
}
|
||||
|
@ -19046,7 +19064,7 @@ namespace ts {
|
|||
originalErrorInfo = undefined;
|
||||
}
|
||||
}
|
||||
else if (isGenericMappedType(target)) {
|
||||
else if (isGenericMappedType(target) && relation !== identityRelation) {
|
||||
// Check if source type `S` is related to target type `{ [P in Q]: T }` or `{ [P in Q as R]: T}`.
|
||||
const keysRemapped = !!target.declaration.nameType;
|
||||
const templateType = getTemplateTypeFromMappedType(target);
|
||||
|
@ -20294,47 +20312,55 @@ namespace ts {
|
|||
return isNonDeferredTypeReference(type) && some(getTypeArguments(type), t => !!(t.flags & TypeFlags.TypeParameter) || isTypeReferenceWithGenericArguments(t));
|
||||
}
|
||||
|
||||
/**
|
||||
* getTypeReferenceId(A<T, number, U>) returns "111=0-12=1"
|
||||
* where A.id=111 and number.id=12
|
||||
*/
|
||||
function getTypeReferenceId(type: TypeReference, typeParameters: Type[], depth = 0) {
|
||||
let result = "" + type.target.id;
|
||||
for (const t of getTypeArguments(type)) {
|
||||
if (isUnconstrainedTypeParameter(t)) {
|
||||
let index = typeParameters.indexOf(t);
|
||||
if (index < 0) {
|
||||
index = typeParameters.length;
|
||||
typeParameters.push(t);
|
||||
function getGenericTypeReferenceRelationKey(source: TypeReference, target: TypeReference, postFix: string, ignoreConstraints: boolean) {
|
||||
const typeParameters: Type[] = [];
|
||||
let constraintMarker = "";
|
||||
const sourceId = getTypeReferenceId(source, 0);
|
||||
const targetId = getTypeReferenceId(target, 0);
|
||||
return `${constraintMarker}${sourceId},${targetId}${postFix}`;
|
||||
// getTypeReferenceId(A<T, number, U>) returns "111=0-12=1"
|
||||
// where A.id=111 and number.id=12
|
||||
function getTypeReferenceId(type: TypeReference, depth = 0) {
|
||||
let result = "" + type.target.id;
|
||||
for (const t of getTypeArguments(type)) {
|
||||
if (t.flags & TypeFlags.TypeParameter) {
|
||||
if (ignoreConstraints || isUnconstrainedTypeParameter(t)) {
|
||||
let index = typeParameters.indexOf(t);
|
||||
if (index < 0) {
|
||||
index = typeParameters.length;
|
||||
typeParameters.push(t);
|
||||
}
|
||||
result += "=" + index;
|
||||
continue;
|
||||
}
|
||||
// We mark type references that reference constrained type parameters such that we know to obtain
|
||||
// and look for a "broadest equivalent key" in the cache.
|
||||
constraintMarker = "*";
|
||||
}
|
||||
else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
|
||||
result += "<" + getTypeReferenceId(t as TypeReference, depth + 1) + ">";
|
||||
continue;
|
||||
}
|
||||
result += "=" + index;
|
||||
}
|
||||
else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
|
||||
result += "<" + getTypeReferenceId(t as TypeReference, typeParameters, depth + 1) + ">";
|
||||
}
|
||||
else {
|
||||
result += "-" + t.id;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* To improve caching, the relation key for two generic types uses the target's id plus ids of the type parameters.
|
||||
* For other cases, the types ids are used.
|
||||
*/
|
||||
function getRelationKey(source: Type, target: Type, intersectionState: IntersectionState, relation: ESMap<string, RelationComparisonResult>) {
|
||||
function getRelationKey(source: Type, target: Type, intersectionState: IntersectionState, relation: ESMap<string, RelationComparisonResult>, ignoreConstraints: boolean) {
|
||||
if (relation === identityRelation && source.id > target.id) {
|
||||
const temp = source;
|
||||
source = target;
|
||||
target = temp;
|
||||
}
|
||||
const postFix = intersectionState ? ":" + intersectionState : "";
|
||||
if (isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target)) {
|
||||
const typeParameters: Type[] = [];
|
||||
return getTypeReferenceId(source as TypeReference, typeParameters) + "," + getTypeReferenceId(target as TypeReference, typeParameters) + postFix;
|
||||
}
|
||||
return source.id + "," + target.id + postFix;
|
||||
return isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) ?
|
||||
getGenericTypeReferenceRelationKey(source as TypeReference, target as TypeReference, postFix, ignoreConstraints) :
|
||||
`${source.id},${target.id}${postFix}`;
|
||||
}
|
||||
|
||||
// Invoke the callback for each underlying property symbol of the given symbol and return the first
|
||||
|
@ -20388,27 +20414,34 @@ namespace ts {
|
|||
}
|
||||
|
||||
// Return true if the given type is deeply nested. We consider this to be the case when structural type comparisons
|
||||
// for 5 or more occurrences or instantiations of the type have been recorded on the given stack. It is possible,
|
||||
// for maxDepth or more occurrences or instantiations of the type have been recorded on the given stack. It is possible,
|
||||
// though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely
|
||||
// expanding. Effectively, we will generate a false positive when two types are structurally equal to at least 5
|
||||
// expanding. Effectively, we will generate a false positive when two types are structurally equal to at least maxDepth
|
||||
// levels, but unequal at some level beyond that.
|
||||
// In addition, this will also detect when an indexed access has been chained off of 5 or more times (which is essentially
|
||||
// the dual of the structural comparison), and likewise mark the type as deeply nested, potentially adding false positives
|
||||
// for finite but deeply expanding indexed accesses (eg, for `Q[P1][P2][P3][P4][P5]`).
|
||||
// It also detects when a recursive type reference has expanded 5 or more times, eg, if the true branch of
|
||||
// In addition, this will also detect when an indexed access has been chained off of maxDepth more times (which is
|
||||
// essentially the dual of the structural comparison), and likewise mark the type as deeply nested, potentially adding
|
||||
// false positives for finite but deeply expanding indexed accesses (eg, for `Q[P1][P2][P3][P4][P5]`).
|
||||
// It also detects when a recursive type reference has expanded maxDepth or more times, e.g. if the true branch of
|
||||
// `type A<T> = null extends T ? [A<NonNullable<T>>] : [T]`
|
||||
// has expanded into `[A<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>>>>>>]`
|
||||
// in such cases we need to terminate the expansion, and we do so here.
|
||||
function isDeeplyNestedType(type: Type, stack: Type[], depth: number, maxDepth = 5): boolean {
|
||||
// has expanded into `[A<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>>>>>>]`. In such cases we need
|
||||
// to terminate the expansion, and we do so here.
|
||||
function isDeeplyNestedType(type: Type, stack: Type[], depth: number, maxDepth = 3): boolean {
|
||||
if (depth >= maxDepth) {
|
||||
const identity = getRecursionIdentity(type);
|
||||
let count = 0;
|
||||
let lastTypeId = 0;
|
||||
for (let i = 0; i < depth; i++) {
|
||||
if (getRecursionIdentity(stack[i]) === identity) {
|
||||
count++;
|
||||
if (count >= maxDepth) {
|
||||
return true;
|
||||
const t = stack[i];
|
||||
if (getRecursionIdentity(t) === identity) {
|
||||
// We only count occurrences with a higher type id than the previous occurrence, since higher
|
||||
// type ids are an indicator of newer instantiations caused by recursion.
|
||||
if (t.id >= lastTypeId) {
|
||||
count++;
|
||||
if (count >= maxDepth) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
lastTypeId = t.id;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -21203,9 +21236,10 @@ namespace ts {
|
|||
(isCallSignatureDeclaration(param.parent) || isMethodSignature(param.parent) || isFunctionTypeNode(param.parent)) &&
|
||||
param.parent.parameters.indexOf(param) > -1 &&
|
||||
(resolveName(param, param.name.escapedText, SymbolFlags.Type, undefined, param.name.escapedText, /*isUse*/ true) ||
|
||||
param.name.originalKeywordKind && isTypeNodeKind(param.name.originalKeywordKind))) {
|
||||
param.name.originalKeywordKind && isTypeNodeKind(param.name.originalKeywordKind))) {
|
||||
const newName = "arg" + param.parent.parameters.indexOf(param);
|
||||
errorOrSuggestion(noImplicitAny, declaration, Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, declarationNameToString(param.name));
|
||||
const typeName = declarationNameToString(param.name) + (param.dotDotDotToken ? "[]" : "");
|
||||
errorOrSuggestion(noImplicitAny, declaration, Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, typeName);
|
||||
return;
|
||||
}
|
||||
diagnostic = (declaration as ParameterDeclaration).dotDotDotToken ?
|
||||
|
@ -22619,30 +22653,6 @@ namespace ts {
|
|||
return false;
|
||||
}
|
||||
|
||||
function getPropertyAccess(expr: Expression) {
|
||||
if (isAccessExpression(expr)) {
|
||||
return expr;
|
||||
}
|
||||
if (isIdentifier(expr)) {
|
||||
const symbol = getResolvedSymbol(expr);
|
||||
if (isConstVariable(symbol)) {
|
||||
const declaration = symbol.valueDeclaration!;
|
||||
// Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind'
|
||||
if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer)) {
|
||||
return declaration.initializer;
|
||||
}
|
||||
// Given 'const { kind: x } = obj', allow 'x' as an alias for 'obj.kind'
|
||||
if (isBindingElement(declaration) && !declaration.initializer) {
|
||||
const parent = declaration.parent.parent;
|
||||
if (isVariableDeclaration(parent) && !parent.type && parent.initializer && (isIdentifier(parent.initializer) || isAccessExpression(parent.initializer))) {
|
||||
return declaration;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function getAccessedPropertyName(access: AccessExpression | BindingElement): __String | undefined {
|
||||
let propertyName;
|
||||
return access.kind === SyntaxKind.PropertyAccessExpression ? access.name.escapedText :
|
||||
|
@ -23612,19 +23622,19 @@ namespace ts {
|
|||
return false;
|
||||
}
|
||||
|
||||
function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node) {
|
||||
function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node, flowNode = reference.flowNode) {
|
||||
let key: string | undefined;
|
||||
let isKeySet = false;
|
||||
let flowDepth = 0;
|
||||
if (flowAnalysisDisabled) {
|
||||
return errorType;
|
||||
}
|
||||
if (!reference.flowNode) {
|
||||
if (!flowNode) {
|
||||
return declaredType;
|
||||
}
|
||||
flowInvocationCount++;
|
||||
const sharedFlowStart = sharedFlowCount;
|
||||
const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(reference.flowNode));
|
||||
const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode));
|
||||
sharedFlowCount = sharedFlowStart;
|
||||
// When the reference is 'x' in an 'x.length', 'x.push(value)', 'x.unshift(value)' or x[n] = value' operation,
|
||||
// we give type 'any[]' to 'x' instead of using the type determined by control flow analysis such that operations
|
||||
|
@ -24068,13 +24078,58 @@ namespace ts {
|
|||
return result;
|
||||
}
|
||||
|
||||
function getCandidateDiscriminantPropertyAccess(expr: Expression) {
|
||||
if (isBindingPattern(reference)) {
|
||||
// When the reference is a binding pattern, we are narrowing a pesudo-reference in getNarrowedTypeOfSymbol.
|
||||
// An identifier for a destructuring variable declared in the same binding pattern is a candidate.
|
||||
if (isIdentifier(expr)) {
|
||||
const symbol = getResolvedSymbol(expr);
|
||||
const declaration = symbol.valueDeclaration;
|
||||
if (declaration && isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && reference === declaration.parent) {
|
||||
return declaration;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (isAccessExpression(expr)) {
|
||||
// An access expression is a candidate if the reference matches the left hand expression.
|
||||
if (isMatchingReference(reference, expr.expression)) {
|
||||
return expr;
|
||||
}
|
||||
}
|
||||
else if (isIdentifier(expr)) {
|
||||
const symbol = getResolvedSymbol(expr);
|
||||
if (isConstVariable(symbol)) {
|
||||
const declaration = symbol.valueDeclaration!;
|
||||
// Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind'
|
||||
if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) &&
|
||||
isMatchingReference(reference, declaration.initializer.expression)) {
|
||||
return declaration.initializer;
|
||||
}
|
||||
// Given 'const { kind: x } = obj', allow 'x' as an alias for 'obj.kind'
|
||||
if (isBindingElement(declaration) && !declaration.initializer) {
|
||||
const parent = declaration.parent.parent;
|
||||
if (isVariableDeclaration(parent) && !parent.type && parent.initializer && (isIdentifier(parent.initializer) || isAccessExpression(parent.initializer)) &&
|
||||
isMatchingReference(reference, parent.initializer)) {
|
||||
return declaration;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function getDiscriminantPropertyAccess(expr: Expression, computedType: Type) {
|
||||
let access, name;
|
||||
const type = declaredType.flags & TypeFlags.Union ? declaredType : computedType;
|
||||
return type.flags & TypeFlags.Union && (access = getPropertyAccess(expr)) && (name = getAccessedPropertyName(access)) &&
|
||||
isMatchingReference(reference, isAccessExpression(access) ? access.expression : access.parent.parent.initializer!) &&
|
||||
isDiscriminantProperty(type, name) ?
|
||||
access : undefined;
|
||||
if (type.flags & TypeFlags.Union) {
|
||||
const access = getCandidateDiscriminantPropertyAccess(expr);
|
||||
if (access) {
|
||||
const name = getAccessedPropertyName(access);
|
||||
if (name && isDiscriminantProperty(type, name)) {
|
||||
return access;
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function narrowTypeByDiscriminant(type: Type, access: AccessExpression | BindingElement, narrowType: (t: Type) => Type): Type {
|
||||
|
@ -24887,6 +24942,50 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
function getNarrowedTypeOfSymbol(symbol: Symbol, location: Identifier) {
|
||||
// If we have a non-rest binding element with no initializer declared as a const variable or a const-like
|
||||
// parameter (a parameter for which there are no assignments in the function body), and if the parent type
|
||||
// for the destructuring is a union type, one or more of the binding elements may represent discriminant
|
||||
// properties, and we want the effects of conditional checks on such discriminants to affect the types of
|
||||
// other binding elements from the same destructuring. Consider:
|
||||
//
|
||||
// type Action =
|
||||
// | { kind: 'A', payload: number }
|
||||
// | { kind: 'B', payload: string };
|
||||
//
|
||||
// function f1({ kind, payload }: Action) {
|
||||
// if (kind === 'A') {
|
||||
// payload.toFixed();
|
||||
// }
|
||||
// if (kind === 'B') {
|
||||
// payload.toUpperCase();
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use
|
||||
// the binding pattern AST instance for '{ kind, payload }' as a pseudo-reference and narrow this reference
|
||||
// as if it occurred in the specified location. We then recompute the narrowed binding element type by
|
||||
// destructuring from the narrowed parent type.
|
||||
const declaration = symbol.valueDeclaration;
|
||||
if (declaration && isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
|
||||
const parent = declaration.parent.parent;
|
||||
if (parent.kind === SyntaxKind.VariableDeclaration && getCombinedNodeFlags(declaration) & NodeFlags.Const || parent.kind === SyntaxKind.Parameter) {
|
||||
const links = getNodeLinks(location);
|
||||
if (!(links.flags & NodeCheckFlags.InCheckIdentifier)) {
|
||||
links.flags |= NodeCheckFlags.InCheckIdentifier;
|
||||
const parentType = getTypeForBindingElementParent(parent);
|
||||
links.flags &= ~NodeCheckFlags.InCheckIdentifier;
|
||||
if (parentType && parentType.flags & TypeFlags.Union && !(parent.kind === SyntaxKind.Parameter && isSymbolAssigned(symbol))) {
|
||||
const pattern = declaration.parent;
|
||||
const narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);
|
||||
return getBindingElementTypeFromParentType(declaration, narrowedType);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return getTypeOfSymbol(symbol);
|
||||
}
|
||||
|
||||
function checkIdentifier(node: Identifier, checkMode: CheckMode | undefined): Type {
|
||||
const symbol = getResolvedSymbol(node);
|
||||
if (symbol === unknownSymbol) {
|
||||
|
@ -24970,7 +25069,7 @@ namespace ts {
|
|||
|
||||
checkNestedBlockScopedBinding(node, symbol);
|
||||
|
||||
let type = getTypeOfSymbol(localOrExportSymbol);
|
||||
let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);
|
||||
const assignmentKind = getAssignmentTargetKind(node);
|
||||
|
||||
if (assignmentKind) {
|
||||
|
@ -26108,12 +26207,12 @@ namespace ts {
|
|||
return !!(getCheckFlags(symbol) & CheckFlags.Mapped && !(symbol as MappedSymbol).type && findResolutionCycleStartIndex(symbol, TypeSystemPropertyName.Type) >= 0);
|
||||
}
|
||||
|
||||
function getTypeOfPropertyOfContextualType(type: Type, name: __String) {
|
||||
function getTypeOfPropertyOfContextualType(type: Type, name: __String, nameType?: Type) {
|
||||
return mapType(type, t => {
|
||||
if (isGenericMappedType(t)) {
|
||||
const constraint = getConstraintTypeFromMappedType(t);
|
||||
const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
|
||||
const propertyNameType = getStringLiteralType(unescapeLeadingUnderscores(name));
|
||||
const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
|
||||
if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
|
||||
return substituteIndexedMappedType(t, propertyNameType);
|
||||
}
|
||||
|
@ -26129,7 +26228,7 @@ namespace ts {
|
|||
return restType;
|
||||
}
|
||||
}
|
||||
return findApplicableIndexInfo(getIndexInfosOfStructuredType(t), getStringLiteralType(unescapeLeadingUnderscores(name)))?.type;
|
||||
return findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))?.type;
|
||||
}
|
||||
return undefined;
|
||||
}, /*noReductions*/ true);
|
||||
|
@ -26159,7 +26258,8 @@ namespace ts {
|
|||
// For a (non-symbol) computed property, there is no reason to look up the name
|
||||
// in the type. It will just be "__computed", which does not appear in any
|
||||
// SymbolTable.
|
||||
return getTypeOfPropertyOfContextualType(type, getSymbolOfNode(element).escapedName);
|
||||
const symbol = getSymbolOfNode(element);
|
||||
return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
|
||||
}
|
||||
if (element.name) {
|
||||
const nameType = getLiteralTypeFromPropertyName(element.name);
|
||||
|
@ -34729,7 +34829,8 @@ namespace ts {
|
|||
function getTypeArgumentConstraint(node: TypeNode): Type | undefined {
|
||||
const typeReferenceNode = tryCast(node.parent, isTypeReferenceType);
|
||||
if (!typeReferenceNode) return undefined;
|
||||
const typeParameters = getTypeParametersForTypeReference(typeReferenceNode)!; // TODO: GH#18217
|
||||
const typeParameters = getTypeParametersForTypeReference(typeReferenceNode);
|
||||
if (!typeParameters) return undefined;
|
||||
const constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments!.indexOf(node)]);
|
||||
return constraint && instantiateType(constraint, createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReferenceNode, typeParameters)));
|
||||
}
|
||||
|
@ -39679,8 +39780,12 @@ namespace ts {
|
|||
|
||||
function checkAssertClause(declaration: ImportDeclaration | ExportDeclaration) {
|
||||
if (declaration.assertClause) {
|
||||
if (moduleKind !== ModuleKind.ESNext) {
|
||||
return grammarErrorOnNode(declaration.assertClause, Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext);
|
||||
const mode = (moduleKind === ModuleKind.NodeNext) && declaration.moduleSpecifier && getUsageModeForExpression(declaration.moduleSpecifier);
|
||||
if (mode !== ModuleKind.ESNext && moduleKind !== ModuleKind.ESNext) {
|
||||
return grammarErrorOnNode(declaration.assertClause,
|
||||
moduleKind === ModuleKind.NodeNext
|
||||
? Diagnostics.Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls
|
||||
: Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext);
|
||||
}
|
||||
|
||||
if (isImportDeclaration(declaration) ? declaration.importClause?.isTypeOnly : declaration.isTypeOnly) {
|
||||
|
@ -40317,9 +40422,8 @@ namespace ts {
|
|||
const enclosingFile = getSourceFileOfNode(node);
|
||||
const links = getNodeLinks(enclosingFile);
|
||||
if (!(links.flags & NodeCheckFlags.TypeChecked)) {
|
||||
links.deferredNodes = links.deferredNodes || new Map();
|
||||
const id = getNodeId(node);
|
||||
links.deferredNodes.set(id, node);
|
||||
links.deferredNodes ||= new Set();
|
||||
links.deferredNodes.add(node);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -41499,7 +41603,7 @@ namespace ts {
|
|||
if (!symbol) {
|
||||
return false;
|
||||
}
|
||||
const target = resolveAlias(symbol);
|
||||
const target = getExportSymbolOfValueSymbolIfExported(resolveAlias(symbol));
|
||||
if (target === unknownSymbol) {
|
||||
return true;
|
||||
}
|
||||
|
@ -42972,8 +43076,7 @@ namespace ts {
|
|||
|
||||
// Modifiers are never allowed on properties except for 'async' on a method declaration
|
||||
if (prop.modifiers) {
|
||||
// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
|
||||
for (const mod of prop.modifiers!) { // TODO: GH#19955
|
||||
for (const mod of prop.modifiers) {
|
||||
if (mod.kind !== SyntaxKind.AsyncKeyword || prop.kind !== SyntaxKind.MethodDeclaration) {
|
||||
grammarErrorOnNode(mod, Diagnostics._0_modifier_cannot_be_used_here, getTextOfNode(mod));
|
||||
}
|
||||
|
@ -43890,13 +43993,13 @@ namespace ts {
|
|||
}
|
||||
|
||||
const nodeArguments = node.arguments;
|
||||
if (moduleKind !== ModuleKind.ESNext) {
|
||||
if (moduleKind !== ModuleKind.ESNext && moduleKind !== ModuleKind.NodeNext) {
|
||||
// We are allowed trailing comma after proposal-import-assertions.
|
||||
checkGrammarForDisallowedTrailingComma(nodeArguments);
|
||||
|
||||
if (nodeArguments.length > 1) {
|
||||
const assertionArgument = nodeArguments[1];
|
||||
return grammarErrorOnNode(assertionArgument, Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext);
|
||||
return grammarErrorOnNode(assertionArgument, Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -29,6 +29,7 @@ namespace ts {
|
|||
["es2019", "lib.es2019.d.ts"],
|
||||
["es2020", "lib.es2020.d.ts"],
|
||||
["es2021", "lib.es2021.d.ts"],
|
||||
["es2022", "lib.es2022.d.ts"],
|
||||
["esnext", "lib.esnext.d.ts"],
|
||||
// Host only
|
||||
["dom", "lib.dom.d.ts"],
|
||||
|
@ -72,12 +73,16 @@ namespace ts {
|
|||
["es2021.string", "lib.es2021.string.d.ts"],
|
||||
["es2021.weakref", "lib.es2021.weakref.d.ts"],
|
||||
["es2021.intl", "lib.es2021.intl.d.ts"],
|
||||
["esnext.array", "lib.es2019.array.d.ts"],
|
||||
["es2022.array", "lib.es2022.array.d.ts"],
|
||||
["es2022.error", "lib.es2022.error.d.ts"],
|
||||
["es2022.object", "lib.es2022.object.d.ts"],
|
||||
["es2022.string", "lib.es2022.string.d.ts"],
|
||||
["esnext.array", "lib.es2022.array.d.ts"],
|
||||
["esnext.symbol", "lib.es2019.symbol.d.ts"],
|
||||
["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
|
||||
["esnext.intl", "lib.esnext.intl.d.ts"],
|
||||
["esnext.bigint", "lib.es2020.bigint.d.ts"],
|
||||
["esnext.string", "lib.es2021.string.d.ts"],
|
||||
["esnext.string", "lib.es2022.string.d.ts"],
|
||||
["esnext.promise", "lib.es2021.promise.d.ts"],
|
||||
["esnext.weakref", "lib.es2021.weakref.d.ts"]
|
||||
];
|
||||
|
@ -314,6 +319,7 @@ namespace ts {
|
|||
es2019: ScriptTarget.ES2019,
|
||||
es2020: ScriptTarget.ES2020,
|
||||
es2021: ScriptTarget.ES2021,
|
||||
es2022: ScriptTarget.ES2022,
|
||||
esnext: ScriptTarget.ESNext,
|
||||
})),
|
||||
affectsSourceFile: true,
|
||||
|
|
|
@ -23,34 +23,6 @@ namespace ts {
|
|||
export const emptyMap: ReadonlyESMap<never, never> = new Map<never, never>();
|
||||
export const emptySet: ReadonlySet<never> = new Set<never>();
|
||||
|
||||
/**
|
||||
* Create a new map.
|
||||
* @deprecated Use `new Map()` instead.
|
||||
*/
|
||||
export function createMap<K, V>(): ESMap<K, V>;
|
||||
export function createMap<T>(): ESMap<string, T>;
|
||||
export function createMap<K, V>(): ESMap<K, V> {
|
||||
return new Map<K, V>();
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new map from a template object is provided, the map will copy entries from it.
|
||||
* @deprecated Use `new Map(getEntries(template))` instead.
|
||||
*/
|
||||
export function createMapFromTemplate<T>(template: MapLike<T>): ESMap<string, T> {
|
||||
const map: ESMap<string, T> = new Map<string, T>();
|
||||
|
||||
// Copies keys/values from template. Note that for..in will not throw if
|
||||
// template is undefined, and instead will just exit the loop.
|
||||
for (const key in template) {
|
||||
if (hasOwnProperty.call(template, key)) {
|
||||
map.set(key, template[key]);
|
||||
}
|
||||
}
|
||||
|
||||
return map;
|
||||
}
|
||||
|
||||
export function length(array: readonly any[] | undefined): number {
|
||||
return array ? array.length : 0;
|
||||
}
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
namespace ts {
|
||||
// WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
|
||||
// If changing the text in this section, be sure to test `configurePrerelease` too.
|
||||
export const versionMajorMinor = "4.5";
|
||||
export const versionMajorMinor = "4.6";
|
||||
// The following is baselined as a literal template type without intervention
|
||||
/** The version of the TypeScript compiler release */
|
||||
// eslint-disable-next-line @typescript-eslint/no-inferrable-types
|
||||
|
|
|
@ -171,12 +171,6 @@ namespace ts {
|
|||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use `checkDefined` to check whether a value is defined inline. Use `assertIsDefined` to check whether
|
||||
* a value is defined at the statement level.
|
||||
*/
|
||||
export const assertDefined = checkDefined;
|
||||
|
||||
export function assertEachIsDefined<T extends Node>(value: NodeArray<T>, message?: string, stackCrawlMark?: AnyFunction): asserts value is NodeArray<T>;
|
||||
export function assertEachIsDefined<T>(value: readonly T[], message?: string, stackCrawlMark?: AnyFunction): asserts value is readonly NonNullable<T>[];
|
||||
export function assertEachIsDefined<T>(value: readonly T[], message?: string, stackCrawlMark?: AnyFunction) {
|
||||
|
@ -190,12 +184,6 @@ namespace ts {
|
|||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use `checkEachDefined` to check whether the elements of an array are defined inline. Use `assertEachIsDefined` to check whether
|
||||
* the elements of an array are defined at the statement level.
|
||||
*/
|
||||
export const assertEachDefined = checkEachDefined;
|
||||
|
||||
export function assertNever(member: never, message = "Illegal value:", stackCrawlMark?: AnyFunction): never {
|
||||
const detail = typeof member === "object" && hasProperty(member, "kind") && hasProperty(member, "pos") && formatSyntaxKind ? "SyntaxKind: " + formatSyntaxKind((member as Node).kind) : JSON.stringify(member);
|
||||
return fail(`${message} ${detail}`, stackCrawlMark || assertNever);
|
||||
|
|
|
@ -924,7 +924,7 @@
|
|||
"category": "Error",
|
||||
"code": 1323
|
||||
},
|
||||
"Dynamic imports only support a second argument when the '--module' option is set to 'esnext'.": {
|
||||
"Dynamic imports only support a second argument when the '--module' option is set to 'esnext' or 'nodenext'.": {
|
||||
"category": "Error",
|
||||
"code": 1324
|
||||
},
|
||||
|
@ -3333,7 +3333,7 @@
|
|||
"category": "Error",
|
||||
"code": 2820
|
||||
},
|
||||
"Import assertions are only supported when the '--module' option is set to 'esnext'.": {
|
||||
"Import assertions are only supported when the '--module' option is set to 'esnext' or 'nodenext'.": {
|
||||
"category": "Error",
|
||||
"code": 2821
|
||||
},
|
||||
|
@ -3353,6 +3353,10 @@
|
|||
"category": "Error",
|
||||
"code": 2835
|
||||
},
|
||||
"Import assertions are not allowed on statements that transpile to commonjs 'require' calls.": {
|
||||
"category": "Error",
|
||||
"code": 2836
|
||||
},
|
||||
|
||||
"Import declaration '{0}' is using private name '{1}'.": {
|
||||
"category": "Error",
|
||||
|
|
|
@ -1604,6 +1604,7 @@ namespace ts {
|
|||
return emitJSDocSignature(node as JSDocSignature);
|
||||
case SyntaxKind.JSDocTag:
|
||||
case SyntaxKind.JSDocClassTag:
|
||||
case SyntaxKind.JSDocOverrideTag:
|
||||
return emitJSDocSimpleTag(node as JSDocTag);
|
||||
case SyntaxKind.JSDocAugmentsTag:
|
||||
case SyntaxKind.JSDocImplementsTag:
|
||||
|
@ -1616,7 +1617,6 @@ namespace ts {
|
|||
case SyntaxKind.JSDocPrivateTag:
|
||||
case SyntaxKind.JSDocProtectedTag:
|
||||
case SyntaxKind.JSDocReadonlyTag:
|
||||
case SyntaxKind.JSDocOverrideTag:
|
||||
return;
|
||||
case SyntaxKind.JSDocCallbackTag:
|
||||
return emitJSDocCallbackTag(node as JSDocCallbackTag);
|
||||
|
|
|
@ -6387,7 +6387,7 @@ namespace ts {
|
|||
sourceMapText = mapTextOrStripInternal as string;
|
||||
}
|
||||
const node = oldFileOfCurrentEmit ?
|
||||
parseOldFileOfCurrentEmit(Debug.assertDefined(bundleFileInfo)) :
|
||||
parseOldFileOfCurrentEmit(Debug.checkDefined(bundleFileInfo)) :
|
||||
parseUnparsedSourceFile(bundleFileInfo, stripInternal, length);
|
||||
node.fileName = fileName;
|
||||
node.sourceMapPath = sourceMapPath;
|
||||
|
@ -6587,13 +6587,13 @@ namespace ts {
|
|||
};
|
||||
node.javascriptPath = declarationTextOrJavascriptPath;
|
||||
node.javascriptMapPath = javascriptMapPath;
|
||||
node.declarationPath = Debug.assertDefined(javascriptMapTextOrDeclarationPath);
|
||||
node.declarationPath = Debug.checkDefined(javascriptMapTextOrDeclarationPath);
|
||||
node.declarationMapPath = declarationMapPath;
|
||||
node.buildInfoPath = declarationMapTextOrBuildInfoPath;
|
||||
Object.defineProperties(node, {
|
||||
javascriptText: { get() { return definedTextGetter(declarationTextOrJavascriptPath); } },
|
||||
javascriptMapText: { get() { return textGetter(javascriptMapPath); } }, // TODO:: if there is inline sourceMap in jsFile, use that
|
||||
declarationText: { get() { return definedTextGetter(Debug.assertDefined(javascriptMapTextOrDeclarationPath)); } },
|
||||
declarationText: { get() { return definedTextGetter(Debug.checkDefined(javascriptMapTextOrDeclarationPath)); } },
|
||||
declarationMapText: { get() { return textGetter(declarationMapPath); } }, // TODO:: if there is inline sourceMap in dtsFile, use that
|
||||
buildInfo: { get() { return getAndCacheBuildInfo(() => textGetter(declarationMapTextOrBuildInfoPath)); } }
|
||||
});
|
||||
|
|
|
@ -707,13 +707,15 @@ namespace ts.moduleSpecifiers {
|
|||
if (host.fileExists(packageJsonPath)) {
|
||||
const packageJsonContent = JSON.parse(host.readFile!(packageJsonPath)!);
|
||||
// TODO: Inject `require` or `import` condition based on the intended import mode
|
||||
const fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
|
||||
if (fromExports) {
|
||||
const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
|
||||
return { ...withJsExtension, verbatimFromExports: true };
|
||||
}
|
||||
if (packageJsonContent.exports) {
|
||||
return { moduleFileToTry: path, blockedByExports: true };
|
||||
if (getEmitModuleResolutionKind(options) === ModuleResolutionKind.Node12 || getEmitModuleResolutionKind(options) === ModuleResolutionKind.NodeNext) {
|
||||
const fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
|
||||
if (fromExports) {
|
||||
const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
|
||||
return { ...withJsExtension, verbatimFromExports: true };
|
||||
}
|
||||
if (packageJsonContent.exports) {
|
||||
return { moduleFileToTry: path, blockedByExports: true };
|
||||
}
|
||||
}
|
||||
const versionPaths = packageJsonContent.typesVersions
|
||||
? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions)
|
||||
|
|
|
@ -818,6 +818,25 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
/** @internal */
|
||||
export const plainJSErrors: Set<number> = new Set([
|
||||
Diagnostics.Cannot_redeclare_block_scoped_variable_0.code,
|
||||
Diagnostics.A_module_cannot_have_multiple_default_exports.code,
|
||||
Diagnostics.Another_export_default_is_here.code,
|
||||
Diagnostics.The_first_export_default_is_here.code,
|
||||
Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module.code,
|
||||
Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode.code,
|
||||
Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here.code,
|
||||
Diagnostics.constructor_is_a_reserved_word.code,
|
||||
Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode.code,
|
||||
Diagnostics.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode.code,
|
||||
Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode.code,
|
||||
Diagnostics.Invalid_use_of_0_in_strict_mode.code,
|
||||
Diagnostics.A_label_is_not_allowed_here.code,
|
||||
Diagnostics.Octal_literals_are_not_allowed_in_strict_mode.code,
|
||||
Diagnostics.with_statements_are_not_allowed_in_strict_mode.code,
|
||||
]);
|
||||
|
||||
/**
|
||||
* Determine if source file needs to be re-created even if its text hasn't changed
|
||||
*/
|
||||
|
@ -1577,6 +1596,7 @@ namespace ts {
|
|||
newSourceFile.originalFileName = oldSourceFile.originalFileName;
|
||||
newSourceFile.resolvedPath = oldSourceFile.resolvedPath;
|
||||
newSourceFile.fileName = oldSourceFile.fileName;
|
||||
newSourceFile.impliedNodeFormat = oldSourceFile.impliedNodeFormat;
|
||||
|
||||
const packageName = oldProgram.sourceFileToPackageName.get(oldSourceFile.path);
|
||||
if (packageName !== undefined) {
|
||||
|
@ -2004,15 +2024,24 @@ namespace ts {
|
|||
|
||||
Debug.assert(!!sourceFile.bindDiagnostics);
|
||||
|
||||
const isCheckJs = isCheckJsEnabledForFile(sourceFile, options);
|
||||
const isJs = sourceFile.scriptKind === ScriptKind.JS || sourceFile.scriptKind === ScriptKind.JSX;
|
||||
const isCheckJs = isJs && isCheckJsEnabledForFile(sourceFile, options);
|
||||
const isPlainJs = isJs && !sourceFile.checkJsDirective && options.checkJs === undefined;
|
||||
const isTsNoCheck = !!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false;
|
||||
// By default, only type-check .ts, .tsx, 'Deferred' and 'External' files (external files are added by plugins)
|
||||
const includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === ScriptKind.TS || sourceFile.scriptKind === ScriptKind.TSX
|
||||
|| sourceFile.scriptKind === ScriptKind.External || isCheckJs || sourceFile.scriptKind === ScriptKind.Deferred);
|
||||
const bindDiagnostics: readonly Diagnostic[] = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : emptyArray;
|
||||
const checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : emptyArray;
|
||||
|
||||
return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : undefined);
|
||||
// By default, only type-check .ts, .tsx, Deferred, plain JS, checked JS and External
|
||||
// - plain JS: .js files with no // ts-check and checkJs: undefined
|
||||
// - check JS: .js files with either // ts-check or checkJs: true
|
||||
// - external: files that are added by plugins
|
||||
const includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === ScriptKind.TS || sourceFile.scriptKind === ScriptKind.TSX
|
||||
|| sourceFile.scriptKind === ScriptKind.External || isPlainJs || isCheckJs || sourceFile.scriptKind === ScriptKind.Deferred);
|
||||
let bindDiagnostics: readonly Diagnostic[] = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : emptyArray;
|
||||
const checkDiagnostics = includeBindAndCheckDiagnostics && !isPlainJs ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : emptyArray;
|
||||
if (isPlainJs) {
|
||||
bindDiagnostics = filter(bindDiagnostics, d => plainJSErrors.has(d.code));
|
||||
}
|
||||
// skip ts-expect-error errors in plain JS files, and skip JSDoc errors except in checked JS
|
||||
return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics && !isPlainJs, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : undefined);
|
||||
});
|
||||
}
|
||||
|
||||
|
@ -3160,7 +3189,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function verifyCompilerOptions() {
|
||||
const isNightly = stringContains(version, "-dev");
|
||||
const isNightly = stringContains(version, "-dev") || stringContains(version, "-insiders");
|
||||
if (!isNightly) {
|
||||
if (getEmitModuleKind(options) === ModuleKind.Node12) {
|
||||
createOptionValueDiagnostic("module", Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "module", "node12");
|
||||
|
|
|
@ -619,7 +619,7 @@ namespace ts {
|
|||
) {
|
||||
if (resolution.refCount) {
|
||||
resolution.refCount++;
|
||||
Debug.assertDefined(resolution.files);
|
||||
Debug.assertIsDefined(resolution.files);
|
||||
}
|
||||
else {
|
||||
resolution.refCount = 1;
|
||||
|
@ -696,7 +696,7 @@ namespace ts {
|
|||
filePath: Path,
|
||||
getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>,
|
||||
) {
|
||||
unorderedRemoveItem(Debug.assertDefined(resolution.files), filePath);
|
||||
unorderedRemoveItem(Debug.checkDefined(resolution.files), filePath);
|
||||
resolution.refCount!--;
|
||||
if (resolution.refCount) {
|
||||
return;
|
||||
|
@ -798,7 +798,7 @@ namespace ts {
|
|||
for (const resolution of resolutions) {
|
||||
if (resolution.isInvalidated || !canInvalidate(resolution)) continue;
|
||||
resolution.isInvalidated = invalidated = true;
|
||||
for (const containingFilePath of Debug.assertDefined(resolution.files)) {
|
||||
for (const containingFilePath of Debug.checkDefined(resolution.files)) {
|
||||
(filesWithInvalidatedResolutions || (filesWithInvalidatedResolutions = new Set())).add(containingFilePath);
|
||||
// When its a file with inferred types resolution, invalidate type reference directive resolution
|
||||
hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || endsWith(containingFilePath, inferredTypesContainingFile);
|
||||
|
|
|
@ -2374,6 +2374,7 @@ namespace ts {
|
|||
tokenValue = tokenValue.slice(0, -1);
|
||||
pos--;
|
||||
}
|
||||
return getIdentifierToken();
|
||||
}
|
||||
return token;
|
||||
}
|
||||
|
|
|
@ -1625,7 +1625,6 @@ namespace ts {
|
|||
sysLog(`sysLog:: ${fileOrDirectory}:: Defaulting to fsWatchFile`);
|
||||
return watchPresentFileSystemEntryWithFsWatchFile();
|
||||
}
|
||||
|
||||
try {
|
||||
const presentWatcher = _fs.watch(
|
||||
fileOrDirectory,
|
||||
|
@ -1804,7 +1803,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function readDirectory(path: string, extensions?: readonly string[], excludes?: readonly string[], includes?: readonly string[], depth?: number): string[] {
|
||||
return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath, directoryExists);
|
||||
return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
|
||||
}
|
||||
|
||||
function fileSystemEntryExists(path: string, entryKind: FileSystemEntryKind): boolean {
|
||||
|
|
|
@ -282,7 +282,7 @@ namespace ts {
|
|||
function visitYieldExpression(node: YieldExpression) {
|
||||
if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) {
|
||||
if (node.asteriskToken) {
|
||||
const expression = visitNode(Debug.assertDefined(node.expression), visitor, isExpression);
|
||||
const expression = visitNode(Debug.checkDefined(node.expression), visitor, isExpression);
|
||||
|
||||
return setOriginalNode(
|
||||
setTextRange(
|
||||
|
|
|
@ -48,11 +48,11 @@ namespace ts {
|
|||
return existing.name;
|
||||
}
|
||||
if (!currentFileState.utilizedImplicitRuntimeImports) {
|
||||
currentFileState.utilizedImplicitRuntimeImports = createMap();
|
||||
currentFileState.utilizedImplicitRuntimeImports = new Map();
|
||||
}
|
||||
let specifierSourceImports = currentFileState.utilizedImplicitRuntimeImports.get(importSource);
|
||||
if (!specifierSourceImports) {
|
||||
specifierSourceImports = createMap();
|
||||
specifierSourceImports = new Map();
|
||||
currentFileState.utilizedImplicitRuntimeImports.set(importSource, specifierSourceImports);
|
||||
}
|
||||
const generatedName = factory.createUniqueName(`_${name}`, GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel | GeneratedIdentifierFlags.AllowNameSubstitution);
|
||||
|
|
|
@ -1609,7 +1609,7 @@ namespace ts {
|
|||
export interface TypePredicateNode extends TypeNode {
|
||||
readonly kind: SyntaxKind.TypePredicate;
|
||||
readonly parent: SignatureDeclaration | JSDocTypeExpression;
|
||||
readonly assertsModifier?: AssertsToken;
|
||||
readonly assertsModifier?: AssertsKeyword;
|
||||
readonly parameterName: Identifier | ThisTypeNode;
|
||||
readonly type?: TypeNode;
|
||||
}
|
||||
|
@ -1702,7 +1702,7 @@ namespace ts {
|
|||
|
||||
export interface MappedTypeNode extends TypeNode, Declaration {
|
||||
readonly kind: SyntaxKind.MappedType;
|
||||
readonly readonlyToken?: ReadonlyToken | PlusToken | MinusToken;
|
||||
readonly readonlyToken?: ReadonlyKeyword | PlusToken | MinusToken;
|
||||
readonly typeParameter: TypeParameterDeclaration;
|
||||
readonly nameType?: TypeNode;
|
||||
readonly questionToken?: QuestionToken | PlusToken | MinusToken;
|
||||
|
@ -2756,7 +2756,7 @@ namespace ts {
|
|||
|
||||
export interface ForOfStatement extends IterationStatement {
|
||||
readonly kind: SyntaxKind.ForOfStatement;
|
||||
readonly awaitModifier?: AwaitKeywordToken;
|
||||
readonly awaitModifier?: AwaitKeyword;
|
||||
readonly initializer: ForInitializer;
|
||||
readonly expression: Expression;
|
||||
}
|
||||
|
@ -5083,6 +5083,7 @@ namespace ts {
|
|||
ConstructorReferenceInClass = 0x02000000, // Binding to a class constructor inside of the class's body.
|
||||
ContainsClassWithPrivateIdentifiers = 0x04000000, // Marked on all block-scoped containers containing a class with private identifiers.
|
||||
ContainsSuperPropertyInStaticInitializer = 0x08000000, // Marked on all block-scoped containers containing a static initializer with 'super.x' or 'super[x]'.
|
||||
InCheckIdentifier = 0x10000000,
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
|
@ -5106,7 +5107,7 @@ namespace ts {
|
|||
jsxNamespace?: Symbol | false; // Resolved jsx namespace symbol for this node
|
||||
jsxImplicitImportContainer?: Symbol | false; // Resolved module symbol the implicit jsx import of this file should refer to
|
||||
contextFreeType?: Type; // Cached context-free type used by the first pass of inference; used when a function's return is partially contextually sensitive
|
||||
deferredNodes?: ESMap<NodeId, Node>; // Set of nodes whose checking has been deferred
|
||||
deferredNodes?: Set<Node>; // Set of nodes whose checking has been deferred
|
||||
capturedBlockScopeBindings?: Symbol[]; // Block-scoped bindings captured beneath this part of an IterationStatement
|
||||
outerTypeParameters?: TypeParameter[]; // Outer type parameters of anonymous object type
|
||||
isExhaustive?: boolean; // Is node an exhaustive switch statement
|
||||
|
@ -5187,8 +5188,6 @@ namespace ts {
|
|||
// 'Narrowable' types are types where narrowing actually narrows.
|
||||
// This *should* be every type other than null, undefined, void, and never
|
||||
Narrowable = Any | Unknown | StructuredOrInstantiable | StringLike | NumberLike | BigIntLike | BooleanLike | ESSymbol | UniqueESSymbol | NonPrimitive,
|
||||
/* @internal */
|
||||
NotPrimitiveUnion = Any | Unknown | Enum | Void | Never | Object | Intersection | Instantiable,
|
||||
// The following flags are aggregated during union and intersection type construction
|
||||
/* @internal */
|
||||
IncludesMask = Any | Unknown | Primitive | Never | Object | Union | Intersection | NonPrimitive | TemplateLiteral,
|
||||
|
@ -5201,6 +5200,10 @@ namespace ts {
|
|||
IncludesWildcard = IndexedAccess,
|
||||
/* @internal */
|
||||
IncludesEmptyObject = Conditional,
|
||||
/* @internal */
|
||||
IncludesInstantiable = Substitution,
|
||||
/* @internal */
|
||||
NotPrimitiveUnion = Any | Unknown | Enum | Void | Never | Object | Intersection | IncludesInstantiable,
|
||||
}
|
||||
|
||||
export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
|
||||
|
@ -6265,6 +6268,7 @@ namespace ts {
|
|||
ES2019 = 6,
|
||||
ES2020 = 7,
|
||||
ES2021 = 8,
|
||||
ES2022 = 9,
|
||||
ESNext = 99,
|
||||
JSON = 100,
|
||||
Latest = ESNext,
|
||||
|
@ -6722,15 +6726,16 @@ namespace ts {
|
|||
ContainsTypeScript = 1 << 0,
|
||||
ContainsJsx = 1 << 1,
|
||||
ContainsESNext = 1 << 2,
|
||||
ContainsES2021 = 1 << 3,
|
||||
ContainsES2020 = 1 << 4,
|
||||
ContainsES2019 = 1 << 5,
|
||||
ContainsES2018 = 1 << 6,
|
||||
ContainsES2017 = 1 << 7,
|
||||
ContainsES2016 = 1 << 8,
|
||||
ContainsES2015 = 1 << 9,
|
||||
ContainsGenerator = 1 << 10,
|
||||
ContainsDestructuringAssignment = 1 << 11,
|
||||
ContainsES2022 = 1 << 3,
|
||||
ContainsES2021 = 1 << 4,
|
||||
ContainsES2020 = 1 << 5,
|
||||
ContainsES2019 = 1 << 6,
|
||||
ContainsES2018 = 1 << 7,
|
||||
ContainsES2017 = 1 << 8,
|
||||
ContainsES2016 = 1 << 9,
|
||||
ContainsES2015 = 1 << 10,
|
||||
ContainsGenerator = 1 << 11,
|
||||
ContainsDestructuringAssignment = 1 << 12,
|
||||
|
||||
// Markers
|
||||
// - Flags used to indicate that a subtree contains a specific transformation.
|
||||
|
@ -6759,6 +6764,7 @@ namespace ts {
|
|||
AssertTypeScript = ContainsTypeScript,
|
||||
AssertJsx = ContainsJsx,
|
||||
AssertESNext = ContainsESNext,
|
||||
AssertES2022 = ContainsES2022,
|
||||
AssertES2021 = ContainsES2021,
|
||||
AssertES2020 = ContainsES2020,
|
||||
AssertES2019 = ContainsES2019,
|
||||
|
|
|
@ -20,21 +20,6 @@ namespace ts {
|
|||
return undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new escaped identifier map.
|
||||
* @deprecated Use `new Map<__String, T>()` instead.
|
||||
*/
|
||||
export function createUnderscoreEscapedMap<T>(): UnderscoreEscapedMap<T> {
|
||||
return new Map<__String, T>();
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use `!!map?.size` instead
|
||||
*/
|
||||
export function hasEntries(map: ReadonlyCollection<any> | undefined): map is ReadonlyCollection<any> {
|
||||
return !!map && !!map.size;
|
||||
}
|
||||
|
||||
export function createSymbolTable(symbols?: readonly Symbol[]): SymbolTable {
|
||||
const result = new Map<__String, Symbol>();
|
||||
if (symbols) {
|
||||
|
@ -606,6 +591,7 @@ namespace ts {
|
|||
AsyncIterableIterator: emptyArray,
|
||||
AsyncGenerator: emptyArray,
|
||||
AsyncGeneratorFunction: emptyArray,
|
||||
NumberFormat: ["formatToParts"]
|
||||
},
|
||||
es2019: {
|
||||
Array: ["flat", "flatMap"],
|
||||
|
@ -627,8 +613,21 @@ namespace ts {
|
|||
PromiseConstructor: ["any"],
|
||||
String: ["replaceAll"]
|
||||
},
|
||||
esnext: {
|
||||
NumberFormat: ["formatToParts"]
|
||||
es2022: {
|
||||
Array: ["at"],
|
||||
String: ["at"],
|
||||
Int8Array: ["at"],
|
||||
Uint8Array: ["at"],
|
||||
Uint8ClampedArray: ["at"],
|
||||
Int16Array: ["at"],
|
||||
Uint16Array: ["at"],
|
||||
Int32Array: ["at"],
|
||||
Uint32Array: ["at"],
|
||||
Float32Array: ["at"],
|
||||
Float64Array: ["at"],
|
||||
BigInt64Array: ["at"],
|
||||
BigUint64Array: ["at"],
|
||||
ObjectConstructor: ["hasOwn"]
|
||||
}
|
||||
};
|
||||
}
|
||||
|
@ -6615,7 +6614,7 @@ namespace ts {
|
|||
includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
|
||||
includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
|
||||
excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
|
||||
basePaths: getBasePaths(absolutePath, includes, useCaseSensitiveFileNames)
|
||||
basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -6624,7 +6623,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
/** @param path directory of the tsconfig.json */
|
||||
export function matchFiles(path: string, extensions: readonly string[] | undefined, excludes: readonly string[] | undefined, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => FileSystemEntries, realpath: (path: string) => string, directoryExists: (path: string) => boolean): string[] {
|
||||
export function matchFiles(path: string, extensions: readonly string[] | undefined, excludes: readonly string[] | undefined, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => FileSystemEntries, realpath: (path: string) => string): string[] {
|
||||
path = normalizePath(path);
|
||||
currentDirectory = normalizePath(currentDirectory);
|
||||
|
||||
|
@ -6639,22 +6638,20 @@ namespace ts {
|
|||
const results: string[][] = includeFileRegexes ? includeFileRegexes.map(() => []) : [[]];
|
||||
const visited = new Map<string, true>();
|
||||
const toCanonical = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
||||
for (const absoluteBasePath of patterns.basePaths) {
|
||||
if (directoryExists(absoluteBasePath)) {
|
||||
visitDirectory(absoluteBasePath, depth);
|
||||
}
|
||||
for (const basePath of patterns.basePaths) {
|
||||
visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
|
||||
}
|
||||
|
||||
return flatten(results);
|
||||
|
||||
function visitDirectory(absolutePath: string, depth: number | undefined) {
|
||||
function visitDirectory(path: string, absolutePath: string, depth: number | undefined) {
|
||||
const canonicalPath = toCanonical(realpath(absolutePath));
|
||||
if (visited.has(canonicalPath)) return;
|
||||
visited.set(canonicalPath, true);
|
||||
const { files, directories } = getFileSystemEntries(absolutePath);
|
||||
const { files, directories } = getFileSystemEntries(path);
|
||||
|
||||
for (const current of sort<string>(files, compareStringsCaseSensitive)) {
|
||||
const name = combinePaths(absolutePath, current);
|
||||
const name = combinePaths(path, current);
|
||||
const absoluteName = combinePaths(absolutePath, current);
|
||||
if (extensions && !fileExtensionIsOneOf(name, extensions)) continue;
|
||||
if (excludeRegex && excludeRegex.test(absoluteName)) continue;
|
||||
|
@ -6677,10 +6674,11 @@ namespace ts {
|
|||
}
|
||||
|
||||
for (const current of sort<string>(directories, compareStringsCaseSensitive)) {
|
||||
const name = combinePaths(path, current);
|
||||
const absoluteName = combinePaths(absolutePath, current);
|
||||
if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
|
||||
(!excludeRegex || !excludeRegex.test(absoluteName))) {
|
||||
visitDirectory(absoluteName, depth);
|
||||
visitDirectory(name, absoluteName, depth);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -6688,11 +6686,10 @@ namespace ts {
|
|||
|
||||
/**
|
||||
* Computes the unique non-wildcard base paths amongst the provided include patterns.
|
||||
* @returns Absolute directory paths
|
||||
*/
|
||||
function getBasePaths(absoluteTsconfigPath: string, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean): string[] {
|
||||
function getBasePaths(path: string, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean): string[] {
|
||||
// Storage for our results in the form of literal paths (e.g. the paths as written by the user).
|
||||
const basePaths: string[] = [absoluteTsconfigPath];
|
||||
const basePaths: string[] = [path];
|
||||
|
||||
if (includes) {
|
||||
// Storage for literal base paths amongst the include patterns.
|
||||
|
@ -6700,9 +6697,9 @@ namespace ts {
|
|||
for (const include of includes) {
|
||||
// We also need to check the relative paths by converting them to absolute and normalizing
|
||||
// in case they escape the base path (e.g "..\somedirectory")
|
||||
const absoluteIncludePath: string = isRootedDiskPath(include) ? include : normalizePath(combinePaths(absoluteTsconfigPath, include));
|
||||
const absolute: string = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path, include));
|
||||
// Append the literal and canonical candidate base paths.
|
||||
includeBasePaths.push(getIncludeBasePath(absoluteIncludePath));
|
||||
includeBasePaths.push(getIncludeBasePath(absolute));
|
||||
}
|
||||
|
||||
// Sort the offsets array using either the literal or canonical path representations.
|
||||
|
@ -6711,7 +6708,7 @@ namespace ts {
|
|||
// Iterate over each include base path and include unique base paths that are not a
|
||||
// subpath of an existing base path
|
||||
for (const includeBasePath of includeBasePaths) {
|
||||
if (every(basePaths, basePath => !containsPath(basePath, includeBasePath, absoluteTsconfigPath, !useCaseSensitiveFileNames))) {
|
||||
if (every(basePaths, basePath => !containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames))) {
|
||||
basePaths.push(includeBasePath);
|
||||
}
|
||||
}
|
||||
|
@ -6982,18 +6979,6 @@ namespace ts {
|
|||
return { min, max };
|
||||
}
|
||||
|
||||
/** @deprecated Use `ReadonlySet<TNode>` instead. */
|
||||
export type ReadonlyNodeSet<TNode extends Node> = ReadonlySet<TNode>;
|
||||
|
||||
/** @deprecated Use `Set<TNode>` instead. */
|
||||
export type NodeSet<TNode extends Node> = Set<TNode>;
|
||||
|
||||
/** @deprecated Use `ReadonlyMap<TNode, TValue>` instead. */
|
||||
export type ReadonlyNodeMap<TNode extends Node, TValue> = ReadonlyESMap<TNode, TValue>;
|
||||
|
||||
/** @deprecated Use `Map<TNode, TValue>` instead. */
|
||||
export type NodeMap<TNode extends Node, TValue> = ESMap<TNode, TValue>;
|
||||
|
||||
export function rangeOfNode(node: Node): TextRange {
|
||||
return { pos: getTokenPosOfNode(node), end: node.end };
|
||||
}
|
||||
|
|
|
@ -14,6 +14,8 @@ namespace ts {
|
|||
switch (getEmitScriptTarget(options)) {
|
||||
case ScriptTarget.ESNext:
|
||||
return "lib.esnext.full.d.ts";
|
||||
case ScriptTarget.ES2022:
|
||||
return "lib.es2022.full.d.ts";
|
||||
case ScriptTarget.ES2021:
|
||||
return "lib.es2021.full.d.ts";
|
||||
case ScriptTarget.ES2020:
|
||||
|
|
|
@ -184,7 +184,7 @@ namespace ts {
|
|||
const rootResult = tryReadDirectory(rootDir, rootDirPath);
|
||||
let rootSymLinkResult: FileSystemEntries | undefined;
|
||||
if (rootResult !== undefined) {
|
||||
return matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath, directoryExists);
|
||||
return matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath);
|
||||
}
|
||||
return host.readDirectory!(rootDir, extensions, excludes, includes, depth);
|
||||
|
||||
|
|
|
@ -95,7 +95,7 @@ namespace fakes {
|
|||
}
|
||||
|
||||
public readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[] {
|
||||
return ts.matchFiles(path, extensions, exclude, include, this.useCaseSensitiveFileNames, this.getCurrentDirectory(), depth, path => this.getAccessibleFileSystemEntries(path), path => this.realpath(path), path => this.directoryExists(path));
|
||||
return ts.matchFiles(path, extensions, exclude, include, this.useCaseSensitiveFileNames, this.getCurrentDirectory(), depth, path => this.getAccessibleFileSystemEntries(path), path => this.realpath(path));
|
||||
}
|
||||
|
||||
public getAccessibleFileSystemEntries(path: string): ts.FileSystemEntries {
|
||||
|
|
|
@ -1,11 +1,11 @@
|
|||
namespace findUpDir {
|
||||
import { join, resolve, dirname } from "path";
|
||||
import { existsSync } from "fs";
|
||||
namespace Utils {
|
||||
const { join, resolve, dirname } = require("path") as typeof import("path");
|
||||
const { existsSync } = require("fs") as typeof import("fs");
|
||||
|
||||
// search directories upward to avoid hard-wired paths based on the
|
||||
// build tree (same as scripts/build/findUpDir.js)
|
||||
|
||||
export function findUpFile(name: string) {
|
||||
export function findUpFile(name: string): string {
|
||||
let dir = __dirname;
|
||||
while (true) {
|
||||
const fullPath = join(dir, name);
|
||||
|
|
|
@ -637,7 +637,8 @@ namespace FourSlash {
|
|||
ts.forEachKey(this.inputFiles, fileName => {
|
||||
if (!ts.isAnySupportedFileExtension(fileName)
|
||||
|| Harness.getConfigNameFromFileName(fileName)
|
||||
|| !ts.getAllowJSCompilerOption(this.getProgram().getCompilerOptions()) && !ts.resolutionExtensionIsTSOrJson(ts.extensionFromPath(fileName))
|
||||
// Can't get a Program in Server tests
|
||||
|| this.testType !== FourSlashTestType.Server && !ts.getAllowJSCompilerOption(this.getProgram().getCompilerOptions()) && !ts.resolutionExtensionIsTSOrJson(ts.extensionFromPath(fileName))
|
||||
|| ts.getBaseFileName(fileName) === "package.json") return;
|
||||
const errors = this.getDiagnostics(fileName).filter(e => e.category !== ts.DiagnosticCategory.Suggestion);
|
||||
if (errors.length) {
|
||||
|
|
|
@ -41,6 +41,7 @@ namespace Harness {
|
|||
export const virtualFileSystemRoot = "/";
|
||||
|
||||
function createNodeIO(): IO {
|
||||
const workspaceRoot = Utils.findUpRoot();
|
||||
let fs: any, pathModule: any;
|
||||
if (require) {
|
||||
fs = require("fs");
|
||||
|
@ -154,7 +155,7 @@ namespace Harness {
|
|||
log: s => console.log(s),
|
||||
args: () => ts.sys.args,
|
||||
getExecutingFilePath: () => ts.sys.getExecutingFilePath(),
|
||||
getWorkspaceRoot: () => vpath.resolve(__dirname, "../.."),
|
||||
getWorkspaceRoot: () => workspaceRoot,
|
||||
exit: exitCode => ts.sys.exit(exitCode),
|
||||
readDirectory: (path, extension, exclude, include, depth) => ts.sys.readDirectory(path, extension, exclude, include, depth),
|
||||
getAccessibleFileSystemEntries,
|
||||
|
|
|
@ -28,6 +28,7 @@
|
|||
"evaluatorImpl.ts",
|
||||
"fakesHosts.ts",
|
||||
"client.ts",
|
||||
"findUpDir.ts",
|
||||
|
||||
"runnerbase.ts",
|
||||
"sourceMapRecorder.ts",
|
||||
|
|
|
@ -922,7 +922,7 @@ interface Array<T> { length: number; [n: number]: T; }`
|
|||
});
|
||||
}
|
||||
return { directories, files };
|
||||
}, path => this.realpath(path), path => this.directoryExists(path));
|
||||
}, path => this.realpath(path));
|
||||
}
|
||||
|
||||
createHash(s: string): string {
|
||||
|
|
4
src/lib/es2020.intl.d.ts
vendored
4
src/lib/es2020.intl.d.ts
vendored
|
@ -200,7 +200,7 @@ declare namespace Intl {
|
|||
interface NumberFormatOptions {
|
||||
compactDisplay?: "short" | "long" | undefined;
|
||||
notation?: "standard" | "scientific" | "engineering" | "compact" | undefined;
|
||||
signDisplay?: "auto" | "never" | "always" | undefined;
|
||||
signDisplay?: "auto" | "never" | "always" | "exceptZero" | undefined;
|
||||
unit?: string | undefined;
|
||||
unitDisplay?: "short" | "long" | "narrow" | undefined;
|
||||
}
|
||||
|
@ -208,7 +208,7 @@ declare namespace Intl {
|
|||
interface ResolvedNumberFormatOptions {
|
||||
compactDisplay?: "short" | "long";
|
||||
notation?: "standard" | "scientific" | "engineering" | "compact";
|
||||
signDisplay?: "auto" | "never" | "always";
|
||||
signDisplay?: "auto" | "never" | "always" | "exceptZero";
|
||||
unit?: string;
|
||||
unitDisplay?: "short" | "long" | "narrow";
|
||||
}
|
||||
|
|
103
src/lib/es2022.array.d.ts
vendored
Normal file
103
src/lib/es2022.array.d.ts
vendored
Normal file
|
@ -0,0 +1,103 @@
|
|||
interface Array<T> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): T | undefined;
|
||||
}
|
||||
|
||||
interface ReadonlyArray<T> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): T | undefined;
|
||||
}
|
||||
|
||||
interface Int8Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Uint8Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Uint8ClampedArray {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Int16Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Uint16Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Int32Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Uint32Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Float32Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Float64Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface BigInt64Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): bigint | undefined;
|
||||
}
|
||||
|
||||
interface BigUint64Array {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): bigint | undefined;
|
||||
}
|
5
src/lib/es2022.d.ts
vendored
Normal file
5
src/lib/es2022.d.ts
vendored
Normal file
|
@ -0,0 +1,5 @@
|
|||
/// <reference lib="es2021" />
|
||||
/// <reference lib="es2022.array" />
|
||||
/// <reference lib="es2022.error" />
|
||||
/// <reference lib="es2022.object" />
|
||||
/// <reference lib="es2022.string" />
|
8
src/lib/es2022.error.d.ts
vendored
Normal file
8
src/lib/es2022.error.d.ts
vendored
Normal file
|
@ -0,0 +1,8 @@
|
|||
interface ErrorOptions {
|
||||
cause?: Error;
|
||||
}
|
||||
|
||||
interface ErrorConstructor {
|
||||
new(message?: string, options?: ErrorOptions): Error;
|
||||
(message?: string, options?: ErrorOptions): Error;
|
||||
}
|
5
src/lib/es2022.full.d.ts
vendored
Normal file
5
src/lib/es2022.full.d.ts
vendored
Normal file
|
@ -0,0 +1,5 @@
|
|||
/// <reference lib="es2022" />
|
||||
/// <reference lib="dom" />
|
||||
/// <reference lib="webworker.importscripts" />
|
||||
/// <reference lib="scripthost" />
|
||||
/// <reference lib="dom.iterable" />
|
8
src/lib/es2022.object.d.ts
vendored
Normal file
8
src/lib/es2022.object.d.ts
vendored
Normal file
|
@ -0,0 +1,8 @@
|
|||
interface Object {
|
||||
/**
|
||||
* Determines whether an object has a property with the specified name.
|
||||
* @param o An object.
|
||||
* @param v A property name.
|
||||
*/
|
||||
hasOwn(o: object, v: PropertyKey): boolean;
|
||||
}
|
7
src/lib/es2022.string.d.ts
vendored
Normal file
7
src/lib/es2022.string.d.ts
vendored
Normal file
|
@ -0,0 +1,7 @@
|
|||
interface String {
|
||||
/**
|
||||
* Returns a new String consisting of the single UTF-16 code unit located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): string | undefined;
|
||||
}
|
2
src/lib/es5.d.ts
vendored
2
src/lib/es5.d.ts
vendored
|
@ -96,7 +96,7 @@ interface PropertyDescriptor {
|
|||
}
|
||||
|
||||
interface PropertyDescriptorMap {
|
||||
[s: string]: PropertyDescriptor;
|
||||
[key: PropertyKey]: PropertyDescriptor;
|
||||
}
|
||||
|
||||
interface Object {
|
||||
|
|
2
src/lib/esnext.d.ts
vendored
2
src/lib/esnext.d.ts
vendored
|
@ -1,2 +1,2 @@
|
|||
/// <reference lib="es2021" />
|
||||
/// <reference lib="es2022" />
|
||||
/// <reference lib="esnext.intl" />
|
||||
|
|
|
@ -9,6 +9,7 @@
|
|||
"es2019",
|
||||
"es2020",
|
||||
"es2021",
|
||||
"es2022",
|
||||
"esnext",
|
||||
// Host only
|
||||
"dom.generated",
|
||||
|
@ -52,6 +53,10 @@
|
|||
"es2021.promise",
|
||||
"es2021.weakref",
|
||||
"es2021.intl",
|
||||
"es2022.array",
|
||||
"es2022.error",
|
||||
"es2022.object",
|
||||
"es2022.string",
|
||||
"esnext.intl",
|
||||
// Default libraries
|
||||
"es5.full",
|
||||
|
@ -62,6 +67,7 @@
|
|||
"es2019.full",
|
||||
"es2020.full",
|
||||
"es2021.full",
|
||||
"es2022.full",
|
||||
"esnext.full"
|
||||
],
|
||||
"paths": {
|
||||
|
|
|
@ -1944,15 +1944,15 @@ namespace ts.server {
|
|||
for (const resolution of resolutions) {
|
||||
if (!resolution.resolvedFileName) continue;
|
||||
const { resolvedFileName, originalPath } = resolution;
|
||||
if (originalPath) {
|
||||
symlinkCache.setSymlinkedDirectoryFromSymlinkedFile(originalPath, resolvedFileName);
|
||||
}
|
||||
if (!program.getSourceFile(resolvedFileName) && (!originalPath || !program.getSourceFile(originalPath))) {
|
||||
rootNames = append(rootNames, resolvedFileName);
|
||||
// Avoid creating a large project that would significantly slow down time to editor interactivity
|
||||
if (dependencySelection === PackageJsonAutoImportPreference.Auto && rootNames.length > this.maxDependencies) {
|
||||
return ts.emptyArray;
|
||||
}
|
||||
if (originalPath) {
|
||||
symlinkCache.setSymlinkedDirectoryFromSymlinkedFile(originalPath, resolvedFileName);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -3199,6 +3199,25 @@ namespace ts.server.protocol {
|
|||
payload: TypingsInstalledTelemetryEventPayload;
|
||||
}
|
||||
|
||||
// A __GDPR__FRAGMENT__ has no meaning until it is ${include}d by a __GDPR__ comment, at which point
|
||||
// the included properties are effectively inlined into the __GDPR__ declaration. In this case, for
|
||||
// example, any __GDPR__ comment including the TypeScriptCommonProperties will be updated with an
|
||||
// additional version property with the classification below. Obviously, the purpose of such a construct
|
||||
// is to reduce duplication and keep multiple use sites consistent (e.g. by making sure that all reflect
|
||||
// any newly added TypeScriptCommonProperties). Unfortunately, the system has limits - in particular,
|
||||
// these reusable __GDPR__FRAGMENT__s are not accessible across repo boundaries. Therefore, even though
|
||||
// the code for adding the common properties (i.e. version), along with the corresponding __GDPR__FRAGMENT__,
|
||||
// lives in the VS Code repo (see https://github.com/microsoft/vscode/blob/main/extensions/typescript-language-features/src/utils/telemetry.ts)
|
||||
// we have to duplicate it here. It would be nice to keep them in sync, but the only likely failure mode
|
||||
// is adding a property to the VS Code repro but not here and the only consequence would be having that
|
||||
// property suppressed on the events (i.e. __GDPT__ comments) in this repo that reference the out-of-date
|
||||
// local __GDPR__FRAGMENT__.
|
||||
/* __GDPR__FRAGMENT__
|
||||
"TypeScriptCommonProperties" : {
|
||||
"version" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
|
||||
}
|
||||
*/
|
||||
|
||||
/* __GDPR__
|
||||
"typingsinstalled" : {
|
||||
"${include}": ["${TypeScriptCommonProperties}"],
|
||||
|
@ -3515,6 +3534,7 @@ namespace ts.server.protocol {
|
|||
ES2019 = "ES2019",
|
||||
ES2020 = "ES2020",
|
||||
ES2021 = "ES2021",
|
||||
ES2022 = "ES2022",
|
||||
ESNext = "ESNext"
|
||||
}
|
||||
|
||||
|
|
|
@ -2112,7 +2112,7 @@ namespace ts.server {
|
|||
private getFullNavigateToItems(args: protocol.NavtoRequestArgs): CombineOutputResult<NavigateToItem> {
|
||||
const { currentFileOnly, searchValue, maxResultCount, projectFileName } = args;
|
||||
if (currentFileOnly) {
|
||||
Debug.assertDefined(args.file);
|
||||
Debug.assertIsDefined(args.file);
|
||||
const { file, project } = this.getFileAndProject(args as protocol.FileRequestArgs);
|
||||
return [{ project, result: project.getLanguageService().getNavigateToItems(searchValue, maxResultCount, file) }];
|
||||
}
|
||||
|
|
|
@ -14,24 +14,24 @@ namespace ts.codefix {
|
|||
|
||||
function makeChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, pos: number) {
|
||||
const token = getTokenAtPosition(sourceFile, pos);
|
||||
if (!isIdentifier(token)) {
|
||||
return Debug.fail("add-name-to-nameless-parameter operates on identifiers, but got a " + Debug.formatSyntaxKind(token.kind));
|
||||
}
|
||||
const param = token.parent;
|
||||
if (!isParameter(param)) {
|
||||
return Debug.fail("Tried to add a parameter name to a non-parameter: " + Debug.formatSyntaxKind(token.kind));
|
||||
}
|
||||
|
||||
const i = param.parent.parameters.indexOf(param);
|
||||
Debug.assert(!param.type, "Tried to add a parameter name to a parameter that already had one.");
|
||||
Debug.assert(i > -1, "Parameter not found in parent parameter list.");
|
||||
|
||||
const typeNode = factory.createTypeReferenceNode(param.name as Identifier, /*typeArguments*/ undefined);
|
||||
const replacement = factory.createParameterDeclaration(
|
||||
/*decorators*/ undefined,
|
||||
param.modifiers,
|
||||
param.dotDotDotToken,
|
||||
"arg" + i,
|
||||
param.questionToken,
|
||||
factory.createTypeReferenceNode(token, /*typeArguments*/ undefined),
|
||||
param.dotDotDotToken ? factory.createArrayTypeNode(typeNode) : typeNode,
|
||||
param.initializer);
|
||||
changeTracker.replaceNode(sourceFile, token, replacement);
|
||||
changeTracker.replaceNode(sourceFile, param, replacement);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -408,9 +408,7 @@ namespace ts.codefix {
|
|||
const importSpecifiers = mapAllOrFail(name.elements, e =>
|
||||
e.dotDotDotToken || e.initializer || e.propertyName && !isIdentifier(e.propertyName) || !isIdentifier(e.name)
|
||||
? undefined
|
||||
// (TODO: GH#18217)
|
||||
// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
|
||||
: makeImportSpecifier(e.propertyName && (e.propertyName as Identifier).text, e.name.text));
|
||||
: makeImportSpecifier(e.propertyName && e.propertyName.text, e.name.text));
|
||||
if (importSpecifiers) {
|
||||
return convertedImports([makeImport(/*name*/ undefined, importSpecifiers, moduleSpecifier, quotePreference)]);
|
||||
}
|
||||
|
|
|
@ -26,9 +26,9 @@ namespace ts.codefix {
|
|||
if (!isFunctionDeclaration(fn) && !isFunctionExpression(fn)) return undefined;
|
||||
|
||||
if (!isSourceFile(getThisContainer(fn, /*includeArrowFunctions*/ false))) { // 'this' is defined outside, convert to arrow function
|
||||
const fnKeyword = Debug.assertDefined(findChildOfKind(fn, SyntaxKind.FunctionKeyword, sourceFile));
|
||||
const fnKeyword = Debug.checkDefined(findChildOfKind(fn, SyntaxKind.FunctionKeyword, sourceFile));
|
||||
const { name } = fn;
|
||||
const body = Debug.assertDefined(fn.body); // Should be defined because the function contained a 'this' expression
|
||||
const body = Debug.checkDefined(fn.body); // Should be defined because the function contained a 'this' expression
|
||||
if (isFunctionExpression(fn)) {
|
||||
if (name && FindAllReferences.Core.isSymbolReferencedInFile(name, checker, sourceFile, body)) {
|
||||
// Function expression references itself. To fix we would have to extract it to a const.
|
||||
|
|
|
@ -17,37 +17,81 @@ namespace ts.codefix {
|
|||
Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code,
|
||||
Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code,
|
||||
Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code,
|
||||
Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code
|
||||
Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code,
|
||||
Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code,
|
||||
Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code,
|
||||
Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code,
|
||||
Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code,
|
||||
];
|
||||
|
||||
const errorCodeFixIdMap: Record<number, [DiagnosticMessage, string | undefined, DiagnosticMessage | undefined]> = {
|
||||
[Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code]: [
|
||||
Diagnostics.Add_override_modifier, fixAddOverrideId, Diagnostics.Add_all_missing_override_modifiers,
|
||||
],
|
||||
[Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code]: [
|
||||
Diagnostics.Remove_override_modifier, fixRemoveOverrideId, Diagnostics.Remove_all_unnecessary_override_modifiers
|
||||
],
|
||||
[Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code]: [
|
||||
Diagnostics.Add_override_modifier, fixAddOverrideId, Diagnostics.Add_all_missing_override_modifiers,
|
||||
],
|
||||
[Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code]: [
|
||||
Diagnostics.Add_override_modifier, fixAddOverrideId, Diagnostics.Remove_all_unnecessary_override_modifiers
|
||||
],
|
||||
[Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code]: [
|
||||
Diagnostics.Remove_override_modifier, fixRemoveOverrideId, Diagnostics.Remove_all_unnecessary_override_modifiers
|
||||
]
|
||||
interface ErrorCodeFixInfo {
|
||||
descriptions: DiagnosticMessage;
|
||||
fixId?: string | undefined;
|
||||
fixAllDescriptions?: DiagnosticMessage | undefined;
|
||||
}
|
||||
|
||||
const errorCodeFixIdMap: Record<number, ErrorCodeFixInfo> = {
|
||||
// case #1:
|
||||
[Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code]: {
|
||||
descriptions: Diagnostics.Add_override_modifier,
|
||||
fixId: fixAddOverrideId,
|
||||
fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers,
|
||||
},
|
||||
[Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code]: {
|
||||
descriptions: Diagnostics.Add_override_modifier,
|
||||
fixId: fixAddOverrideId,
|
||||
fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers
|
||||
},
|
||||
// case #2:
|
||||
[Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code]: {
|
||||
descriptions: Diagnostics.Remove_override_modifier,
|
||||
fixId: fixRemoveOverrideId,
|
||||
fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers,
|
||||
},
|
||||
[Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code]: {
|
||||
descriptions: Diagnostics.Remove_override_modifier,
|
||||
fixId: fixRemoveOverrideId,
|
||||
fixAllDescriptions: Diagnostics.Remove_override_modifier
|
||||
},
|
||||
// case #3:
|
||||
[Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code]: {
|
||||
descriptions: Diagnostics.Add_override_modifier,
|
||||
fixId: fixAddOverrideId,
|
||||
fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers,
|
||||
},
|
||||
[Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code]: {
|
||||
descriptions: Diagnostics.Add_override_modifier,
|
||||
fixId: fixAddOverrideId,
|
||||
fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers,
|
||||
},
|
||||
// case #4:
|
||||
[Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code]: {
|
||||
descriptions: Diagnostics.Add_override_modifier,
|
||||
fixId: fixAddOverrideId,
|
||||
fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers,
|
||||
},
|
||||
// case #5:
|
||||
[Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code]: {
|
||||
descriptions: Diagnostics.Remove_override_modifier,
|
||||
fixId: fixRemoveOverrideId,
|
||||
fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers,
|
||||
},
|
||||
[Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code]: {
|
||||
descriptions: Diagnostics.Remove_override_modifier,
|
||||
fixId: fixRemoveOverrideId,
|
||||
fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers,
|
||||
}
|
||||
};
|
||||
|
||||
registerCodeFix({
|
||||
errorCodes,
|
||||
getCodeActions: context => {
|
||||
const { errorCode, span, sourceFile } = context;
|
||||
const { errorCode, span } = context;
|
||||
|
||||
const info = errorCodeFixIdMap[errorCode];
|
||||
if (!info) return emptyArray;
|
||||
|
||||
const [ descriptions, fixId, fixAllDescriptions ] = info;
|
||||
if (isSourceFileJS(sourceFile)) return emptyArray;
|
||||
const { descriptions, fixId, fixAllDescriptions } = info;
|
||||
const changes = textChanges.ChangeTracker.with(context, changes => dispatchChanges(changes, context, errorCode, span.start));
|
||||
|
||||
return [
|
||||
|
@ -57,9 +101,9 @@ namespace ts.codefix {
|
|||
fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId],
|
||||
getAllCodeActions: context =>
|
||||
codeFixAll(context, errorCodes, (changes, diag) => {
|
||||
const { code, start, file } = diag;
|
||||
const { code, start } = diag;
|
||||
const info = errorCodeFixIdMap[code];
|
||||
if (!info || info[1] !== context.fixId || isSourceFileJS(file)) {
|
||||
if (!info || info.fixId !== context.fixId) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -74,11 +118,15 @@ namespace ts.codefix {
|
|||
pos: number) {
|
||||
switch (errorCode) {
|
||||
case Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code:
|
||||
case Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code:
|
||||
case Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code:
|
||||
case Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code:
|
||||
case Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code:
|
||||
return doAddOverrideModifierChange(changeTracker, context.sourceFile, pos);
|
||||
case Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code:
|
||||
case Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code:
|
||||
case Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code:
|
||||
case Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code:
|
||||
return doRemoveOverrideModifierChange(changeTracker, context.sourceFile, pos);
|
||||
default:
|
||||
Debug.fail("Unexpected error code: " + errorCode);
|
||||
|
@ -87,6 +135,10 @@ namespace ts.codefix {
|
|||
|
||||
function doAddOverrideModifierChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, pos: number) {
|
||||
const classElement = findContainerClassElementLike(sourceFile, pos);
|
||||
if (isSourceFileJS(sourceFile)) {
|
||||
changeTracker.addJSDocTags(sourceFile, classElement, [factory.createJSDocOverrideTag(factory.createIdentifier("override"))]);
|
||||
return;
|
||||
}
|
||||
const modifiers = classElement.modifiers || emptyArray;
|
||||
const staticModifier = find(modifiers, isStaticModifier);
|
||||
const abstractModifier = find(modifiers, isAbstractModifier);
|
||||
|
@ -101,6 +153,10 @@ namespace ts.codefix {
|
|||
|
||||
function doRemoveOverrideModifierChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, pos: number) {
|
||||
const classElement = findContainerClassElementLike(sourceFile, pos);
|
||||
if (isSourceFileJS(sourceFile)) {
|
||||
changeTracker.filterJSDocTags(sourceFile, classElement, not(isJSDocOverrideTag));
|
||||
return;
|
||||
}
|
||||
const overrideModifier = classElement.modifiers && find(classElement.modifiers, modifier => modifier.kind === SyntaxKind.OverrideKeyword);
|
||||
Debug.assertIsDefined(overrideModifier);
|
||||
|
||||
|
|
|
@ -37,6 +37,12 @@ namespace ts.codefix {
|
|||
|
||||
type AddNode = PropertyDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | MethodDeclaration | FunctionExpression | ArrowFunction;
|
||||
|
||||
export const enum PreserveOptionalFlags {
|
||||
Method = 1 << 0,
|
||||
Property = 1 << 1,
|
||||
All = Method | Property
|
||||
}
|
||||
|
||||
/**
|
||||
* `addClassElement` will not be called if we can't figure out a representation for `symbol` in `enclosingDeclaration`.
|
||||
* @param body If defined, this will be the body of the member node passed to `addClassElement`. Otherwise, the body will default to a stub.
|
||||
|
@ -50,6 +56,7 @@ namespace ts.codefix {
|
|||
importAdder: ImportAdder | undefined,
|
||||
addClassElement: (node: AddNode) => void,
|
||||
body: Block | undefined,
|
||||
preserveOptional = PreserveOptionalFlags.All,
|
||||
isAmbient = false,
|
||||
): void {
|
||||
const declarations = symbol.getDeclarations();
|
||||
|
@ -83,7 +90,7 @@ namespace ts.codefix {
|
|||
/*decorators*/ undefined,
|
||||
modifiers,
|
||||
name,
|
||||
optional ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
|
||||
optional && (preserveOptional & PreserveOptionalFlags.Property) ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
|
||||
typeNode,
|
||||
/*initializer*/ undefined));
|
||||
break;
|
||||
|
@ -158,14 +165,14 @@ namespace ts.codefix {
|
|||
}
|
||||
else {
|
||||
Debug.assert(declarations.length === signatures.length, "Declarations and signatures should match count");
|
||||
addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference, body));
|
||||
addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional && !!(preserveOptional & PreserveOptionalFlags.Method), modifiers, quotePreference, body));
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
function outputMethod(quotePreference: QuotePreference, signature: Signature, modifiers: NodeArray<Modifier> | undefined, name: PropertyName, body?: Block): void {
|
||||
const method = createSignatureDeclarationFromSignature(SyntaxKind.MethodDeclaration, context, quotePreference, signature, body, name, modifiers, optional, enclosingDeclaration, importAdder);
|
||||
const method = createSignatureDeclarationFromSignature(SyntaxKind.MethodDeclaration, context, quotePreference, signature, body, name, modifiers, optional && !!(preserveOptional & PreserveOptionalFlags.Method), enclosingDeclaration, importAdder);
|
||||
if (method) addClassElement(method);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -131,7 +131,7 @@ namespace ts.codefix {
|
|||
if (typeNode) {
|
||||
// Note that the codefix will never fire with an existing `@type` tag, so there is no need to merge tags
|
||||
const typeTag = factory.createJSDocTypeTag(/*tagName*/ undefined, factory.createJSDocTypeExpression(typeNode), /*comment*/ undefined);
|
||||
addJSDocTags(changes, sourceFile, cast(parent.parent.parent, isExpressionStatement), [typeTag]);
|
||||
changes.addJSDocTags(sourceFile, cast(parent.parent.parent, isExpressionStatement), [typeTag]);
|
||||
}
|
||||
importAdder.writeFixes(changes);
|
||||
return parent;
|
||||
|
@ -271,7 +271,7 @@ namespace ts.codefix {
|
|||
}
|
||||
|
||||
function annotateJSDocThis(changes: textChanges.ChangeTracker, sourceFile: SourceFile, containingFunction: SignatureDeclaration, typeNode: TypeNode) {
|
||||
addJSDocTags(changes, sourceFile, containingFunction, [
|
||||
changes.addJSDocTags(sourceFile, containingFunction, [
|
||||
factory.createJSDocThisTag(/*tagName*/ undefined, factory.createJSDocTypeExpression(typeNode)),
|
||||
]);
|
||||
}
|
||||
|
@ -311,7 +311,7 @@ namespace ts.codefix {
|
|||
}
|
||||
const typeExpression = factory.createJSDocTypeExpression(typeNode);
|
||||
const typeTag = isGetAccessorDeclaration(declaration) ? factory.createJSDocReturnTag(/*tagName*/ undefined, typeExpression, /*comment*/ undefined) : factory.createJSDocTypeTag(/*tagName*/ undefined, typeExpression, /*comment*/ undefined);
|
||||
addJSDocTags(changes, sourceFile, parent, [typeTag]);
|
||||
changes.addJSDocTags(sourceFile, parent, [typeTag]);
|
||||
}
|
||||
else if (!tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, sourceFile, changes, importAdder, getEmitScriptTarget(program.getCompilerOptions()))) {
|
||||
changes.tryInsertTypeAnnotation(sourceFile, declaration, typeNode);
|
||||
|
@ -378,46 +378,7 @@ namespace ts.codefix {
|
|||
else {
|
||||
const paramTags = map(inferences, ({ name, typeNode, isOptional }) =>
|
||||
factory.createJSDocParameterTag(/*tagName*/ undefined, name, /*isBracketed*/ !!isOptional, factory.createJSDocTypeExpression(typeNode), /* isNameFirst */ false, /*comment*/ undefined));
|
||||
addJSDocTags(changes, sourceFile, signature, paramTags);
|
||||
}
|
||||
}
|
||||
|
||||
export function addJSDocTags(changes: textChanges.ChangeTracker, sourceFile: SourceFile, parent: HasJSDoc, newTags: readonly JSDocTag[]): void {
|
||||
const comments = flatMap(parent.jsDoc, j => typeof j.comment === "string" ? factory.createJSDocText(j.comment) : j.comment) as JSDocComment[];
|
||||
const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);
|
||||
const unmergedNewTags = newTags.filter(newTag => !oldTags || !oldTags.some((tag, i) => {
|
||||
const merged = tryMergeJsdocTags(tag, newTag);
|
||||
if (merged) oldTags[i] = merged;
|
||||
return !!merged;
|
||||
}));
|
||||
const tag = factory.createJSDocComment(factory.createNodeArray(intersperse(comments, factory.createJSDocText("\n"))), factory.createNodeArray([...(oldTags || emptyArray), ...unmergedNewTags]));
|
||||
const jsDocNode = parent.kind === SyntaxKind.ArrowFunction ? getJsDocNodeForArrowFunction(parent) : parent;
|
||||
jsDocNode.jsDoc = parent.jsDoc;
|
||||
jsDocNode.jsDocCache = parent.jsDocCache;
|
||||
changes.insertJsdocCommentBefore(sourceFile, jsDocNode, tag);
|
||||
}
|
||||
|
||||
function getJsDocNodeForArrowFunction(signature: ArrowFunction): HasJSDoc {
|
||||
if (signature.parent.kind === SyntaxKind.PropertyDeclaration) {
|
||||
return signature.parent as HasJSDoc;
|
||||
}
|
||||
return signature.parent.parent as HasJSDoc;
|
||||
}
|
||||
|
||||
function tryMergeJsdocTags(oldTag: JSDocTag, newTag: JSDocTag): JSDocTag | undefined {
|
||||
if (oldTag.kind !== newTag.kind) {
|
||||
return undefined;
|
||||
}
|
||||
switch (oldTag.kind) {
|
||||
case SyntaxKind.JSDocParameterTag: {
|
||||
const oldParam = oldTag as JSDocParameterTag;
|
||||
const newParam = newTag as JSDocParameterTag;
|
||||
return isIdentifier(oldParam.name) && isIdentifier(newParam.name) && oldParam.name.escapedText === newParam.name.escapedText
|
||||
? factory.createJSDocParameterTag(/*tagName*/ undefined, newParam.name, /*isBracketed*/ false, newParam.typeExpression, newParam.isNameFirst, oldParam.comment)
|
||||
: undefined;
|
||||
}
|
||||
case SyntaxKind.JSDocReturnTag:
|
||||
return factory.createJSDocReturnTag(/*tagName*/ undefined, (newTag as JSDocReturnTag).typeExpression, oldTag.comment);
|
||||
changes.addJSDocTags(sourceFile, signature, paramTags);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1000,13 +961,25 @@ namespace ts.codefix {
|
|||
if (usage.numberIndex) {
|
||||
types.push(checker.createArrayType(combineFromUsage(usage.numberIndex)));
|
||||
}
|
||||
if (usage.properties?.size || usage.calls?.length || usage.constructs?.length || usage.stringIndex) {
|
||||
if (usage.properties?.size || usage.constructs?.length || usage.stringIndex) {
|
||||
types.push(inferStructuralType(usage));
|
||||
}
|
||||
|
||||
types.push(...(usage.candidateTypes || []).map(t => checker.getBaseTypeOfLiteralType(t)));
|
||||
types.push(...inferNamedTypesFromProperties(usage));
|
||||
const candidateTypes = (usage.candidateTypes || []).map(t => checker.getBaseTypeOfLiteralType(t));
|
||||
const callsType = usage.calls?.length ? inferStructuralType(usage) : undefined;
|
||||
if (callsType && candidateTypes) {
|
||||
types.push(checker.getUnionType([callsType, ...candidateTypes], UnionReduction.Subtype));
|
||||
}
|
||||
else {
|
||||
if (callsType) {
|
||||
types.push(callsType);
|
||||
}
|
||||
if (length(candidateTypes)) {
|
||||
types.push(...candidateTypes);
|
||||
}
|
||||
}
|
||||
|
||||
types.push(...inferNamedTypesFromProperties(usage));
|
||||
return types;
|
||||
}
|
||||
|
||||
|
|
|
@ -738,10 +738,6 @@ namespace ts.Completions {
|
|||
insertText = `${escapeSnippetText(name)}={$1}`;
|
||||
isSnippet = true;
|
||||
}
|
||||
|
||||
if (isSnippet) {
|
||||
replacementSpan = createTextSpanFromNode(location, sourceFile);
|
||||
}
|
||||
}
|
||||
|
||||
if (insertText !== undefined && !preferences.includeCompletionsWithInsertText) {
|
||||
|
@ -851,7 +847,7 @@ namespace ts.Completions {
|
|||
removeComments: true,
|
||||
module: options.module,
|
||||
target: options.target,
|
||||
omitTrailingSemicolon: true,
|
||||
omitTrailingSemicolon: false,
|
||||
newLine: getNewLineKind(getNewLineCharacter(options, maybeBind(host, host.getNewLine))),
|
||||
});
|
||||
const importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
|
||||
|
@ -895,7 +891,7 @@ namespace ts.Completions {
|
|||
node => {
|
||||
let requiredModifiers = ModifierFlags.None;
|
||||
if (isAbstract) {
|
||||
requiredModifiers |= ModifierFlags.Abstract;
|
||||
requiredModifiers |= ModifierFlags.Abstract;
|
||||
}
|
||||
if (isClassElement(node)
|
||||
&& checker.getMemberOverrideModifierStatus(classLikeDeclaration, node) === MemberOverrideStatus.NeedsOverride) {
|
||||
|
@ -919,10 +915,14 @@ namespace ts.Completions {
|
|||
completionNodes.push(node);
|
||||
},
|
||||
body,
|
||||
codefix.PreserveOptionalFlags.Property,
|
||||
isAbstract);
|
||||
|
||||
if (completionNodes.length) {
|
||||
insertText = printer.printSnippetList(ListFormat.MultiLine, factory.createNodeArray(completionNodes), sourceFile);
|
||||
insertText = printer.printSnippetList(
|
||||
ListFormat.MultiLine | ListFormat.NoTrailingNewLine,
|
||||
factory.createNodeArray(completionNodes),
|
||||
sourceFile);
|
||||
}
|
||||
|
||||
return { insertText, isSnippet, importAdder };
|
||||
|
@ -3525,6 +3525,7 @@ namespace ts.Completions {
|
|||
// function f<T>(x: T) {}
|
||||
// f({ abc/**/: "" }) // `abc` is a member of `T` but only because it declares itself
|
||||
function hasDeclarationOtherThanSelf(member: Symbol) {
|
||||
if (!length(member.declarations)) return true;
|
||||
return some(member.declarations, decl => decl.parent !== obj);
|
||||
}
|
||||
}
|
||||
|
@ -3888,5 +3889,6 @@ namespace ts.Completions {
|
|||
}
|
||||
return charCode;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
|
@ -1323,7 +1323,7 @@ namespace ts.FindAllReferences {
|
|||
if (!symbol) return undefined;
|
||||
for (const token of getPossibleSymbolReferenceNodes(sourceFile, symbol.name, searchContainer)) {
|
||||
if (!isIdentifier(token) || token === definition || token.escapedText !== definition.escapedText) continue;
|
||||
const referenceSymbol: Symbol = checker.getSymbolAtLocation(token)!; // See GH#19955 for why the type annotation is necessary
|
||||
const referenceSymbol = checker.getSymbolAtLocation(token)!;
|
||||
if (referenceSymbol === symbol
|
||||
|| checker.getShorthandAssignmentValueSymbol(token.parent) === symbol
|
||||
|| isExportSpecifier(token.parent) && getLocalSymbolForExportSpecifier(token, referenceSymbol, token.parent, checker) === symbol) {
|
||||
|
@ -2021,7 +2021,8 @@ namespace ts.FindAllReferences {
|
|||
}
|
||||
}
|
||||
else {
|
||||
return nodeEntry(ref, EntryKind.StringLiteral);
|
||||
return isNoSubstitutionTemplateLiteral(ref) && !rangeIsOnSingleLine(ref, sourceFile) ? undefined :
|
||||
nodeEntry(ref, EntryKind.StringLiteral);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
|
|
@ -198,14 +198,17 @@ namespace ts.GoToDefinition {
|
|||
return undefined;
|
||||
}
|
||||
|
||||
const symbol = typeChecker.getSymbolAtLocation(node);
|
||||
const symbol = getSymbol(node, typeChecker);
|
||||
if (!symbol) return undefined;
|
||||
|
||||
const typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
|
||||
const returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
|
||||
const fromReturnType = returnType && definitionFromType(returnType, typeChecker, node);
|
||||
// If a function returns 'void' or some other type with no definition, just return the function definition.
|
||||
return fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node);
|
||||
const typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node);
|
||||
return typeDefinitions.length ? typeDefinitions
|
||||
: !(symbol.flags & SymbolFlags.Value) && symbol.flags & SymbolFlags.Type ? getDefinitionFromSymbol(typeChecker, skipAlias(symbol, typeChecker), node)
|
||||
: undefined;
|
||||
}
|
||||
|
||||
function definitionFromType(type: Type, checker: TypeChecker, node: Node): readonly DefinitionInfo[] {
|
||||
|
|
|
@ -34,7 +34,7 @@ namespace ts.OutliningElementsCollector {
|
|||
if (depthRemaining === 0) return;
|
||||
cancellationToken.throwIfCancellationRequested();
|
||||
|
||||
if (isDeclaration(n) || isVariableStatement(n) || isReturnStatement(n) || n.kind === SyntaxKind.EndOfFileToken) {
|
||||
if (isDeclaration(n) || isVariableStatement(n) || isReturnStatement(n) || isCallOrNewExpression(n) || n.kind === SyntaxKind.EndOfFileToken) {
|
||||
addOutliningForLeadingCommentsForNode(n, sourceFile, cancellationToken, out);
|
||||
}
|
||||
|
||||
|
|
|
@ -314,8 +314,7 @@ namespace ts.refactor.extractSymbol {
|
|||
return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
|
||||
}
|
||||
const statements: Statement[] = [];
|
||||
const start2 = start; // TODO: GH#18217 Need to alias `start` to get this to compile. See https://github.com/Microsoft/TypeScript/issues/19955#issuecomment-344118248
|
||||
for (const statement of (start2.parent as BlockLike).statements) {
|
||||
for (const statement of start.parent.statements) {
|
||||
if (statement === start || statements.length) {
|
||||
const errors = checkNode(statement);
|
||||
if (errors) {
|
||||
|
@ -364,10 +363,11 @@ namespace ts.refactor.extractSymbol {
|
|||
return node.expression;
|
||||
}
|
||||
}
|
||||
else if (isVariableStatement(node)) {
|
||||
else if (isVariableStatement(node) || isVariableDeclarationList(node)) {
|
||||
const declarations = isVariableStatement(node) ? node.declarationList.declarations : node.declarations;
|
||||
let numInitializers = 0;
|
||||
let lastInitializer: Expression | undefined;
|
||||
for (const declaration of node.declarationList.declarations) {
|
||||
for (const declaration of declarations) {
|
||||
if (declaration.initializer) {
|
||||
numInitializers++;
|
||||
lastInitializer = declaration.initializer;
|
||||
|
@ -383,7 +383,6 @@ namespace ts.refactor.extractSymbol {
|
|||
return node.initializer;
|
||||
}
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
|
|
|
@ -599,10 +599,11 @@ namespace ts {
|
|||
}
|
||||
|
||||
function findBaseOfDeclaration<T>(checker: TypeChecker, declaration: Declaration, cb: (symbol: Symbol) => T[] | undefined): T[] | undefined {
|
||||
if (hasStaticModifier(declaration)) return;
|
||||
|
||||
const classOrInterfaceDeclaration = declaration.parent?.kind === SyntaxKind.Constructor ? declaration.parent.parent : declaration.parent;
|
||||
if (!classOrInterfaceDeclaration) {
|
||||
return;
|
||||
}
|
||||
if (!classOrInterfaceDeclaration) return;
|
||||
|
||||
return firstDefined(getAllSuperTypeNodes(classOrInterfaceDeclaration), superTypeNode => {
|
||||
const symbol = checker.getPropertyOfType(checker.getTypeAtLocation(superTypeNode), declaration.symbol.name);
|
||||
return symbol ? cb(symbol) : undefined;
|
||||
|
|
|
@ -494,6 +494,27 @@ namespace ts.textChanges {
|
|||
this.insertNodeAt(sourceFile, fnStart, tag, { preserveLeadingWhitespace: false, suffix: this.newLineCharacter + indent });
|
||||
}
|
||||
|
||||
public addJSDocTags(sourceFile: SourceFile, parent: HasJSDoc, newTags: readonly JSDocTag[]): void {
|
||||
const comments = flatMap(parent.jsDoc, j => typeof j.comment === "string" ? factory.createJSDocText(j.comment) : j.comment) as JSDocComment[];
|
||||
const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);
|
||||
const unmergedNewTags = newTags.filter(newTag => !oldTags.some((tag, i) => {
|
||||
const merged = tryMergeJsdocTags(tag, newTag);
|
||||
if (merged) oldTags[i] = merged;
|
||||
return !!merged;
|
||||
}));
|
||||
const tag = factory.createJSDocComment(factory.createNodeArray(intersperse(comments, factory.createJSDocText("\n"))), factory.createNodeArray([...oldTags, ...unmergedNewTags]));
|
||||
const host = updateJSDocHost(parent);
|
||||
this.insertJsdocCommentBefore(sourceFile, host, tag);
|
||||
}
|
||||
|
||||
public filterJSDocTags(sourceFile: SourceFile, parent: HasJSDoc, predicate: (tag: JSDocTag) => boolean): void {
|
||||
const comments = flatMap(parent.jsDoc, j => typeof j.comment === "string" ? factory.createJSDocText(j.comment) : j.comment) as JSDocComment[];
|
||||
const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);
|
||||
const tag = factory.createJSDocComment(factory.createNodeArray(intersperse(comments, factory.createJSDocText("\n"))), factory.createNodeArray([...(filter(oldTags, predicate) || emptyArray)]));
|
||||
const host = updateJSDocHost(parent);
|
||||
this.insertJsdocCommentBefore(sourceFile, host, tag);
|
||||
}
|
||||
|
||||
public replaceRangeWithText(sourceFile: SourceFile, range: TextRange, text: string): void {
|
||||
this.changes.push({ kind: ChangeKind.Text, sourceFile, range, text });
|
||||
}
|
||||
|
@ -920,6 +941,35 @@ namespace ts.textChanges {
|
|||
}
|
||||
}
|
||||
|
||||
function updateJSDocHost(parent: HasJSDoc): HasJSDoc {
|
||||
if (parent.kind !== SyntaxKind.ArrowFunction) {
|
||||
return parent;
|
||||
}
|
||||
const jsDocNode = parent.parent.kind === SyntaxKind.PropertyDeclaration ?
|
||||
parent.parent as HasJSDoc :
|
||||
parent.parent.parent as HasJSDoc;
|
||||
jsDocNode.jsDoc = parent.jsDoc;
|
||||
jsDocNode.jsDocCache = parent.jsDocCache;
|
||||
return jsDocNode;
|
||||
}
|
||||
|
||||
function tryMergeJsdocTags(oldTag: JSDocTag, newTag: JSDocTag): JSDocTag | undefined {
|
||||
if (oldTag.kind !== newTag.kind) {
|
||||
return undefined;
|
||||
}
|
||||
switch (oldTag.kind) {
|
||||
case SyntaxKind.JSDocParameterTag: {
|
||||
const oldParam = oldTag as JSDocParameterTag;
|
||||
const newParam = newTag as JSDocParameterTag;
|
||||
return isIdentifier(oldParam.name) && isIdentifier(newParam.name) && oldParam.name.escapedText === newParam.name.escapedText
|
||||
? factory.createJSDocParameterTag(/*tagName*/ undefined, newParam.name, /*isBracketed*/ false, newParam.typeExpression, newParam.isNameFirst, oldParam.comment)
|
||||
: undefined;
|
||||
}
|
||||
case SyntaxKind.JSDocReturnTag:
|
||||
return factory.createJSDocReturnTag(/*tagName*/ undefined, (newTag as JSDocReturnTag).typeExpression, oldTag.comment);
|
||||
}
|
||||
}
|
||||
|
||||
// find first non-whitespace position in the leading trivia of the node
|
||||
function startPositionToDeleteNodeInList(sourceFile: SourceFile, node: Node): number {
|
||||
return skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.IncludeAll }), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);
|
||||
|
|
|
@ -14,7 +14,7 @@ namespace Harness.Parallel.Host {
|
|||
const { statSync } = require("fs") as typeof import("fs");
|
||||
|
||||
// NOTE: paths for module and types for FailedTestReporter _do not_ line up due to our use of --outFile for run.js
|
||||
const FailedTestReporter = require(path.resolve(__dirname, "../../scripts/failed-tests")) as typeof import("../../../scripts/failed-tests");
|
||||
const FailedTestReporter = require(Utils.findUpFile("scripts/failed-tests.js")) as typeof import("../../../scripts/failed-tests");
|
||||
|
||||
const perfdataFileNameFragment = ".parallelperf";
|
||||
const perfData = readSavedPerfData(configOption);
|
||||
|
|
|
@ -211,7 +211,7 @@ namespace ts {
|
|||
start: undefined,
|
||||
length: undefined,
|
||||
}, {
|
||||
messageText: "Argument for '--target' option must be: 'es3', 'es5', 'es6', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'esnext'.",
|
||||
messageText: "Argument for '--target' option must be: 'es3', 'es5', 'es6', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'esnext'.",
|
||||
category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
|
||||
code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
|
||||
|
||||
|
|
|
@ -182,34 +182,3 @@ describe("unittests:: Public APIs:: getChild* methods on EndOfFileToken with JSD
|
|||
assert.equal(endOfFileToken.getChildCount(), 1);
|
||||
assert.notEqual(endOfFileToken.getChildAt(0), /*expected*/ undefined);
|
||||
});
|
||||
|
||||
describe("unittests:: Public APIs:: sys", () => {
|
||||
it("readDirectory", () => {
|
||||
// #45990, testing passing a non-absolute path
|
||||
// `sys.readDirectory` is just `matchFiles` plugged into the real FS
|
||||
const read = ts.matchFiles(
|
||||
/*path*/ "",
|
||||
/*extensions*/ [".ts", ".tsx"],
|
||||
/*excludes*/ ["node_modules", "dist"],
|
||||
/*includes*/ ["**/*"],
|
||||
/*useCaseSensitiveFileNames*/ true,
|
||||
/*currentDirectory*/ "/",
|
||||
/*depth*/ undefined,
|
||||
/*getFileSystemEntries*/ path => {
|
||||
switch (path) {
|
||||
case "/": return { directories: [], files: ["file.ts"] };
|
||||
default: return { directories: [], files: [] };
|
||||
}
|
||||
},
|
||||
/*realpath*/ ts.identity,
|
||||
/*directoryExists*/ path => {
|
||||
switch (path) {
|
||||
case "/": return true;
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
assert.deepEqual(read, ["/file.ts"]);
|
||||
});
|
||||
});
|
||||
|
|
|
@ -191,7 +191,7 @@ namespace ts {
|
|||
testExtractRange("extractRange28", `[#|return [$|1|];|]`);
|
||||
|
||||
// For statements
|
||||
testExtractRange("extractRange29", `for ([#|var i = 1|]; i < 2; i++) {}`);
|
||||
testExtractRange("extractRange29", `for ([#|var i = [$|1|]|]; i < 2; i++) {}`);
|
||||
testExtractRange("extractRange30", `for (var i = [#|[$|1|]|]; i < 2; i++) {}`);
|
||||
});
|
||||
|
||||
|
|
|
@ -326,7 +326,7 @@ namespace ts.projectSystem {
|
|||
};
|
||||
|
||||
function updateFile(path: string, newText: string) {
|
||||
Debug.assertDefined(files.find(f => f.path === path));
|
||||
Debug.assertIsDefined(files.find(f => f.path === path));
|
||||
session.executeCommandSeq<protocol.ApplyChangedToOpenFilesRequest>({
|
||||
command: protocol.CommandTypes.ApplyChangedToOpenFiles,
|
||||
arguments: {
|
||||
|
@ -339,7 +339,7 @@ namespace ts.projectSystem {
|
|||
}
|
||||
|
||||
function findAllReferences(file: string, line: number, offset: number) {
|
||||
Debug.assertDefined(files.find(f => f.path === file));
|
||||
Debug.assertIsDefined(files.find(f => f.path === file));
|
||||
session.executeCommandSeq<protocol.ReferencesRequest>({
|
||||
command: protocol.CommandTypes.References,
|
||||
arguments: {
|
||||
|
|
|
@ -14,7 +14,7 @@ and limitations under the License.
|
|||
***************************************************************************** */
|
||||
|
||||
declare namespace ts {
|
||||
const versionMajorMinor = "4.5";
|
||||
const versionMajorMinor = "4.6";
|
||||
/** The version of the TypeScript compiler release */
|
||||
const version: string;
|
||||
/**
|
||||
|
@ -897,7 +897,7 @@ declare namespace ts {
|
|||
export interface TypePredicateNode extends TypeNode {
|
||||
readonly kind: SyntaxKind.TypePredicate;
|
||||
readonly parent: SignatureDeclaration | JSDocTypeExpression;
|
||||
readonly assertsModifier?: AssertsToken;
|
||||
readonly assertsModifier?: AssertsKeyword;
|
||||
readonly parameterName: Identifier | ThisTypeNode;
|
||||
readonly type?: TypeNode;
|
||||
}
|
||||
|
@ -968,7 +968,7 @@ declare namespace ts {
|
|||
}
|
||||
export interface MappedTypeNode extends TypeNode, Declaration {
|
||||
readonly kind: SyntaxKind.MappedType;
|
||||
readonly readonlyToken?: ReadonlyToken | PlusToken | MinusToken;
|
||||
readonly readonlyToken?: ReadonlyKeyword | PlusToken | MinusToken;
|
||||
readonly typeParameter: TypeParameterDeclaration;
|
||||
readonly nameType?: TypeNode;
|
||||
readonly questionToken?: QuestionToken | PlusToken | MinusToken;
|
||||
|
@ -1465,7 +1465,7 @@ declare namespace ts {
|
|||
}
|
||||
export interface ForOfStatement extends IterationStatement {
|
||||
readonly kind: SyntaxKind.ForOfStatement;
|
||||
readonly awaitModifier?: AwaitKeywordToken;
|
||||
readonly awaitModifier?: AwaitKeyword;
|
||||
readonly initializer: ForInitializer;
|
||||
readonly expression: Expression;
|
||||
}
|
||||
|
@ -3078,6 +3078,7 @@ declare namespace ts {
|
|||
ES2019 = 6,
|
||||
ES2020 = 7,
|
||||
ES2021 = 8,
|
||||
ES2022 = 9,
|
||||
ESNext = 99,
|
||||
JSON = 100,
|
||||
Latest = 99
|
||||
|
@ -9666,6 +9667,7 @@ declare namespace ts.server.protocol {
|
|||
ES2019 = "ES2019",
|
||||
ES2020 = "ES2020",
|
||||
ES2021 = "ES2021",
|
||||
ES2022 = "ES2022",
|
||||
ESNext = "ESNext"
|
||||
}
|
||||
enum ClassificationType {
|
||||
|
|
|
@ -14,7 +14,7 @@ and limitations under the License.
|
|||
***************************************************************************** */
|
||||
|
||||
declare namespace ts {
|
||||
const versionMajorMinor = "4.5";
|
||||
const versionMajorMinor = "4.6";
|
||||
/** The version of the TypeScript compiler release */
|
||||
const version: string;
|
||||
/**
|
||||
|
@ -897,7 +897,7 @@ declare namespace ts {
|
|||
export interface TypePredicateNode extends TypeNode {
|
||||
readonly kind: SyntaxKind.TypePredicate;
|
||||
readonly parent: SignatureDeclaration | JSDocTypeExpression;
|
||||
readonly assertsModifier?: AssertsToken;
|
||||
readonly assertsModifier?: AssertsKeyword;
|
||||
readonly parameterName: Identifier | ThisTypeNode;
|
||||
readonly type?: TypeNode;
|
||||
}
|
||||
|
@ -968,7 +968,7 @@ declare namespace ts {
|
|||
}
|
||||
export interface MappedTypeNode extends TypeNode, Declaration {
|
||||
readonly kind: SyntaxKind.MappedType;
|
||||
readonly readonlyToken?: ReadonlyToken | PlusToken | MinusToken;
|
||||
readonly readonlyToken?: ReadonlyKeyword | PlusToken | MinusToken;
|
||||
readonly typeParameter: TypeParameterDeclaration;
|
||||
readonly nameType?: TypeNode;
|
||||
readonly questionToken?: QuestionToken | PlusToken | MinusToken;
|
||||
|
@ -1465,7 +1465,7 @@ declare namespace ts {
|
|||
}
|
||||
export interface ForOfStatement extends IterationStatement {
|
||||
readonly kind: SyntaxKind.ForOfStatement;
|
||||
readonly awaitModifier?: AwaitKeywordToken;
|
||||
readonly awaitModifier?: AwaitKeyword;
|
||||
readonly initializer: ForInitializer;
|
||||
readonly expression: Expression;
|
||||
}
|
||||
|
@ -3078,6 +3078,7 @@ declare namespace ts {
|
|||
ES2019 = 6,
|
||||
ES2020 = 7,
|
||||
ES2021 = 8,
|
||||
ES2022 = 9,
|
||||
ESNext = 99,
|
||||
JSON = 100,
|
||||
Latest = 99
|
||||
|
|
|
@ -0,0 +1,46 @@
|
|||
/a.js(18,9): error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode.
|
||||
|
||||
|
||||
==== /a.js (1 errors) ====
|
||||
class A {
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* @param {object} [foo={}]
|
||||
*/
|
||||
constructor(foo = {}) {
|
||||
const key = "bar";
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
this.foo = foo;
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
const arguments = this.arguments;
|
||||
~~~~~~~~~
|
||||
!!! error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode.
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
this.bar = arguments.bar;
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
this.baz = arguments[key];
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
this.options = arguments;
|
||||
}
|
||||
|
||||
get arguments() {
|
||||
return { bar: {} };
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
/a.js(16,9): error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode.
|
||||
|
||||
|
||||
==== /a.js (1 errors) ====
|
||||
class A {
|
||||
/**
|
||||
* @param {object} [foo={}]
|
||||
*/
|
||||
m(foo = {}) {
|
||||
const key = "bar";
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
this.foo = foo;
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
const arguments = this.arguments;
|
||||
~~~~~~~~~
|
||||
!!! error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode.
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
this.bar = arguments.bar;
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
this.baz = arguments[key];
|
||||
|
||||
/**
|
||||
* @type object
|
||||
*/
|
||||
this.options = arguments;
|
||||
}
|
||||
|
||||
get arguments() {
|
||||
return { bar: {} };
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
//// [callChainWithSuper.ts]
|
||||
// GH#34952
|
||||
class Base { method?() {} }
|
||||
class Derived extends Base {
|
||||
method1() { return super.method?.(); }
|
||||
method2() { return super["method"]?.(); }
|
||||
}
|
||||
|
||||
//// [callChainWithSuper.js]
|
||||
"use strict";
|
||||
// GH#34952
|
||||
class Base {
|
||||
method() { }
|
||||
}
|
||||
class Derived extends Base {
|
||||
method1() { return super.method?.(); }
|
||||
method2() { return super["method"]?.(); }
|
||||
}
|
|
@ -30,7 +30,7 @@ declare const pli: {
|
|||
|
||||
(streams: ReadonlyArray<R | W | RW>): Promise<void>;
|
||||
>streams : Symbol(streams, Decl(callWithSpread4.ts, 5, 5))
|
||||
>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es2019.array.d.ts, --, --))
|
||||
>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es2019.array.d.ts, --, --) ... and 1 more)
|
||||
>R : Symbol(R, Decl(callWithSpread4.ts, 0, 0))
|
||||
>W : Symbol(W, Decl(callWithSpread4.ts, 0, 22))
|
||||
>RW : Symbol(RW, Decl(callWithSpread4.ts, 1, 22))
|
||||
|
@ -43,7 +43,7 @@ declare const pli: {
|
|||
>RW : Symbol(RW, Decl(callWithSpread4.ts, 1, 22))
|
||||
>W : Symbol(W, Decl(callWithSpread4.ts, 0, 22))
|
||||
>streams : Symbol(streams, Decl(callWithSpread4.ts, 6, 23))
|
||||
>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 2 more)
|
||||
>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more)
|
||||
>RW : Symbol(RW, Decl(callWithSpread4.ts, 1, 22))
|
||||
>W : Symbol(W, Decl(callWithSpread4.ts, 0, 22))
|
||||
>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --))
|
||||
|
|
|
@ -0,0 +1,53 @@
|
|||
//// [contextuallyTypedSymbolNamedProperties.ts]
|
||||
// Repros from #43628
|
||||
|
||||
const A = Symbol("A");
|
||||
const B = Symbol("B");
|
||||
|
||||
type Action =
|
||||
| {type: typeof A, data: string}
|
||||
| {type: typeof B, data: number}
|
||||
|
||||
declare const ab: Action;
|
||||
|
||||
declare function f<T extends { type: string | symbol }>(action: T, blah: { [K in T['type']]: (p: K) => void }): any;
|
||||
|
||||
f(ab, {
|
||||
[A]: ap => { ap.description },
|
||||
[B]: bp => { bp.description },
|
||||
})
|
||||
|
||||
const x: { [sym: symbol]: (p: string) => void } = { [A]: s => s.length };
|
||||
|
||||
|
||||
//// [contextuallyTypedSymbolNamedProperties.js]
|
||||
"use strict";
|
||||
// Repros from #43628
|
||||
const A = Symbol("A");
|
||||
const B = Symbol("B");
|
||||
f(ab, {
|
||||
[A]: ap => { ap.description; },
|
||||
[B]: bp => { bp.description; },
|
||||
});
|
||||
const x = { [A]: s => s.length };
|
||||
|
||||
|
||||
//// [contextuallyTypedSymbolNamedProperties.d.ts]
|
||||
declare const A: unique symbol;
|
||||
declare const B: unique symbol;
|
||||
declare type Action = {
|
||||
type: typeof A;
|
||||
data: string;
|
||||
} | {
|
||||
type: typeof B;
|
||||
data: number;
|
||||
};
|
||||
declare const ab: Action;
|
||||
declare function f<T extends {
|
||||
type: string | symbol;
|
||||
}>(action: T, blah: {
|
||||
[K in T['type']]: (p: K) => void;
|
||||
}): any;
|
||||
declare const x: {
|
||||
[sym: symbol]: (p: string) => void;
|
||||
};
|
|
@ -0,0 +1,73 @@
|
|||
=== tests/cases/compiler/contextuallyTypedSymbolNamedProperties.ts ===
|
||||
// Repros from #43628
|
||||
|
||||
const A = Symbol("A");
|
||||
>A : Symbol(A, Decl(contextuallyTypedSymbolNamedProperties.ts, 2, 5))
|
||||
>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --))
|
||||
|
||||
const B = Symbol("B");
|
||||
>B : Symbol(B, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 5))
|
||||
>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --))
|
||||
|
||||
type Action =
|
||||
>Action : Symbol(Action, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 22))
|
||||
|
||||
| {type: typeof A, data: string}
|
||||
>type : Symbol(type, Decl(contextuallyTypedSymbolNamedProperties.ts, 6, 7))
|
||||
>A : Symbol(A, Decl(contextuallyTypedSymbolNamedProperties.ts, 2, 5))
|
||||
>data : Symbol(data, Decl(contextuallyTypedSymbolNamedProperties.ts, 6, 22))
|
||||
|
||||
| {type: typeof B, data: number}
|
||||
>type : Symbol(type, Decl(contextuallyTypedSymbolNamedProperties.ts, 7, 7))
|
||||
>B : Symbol(B, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 5))
|
||||
>data : Symbol(data, Decl(contextuallyTypedSymbolNamedProperties.ts, 7, 22))
|
||||
|
||||
declare const ab: Action;
|
||||
>ab : Symbol(ab, Decl(contextuallyTypedSymbolNamedProperties.ts, 9, 13))
|
||||
>Action : Symbol(Action, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 22))
|
||||
|
||||
declare function f<T extends { type: string | symbol }>(action: T, blah: { [K in T['type']]: (p: K) => void }): any;
|
||||
>f : Symbol(f, Decl(contextuallyTypedSymbolNamedProperties.ts, 9, 25))
|
||||
>T : Symbol(T, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 19))
|
||||
>type : Symbol(type, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 30))
|
||||
>action : Symbol(action, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 56))
|
||||
>T : Symbol(T, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 19))
|
||||
>blah : Symbol(blah, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 66))
|
||||
>K : Symbol(K, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 76))
|
||||
>T : Symbol(T, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 19))
|
||||
>p : Symbol(p, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 94))
|
||||
>K : Symbol(K, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 76))
|
||||
|
||||
f(ab, {
|
||||
>f : Symbol(f, Decl(contextuallyTypedSymbolNamedProperties.ts, 9, 25))
|
||||
>ab : Symbol(ab, Decl(contextuallyTypedSymbolNamedProperties.ts, 9, 13))
|
||||
|
||||
[A]: ap => { ap.description },
|
||||
>[A] : Symbol([A], Decl(contextuallyTypedSymbolNamedProperties.ts, 13, 7))
|
||||
>A : Symbol(A, Decl(contextuallyTypedSymbolNamedProperties.ts, 2, 5))
|
||||
>ap : Symbol(ap, Decl(contextuallyTypedSymbolNamedProperties.ts, 14, 8))
|
||||
>ap.description : Symbol(Symbol.description, Decl(lib.es2019.symbol.d.ts, --, --))
|
||||
>ap : Symbol(ap, Decl(contextuallyTypedSymbolNamedProperties.ts, 14, 8))
|
||||
>description : Symbol(Symbol.description, Decl(lib.es2019.symbol.d.ts, --, --))
|
||||
|
||||
[B]: bp => { bp.description },
|
||||
>[B] : Symbol([B], Decl(contextuallyTypedSymbolNamedProperties.ts, 14, 34))
|
||||
>B : Symbol(B, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 5))
|
||||
>bp : Symbol(bp, Decl(contextuallyTypedSymbolNamedProperties.ts, 15, 8))
|
||||
>bp.description : Symbol(Symbol.description, Decl(lib.es2019.symbol.d.ts, --, --))
|
||||
>bp : Symbol(bp, Decl(contextuallyTypedSymbolNamedProperties.ts, 15, 8))
|
||||
>description : Symbol(Symbol.description, Decl(lib.es2019.symbol.d.ts, --, --))
|
||||
|
||||
})
|
||||
|
||||
const x: { [sym: symbol]: (p: string) => void } = { [A]: s => s.length };
|
||||
>x : Symbol(x, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 5))
|
||||
>sym : Symbol(sym, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 12))
|
||||
>p : Symbol(p, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 27))
|
||||
>[A] : Symbol([A], Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 51))
|
||||
>A : Symbol(A, Decl(contextuallyTypedSymbolNamedProperties.ts, 2, 5))
|
||||
>s : Symbol(s, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 56))
|
||||
>s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
|
||||
>s : Symbol(s, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 56))
|
||||
>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
=== tests/cases/compiler/contextuallyTypedSymbolNamedProperties.ts ===
|
||||
// Repros from #43628
|
||||
|
||||
const A = Symbol("A");
|
||||
>A : unique symbol
|
||||
>Symbol("A") : unique symbol
|
||||
>Symbol : SymbolConstructor
|
||||
>"A" : "A"
|
||||
|
||||
const B = Symbol("B");
|
||||
>B : unique symbol
|
||||
>Symbol("B") : unique symbol
|
||||
>Symbol : SymbolConstructor
|
||||
>"B" : "B"
|
||||
|
||||
type Action =
|
||||
>Action : Action
|
||||
|
||||
| {type: typeof A, data: string}
|
||||
>type : unique symbol
|
||||
>A : unique symbol
|
||||
>data : string
|
||||
|
||||
| {type: typeof B, data: number}
|
||||
>type : unique symbol
|
||||
>B : unique symbol
|
||||
>data : number
|
||||
|
||||
declare const ab: Action;
|
||||
>ab : Action
|
||||
|
||||
declare function f<T extends { type: string | symbol }>(action: T, blah: { [K in T['type']]: (p: K) => void }): any;
|
||||
>f : <T extends { type: string | symbol; }>(action: T, blah: { [K in T["type"]]: (p: K) => void; }) => any
|
||||
>type : string | symbol
|
||||
>action : T
|
||||
>blah : { [K in T["type"]]: (p: K) => void; }
|
||||
>p : K
|
||||
|
||||
f(ab, {
|
||||
>f(ab, { [A]: ap => { ap.description }, [B]: bp => { bp.description },}) : any
|
||||
>f : <T extends { type: string | symbol; }>(action: T, blah: { [K in T["type"]]: (p: K) => void; }) => any
|
||||
>ab : Action
|
||||
>{ [A]: ap => { ap.description }, [B]: bp => { bp.description },} : { [A]: (ap: unique symbol) => void; [B]: (bp: unique symbol) => void; }
|
||||
|
||||
[A]: ap => { ap.description },
|
||||
>[A] : (ap: unique symbol) => void
|
||||
>A : unique symbol
|
||||
>ap => { ap.description } : (ap: unique symbol) => void
|
||||
>ap : unique symbol
|
||||
>ap.description : string | undefined
|
||||
>ap : unique symbol
|
||||
>description : string | undefined
|
||||
|
||||
[B]: bp => { bp.description },
|
||||
>[B] : (bp: unique symbol) => void
|
||||
>B : unique symbol
|
||||
>bp => { bp.description } : (bp: unique symbol) => void
|
||||
>bp : unique symbol
|
||||
>bp.description : string | undefined
|
||||
>bp : unique symbol
|
||||
>description : string | undefined
|
||||
|
||||
})
|
||||
|
||||
const x: { [sym: symbol]: (p: string) => void } = { [A]: s => s.length };
|
||||
>x : { [sym: symbol]: (p: string) => void; }
|
||||
>sym : symbol
|
||||
>p : string
|
||||
>{ [A]: s => s.length } : { [A]: (s: string) => number; }
|
||||
>[A] : (s: string) => number
|
||||
>A : unique symbol
|
||||
>s => s.length : (s: string) => number
|
||||
>s : string
|
||||
>s.length : number
|
||||
>s : string
|
||||
>length : number
|
||||
|
|
@ -28,15 +28,11 @@ tests/cases/conformance/controlFlow/controlFlowAliasing.ts(232,13): error TS2322
|
|||
Type 'number' is not assignable to type 'string'.
|
||||
tests/cases/conformance/controlFlow/controlFlowAliasing.ts(233,13): error TS2322: Type 'string | number' is not assignable to type 'string'.
|
||||
Type 'number' is not assignable to type 'string'.
|
||||
tests/cases/conformance/controlFlow/controlFlowAliasing.ts(267,13): error TS2322: Type 'string | number' is not assignable to type 'string'.
|
||||
Type 'number' is not assignable to type 'string'.
|
||||
tests/cases/conformance/controlFlow/controlFlowAliasing.ts(270,13): error TS2322: Type 'string | number' is not assignable to type 'number'.
|
||||
Type 'string' is not assignable to type 'number'.
|
||||
tests/cases/conformance/controlFlow/controlFlowAliasing.ts(280,5): error TS2448: Block-scoped variable 'a' used before its declaration.
|
||||
tests/cases/conformance/controlFlow/controlFlowAliasing.ts(280,5): error TS2454: Variable 'a' is used before being assigned.
|
||||
|
||||
|
||||
==== tests/cases/conformance/controlFlow/controlFlowAliasing.ts (19 errors) ====
|
||||
==== tests/cases/conformance/controlFlow/controlFlowAliasing.ts (17 errors) ====
|
||||
// Narrowing by aliased conditional expressions
|
||||
|
||||
function f10(x: string | number) {
|
||||
|
@ -349,15 +345,9 @@ tests/cases/conformance/controlFlow/controlFlowAliasing.ts(280,5): error TS2454:
|
|||
function foo({ kind, payload }: Data) {
|
||||
if (kind === 'str') {
|
||||
let t: string = payload;
|
||||
~
|
||||
!!! error TS2322: Type 'string | number' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'number' is not assignable to type 'string'.
|
||||
}
|
||||
else {
|
||||
let t: number = payload;
|
||||
~
|
||||
!!! error TS2322: Type 'string | number' is not assignable to type 'number'.
|
||||
!!! error TS2322: Type 'string' is not assignable to type 'number'.
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -888,12 +888,12 @@ function foo({ kind, payload }: Data) {
|
|||
|
||||
let t: string = payload;
|
||||
>t : string
|
||||
>payload : string | number
|
||||
>payload : string
|
||||
}
|
||||
else {
|
||||
let t: number = payload;
|
||||
>t : number
|
||||
>payload : string | number
|
||||
>payload : number
|
||||
}
|
||||
}
|
||||
|
||||
|
|
9
tests/baselines/reference/defaultNamedExportWithType1.js
Normal file
9
tests/baselines/reference/defaultNamedExportWithType1.js
Normal file
|
@ -0,0 +1,9 @@
|
|||
//// [defaultNamedExportWithType1.ts]
|
||||
type Foo = number;
|
||||
export const Foo = 1;
|
||||
export default Foo;
|
||||
|
||||
|
||||
//// [defaultNamedExportWithType1.js]
|
||||
export const Foo = 1;
|
||||
export default Foo;
|
|
@ -0,0 +1,10 @@
|
|||
=== tests/cases/compiler/defaultNamedExportWithType1.ts ===
|
||||
type Foo = number;
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType1.ts, 0, 0), Decl(defaultNamedExportWithType1.ts, 1, 12))
|
||||
|
||||
export const Foo = 1;
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType1.ts, 1, 12))
|
||||
|
||||
export default Foo;
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType1.ts, 0, 0), Decl(defaultNamedExportWithType1.ts, 1, 12))
|
||||
|
11
tests/baselines/reference/defaultNamedExportWithType1.types
Normal file
11
tests/baselines/reference/defaultNamedExportWithType1.types
Normal file
|
@ -0,0 +1,11 @@
|
|||
=== tests/cases/compiler/defaultNamedExportWithType1.ts ===
|
||||
type Foo = number;
|
||||
>Foo : number
|
||||
|
||||
export const Foo = 1;
|
||||
>Foo : 1
|
||||
>1 : 1
|
||||
|
||||
export default Foo;
|
||||
>Foo : number
|
||||
|
9
tests/baselines/reference/defaultNamedExportWithType2.js
Normal file
9
tests/baselines/reference/defaultNamedExportWithType2.js
Normal file
|
@ -0,0 +1,9 @@
|
|||
//// [defaultNamedExportWithType2.ts]
|
||||
type Foo = number;
|
||||
const Foo = 1;
|
||||
export default Foo;
|
||||
|
||||
|
||||
//// [defaultNamedExportWithType2.js]
|
||||
const Foo = 1;
|
||||
export default Foo;
|
|
@ -0,0 +1,10 @@
|
|||
=== tests/cases/compiler/defaultNamedExportWithType2.ts ===
|
||||
type Foo = number;
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType2.ts, 0, 0), Decl(defaultNamedExportWithType2.ts, 1, 5))
|
||||
|
||||
const Foo = 1;
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType2.ts, 0, 0), Decl(defaultNamedExportWithType2.ts, 1, 5))
|
||||
|
||||
export default Foo;
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType2.ts, 0, 0), Decl(defaultNamedExportWithType2.ts, 1, 5))
|
||||
|
11
tests/baselines/reference/defaultNamedExportWithType2.types
Normal file
11
tests/baselines/reference/defaultNamedExportWithType2.types
Normal file
|
@ -0,0 +1,11 @@
|
|||
=== tests/cases/compiler/defaultNamedExportWithType2.ts ===
|
||||
type Foo = number;
|
||||
>Foo : number
|
||||
|
||||
const Foo = 1;
|
||||
>Foo : 1
|
||||
>1 : 1
|
||||
|
||||
export default Foo;
|
||||
>Foo : number
|
||||
|
9
tests/baselines/reference/defaultNamedExportWithType3.js
Normal file
9
tests/baselines/reference/defaultNamedExportWithType3.js
Normal file
|
@ -0,0 +1,9 @@
|
|||
//// [defaultNamedExportWithType3.ts]
|
||||
interface Foo {}
|
||||
export const Foo = {};
|
||||
export default Foo;
|
||||
|
||||
|
||||
//// [defaultNamedExportWithType3.js]
|
||||
export const Foo = {};
|
||||
export default Foo;
|
|
@ -0,0 +1,10 @@
|
|||
=== tests/cases/compiler/defaultNamedExportWithType3.ts ===
|
||||
interface Foo {}
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType3.ts, 0, 0), Decl(defaultNamedExportWithType3.ts, 1, 12))
|
||||
|
||||
export const Foo = {};
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType3.ts, 1, 12))
|
||||
|
||||
export default Foo;
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType3.ts, 0, 0), Decl(defaultNamedExportWithType3.ts, 1, 12))
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
=== tests/cases/compiler/defaultNamedExportWithType3.ts ===
|
||||
interface Foo {}
|
||||
export const Foo = {};
|
||||
>Foo : {}
|
||||
>{} : {}
|
||||
|
||||
export default Foo;
|
||||
>Foo : Foo
|
||||
|
9
tests/baselines/reference/defaultNamedExportWithType4.js
Normal file
9
tests/baselines/reference/defaultNamedExportWithType4.js
Normal file
|
@ -0,0 +1,9 @@
|
|||
//// [defaultNamedExportWithType4.ts]
|
||||
interface Foo {}
|
||||
const Foo = {};
|
||||
export default Foo;
|
||||
|
||||
|
||||
//// [defaultNamedExportWithType4.js]
|
||||
const Foo = {};
|
||||
export default Foo;
|
|
@ -0,0 +1,10 @@
|
|||
=== tests/cases/compiler/defaultNamedExportWithType4.ts ===
|
||||
interface Foo {}
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType4.ts, 0, 0), Decl(defaultNamedExportWithType4.ts, 1, 5))
|
||||
|
||||
const Foo = {};
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType4.ts, 0, 0), Decl(defaultNamedExportWithType4.ts, 1, 5))
|
||||
|
||||
export default Foo;
|
||||
>Foo : Symbol(Foo, Decl(defaultNamedExportWithType4.ts, 0, 0), Decl(defaultNamedExportWithType4.ts, 1, 5))
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
=== tests/cases/compiler/defaultNamedExportWithType4.ts ===
|
||||
interface Foo {}
|
||||
const Foo = {};
|
||||
>Foo : {}
|
||||
>{} : {}
|
||||
|
||||
export default Foo;
|
||||
>Foo : Foo
|
||||
|
336
tests/baselines/reference/dependentDestructuredVariables.js
Normal file
336
tests/baselines/reference/dependentDestructuredVariables.js
Normal file
|
@ -0,0 +1,336 @@
|
|||
//// [dependentDestructuredVariables.ts]
|
||||
type Action =
|
||||
| { kind: 'A', payload: number }
|
||||
| { kind: 'B', payload: string };
|
||||
|
||||
function f10({ kind, payload }: Action) {
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
|
||||
function f11(action: Action) {
|
||||
const { kind, payload } = action;
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
|
||||
function f12({ kind, payload }: Action) {
|
||||
switch (kind) {
|
||||
case 'A':
|
||||
payload.toFixed();
|
||||
break;
|
||||
case 'B':
|
||||
payload.toUpperCase();
|
||||
break;
|
||||
default:
|
||||
payload; // never
|
||||
}
|
||||
}
|
||||
|
||||
type Action2 =
|
||||
| { kind: 'A', payload: number | undefined }
|
||||
| { kind: 'B', payload: string | undefined };
|
||||
|
||||
function f20({ kind, payload }: Action2) {
|
||||
if (payload) {
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f21(action: Action2) {
|
||||
const { kind, payload } = action;
|
||||
if (payload) {
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f22(action: Action2) {
|
||||
if (action.payload) {
|
||||
const { kind, payload } = action;
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f23({ kind, payload }: Action2) {
|
||||
if (payload) {
|
||||
switch (kind) {
|
||||
case 'A':
|
||||
payload.toFixed();
|
||||
break;
|
||||
case 'B':
|
||||
payload.toUpperCase();
|
||||
break;
|
||||
default:
|
||||
payload; // never
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type Foo =
|
||||
| { kind: 'A', isA: true }
|
||||
| { kind: 'B', isA: false }
|
||||
| { kind: 'C', isA: false };
|
||||
|
||||
function f30({ kind, isA }: Foo) {
|
||||
if (kind === 'A') {
|
||||
isA; // true
|
||||
}
|
||||
if (kind === 'B') {
|
||||
isA; // false
|
||||
}
|
||||
if (kind === 'C') {
|
||||
isA; // false
|
||||
}
|
||||
if (isA) {
|
||||
kind; // 'A'
|
||||
}
|
||||
else {
|
||||
kind; // 'B' | 'C'
|
||||
}
|
||||
}
|
||||
|
||||
// Repro from #35283
|
||||
|
||||
interface A<T> { variant: 'a', value: T }
|
||||
|
||||
interface B<T> { variant: 'b', value: Array<T> }
|
||||
|
||||
type AB<T> = A<T> | B<T>;
|
||||
|
||||
declare function printValue<T>(t: T): void;
|
||||
|
||||
declare function printValueList<T>(t: Array<T>): void;
|
||||
|
||||
function unrefined1<T>(ab: AB<T>): void {
|
||||
const { variant, value } = ab;
|
||||
if (variant === 'a') {
|
||||
printValue<T>(value);
|
||||
}
|
||||
else {
|
||||
printValueList<T>(value);
|
||||
}
|
||||
}
|
||||
|
||||
// Repro from #38020
|
||||
|
||||
type Action3 =
|
||||
| {type: 'add', payload: { toAdd: number } }
|
||||
| {type: 'remove', payload: { toRemove: number } };
|
||||
|
||||
const reducerBroken = (state: number, { type, payload }: Action3) => {
|
||||
switch (type) {
|
||||
case 'add':
|
||||
return state + payload.toAdd;
|
||||
case 'remove':
|
||||
return state - payload.toRemove;
|
||||
}
|
||||
}
|
||||
|
||||
// Repro from #46143
|
||||
|
||||
declare var it: Iterator<number>;
|
||||
const { value, done } = it.next();
|
||||
if (!done) {
|
||||
value; // number
|
||||
}
|
||||
|
||||
|
||||
//// [dependentDestructuredVariables.js]
|
||||
"use strict";
|
||||
function f10({ kind, payload }) {
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
function f11(action) {
|
||||
const { kind, payload } = action;
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
function f12({ kind, payload }) {
|
||||
switch (kind) {
|
||||
case 'A':
|
||||
payload.toFixed();
|
||||
break;
|
||||
case 'B':
|
||||
payload.toUpperCase();
|
||||
break;
|
||||
default:
|
||||
payload; // never
|
||||
}
|
||||
}
|
||||
function f20({ kind, payload }) {
|
||||
if (payload) {
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
}
|
||||
function f21(action) {
|
||||
const { kind, payload } = action;
|
||||
if (payload) {
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
}
|
||||
function f22(action) {
|
||||
if (action.payload) {
|
||||
const { kind, payload } = action;
|
||||
if (kind === 'A') {
|
||||
payload.toFixed();
|
||||
}
|
||||
if (kind === 'B') {
|
||||
payload.toUpperCase();
|
||||
}
|
||||
}
|
||||
}
|
||||
function f23({ kind, payload }) {
|
||||
if (payload) {
|
||||
switch (kind) {
|
||||
case 'A':
|
||||
payload.toFixed();
|
||||
break;
|
||||
case 'B':
|
||||
payload.toUpperCase();
|
||||
break;
|
||||
default:
|
||||
payload; // never
|
||||
}
|
||||
}
|
||||
}
|
||||
function f30({ kind, isA }) {
|
||||
if (kind === 'A') {
|
||||
isA; // true
|
||||
}
|
||||
if (kind === 'B') {
|
||||
isA; // false
|
||||
}
|
||||
if (kind === 'C') {
|
||||
isA; // false
|
||||
}
|
||||
if (isA) {
|
||||
kind; // 'A'
|
||||
}
|
||||
else {
|
||||
kind; // 'B' | 'C'
|
||||
}
|
||||
}
|
||||
function unrefined1(ab) {
|
||||
const { variant, value } = ab;
|
||||
if (variant === 'a') {
|
||||
printValue(value);
|
||||
}
|
||||
else {
|
||||
printValueList(value);
|
||||
}
|
||||
}
|
||||
const reducerBroken = (state, { type, payload }) => {
|
||||
switch (type) {
|
||||
case 'add':
|
||||
return state + payload.toAdd;
|
||||
case 'remove':
|
||||
return state - payload.toRemove;
|
||||
}
|
||||
};
|
||||
const { value, done } = it.next();
|
||||
if (!done) {
|
||||
value; // number
|
||||
}
|
||||
|
||||
|
||||
//// [dependentDestructuredVariables.d.ts]
|
||||
declare type Action = {
|
||||
kind: 'A';
|
||||
payload: number;
|
||||
} | {
|
||||
kind: 'B';
|
||||
payload: string;
|
||||
};
|
||||
declare function f10({ kind, payload }: Action): void;
|
||||
declare function f11(action: Action): void;
|
||||
declare function f12({ kind, payload }: Action): void;
|
||||
declare type Action2 = {
|
||||
kind: 'A';
|
||||
payload: number | undefined;
|
||||
} | {
|
||||
kind: 'B';
|
||||
payload: string | undefined;
|
||||
};
|
||||
declare function f20({ kind, payload }: Action2): void;
|
||||
declare function f21(action: Action2): void;
|
||||
declare function f22(action: Action2): void;
|
||||
declare function f23({ kind, payload }: Action2): void;
|
||||
declare type Foo = {
|
||||
kind: 'A';
|
||||
isA: true;
|
||||
} | {
|
||||
kind: 'B';
|
||||
isA: false;
|
||||
} | {
|
||||
kind: 'C';
|
||||
isA: false;
|
||||
};
|
||||
declare function f30({ kind, isA }: Foo): void;
|
||||
interface A<T> {
|
||||
variant: 'a';
|
||||
value: T;
|
||||
}
|
||||
interface B<T> {
|
||||
variant: 'b';
|
||||
value: Array<T>;
|
||||
}
|
||||
declare type AB<T> = A<T> | B<T>;
|
||||
declare function printValue<T>(t: T): void;
|
||||
declare function printValueList<T>(t: Array<T>): void;
|
||||
declare function unrefined1<T>(ab: AB<T>): void;
|
||||
declare type Action3 = {
|
||||
type: 'add';
|
||||
payload: {
|
||||
toAdd: number;
|
||||
};
|
||||
} | {
|
||||
type: 'remove';
|
||||
payload: {
|
||||
toRemove: number;
|
||||
};
|
||||
};
|
||||
declare const reducerBroken: (state: number, { type, payload }: Action3) => number;
|
||||
declare var it: Iterator<number>;
|
||||
declare const value: any, done: boolean | undefined;
|
409
tests/baselines/reference/dependentDestructuredVariables.symbols
Normal file
409
tests/baselines/reference/dependentDestructuredVariables.symbols
Normal file
|
@ -0,0 +1,409 @@
|
|||
=== tests/cases/conformance/controlFlow/dependentDestructuredVariables.ts ===
|
||||
type Action =
|
||||
>Action : Symbol(Action, Decl(dependentDestructuredVariables.ts, 0, 0))
|
||||
|
||||
| { kind: 'A', payload: number }
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 1, 7))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 1, 18))
|
||||
|
||||
| { kind: 'B', payload: string };
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 2, 7))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 2, 18))
|
||||
|
||||
function f10({ kind, payload }: Action) {
|
||||
>f10 : Symbol(f10, Decl(dependentDestructuredVariables.ts, 2, 37))
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 4, 14))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 4, 20))
|
||||
>Action : Symbol(Action, Decl(dependentDestructuredVariables.ts, 0, 0))
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 4, 14))
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 4, 20))
|
||||
>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 4, 14))
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 4, 20))
|
||||
>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
}
|
||||
|
||||
function f11(action: Action) {
|
||||
>f11 : Symbol(f11, Decl(dependentDestructuredVariables.ts, 11, 1))
|
||||
>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 13, 13))
|
||||
>Action : Symbol(Action, Decl(dependentDestructuredVariables.ts, 0, 0))
|
||||
|
||||
const { kind, payload } = action;
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 14, 11))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 14, 17))
|
||||
>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 13, 13))
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 14, 11))
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 14, 17))
|
||||
>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 14, 11))
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 14, 17))
|
||||
>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
}
|
||||
|
||||
function f12({ kind, payload }: Action) {
|
||||
>f12 : Symbol(f12, Decl(dependentDestructuredVariables.ts, 21, 1))
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 23, 14))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 23, 20))
|
||||
>Action : Symbol(Action, Decl(dependentDestructuredVariables.ts, 0, 0))
|
||||
|
||||
switch (kind) {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 23, 14))
|
||||
|
||||
case 'A':
|
||||
payload.toFixed();
|
||||
>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 23, 20))
|
||||
>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
|
||||
break;
|
||||
case 'B':
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 23, 20))
|
||||
>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
|
||||
break;
|
||||
default:
|
||||
payload; // never
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 23, 20))
|
||||
}
|
||||
}
|
||||
|
||||
type Action2 =
|
||||
>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
|
||||
|
||||
| { kind: 'A', payload: number | undefined }
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 37, 7))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 37, 18))
|
||||
|
||||
| { kind: 'B', payload: string | undefined };
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 38, 7))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 38, 18))
|
||||
|
||||
function f20({ kind, payload }: Action2) {
|
||||
>f20 : Symbol(f20, Decl(dependentDestructuredVariables.ts, 38, 49))
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 40, 14))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 40, 20))
|
||||
>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
|
||||
|
||||
if (payload) {
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 40, 20))
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 40, 14))
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 40, 20))
|
||||
>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 40, 14))
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 40, 20))
|
||||
>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f21(action: Action2) {
|
||||
>f21 : Symbol(f21, Decl(dependentDestructuredVariables.ts, 49, 1))
|
||||
>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 51, 13))
|
||||
>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
|
||||
|
||||
const { kind, payload } = action;
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 52, 11))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 52, 17))
|
||||
>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 51, 13))
|
||||
|
||||
if (payload) {
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 52, 17))
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 52, 11))
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 52, 17))
|
||||
>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 52, 11))
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 52, 17))
|
||||
>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f22(action: Action2) {
|
||||
>f22 : Symbol(f22, Decl(dependentDestructuredVariables.ts, 61, 1))
|
||||
>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 63, 13))
|
||||
>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
|
||||
|
||||
if (action.payload) {
|
||||
>action.payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 37, 18), Decl(dependentDestructuredVariables.ts, 38, 18))
|
||||
>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 63, 13))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 37, 18), Decl(dependentDestructuredVariables.ts, 38, 18))
|
||||
|
||||
const { kind, payload } = action;
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 65, 15))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 65, 21))
|
||||
>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 63, 13))
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 65, 15))
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 65, 21))
|
||||
>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 65, 15))
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 65, 21))
|
||||
>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f23({ kind, payload }: Action2) {
|
||||
>f23 : Symbol(f23, Decl(dependentDestructuredVariables.ts, 73, 1))
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 75, 14))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
|
||||
>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
|
||||
|
||||
if (payload) {
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
|
||||
|
||||
switch (kind) {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 75, 14))
|
||||
|
||||
case 'A':
|
||||
payload.toFixed();
|
||||
>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
|
||||
>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
|
||||
|
||||
break;
|
||||
case 'B':
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
|
||||
>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
|
||||
|
||||
break;
|
||||
default:
|
||||
payload; // never
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type Foo =
|
||||
>Foo : Symbol(Foo, Decl(dependentDestructuredVariables.ts, 88, 1))
|
||||
|
||||
| { kind: 'A', isA: true }
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 91, 7))
|
||||
>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 91, 18))
|
||||
|
||||
| { kind: 'B', isA: false }
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 92, 7))
|
||||
>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 92, 18))
|
||||
|
||||
| { kind: 'C', isA: false };
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 93, 7))
|
||||
>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 93, 18))
|
||||
|
||||
function f30({ kind, isA }: Foo) {
|
||||
>f30 : Symbol(f30, Decl(dependentDestructuredVariables.ts, 93, 32))
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
|
||||
>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
|
||||
>Foo : Symbol(Foo, Decl(dependentDestructuredVariables.ts, 88, 1))
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
|
||||
|
||||
isA; // true
|
||||
>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
|
||||
|
||||
isA; // false
|
||||
>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
|
||||
}
|
||||
if (kind === 'C') {
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
|
||||
|
||||
isA; // false
|
||||
>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
|
||||
}
|
||||
if (isA) {
|
||||
>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
|
||||
|
||||
kind; // 'A'
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
|
||||
}
|
||||
else {
|
||||
kind; // 'B' | 'C'
|
||||
>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
|
||||
}
|
||||
}
|
||||
|
||||
// Repro from #35283
|
||||
|
||||
interface A<T> { variant: 'a', value: T }
|
||||
>A : Symbol(A, Decl(dependentDestructuredVariables.ts, 111, 1))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 115, 12))
|
||||
>variant : Symbol(A.variant, Decl(dependentDestructuredVariables.ts, 115, 16))
|
||||
>value : Symbol(A.value, Decl(dependentDestructuredVariables.ts, 115, 30))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 115, 12))
|
||||
|
||||
interface B<T> { variant: 'b', value: Array<T> }
|
||||
>B : Symbol(B, Decl(dependentDestructuredVariables.ts, 115, 41))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 117, 12))
|
||||
>variant : Symbol(B.variant, Decl(dependentDestructuredVariables.ts, 117, 16))
|
||||
>value : Symbol(B.value, Decl(dependentDestructuredVariables.ts, 117, 30))
|
||||
>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 117, 12))
|
||||
|
||||
type AB<T> = A<T> | B<T>;
|
||||
>AB : Symbol(AB, Decl(dependentDestructuredVariables.ts, 117, 48))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 119, 8))
|
||||
>A : Symbol(A, Decl(dependentDestructuredVariables.ts, 111, 1))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 119, 8))
|
||||
>B : Symbol(B, Decl(dependentDestructuredVariables.ts, 115, 41))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 119, 8))
|
||||
|
||||
declare function printValue<T>(t: T): void;
|
||||
>printValue : Symbol(printValue, Decl(dependentDestructuredVariables.ts, 119, 25))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 121, 28))
|
||||
>t : Symbol(t, Decl(dependentDestructuredVariables.ts, 121, 31))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 121, 28))
|
||||
|
||||
declare function printValueList<T>(t: Array<T>): void;
|
||||
>printValueList : Symbol(printValueList, Decl(dependentDestructuredVariables.ts, 121, 43))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 123, 32))
|
||||
>t : Symbol(t, Decl(dependentDestructuredVariables.ts, 123, 35))
|
||||
>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 123, 32))
|
||||
|
||||
function unrefined1<T>(ab: AB<T>): void {
|
||||
>unrefined1 : Symbol(unrefined1, Decl(dependentDestructuredVariables.ts, 123, 54))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 125, 20))
|
||||
>ab : Symbol(ab, Decl(dependentDestructuredVariables.ts, 125, 23))
|
||||
>AB : Symbol(AB, Decl(dependentDestructuredVariables.ts, 117, 48))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 125, 20))
|
||||
|
||||
const { variant, value } = ab;
|
||||
>variant : Symbol(variant, Decl(dependentDestructuredVariables.ts, 126, 11))
|
||||
>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 126, 20))
|
||||
>ab : Symbol(ab, Decl(dependentDestructuredVariables.ts, 125, 23))
|
||||
|
||||
if (variant === 'a') {
|
||||
>variant : Symbol(variant, Decl(dependentDestructuredVariables.ts, 126, 11))
|
||||
|
||||
printValue<T>(value);
|
||||
>printValue : Symbol(printValue, Decl(dependentDestructuredVariables.ts, 119, 25))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 125, 20))
|
||||
>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 126, 20))
|
||||
}
|
||||
else {
|
||||
printValueList<T>(value);
|
||||
>printValueList : Symbol(printValueList, Decl(dependentDestructuredVariables.ts, 121, 43))
|
||||
>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 125, 20))
|
||||
>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 126, 20))
|
||||
}
|
||||
}
|
||||
|
||||
// Repro from #38020
|
||||
|
||||
type Action3 =
|
||||
>Action3 : Symbol(Action3, Decl(dependentDestructuredVariables.ts, 133, 1))
|
||||
|
||||
| {type: 'add', payload: { toAdd: number } }
|
||||
>type : Symbol(type, Decl(dependentDestructuredVariables.ts, 138, 7))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 138, 19))
|
||||
>toAdd : Symbol(toAdd, Decl(dependentDestructuredVariables.ts, 138, 30))
|
||||
|
||||
| {type: 'remove', payload: { toRemove: number } };
|
||||
>type : Symbol(type, Decl(dependentDestructuredVariables.ts, 139, 7))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 139, 22))
|
||||
>toRemove : Symbol(toRemove, Decl(dependentDestructuredVariables.ts, 139, 33))
|
||||
|
||||
const reducerBroken = (state: number, { type, payload }: Action3) => {
|
||||
>reducerBroken : Symbol(reducerBroken, Decl(dependentDestructuredVariables.ts, 141, 5))
|
||||
>state : Symbol(state, Decl(dependentDestructuredVariables.ts, 141, 23))
|
||||
>type : Symbol(type, Decl(dependentDestructuredVariables.ts, 141, 39))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 141, 45))
|
||||
>Action3 : Symbol(Action3, Decl(dependentDestructuredVariables.ts, 133, 1))
|
||||
|
||||
switch (type) {
|
||||
>type : Symbol(type, Decl(dependentDestructuredVariables.ts, 141, 39))
|
||||
|
||||
case 'add':
|
||||
return state + payload.toAdd;
|
||||
>state : Symbol(state, Decl(dependentDestructuredVariables.ts, 141, 23))
|
||||
>payload.toAdd : Symbol(toAdd, Decl(dependentDestructuredVariables.ts, 138, 30))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 141, 45))
|
||||
>toAdd : Symbol(toAdd, Decl(dependentDestructuredVariables.ts, 138, 30))
|
||||
|
||||
case 'remove':
|
||||
return state - payload.toRemove;
|
||||
>state : Symbol(state, Decl(dependentDestructuredVariables.ts, 141, 23))
|
||||
>payload.toRemove : Symbol(toRemove, Decl(dependentDestructuredVariables.ts, 139, 33))
|
||||
>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 141, 45))
|
||||
>toRemove : Symbol(toRemove, Decl(dependentDestructuredVariables.ts, 139, 33))
|
||||
}
|
||||
}
|
||||
|
||||
// Repro from #46143
|
||||
|
||||
declare var it: Iterator<number>;
|
||||
>it : Symbol(it, Decl(dependentDestructuredVariables.ts, 152, 11))
|
||||
>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
|
||||
|
||||
const { value, done } = it.next();
|
||||
>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 153, 7))
|
||||
>done : Symbol(done, Decl(dependentDestructuredVariables.ts, 153, 14))
|
||||
>it.next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --))
|
||||
>it : Symbol(it, Decl(dependentDestructuredVariables.ts, 152, 11))
|
||||
>next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --))
|
||||
|
||||
if (!done) {
|
||||
>done : Symbol(done, Decl(dependentDestructuredVariables.ts, 153, 14))
|
||||
|
||||
value; // number
|
||||
>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 153, 7))
|
||||
}
|
||||
|
441
tests/baselines/reference/dependentDestructuredVariables.types
Normal file
441
tests/baselines/reference/dependentDestructuredVariables.types
Normal file
|
@ -0,0 +1,441 @@
|
|||
=== tests/cases/conformance/controlFlow/dependentDestructuredVariables.ts ===
|
||||
type Action =
|
||||
>Action : Action
|
||||
|
||||
| { kind: 'A', payload: number }
|
||||
>kind : "A"
|
||||
>payload : number
|
||||
|
||||
| { kind: 'B', payload: string };
|
||||
>kind : "B"
|
||||
>payload : string
|
||||
|
||||
function f10({ kind, payload }: Action) {
|
||||
>f10 : ({ kind, payload }: Action) => void
|
||||
>kind : "A" | "B"
|
||||
>payload : string | number
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind === 'A' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'A' : "A"
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed() : string
|
||||
>payload.toFixed : (fractionDigits?: number | undefined) => string
|
||||
>payload : number
|
||||
>toFixed : (fractionDigits?: number | undefined) => string
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind === 'B' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'B' : "B"
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase() : string
|
||||
>payload.toUpperCase : () => string
|
||||
>payload : string
|
||||
>toUpperCase : () => string
|
||||
}
|
||||
}
|
||||
|
||||
function f11(action: Action) {
|
||||
>f11 : (action: Action) => void
|
||||
>action : Action
|
||||
|
||||
const { kind, payload } = action;
|
||||
>kind : "A" | "B"
|
||||
>payload : string | number
|
||||
>action : Action
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind === 'A' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'A' : "A"
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed() : string
|
||||
>payload.toFixed : (fractionDigits?: number | undefined) => string
|
||||
>payload : number
|
||||
>toFixed : (fractionDigits?: number | undefined) => string
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind === 'B' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'B' : "B"
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase() : string
|
||||
>payload.toUpperCase : () => string
|
||||
>payload : string
|
||||
>toUpperCase : () => string
|
||||
}
|
||||
}
|
||||
|
||||
function f12({ kind, payload }: Action) {
|
||||
>f12 : ({ kind, payload }: Action) => void
|
||||
>kind : "A" | "B"
|
||||
>payload : string | number
|
||||
|
||||
switch (kind) {
|
||||
>kind : "A" | "B"
|
||||
|
||||
case 'A':
|
||||
>'A' : "A"
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed() : string
|
||||
>payload.toFixed : (fractionDigits?: number | undefined) => string
|
||||
>payload : number
|
||||
>toFixed : (fractionDigits?: number | undefined) => string
|
||||
|
||||
break;
|
||||
case 'B':
|
||||
>'B' : "B"
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase() : string
|
||||
>payload.toUpperCase : () => string
|
||||
>payload : string
|
||||
>toUpperCase : () => string
|
||||
|
||||
break;
|
||||
default:
|
||||
payload; // never
|
||||
>payload : never
|
||||
}
|
||||
}
|
||||
|
||||
type Action2 =
|
||||
>Action2 : Action2
|
||||
|
||||
| { kind: 'A', payload: number | undefined }
|
||||
>kind : "A"
|
||||
>payload : number | undefined
|
||||
|
||||
| { kind: 'B', payload: string | undefined };
|
||||
>kind : "B"
|
||||
>payload : string | undefined
|
||||
|
||||
function f20({ kind, payload }: Action2) {
|
||||
>f20 : ({ kind, payload }: Action2) => void
|
||||
>kind : "A" | "B"
|
||||
>payload : string | number | undefined
|
||||
|
||||
if (payload) {
|
||||
>payload : string | number | undefined
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind === 'A' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'A' : "A"
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed() : string
|
||||
>payload.toFixed : (fractionDigits?: number | undefined) => string
|
||||
>payload : number
|
||||
>toFixed : (fractionDigits?: number | undefined) => string
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind === 'B' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'B' : "B"
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase() : string
|
||||
>payload.toUpperCase : () => string
|
||||
>payload : string
|
||||
>toUpperCase : () => string
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f21(action: Action2) {
|
||||
>f21 : (action: Action2) => void
|
||||
>action : Action2
|
||||
|
||||
const { kind, payload } = action;
|
||||
>kind : "A" | "B"
|
||||
>payload : string | number | undefined
|
||||
>action : Action2
|
||||
|
||||
if (payload) {
|
||||
>payload : string | number | undefined
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind === 'A' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'A' : "A"
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed() : string
|
||||
>payload.toFixed : (fractionDigits?: number | undefined) => string
|
||||
>payload : number
|
||||
>toFixed : (fractionDigits?: number | undefined) => string
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind === 'B' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'B' : "B"
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase() : string
|
||||
>payload.toUpperCase : () => string
|
||||
>payload : string
|
||||
>toUpperCase : () => string
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f22(action: Action2) {
|
||||
>f22 : (action: Action2) => void
|
||||
>action : Action2
|
||||
|
||||
if (action.payload) {
|
||||
>action.payload : string | number | undefined
|
||||
>action : Action2
|
||||
>payload : string | number | undefined
|
||||
|
||||
const { kind, payload } = action;
|
||||
>kind : "A" | "B"
|
||||
>payload : string | number
|
||||
>action : Action2
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind === 'A' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'A' : "A"
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed() : string
|
||||
>payload.toFixed : (fractionDigits?: number | undefined) => string
|
||||
>payload : number
|
||||
>toFixed : (fractionDigits?: number | undefined) => string
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind === 'B' : boolean
|
||||
>kind : "A" | "B"
|
||||
>'B' : "B"
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase() : string
|
||||
>payload.toUpperCase : () => string
|
||||
>payload : string
|
||||
>toUpperCase : () => string
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f23({ kind, payload }: Action2) {
|
||||
>f23 : ({ kind, payload }: Action2) => void
|
||||
>kind : "A" | "B"
|
||||
>payload : string | number | undefined
|
||||
|
||||
if (payload) {
|
||||
>payload : string | number | undefined
|
||||
|
||||
switch (kind) {
|
||||
>kind : "A" | "B"
|
||||
|
||||
case 'A':
|
||||
>'A' : "A"
|
||||
|
||||
payload.toFixed();
|
||||
>payload.toFixed() : string
|
||||
>payload.toFixed : (fractionDigits?: number | undefined) => string
|
||||
>payload : number
|
||||
>toFixed : (fractionDigits?: number | undefined) => string
|
||||
|
||||
break;
|
||||
case 'B':
|
||||
>'B' : "B"
|
||||
|
||||
payload.toUpperCase();
|
||||
>payload.toUpperCase() : string
|
||||
>payload.toUpperCase : () => string
|
||||
>payload : string
|
||||
>toUpperCase : () => string
|
||||
|
||||
break;
|
||||
default:
|
||||
payload; // never
|
||||
>payload : never
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type Foo =
|
||||
>Foo : Foo
|
||||
|
||||
| { kind: 'A', isA: true }
|
||||
>kind : "A"
|
||||
>isA : true
|
||||
>true : true
|
||||
|
||||
| { kind: 'B', isA: false }
|
||||
>kind : "B"
|
||||
>isA : false
|
||||
>false : false
|
||||
|
||||
| { kind: 'C', isA: false };
|
||||
>kind : "C"
|
||||
>isA : false
|
||||
>false : false
|
||||
|
||||
function f30({ kind, isA }: Foo) {
|
||||
>f30 : ({ kind, isA }: Foo) => void
|
||||
>kind : "A" | "B" | "C"
|
||||
>isA : boolean
|
||||
|
||||
if (kind === 'A') {
|
||||
>kind === 'A' : boolean
|
||||
>kind : "A" | "B" | "C"
|
||||
>'A' : "A"
|
||||
|
||||
isA; // true
|
||||
>isA : true
|
||||
}
|
||||
if (kind === 'B') {
|
||||
>kind === 'B' : boolean
|
||||
>kind : "A" | "B" | "C"
|
||||
>'B' : "B"
|
||||
|
||||
isA; // false
|
||||
>isA : false
|
||||
}
|
||||
if (kind === 'C') {
|
||||
>kind === 'C' : boolean
|
||||
>kind : "A" | "B" | "C"
|
||||
>'C' : "C"
|
||||
|
||||
isA; // false
|
||||
>isA : false
|
||||
}
|
||||
if (isA) {
|
||||
>isA : boolean
|
||||
|
||||
kind; // 'A'
|
||||
>kind : "A"
|
||||
}
|
||||
else {
|
||||
kind; // 'B' | 'C'
|
||||
>kind : "B" | "C"
|
||||
}
|
||||
}
|
||||
|
||||
// Repro from #35283
|
||||
|
||||
interface A<T> { variant: 'a', value: T }
|
||||
>variant : "a"
|
||||
>value : T
|
||||
|
||||
interface B<T> { variant: 'b', value: Array<T> }
|
||||
>variant : "b"
|
||||
>value : T[]
|
||||
|
||||
type AB<T> = A<T> | B<T>;
|
||||
>AB : AB<T>
|
||||
|
||||
declare function printValue<T>(t: T): void;
|
||||
>printValue : <T>(t: T) => void
|
||||
>t : T
|
||||
|
||||
declare function printValueList<T>(t: Array<T>): void;
|
||||
>printValueList : <T>(t: Array<T>) => void
|
||||
>t : T[]
|
||||
|
||||
function unrefined1<T>(ab: AB<T>): void {
|
||||
>unrefined1 : <T>(ab: AB<T>) => void
|
||||
>ab : AB<T>
|
||||
|
||||
const { variant, value } = ab;
|
||||
>variant : "a" | "b"
|
||||
>value : T | T[]
|
||||
>ab : AB<T>
|
||||
|
||||
if (variant === 'a') {
|
||||
>variant === 'a' : boolean
|
||||
>variant : "a" | "b"
|
||||
>'a' : "a"
|
||||
|
||||
printValue<T>(value);
|
||||
>printValue<T>(value) : void
|
||||
>printValue : <T>(t: T) => void
|
||||
>value : T
|
||||
}
|
||||
else {
|
||||
printValueList<T>(value);
|
||||
>printValueList<T>(value) : void
|
||||
>printValueList : <T>(t: T[]) => void
|
||||
>value : T[]
|
||||
}
|
||||
}
|
||||
|
||||
// Repro from #38020
|
||||
|
||||
type Action3 =
|
||||
>Action3 : Action3
|
||||
|
||||
| {type: 'add', payload: { toAdd: number } }
|
||||
>type : "add"
|
||||
>payload : { toAdd: number; }
|
||||
>toAdd : number
|
||||
|
||||
| {type: 'remove', payload: { toRemove: number } };
|
||||
>type : "remove"
|
||||
>payload : { toRemove: number; }
|
||||
>toRemove : number
|
||||
|
||||
const reducerBroken = (state: number, { type, payload }: Action3) => {
|
||||
>reducerBroken : (state: number, { type, payload }: Action3) => number
|
||||
>(state: number, { type, payload }: Action3) => { switch (type) { case 'add': return state + payload.toAdd; case 'remove': return state - payload.toRemove; }} : (state: number, { type, payload }: Action3) => number
|
||||
>state : number
|
||||
>type : "add" | "remove"
|
||||
>payload : { toAdd: number; } | { toRemove: number; }
|
||||
|
||||
switch (type) {
|
||||
>type : "add" | "remove"
|
||||
|
||||
case 'add':
|
||||
>'add' : "add"
|
||||
|
||||
return state + payload.toAdd;
|
||||
>state + payload.toAdd : number
|
||||
>state : number
|
||||
>payload.toAdd : number
|
||||
>payload : { toAdd: number; }
|
||||
>toAdd : number
|
||||
|
||||
case 'remove':
|
||||
>'remove' : "remove"
|
||||
|
||||
return state - payload.toRemove;
|
||||
>state - payload.toRemove : number
|
||||
>state : number
|
||||
>payload.toRemove : number
|
||||
>payload : { toRemove: number; }
|
||||
>toRemove : number
|
||||
}
|
||||
}
|
||||
|
||||
// Repro from #46143
|
||||
|
||||
declare var it: Iterator<number>;
|
||||
>it : Iterator<number, any, undefined>
|
||||
|
||||
const { value, done } = it.next();
|
||||
>value : any
|
||||
>done : boolean | undefined
|
||||
>it.next() : IteratorResult<number, any>
|
||||
>it.next : (...args: [] | [undefined]) => IteratorResult<number, any>
|
||||
>it : Iterator<number, any, undefined>
|
||||
>next : (...args: [] | [undefined]) => IteratorResult<number, any>
|
||||
|
||||
if (!done) {
|
||||
>!done : boolean
|
||||
>done : boolean | undefined
|
||||
|
||||
value; // number
|
||||
>value : number
|
||||
}
|
||||
|
|
@ -16,7 +16,7 @@ tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(20,27): err
|
|||
tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(21,35): error TS2583: Cannot find name 'AsyncGeneratorFunction'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
|
||||
tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(22,26): error TS2583: Cannot find name 'AsyncIterable'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
|
||||
tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(23,34): error TS2583: Cannot find name 'AsyncIterableIterator'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
|
||||
tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(24,70): error TS2550: Property 'formatToParts' does not exist on type 'NumberFormat'. Do you need to change your target library? Try changing the 'lib' compiler option to 'esnext' or later.
|
||||
tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(24,70): error TS2550: Property 'formatToParts' does not exist on type 'NumberFormat'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
|
||||
tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(27,26): error TS2550: Property 'flat' does not exist on type 'undefined[]'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2019' or later.
|
||||
tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(28,29): error TS2550: Property 'flatMap' does not exist on type 'undefined[]'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2019' or later.
|
||||
tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(29,49): error TS2550: Property 'fromEntries' does not exist on type 'ObjectConstructor'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2019' or later.
|
||||
|
@ -95,7 +95,7 @@ tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(44,33): err
|
|||
!!! error TS2583: Cannot find name 'AsyncIterableIterator'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
|
||||
const testNumberFormatFormatToParts = new Intl.NumberFormat("en-US").formatToParts();
|
||||
~~~~~~~~~~~~~
|
||||
!!! error TS2550: Property 'formatToParts' does not exist on type 'NumberFormat'. Do you need to change your target library? Try changing the 'lib' compiler option to 'esnext' or later.
|
||||
!!! error TS2550: Property 'formatToParts' does not exist on type 'NumberFormat'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
|
||||
|
||||
// es2019
|
||||
const testArrayFlat = [].flat();
|
||||
|
|
|
@ -43,6 +43,7 @@ var x = 0;
|
|||
var y = "";
|
||||
var z = 0;
|
||||
//// [duplicateVarsAcrossFileBoundaries_4.js]
|
||||
var p = P;
|
||||
var q;
|
||||
//// [duplicateVarsAcrossFileBoundaries_5.js]
|
||||
var p;
|
||||
|
|
|
@ -3,6 +3,6 @@ enum E {
|
|||
>E : Symbol(E, Decl(enumWithUnicodeEscape1.ts, 0, 0))
|
||||
|
||||
'gold \u2730'
|
||||
>'gold \u2730' : Symbol(E['gold u2730'], Decl(enumWithUnicodeEscape1.ts, 0, 8))
|
||||
>'gold \u2730' : Symbol(E['gold \u2730'], Decl(enumWithUnicodeEscape1.ts, 0, 8))
|
||||
}
|
||||
|
||||
|
|
|
@ -0,0 +1,8 @@
|
|||
tests/cases/compiler/errorCause.ts(1,18): error TS2554: Expected 0-1 arguments, but got 2.
|
||||
|
||||
|
||||
==== tests/cases/compiler/errorCause.ts (1 errors) ====
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! error TS2554: Expected 0-1 arguments, but got 2.
|
||||
|
6
tests/baselines/reference/errorCause(target=es2021).js
Normal file
6
tests/baselines/reference/errorCause(target=es2021).js
Normal file
|
@ -0,0 +1,6 @@
|
|||
//// [errorCause.ts]
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
|
||||
|
||||
//// [errorCause.js]
|
||||
new Error("foo", { cause: new Error("bar") });
|
|
@ -0,0 +1,6 @@
|
|||
=== tests/cases/compiler/errorCause.ts ===
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
|
||||
>cause : Symbol(cause, Decl(errorCause.ts, 0, 18))
|
||||
>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
|
||||
|
11
tests/baselines/reference/errorCause(target=es2021).types
Normal file
11
tests/baselines/reference/errorCause(target=es2021).types
Normal file
|
@ -0,0 +1,11 @@
|
|||
=== tests/cases/compiler/errorCause.ts ===
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
>new Error("foo", { cause: new Error("bar") }) : Error
|
||||
>Error : ErrorConstructor
|
||||
>"foo" : "foo"
|
||||
>{ cause: new Error("bar") } : { cause: Error; }
|
||||
>cause : Error
|
||||
>new Error("bar") : Error
|
||||
>Error : ErrorConstructor
|
||||
>"bar" : "bar"
|
||||
|
6
tests/baselines/reference/errorCause(target=es2022).js
Normal file
6
tests/baselines/reference/errorCause(target=es2022).js
Normal file
|
@ -0,0 +1,6 @@
|
|||
//// [errorCause.ts]
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
|
||||
|
||||
//// [errorCause.js]
|
||||
new Error("foo", { cause: new Error("bar") });
|
|
@ -0,0 +1,6 @@
|
|||
=== tests/cases/compiler/errorCause.ts ===
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
|
||||
>cause : Symbol(cause, Decl(errorCause.ts, 0, 18))
|
||||
>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
|
||||
|
11
tests/baselines/reference/errorCause(target=es2022).types
Normal file
11
tests/baselines/reference/errorCause(target=es2022).types
Normal file
|
@ -0,0 +1,11 @@
|
|||
=== tests/cases/compiler/errorCause.ts ===
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
>new Error("foo", { cause: new Error("bar") }) : Error
|
||||
>Error : ErrorConstructor
|
||||
>"foo" : "foo"
|
||||
>{ cause: new Error("bar") } : { cause: Error; }
|
||||
>cause : Error
|
||||
>new Error("bar") : Error
|
||||
>Error : ErrorConstructor
|
||||
>"bar" : "bar"
|
||||
|
6
tests/baselines/reference/errorCause(target=esnext).js
Normal file
6
tests/baselines/reference/errorCause(target=esnext).js
Normal file
|
@ -0,0 +1,6 @@
|
|||
//// [errorCause.ts]
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
|
||||
|
||||
//// [errorCause.js]
|
||||
new Error("foo", { cause: new Error("bar") });
|
|
@ -0,0 +1,6 @@
|
|||
=== tests/cases/compiler/errorCause.ts ===
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
|
||||
>cause : Symbol(cause, Decl(errorCause.ts, 0, 18))
|
||||
>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
|
||||
|
11
tests/baselines/reference/errorCause(target=esnext).types
Normal file
11
tests/baselines/reference/errorCause(target=esnext).types
Normal file
|
@ -0,0 +1,11 @@
|
|||
=== tests/cases/compiler/errorCause.ts ===
|
||||
new Error("foo", { cause: new Error("bar") });
|
||||
>new Error("foo", { cause: new Error("bar") }) : Error
|
||||
>Error : ErrorConstructor
|
||||
>"foo" : "foo"
|
||||
>{ cause: new Error("bar") } : { cause: Error; }
|
||||
>cause : Error
|
||||
>new Error("bar") : Error
|
||||
>Error : ErrorConstructor
|
||||
>"bar" : "bar"
|
||||
|
|
@ -297,7 +297,7 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
|
|||
|
||||
Object.defineProperties(IterableWeakMap.prototype, {
|
||||
>Object.defineProperties : Symbol(ObjectConstructor.defineProperties, Decl(lib.es5.d.ts, --, --))
|
||||
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
|
||||
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.object.d.ts, --, --))
|
||||
>defineProperties : Symbol(ObjectConstructor.defineProperties, Decl(lib.es5.d.ts, --, --))
|
||||
>IterableWeakMap.prototype : Symbol(IterableWeakMap.prototype)
|
||||
>IterableWeakMap : Symbol(IterableWeakMap, Decl(esNextWeakRefs_IterableWeakMap.ts, 6, 2))
|
||||
|
@ -322,7 +322,7 @@ Object.defineProperties(IterableWeakMap.prototype, {
|
|||
>value : Symbol(value, Decl(esNextWeakRefs_IterableWeakMap.ts, 89, 23))
|
||||
>Object.getOwnPropertyDescriptor( IterableWeakMap.prototype, "entries", )!.value : Symbol(PropertyDescriptor.value, Decl(lib.es5.d.ts, --, --))
|
||||
>Object.getOwnPropertyDescriptor : Symbol(ObjectConstructor.getOwnPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
|
||||
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
|
||||
>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.object.d.ts, --, --))
|
||||
>getOwnPropertyDescriptor : Symbol(ObjectConstructor.getOwnPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
|
||||
|
||||
IterableWeakMap.prototype,
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue