diff --git a/lib/tsc.js b/lib/tsc.js index 74ae05b7828e39188afd443983fe468f7e45fc36..87edafe79a90dfb23b8321cb2e77cfd67fdc5f86 100644 --- a/lib/tsc.js +++ b/lib/tsc.js @@ -43265,9 +43265,16 @@ var ts; getConstEnumRelate: function () { return constEnumRelate; }, clearConstEnumRelate: function () { constEnumRelate && constEnumRelate.clear(); }, deleteConstEnumRelate: function (path) { constEnumRelate && constEnumRelate.delete(path); }, + getTypeArgumentsForResolvedSignature: getTypeArgumentsForResolvedSignature, getCheckedSourceFiles: function () { return checkedSourceFiles; }, collectHaveTsNoCheckFilesForLinter: function (sourceFile) { isTypeCheckerForLinter && checkedSourceFiles.add(sourceFile); }, }; + function getTypeArgumentsForResolvedSignature(signature) { + if (signature.mapper === undefined) { + return undefined; + } + return instantiateTypes((signature.target || signature).typeParameters, signature.mapper); + } function runWithInferenceBlockedFromSourceNode(node, fn) { var containingCall = ts.findAncestor(node, ts.isCallLikeExpression); var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature; diff --git a/lib/tsserver.js b/lib/tsserver.js index 4561650f9c5452cad0cb7041df767e826403e820..c4af8ce02dd3f8d767d980222eeae93942b7047c 100644 --- a/lib/tsserver.js +++ b/lib/tsserver.js @@ -52454,9 +52454,16 @@ var ts; getConstEnumRelate: function () { return constEnumRelate; }, clearConstEnumRelate: function () { constEnumRelate && constEnumRelate.clear(); }, deleteConstEnumRelate: function (path) { constEnumRelate && constEnumRelate.delete(path); }, + getTypeArgumentsForResolvedSignature: getTypeArgumentsForResolvedSignature, getCheckedSourceFiles: function () { return checkedSourceFiles; }, collectHaveTsNoCheckFilesForLinter: function (sourceFile) { isTypeCheckerForLinter && checkedSourceFiles.add(sourceFile); }, }; + function getTypeArgumentsForResolvedSignature(signature) { + if (signature.mapper === undefined) { + return undefined; + } + return instantiateTypes((signature.target || signature).typeParameters, signature.mapper); + } function runWithInferenceBlockedFromSourceNode(node, fn) { var containingCall = ts.findAncestor(node, ts.isCallLikeExpression); var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature; @@ -200164,19 +200171,16 @@ var ts; }; TypeScriptLinter.prototype.handleGenericCallWithNoTypeArgs = function (callLikeExpr, callSignature) { var _a, _b; - var tsSyntaxKind = ts.isNewExpression(callLikeExpr) ? 176 /* SyntaxKind.Constructor */ : 263 /* SyntaxKind.FunctionDeclaration */; - var signDecl = TypeScriptLinter.tsTypeChecker.signatureToSignatureDeclaration(callSignature, tsSyntaxKind, undefined, 32 /* NodeBuilderFlags.WriteTypeArgumentsOfSignature */ | 70221824 /* NodeBuilderFlags.IgnoreErrors */); - if (signDecl === null || signDecl === void 0 ? void 0 : signDecl.typeArguments) { - var resolvedTypeArgs = signDecl.typeArguments; + var typeArguments = TypeScriptLinter.tsTypeChecker.getTypeArgumentsForResolvedSignature(callSignature); + if (typeArguments && typeArguments.length > 0) { var startTypeArg = (_b = (_a = callLikeExpr.typeArguments) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0; - for (var i = startTypeArg; i < resolvedTypeArgs.length; ++i) { - var typeNode = resolvedTypeArgs[i]; + for (var i = startTypeArg; i < typeArguments.length; ++i) { // if compiler infers 'unknown' type there are 2 possible cases: // 1. Compiler unable to infer type from arguments and use 'unknown' // 2. Compiler infer 'unknown' from arguments // We report error in both cases. It is ok because we cannot use 'unknown' // in ArkTS and already have separate check for it. - if (typeNode.kind == 159 /* ts.SyntaxKind.UnknownKeyword */) { + if (typeArguments[i].flags & 2 /* TypeFlags.Unknown */) { this.incrementCounters(callLikeExpr, FaultID.GenericCallNoTypeArgs); break; } diff --git a/lib/tsserverlibrary.d.ts b/lib/tsserverlibrary.d.ts index 8e0941e4712504a7bdb1db7c111e76a1c894c2d6..dc8a7158165c0425f9af2239decd8cf428e06872 100644 --- a/lib/tsserverlibrary.d.ts +++ b/lib/tsserverlibrary.d.ts @@ -2545,6 +2545,7 @@ declare namespace ts { getConstEnumRelate?(): ESMap>; clearConstEnumRelate?(): void; deleteConstEnumRelate?(path: string): void; + getTypeArgumentsForResolvedSignature(signature: Signature): readonly Type[] | undefined; getCheckedSourceFiles(): Set; collectHaveTsNoCheckFilesForLinter(sourceFile: SourceFile): void; } diff --git a/lib/tsserverlibrary.js b/lib/tsserverlibrary.js index 36c65e0a066b57a9b9eaf794b7e0f3c261c7b646..6fc4adbc33cf262a2edbd2df5d5c671d137a0648 100644 --- a/lib/tsserverlibrary.js +++ b/lib/tsserverlibrary.js @@ -52453,9 +52453,16 @@ var ts; getConstEnumRelate: function () { return constEnumRelate; }, clearConstEnumRelate: function () { constEnumRelate && constEnumRelate.clear(); }, deleteConstEnumRelate: function (path) { constEnumRelate && constEnumRelate.delete(path); }, + getTypeArgumentsForResolvedSignature: getTypeArgumentsForResolvedSignature, getCheckedSourceFiles: function () { return checkedSourceFiles; }, collectHaveTsNoCheckFilesForLinter: function (sourceFile) { isTypeCheckerForLinter && checkedSourceFiles.add(sourceFile); }, }; + function getTypeArgumentsForResolvedSignature(signature) { + if (signature.mapper === undefined) { + return undefined; + } + return instantiateTypes((signature.target || signature).typeParameters, signature.mapper); + } function runWithInferenceBlockedFromSourceNode(node, fn) { var containingCall = ts.findAncestor(node, ts.isCallLikeExpression); var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature; @@ -199909,19 +199916,16 @@ var ts; }; TypeScriptLinter.prototype.handleGenericCallWithNoTypeArgs = function (callLikeExpr, callSignature) { var _a, _b; - var tsSyntaxKind = ts.isNewExpression(callLikeExpr) ? 176 /* SyntaxKind.Constructor */ : 263 /* SyntaxKind.FunctionDeclaration */; - var signDecl = TypeScriptLinter.tsTypeChecker.signatureToSignatureDeclaration(callSignature, tsSyntaxKind, undefined, 32 /* NodeBuilderFlags.WriteTypeArgumentsOfSignature */ | 70221824 /* NodeBuilderFlags.IgnoreErrors */); - if (signDecl === null || signDecl === void 0 ? void 0 : signDecl.typeArguments) { - var resolvedTypeArgs = signDecl.typeArguments; + var typeArguments = TypeScriptLinter.tsTypeChecker.getTypeArgumentsForResolvedSignature(callSignature); + if (typeArguments && typeArguments.length > 0) { var startTypeArg = (_b = (_a = callLikeExpr.typeArguments) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0; - for (var i = startTypeArg; i < resolvedTypeArgs.length; ++i) { - var typeNode = resolvedTypeArgs[i]; + for (var i = startTypeArg; i < typeArguments.length; ++i) { // if compiler infers 'unknown' type there are 2 possible cases: // 1. Compiler unable to infer type from arguments and use 'unknown' // 2. Compiler infer 'unknown' from arguments // We report error in both cases. It is ok because we cannot use 'unknown' // in ArkTS and already have separate check for it. - if (typeNode.kind == 159 /* ts.SyntaxKind.UnknownKeyword */) { + if (typeArguments[i].flags & 2 /* TypeFlags.Unknown */) { this.incrementCounters(callLikeExpr, FaultID.GenericCallNoTypeArgs); break; } diff --git a/lib/typescript.d.ts b/lib/typescript.d.ts index 418bfa34fdd349d7130d62c57bc7fc98cf4b44ba..33fc43a6968291a924a051beebb61decef1c8a46 100644 --- a/lib/typescript.d.ts +++ b/lib/typescript.d.ts @@ -2545,6 +2545,7 @@ declare namespace ts { getConstEnumRelate?(): ESMap>; clearConstEnumRelate?(): void; deleteConstEnumRelate?(path: string): void; + getTypeArgumentsForResolvedSignature(signature: Signature): readonly Type[] | undefined; getCheckedSourceFiles(): Set; collectHaveTsNoCheckFilesForLinter(sourceFile: SourceFile): void; } diff --git a/lib/typescript.js b/lib/typescript.js index e05638092cd4f9404dc38654a7058af2e7a6029a..cacfb72b004a0e699ee9f3cfb42900993964111a 100644 --- a/lib/typescript.js +++ b/lib/typescript.js @@ -52444,9 +52444,16 @@ var ts; getConstEnumRelate: function () { return constEnumRelate; }, clearConstEnumRelate: function () { constEnumRelate && constEnumRelate.clear(); }, deleteConstEnumRelate: function (path) { constEnumRelate && constEnumRelate.delete(path); }, + getTypeArgumentsForResolvedSignature: getTypeArgumentsForResolvedSignature, getCheckedSourceFiles: function () { return checkedSourceFiles; }, collectHaveTsNoCheckFilesForLinter: function (sourceFile) { isTypeCheckerForLinter && checkedSourceFiles.add(sourceFile); }, }; + function getTypeArgumentsForResolvedSignature(signature) { + if (signature.mapper === undefined) { + return undefined; + } + return instantiateTypes((signature.target || signature).typeParameters, signature.mapper); + } function runWithInferenceBlockedFromSourceNode(node, fn) { var containingCall = ts.findAncestor(node, ts.isCallLikeExpression); var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature; @@ -189003,19 +189010,16 @@ var ts; }; TypeScriptLinter.prototype.handleGenericCallWithNoTypeArgs = function (callLikeExpr, callSignature) { var _a, _b; - var tsSyntaxKind = ts.isNewExpression(callLikeExpr) ? 176 /* SyntaxKind.Constructor */ : 263 /* SyntaxKind.FunctionDeclaration */; - var signDecl = TypeScriptLinter.tsTypeChecker.signatureToSignatureDeclaration(callSignature, tsSyntaxKind, undefined, 32 /* NodeBuilderFlags.WriteTypeArgumentsOfSignature */ | 70221824 /* NodeBuilderFlags.IgnoreErrors */); - if (signDecl === null || signDecl === void 0 ? void 0 : signDecl.typeArguments) { - var resolvedTypeArgs = signDecl.typeArguments; + var typeArguments = TypeScriptLinter.tsTypeChecker.getTypeArgumentsForResolvedSignature(callSignature); + if (typeArguments && typeArguments.length > 0) { var startTypeArg = (_b = (_a = callLikeExpr.typeArguments) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0; - for (var i = startTypeArg; i < resolvedTypeArgs.length; ++i) { - var typeNode = resolvedTypeArgs[i]; + for (var i = startTypeArg; i < typeArguments.length; ++i) { // if compiler infers 'unknown' type there are 2 possible cases: // 1. Compiler unable to infer type from arguments and use 'unknown' // 2. Compiler infer 'unknown' from arguments // We report error in both cases. It is ok because we cannot use 'unknown' // in ArkTS and already have separate check for it. - if (typeNode.kind == 159 /* ts.SyntaxKind.UnknownKeyword */) { + if (typeArguments[i].flags & 2 /* TypeFlags.Unknown */) { this.incrementCounters(callLikeExpr, FaultID.GenericCallNoTypeArgs); break; } diff --git a/lib/typescriptServices.d.ts b/lib/typescriptServices.d.ts index d7995c31a3f7e5012d9f220f247d4e85ca8273aa..7be07b460a2139656c0c3f67b9f91124de527927 100644 --- a/lib/typescriptServices.d.ts +++ b/lib/typescriptServices.d.ts @@ -2545,6 +2545,7 @@ declare namespace ts { getConstEnumRelate?(): ESMap>; clearConstEnumRelate?(): void; deleteConstEnumRelate?(path: string): void; + getTypeArgumentsForResolvedSignature(signature: Signature): readonly Type[] | undefined; getCheckedSourceFiles(): Set; collectHaveTsNoCheckFilesForLinter(sourceFile: SourceFile): void; } diff --git a/lib/typescriptServices.js b/lib/typescriptServices.js index d9f533df52469a71c395701f7fffcc77585502be..1c2ae1b154478793154f19d293f5ab28e3760edb 100644 --- a/lib/typescriptServices.js +++ b/lib/typescriptServices.js @@ -52444,9 +52444,16 @@ var ts; getConstEnumRelate: function () { return constEnumRelate; }, clearConstEnumRelate: function () { constEnumRelate && constEnumRelate.clear(); }, deleteConstEnumRelate: function (path) { constEnumRelate && constEnumRelate.delete(path); }, + getTypeArgumentsForResolvedSignature: getTypeArgumentsForResolvedSignature, getCheckedSourceFiles: function () { return checkedSourceFiles; }, collectHaveTsNoCheckFilesForLinter: function (sourceFile) { isTypeCheckerForLinter && checkedSourceFiles.add(sourceFile); }, }; + function getTypeArgumentsForResolvedSignature(signature) { + if (signature.mapper === undefined) { + return undefined; + } + return instantiateTypes((signature.target || signature).typeParameters, signature.mapper); + } function runWithInferenceBlockedFromSourceNode(node, fn) { var containingCall = ts.findAncestor(node, ts.isCallLikeExpression); var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature; @@ -189003,19 +189010,16 @@ var ts; }; TypeScriptLinter.prototype.handleGenericCallWithNoTypeArgs = function (callLikeExpr, callSignature) { var _a, _b; - var tsSyntaxKind = ts.isNewExpression(callLikeExpr) ? 176 /* SyntaxKind.Constructor */ : 263 /* SyntaxKind.FunctionDeclaration */; - var signDecl = TypeScriptLinter.tsTypeChecker.signatureToSignatureDeclaration(callSignature, tsSyntaxKind, undefined, 32 /* NodeBuilderFlags.WriteTypeArgumentsOfSignature */ | 70221824 /* NodeBuilderFlags.IgnoreErrors */); - if (signDecl === null || signDecl === void 0 ? void 0 : signDecl.typeArguments) { - var resolvedTypeArgs = signDecl.typeArguments; + var typeArguments = TypeScriptLinter.tsTypeChecker.getTypeArgumentsForResolvedSignature(callSignature); + if (typeArguments && typeArguments.length > 0) { var startTypeArg = (_b = (_a = callLikeExpr.typeArguments) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0; - for (var i = startTypeArg; i < resolvedTypeArgs.length; ++i) { - var typeNode = resolvedTypeArgs[i]; + for (var i = startTypeArg; i < typeArguments.length; ++i) { // if compiler infers 'unknown' type there are 2 possible cases: // 1. Compiler unable to infer type from arguments and use 'unknown' // 2. Compiler infer 'unknown' from arguments // We report error in both cases. It is ok because we cannot use 'unknown' // in ArkTS and already have separate check for it. - if (typeNode.kind == 159 /* ts.SyntaxKind.UnknownKeyword */) { + if (typeArguments[i].flags & 2 /* TypeFlags.Unknown */) { this.incrementCounters(callLikeExpr, FaultID.GenericCallNoTypeArgs); break; } diff --git a/lib/typingsInstaller.js b/lib/typingsInstaller.js index 458eac653169f824f5d2986b662116832ae49bd7..c00d208cb02b06b5436e0e27e801b9ea3f1d71e9 100644 --- a/lib/typingsInstaller.js +++ b/lib/typingsInstaller.js @@ -52434,9 +52434,16 @@ var ts; getConstEnumRelate: function () { return constEnumRelate; }, clearConstEnumRelate: function () { constEnumRelate && constEnumRelate.clear(); }, deleteConstEnumRelate: function (path) { constEnumRelate && constEnumRelate.delete(path); }, + getTypeArgumentsForResolvedSignature: getTypeArgumentsForResolvedSignature, getCheckedSourceFiles: function () { return checkedSourceFiles; }, collectHaveTsNoCheckFilesForLinter: function (sourceFile) { isTypeCheckerForLinter && checkedSourceFiles.add(sourceFile); }, }; + function getTypeArgumentsForResolvedSignature(signature) { + if (signature.mapper === undefined) { + return undefined; + } + return instantiateTypes((signature.target || signature).typeParameters, signature.mapper); + } function runWithInferenceBlockedFromSourceNode(node, fn) { var containingCall = ts.findAncestor(node, ts.isCallLikeExpression); var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature; diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b53c249089ffe0547184fed54f7927b51e53bda4..70e8b13cda6397d9d63756111f2a60c7ebae9bd7 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -765,10 +765,18 @@ namespace ts { getConstEnumRelate: () => constEnumRelate, clearConstEnumRelate: () => {constEnumRelate && constEnumRelate.clear()}, deleteConstEnumRelate: (path: string) => {constEnumRelate && constEnumRelate.delete(path)}, + getTypeArgumentsForResolvedSignature, getCheckedSourceFiles: () => checkedSourceFiles, collectHaveTsNoCheckFilesForLinter: (sourceFile: SourceFile) => {isTypeCheckerForLinter && checkedSourceFiles.add(sourceFile)}, }; + function getTypeArgumentsForResolvedSignature(signature: Signature): readonly Type[] | undefined { + if (signature.mapper === undefined) { + return undefined; + } + return instantiateTypes((signature.target || signature).typeParameters, signature.mapper); + } + function runWithInferenceBlockedFromSourceNode(node: Node | undefined, fn: () => T): T { const containingCall = findAncestor(node, isCallLikeExpression); const containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 33576341cc46e53216ea55102124932ef2d8006a..53a758bd1d85817c7bf06d5cf79331505b1e262d 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -4986,6 +4986,7 @@ namespace ts { getConstEnumRelate?(): ESMap>; clearConstEnumRelate?(): void; deleteConstEnumRelate?(path: string): void; + getTypeArgumentsForResolvedSignature(signature: Signature): readonly Type[] | undefined; getCheckedSourceFiles(): Set; collectHaveTsNoCheckFilesForLinter(sourceFile: SourceFile): void; } diff --git a/src/linter/ArkTSLinter_1_1/TypeScriptLinter.ts b/src/linter/ArkTSLinter_1_1/TypeScriptLinter.ts index 1aad039431a4e50981cc9971b44b345d4da15070..a64d12de00c7ecaccd226c5d88012803147187f9 100644 --- a/src/linter/ArkTSLinter_1_1/TypeScriptLinter.ts +++ b/src/linter/ArkTSLinter_1_1/TypeScriptLinter.ts @@ -1896,23 +1896,16 @@ export class TypeScriptLinter { } private handleGenericCallWithNoTypeArgs(callLikeExpr: ts.CallExpression | ts.NewExpression, callSignature: ts.Signature) { - - const tsSyntaxKind = isNewExpression(callLikeExpr) ? SyntaxKind.Constructor : SyntaxKind.FunctionDeclaration; - const signDecl = TypeScriptLinter.tsTypeChecker.signatureToSignatureDeclaration(callSignature, tsSyntaxKind, - undefined, NodeBuilderFlags.WriteTypeArgumentsOfSignature | NodeBuilderFlags.IgnoreErrors); - - if (signDecl?.typeArguments) { - const resolvedTypeArgs = signDecl.typeArguments; - + const typeArguments = TypeScriptLinter.tsTypeChecker.getTypeArgumentsForResolvedSignature(callSignature); + if (typeArguments && typeArguments.length > 0) { const startTypeArg = callLikeExpr.typeArguments?.length ?? 0; - for (let i = startTypeArg; i < resolvedTypeArgs.length; ++i) { - const typeNode = resolvedTypeArgs[i]; + for (let i = startTypeArg; i < typeArguments.length; ++i) { // if compiler infers 'unknown' type there are 2 possible cases: // 1. Compiler unable to infer type from arguments and use 'unknown' // 2. Compiler infer 'unknown' from arguments // We report error in both cases. It is ok because we cannot use 'unknown' // in ArkTS and already have separate check for it. - if (typeNode.kind == ts.SyntaxKind.UnknownKeyword) { + if (typeArguments[i].flags & 2 /* TypeFlags.Unknown */) { this.incrementCounters(callLikeExpr, FaultID.GenericCallNoTypeArgs); break; } diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 8e0941e4712504a7bdb1db7c111e76a1c894c2d6..dc8a7158165c0425f9af2239decd8cf428e06872 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -2545,6 +2545,7 @@ declare namespace ts { getConstEnumRelate?(): ESMap>; clearConstEnumRelate?(): void; deleteConstEnumRelate?(path: string): void; + getTypeArgumentsForResolvedSignature(signature: Signature): readonly Type[] | undefined; getCheckedSourceFiles(): Set; collectHaveTsNoCheckFilesForLinter(sourceFile: SourceFile): void; } diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 418bfa34fdd349d7130d62c57bc7fc98cf4b44ba..33fc43a6968291a924a051beebb61decef1c8a46 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -2545,6 +2545,7 @@ declare namespace ts { getConstEnumRelate?(): ESMap>; clearConstEnumRelate?(): void; deleteConstEnumRelate?(path: string): void; + getTypeArgumentsForResolvedSignature(signature: Signature): readonly Type[] | undefined; getCheckedSourceFiles(): Set; collectHaveTsNoCheckFilesForLinter(sourceFile: SourceFile): void; }