tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/checker-iteration.d.ts

@@ -39,16 +39,6 @@ export declare class IterationTypes {
     hasTypes(): boolean;
     getType(kind: IterationTypeKind): Type | undefined;
 }
-/** A not-iterable error, reported once the file is checked so printing its type can't recurse. */
-export declare class DeferredIterationError {
-    readonly errorNode: Node;
-    readonly type: Type;
-    readonly allowAsyncIterables: boolean;
-    readonly related: Diagnostic[];
-    constructor(errorNode: Node, type: Type, allowAsyncIterables: boolean, related: Diagnostic[]);
-}
-/** Reports the not-iterable errors deferred while checking a file. */
-export declare function produceDeferredIterationErrors(c: Checker): void;
 export declare function getGlobalIteratorType(c: Checker, isAsync: boolean): Type;
 export declare function getGlobalIterableType(c: Checker, isAsync: boolean): Type;
 export declare function getGlobalIterableIteratorType(c: Checker, isAsync: boolean): Type;

package/dist/api/compiler/checker-iteration.js

@@ -3,7 +3,7 @@
 // promised types.
 import { getExpression } from './ast.js';
 import { createDiagnosticForNode } from './checker.js';
-import { cachedTypeKey, } from './checker-types.js';
+import { cachedTypeKey, getMappedType, } from './checker-types.js';
 import { createTypeFromGenericGlobalType, createTypeReference, filterType, getIntersectionType, getTypeArguments, getUnionType, getUnionTypeEx, isEmptyObjectType, mapType, someType, typesOf, } from './checker-type-factory.js';
 import { getBaseConstraintOfType, getBaseConstraintOrType, getIndexTypeOfType, getPropertyOfType, getReducedType, getSignaturesOfType, getTypeOfPropertyOfType, isArrayLikeType, } from './checker-members.js';
 import { getTypeOfSymbol } from './checker-symbol-types.js';
@@ -45,30 +45,13 @@ function noIterationTypes() {
 function anyIterationTypes(c) {
     return new IterationTypes(c.anyType, c.anyType, c.anyType);
 }
-/** A not-iterable error, reported once the file is checked so printing its type can't recurse. */
-export class DeferredIterationError {
-    errorNode;
-    type;
-    allowAsyncIterables;
-    related;
-    constructor(errorNode, type, allowAsyncIterables, related) {
-        this.errorNode = errorNode;
-        this.type = type;
-        this.allowAsyncIterables = allowAsyncIterables;
-        this.related = related;
-    }
-}
-/** Reports the not-iterable errors deferred while checking a file. */
-export function produceDeferredIterationErrors(c) {
-    const errors = c.deferredIterationErrors;
-    if (errors.length === 0)
-        return;
-    c.deferredIterationErrors = [];
-    for (const e of errors) {
-        const diagnostic = reportTypeNotIterableError(c, e.errorNode, e.type, e.allowAsyncIterables);
-        for (const d of e.related)
+/** Defers a not-iterable error, so printing its type can't resolve types that are being resolved. */
+function deferTypeNotIterableError(c, errorNode, t, allowAsyncIterables, related) {
+    c.deferDiagnostic(errorNode, () => {
+        const diagnostic = reportTypeNotIterableError(c, errorNode, t, allowAsyncIterables);
+        for (const d of related)
             diagnostic.addRelatedInfo(d);
-    }
+    });
 }
 // ---- Global types
 export function getGlobalIteratorType(c, isAsync) {
@@ -160,16 +143,16 @@ export function getIteratedTypeOrElementType(c, use, inputType, sentType, errorN
             let diagnostic;
             if ((use & 8 /* IterationUse.ForOfFlag */) !== 0)
                 diagnostic =
-                    895 /* Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 */;
+                    902 /* Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 */;
             else if ((use & 32 /* IterationUse.SpreadFlag */) !== 0)
                 diagnostic =
-                    896 /* Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 */;
+                    903 /* Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 */;
             else if ((use & 64 /* IterationUse.DestructuringFlag */) !== 0)
                 diagnostic =
-                    897 /* Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 */;
+                    904 /* Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 */;
             else if ((use & 16 /* IterationUse.YieldStarFlag */) !== 0)
                 diagnostic =
-                    898 /* Diagnostics.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 */;
+                    905 /* Diagnostics.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 */;
             if (diagnostic !== undefined)
                 checkTypeRelatedTo(c, sentType, iterationTypes.nextType, c.assignableRelation, errorNode, diagnostic, undefined);
         }
@@ -235,12 +218,12 @@ class IterationDiagnosticDetails {
     }
 }
 function getIterationDiagnosticDetails(c, use, inputType, allowsStrings) {
-    const downlevel = 934 /* Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher */;
+    const downlevel = 941 /* Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher */;
     if (getIterationTypeOfIterable(c, use, 0 /* IterationTypeKind.Yield */, inputType, undefined) !== undefined)
         return new IterationDiagnosticDetails(downlevel, false);
     if (inputType.symbol !== undefined && isES2015OrLaterIterable(inputType.symbol.name))
         return new IterationDiagnosticDetails(downlevel, true);
-    return new IterationDiagnosticDetails(allowsStrings ? 655 /* Diagnostics.Type_0_is_not_an_array_type_or_a_string_type */ : 627 /* Diagnostics.Type_0_is_not_an_array_type */, true);
+    return new IterationDiagnosticDetails(allowsStrings ? 662 /* Diagnostics.Type_0_is_not_an_array_type_or_a_string_type */ : 634 /* Diagnostics.Type_0_is_not_an_array_type */, true);
 }
 function isES2015OrLaterIterable(name) {
     switch (name) {
@@ -260,13 +243,13 @@ function isES2015OrLaterIterable(name) {
 }
 function reportTypeNotIterableError(c, errorNode, t, allowAsyncIterables) {
     const message = allowAsyncIterables
-        ? 664 /* Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator */
-        : 648 /* Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator */;
+        ? 671 /* Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator */
+        : 655 /* Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator */;
     const parent = errorNode.parent;
     const suggestAwait = getAwaitedTypeOfPromise(c, t) !== undefined ||
         (!allowAsyncIterables &&
             parent !== undefined &&
-            parent.kind === 251 /* SyntaxKind.ForOfStatement */ &&
+            parent.kind === 252 /* SyntaxKind.ForOfStatement */ &&
             getExpression(parent) === errorNode &&
             getGlobalIterableType(c, true) !== c.emptyGenericType &&
             isTypeAssignableTo(c, t, createTypeFromGenericGlobalType(c, getGlobalIterableType(c, true), [c.anyType, c.anyType, c.anyType])));
@@ -312,8 +295,8 @@ function getIterationTypesOfIterableWorker(c, t, use, errorNode) {
         for (const constituent of typesOf(t)) {
             const iterationTypes = getIterationTypesOfIterableWorker(c, constituent, use, undefined);
             if (!iterationTypes.hasTypes()) {
-                if (errorNode !== undefined && c.saveDeferredDiagnostics)
-                    c.deferredIterationErrors.push(new DeferredIterationError(errorNode, t, allowAsync, []));
+                if (errorNode !== undefined)
+                    deferTypeNotIterableError(c, errorNode, t, allowAsync, []);
                 return noIterationTypes();
             }
             all.push(iterationTypes);
@@ -345,8 +328,8 @@ function getIterationTypesOfIterableWorker(c, t, use, errorNode) {
             return allowAsync ? getAsyncFromSyncIterationTypes(c, iterationTypes, errorNode) : iterationTypes;
         }
     }
-    if (errorNode !== undefined && c.saveDeferredDiagnostics)
-        c.deferredIterationErrors.push(new DeferredIterationError(errorNode, t, allowAsync, diagnostics));
+    if (errorNode !== undefined)
+        deferTypeNotIterableError(c, errorNode, t, allowAsync, diagnostics);
     return noIterationTypes();
 }
 /** Reads the iteration types of references to the global iterable types from their type arguments. */
@@ -459,11 +442,11 @@ function getIterationTypesOfMethod(c, t, isAsync, methodName, errorNode, diagnos
         if (errorNode !== undefined) {
             const message = methodName === 'next'
                 ? isAsync
-                    ? 679 /* Diagnostics.An_async_iterator_must_have_a_next_method */
-                    : 649 /* Diagnostics.An_iterator_must_have_a_next_method */
+                    ? 686 /* Diagnostics.An_async_iterator_must_have_a_next_method */
+                    : 656 /* Diagnostics.An_iterator_must_have_a_next_method */
                 : isAsync
-                    ? 900 /* Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method */
-                    : 899 /* Diagnostics.The_0_property_of_an_iterator_must_be_a_method */;
+                    ? 907 /* Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method */
+                    : 906 /* Diagnostics.The_0_property_of_an_iterator_must_be_a_method */;
             reportDiagnostic(c, createDiagnosticForNode(errorNode, message, [methodName]), diagnosticOutput);
         }
         return noIterationTypes();
@@ -483,7 +466,7 @@ function getIterationTypesOfMethod(c, t, isAsync, methodName, errorNode, diagnos
             const typeParameters = (isGeneratorMethod ? globalGeneratorType : globalIteratorType).typeParameters();
             const mapper = methodType.mapper;
             if (mapper !== undefined)
-                return new IterationTypes(mapper.map(typeParameters[0]), mapper.map(typeParameters[1]), methodName === 'next' ? mapper.map(typeParameters[2]) : undefined);
+                return new IterationTypes(getMappedType(typeParameters[0], mapper), getMappedType(typeParameters[1], mapper), methodName === 'next' ? getMappedType(typeParameters[2], mapper) : undefined);
         }
     }
     // The first parameter and return type of each signature.
@@ -513,8 +496,8 @@ function getIterationTypesOfMethod(c, t, isAsync, methodName, errorNode, diagnos
     if (!iterationTypes.hasTypes()) {
         if (errorNode !== undefined)
             reportDiagnostic(c, createDiagnosticForNode(errorNode, isAsync
-                ? 702 /* Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property */
-                : 650 /* Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property */, [methodName]), diagnosticOutput);
+                ? 709 /* Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property */
+                : 657 /* Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property */, [methodName]), diagnosticOutput);
         yieldType = c.anyType;
         returnTypes.push(c.anyType);
     }
@@ -676,7 +659,7 @@ export function getAwaitedTypeNoAliasEx(c, t, errorNode, message) {
         if (errorNode !== undefined && message !== undefined) {
             let chain;
             if (promised.thisTypeForError !== undefined)
-                chain = createDiagnosticForNode(errorNode, 817 /* Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1 */, [typeToString(c, t), typeToString(c, promised.thisTypeForError)]);
+                chain = createDiagnosticForNode(errorNode, 824 /* Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1 */, [typeToString(c, t), typeToString(c, promised.thisTypeForError)]);
             const diagnostic = createDiagnosticForNode(errorNode, message, []);
             if (chain !== undefined) {
                 diagnostic.addMessageChain(chain);
@@ -799,7 +782,7 @@ function getPromisedTypeOfPromiseWorker(c, t, errorNode) {
     }
     if (candidates.length === 0) {
         if (errorNode !== undefined)
-            c.error(errorNode, 817 /* Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1 */, typeToString(c, t), typeToString(c, thisTypeForError));
+            c.error(errorNode, 824 /* Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1 */, typeToString(c, t), typeToString(c, thisTypeForError));
         return new PromisedType(undefined, thisTypeForError);
     }
     const onfulfilledParameterType = getTypeWithFacts(c, getUnionType(c, getTypesOfFirstParameterOfSignatures(c, candidates)), 2097152 /* TypeFacts.NEUndefinedOrNull */);
@@ -844,14 +827,14 @@ export function createPromiseLikeType(c, promisedType) {
 export function createPromiseReturnType(c, func, promisedType) {
     const promiseType = createPromiseType(c, promisedType);
     if (promiseType === c.unknownType) {
-        c.error(func, func.kind === 214 /* SyntaxKind.CallExpression */
-            ? 843 /* Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option */
-            : 829 /* Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option */);
+        c.error(func, func.kind === 215 /* SyntaxKind.CallExpression */
+            ? 850 /* Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option */
+            : 836 /* Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option */);
         return c.errorType;
     }
     if (getGlobalValueSymbol(c, 'Promise', true) === undefined)
-        c.error(func, func.kind === 214 /* SyntaxKind.CallExpression */
-            ? 844 /* Diagnostics.A_dynamic_import_call_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option */
-            : 837 /* Diagnostics.An_async_function_or_method_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option */);
+        c.error(func, func.kind === 215 /* SyntaxKind.CallExpression */
+            ? 851 /* Diagnostics.A_dynamic_import_call_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option */
+            : 844 /* Diagnostics.An_async_function_or_method_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option */);
     return promiseType;
 }

package/dist/api/compiler/checker-javascript.js

@@ -100,7 +100,7 @@ function getAssignmentDeclarationInitializerType(c, node) {
         }
         return t;
     }
-    if (node.kind === 214 /* SyntaxKind.CallExpression */)
+    if (node.kind === 215 /* SyntaxKind.CallExpression */)
         return getTypeFromPropertyDescriptor(c, getArguments(node).nodes[2]);
     return undefined;
 }
@@ -116,7 +116,7 @@ function hasParentWithTypeAnnotation(c, symbol) {
     if (parent === undefined || parent.valueDeclaration === undefined)
         return false;
     const kind = parent.valueDeclaration.kind;
-    if (kind !== 219 /* SyntaxKind.FunctionExpression */ && kind !== 220 /* SyntaxKind.ArrowFunction */)
+    if (kind !== 220 /* SyntaxKind.FunctionExpression */ && kind !== 221 /* SyntaxKind.ArrowFunction */)
         return false;
     const annotated = getSymbolOfDeclaration(c, parent.valueDeclaration.parent);
     return (annotated !== undefined &&
@@ -178,7 +178,7 @@ function getThisAssignmentKind(c, symbol) {
         }
         const left = declaration.left;
         if (getAssignmentDeclarationKind(declaration) === 3 /* JSDeclarationKind.ThisProperty */ &&
-            (left.kind !== 213 /* SyntaxKind.ElementAccessExpression */ || isStringOrNumericLiteralLike(getArgumentExpression(left)))) {
+            (left.kind !== 214 /* SyntaxKind.ElementAccessExpression */ || isStringOrNumericLiteralLike(getArgumentExpression(left)))) {
             if (declaration.type !== undefined)
                 typeAnnotation = declaration.type;
         }
@@ -213,7 +213,7 @@ export function isConstructorDeclaredThisProperty(c, symbol) {
 function getDeclaringConstructor(symbol) {
     for (const declaration of getDeclarations(symbol)) {
         const container = getThisContainer(declaration, false, false);
-        if (container.kind === 177 /* SyntaxKind.Constructor */)
+        if (container.kind === 178 /* SyntaxKind.Constructor */)
             return container;
     }
     return undefined;
@@ -243,7 +243,7 @@ export function getFlowTypeOfAutoTypedProperty(c, reference, prop) {
 /** The leftmost expression of a property access, element access or call chain. */
 function getLeftmostAccessExpression(node) {
     let current = node;
-    while (isAccessExpression(current) || current.kind === 214 /* SyntaxKind.CallExpression */)
+    while (isAccessExpression(current) || current.kind === 215 /* SyntaxKind.CallExpression */)
         current = getExpression(current);
     return current;
 }
@@ -267,7 +267,7 @@ export function getContextualTypeForAssignmentExpression(c, binary) {
                     break;
                 // `F.id = expr` takes a contextual type only from an annotated variable F.
                 const declaration = symbol.valueDeclaration;
-                if (declaration === undefined || declaration.kind !== 261 /* SyntaxKind.VariableDeclaration */)
+                if (declaration === undefined || declaration.kind !== 262 /* SyntaxKind.VariableDeclaration */)
                     return undefined;
                 const typeNode = getType(declaration);
                 if (typeNode === undefined)
@@ -279,8 +279,8 @@ export function getContextualTypeForAssignmentExpression(c, binary) {
                     return getTypeOfPropertyOfContextualType(c, getTypeFromTypeNode(c, typeNode), getPropertyNameFromType(nameType));
                 return getTypeOfExpression(c, left);
             }
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 if (binary.symbol !== undefined)
                     return undefined;
                 break;
@@ -304,7 +304,7 @@ export function getContextualTypeForAssignmentExpression(c, binary) {
                 const d = symbol?.valueDeclaration;
                 // `this.x = expr` where x is a property with no type annotation or initializer.
                 if (d !== undefined &&
-                    (d.kind === 173 /* SyntaxKind.PropertyDeclaration */ || d.kind === 172 /* SyntaxKind.PropertySignature */) &&
+                    (d.kind === 174 /* SyntaxKind.PropertyDeclaration */ || d.kind === 173 /* SyntaxKind.PropertySignature */) &&
                     getType(d) === undefined &&
                     getInitializer(d) === undefined)
                     return undefined;
@@ -332,9 +332,9 @@ export function isCommonJSRequire(c, node) {
         return false;
     let kind = 0 /* SyntaxKind.Unknown */;
     if ((resolved.flags & 16 /* SymbolFlags.Function */) !== 0)
-        kind = 263 /* SyntaxKind.FunctionDeclaration */;
+        kind = 264 /* SyntaxKind.FunctionDeclaration */;
     else if ((resolved.flags & 3 /* SymbolFlags.Variable */) !== 0)
-        kind = 261 /* SyntaxKind.VariableDeclaration */;
+        kind = 262 /* SyntaxKind.VariableDeclaration */;
     if (kind === 0 /* SyntaxKind.Unknown */)
         return false;
     const declaration = getDeclarationOfKind(resolved, kind);
@@ -342,7 +342,7 @@ export function isCommonJSRequire(c, node) {
 }
 /** The type of the module a `require("m")` call names. */
 export function resolveExternalModuleTypeByLiteral(c, name) {
-    const moduleSymbol = resolveExternalModuleName(c, name, name, false);
+    const moduleSymbol = resolveExternalModuleName(c, name, name, false, undefined);
     if (moduleSymbol !== undefined) {
         const resolved = resolveExternalModuleSymbol(c, moduleSymbol, false);
         if (resolved !== undefined)
@@ -352,7 +352,7 @@ export function resolveExternalModuleTypeByLiteral(c, name) {
 }
 /** Whether a JavaScript declaration declares an alias: a `require` or an exported entity name. */
 export function isJSAliasDeclaration(node) {
-    if (node.kind !== 227 /* SyntaxKind.BinaryExpression */)
+    if (node.kind !== 228 /* SyntaxKind.BinaryExpression */)
         return isVariableDeclarationInitializedToRequire(node);
     const kind = getAssignmentDeclarationKind(node);
     return ((kind === 1 /* JSDeclarationKind.ModuleExports */ || kind === 2 /* JSDeclarationKind.ExportsProperty */) &&
@@ -361,7 +361,7 @@ export function isJSAliasDeclaration(node) {
 /** `this` in `obj.x = function () {}` is `obj`, except for CommonJS `exports.x = function () {}`. */
 export function getThisTypeOfAssignedFunction(c, func) {
     let parent = func.parent;
-    while (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    while (parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         parent = parent.parent;
     // Compound assignments like `??=` count too.
     if (!(parent instanceof BinaryExpression) ||

package/dist/api/compiler/checker-jsdoc.d.ts

@@ -11,6 +11,8 @@ export declare function getSignatureOfFullSignatureType(c: Checker, node: Node):
 export declare function getParameterTypeOfFullSignature(c: Checker, fn: Node, parameter: Node): Type | undefined;
 /** The return type of a function typed by a JSDoc `@type` tag. */
 export declare function getReturnTypeOfFullSignature(c: Checker, fn: Node): Type | undefined;
+/** Checks the type of a JSDoc `@type` on a function as a type node. */
+export declare function checkJSDocFullSignatureType(c: Checker, fn: Node): void;
 /** A JSDoc `@type` on a function needs a call signature taking at least its parameters. */
 export declare function checkJSDocFullSignature(c: Checker, fn: Node): void;
 /**
@@ -18,13 +20,9 @@ export declare function checkJSDocFullSignature(c: Checker, fn: Node): void;
  * without a parent `@param {object}`.
  */
 export declare function checkUnmatchedJSDocParameters(c: Checker, node: Node): void;
-/** An `@augments` or `@extends` tag naming another class than the `extends` clause. */
-export declare class AugmentsMismatch {
-    readonly name: Node;
-    readonly tagName: string;
-    readonly className: string;
-    readonly extendsName: string;
-    constructor(name: Node, tagName: string, className: string, extendsName: string);
-}
-/** The `@augments` or `@extends` tag of a class whose class name differs from its `extends` clause. */
-export declare function findMismatchedAugmentsTag(classLike: Node, extendsType: ExpressionWithTypeArguments): AugmentsMismatch | undefined;
+/**
+ * Reports an `@augments` or `@extends` tag of a JavaScript class whose class doesn't match the
+ * `extends` clause: for an entity name, a different type; for another expression, a type the base
+ * type isn't assignable to.
+ */
+export declare function checkJSDocAugmentsTagMatchesExtends(c: Checker, node: Node, baseTypeNode: ExpressionWithTypeArguments, baseType: Type): void;

package/dist/api/compiler/checker-jsdoc.js

@@ -1,7 +1,8 @@
 // JSDoc semantics: the intended types of JSDoc type references like `String`, `function` and
 // `Object<K, V>`, functions typed by a JSDoc `@type` tag, and `@param` tags without parameters.
 import { ArrowFunction, FunctionDeclaration, FunctionExpression, MethodDeclaration, NodeVisitor, getBody, getDotDotDotToken, getExpression, getInitializer, getName, getParameters, getText, getType, } from './ast.js';
-import { getSourceFileOfNode, isTypeNodeKind } from './binder-utilities.js';
+import { getSourceFileOfNode, getSourceTextOfNode, isEntityNameExpression, isTypeNodeKind, } from './binder-utilities.js';
+import { isTypeAssignableTo, isTypeIdenticalTo } from './relations.js';
 import { getAttachedJSDoc, getJSDoc } from './parser.js';
 import { isInJSFile } from './ast-utilities.js';
 import { getGlobalTypeAliasSymbol } from './checker-symbols.js';
@@ -12,9 +13,10 @@ import { getRestTypeAtPosition, getReturnTypeOfSignature, getSingleCallSignature
 import { getContextualCallSignature } from './checker-contextual.js';
 import { entityNameToString, getResolvedSymbol } from './checker-expressions.js';
 import { isArrayType } from './checker-type-factory.js';
+import { checkSourceElement } from './checker-source-file.js';
 /** The type a JSDoc type reference to a JavaScript-style name means, if it is one. */
 export function getIntendedTypeFromJSDocTypeReference(c, node) {
-    if ((node.flags & 4194304 /* NodeFlags.JSDoc */) === 0 || node.kind !== 184 /* SyntaxKind.TypeReference */)
+    if ((node.flags & 4194304 /* NodeFlags.JSDoc */) === 0 || node.kind !== 185 /* SyntaxKind.TypeReference */)
         return undefined;
     const reference = node;
     const typeName = reference.typeName;
@@ -108,13 +110,19 @@ export function getReturnTypeOfFullSignature(c, fn) {
     const signature = getSignatureOfFullSignatureType(c, fn);
     return signature !== undefined ? getReturnTypeOfSignature(c, signature) : undefined;
 }
+/** Checks the type of a JSDoc `@type` on a function as a type node. */
+export function checkJSDocFullSignatureType(c, fn) {
+    const typeNode = getFullSignatureTypeNode(fn);
+    if (typeNode !== undefined)
+        checkSourceElement(c, typeNode);
+}
 /** A JSDoc `@type` on a function needs a call signature taking at least its parameters. */
 export function checkJSDocFullSignature(c, fn) {
     const typeNode = getFullSignatureTypeNode(fn);
     if (typeNode === undefined)
         return;
     if (getContextualCallSignature(c, getTypeFromTypeNode(c, typeNode), fn) === undefined)
-        c.error(typeNode, 1759 /* Diagnostics.A_JSDoc_type_tag_on_a_function_must_have_a_signature_with_the_correct_number_of_arguments */);
+        c.error(typeNode, 1779 /* Diagnostics.A_JSDoc_type_tag_on_a_function_must_have_a_signature_with_the_correct_number_of_arguments */);
 }
 // ---- `@param` tags
 /** The tags of the last JSDoc comment of `node` or of the declaration or statement it heads. */
@@ -137,16 +145,16 @@ function getNextJSDocCommentLocation(node) {
     if (parent === undefined)
         return undefined;
     switch (parent.kind) {
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 278 /* SyntaxKind.ExportAssignment */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
-        case 254 /* SyntaxKind.ReturnStatement */:
-        case 244 /* SyntaxKind.VariableStatement */:
-        case 245 /* SyntaxKind.ExpressionStatement */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
+        case 255 /* SyntaxKind.ReturnStatement */:
+        case 245 /* SyntaxKind.VariableStatement */:
+        case 246 /* SyntaxKind.ExpressionStatement */:
             return parent;
-        case 262 /* SyntaxKind.VariableDeclarationList */:
+        case 263 /* SyntaxKind.VariableDeclarationList */:
             return parent.declarations.nodes[0] === node ? parent : undefined;
     }
     return undefined;
@@ -164,7 +172,7 @@ export function checkUnmatchedJSDocParameters(c, node) {
         return;
     const jsdocParameters = [];
     for (const tag of getAllJSDocTags(node)) {
-        if (tag.kind !== 333 /* SyntaxKind.JSDocParameterTag */)
+        if (tag.kind !== 334 /* SyntaxKind.JSDocParameterTag */)
             continue;
         const name = tag.name;
         if (name.kind === 79 /* SyntaxKind.Identifier */ && getText(name).length === 0)
@@ -180,7 +188,7 @@ export function checkUnmatchedJSDocParameters(c, node) {
         const name = getName(params[i]);
         if (name.kind === 79 /* SyntaxKind.Identifier */)
             parameters.add(getText(name));
-        if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+        if (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)
             excludedParameters.add(i);
     }
     if (containsArgumentsReference(c, node)) {
@@ -196,7 +204,7 @@ export function checkUnmatchedJSDocParameters(c, node) {
         const typeNode = typeExpression !== undefined ? getType(typeExpression) : undefined;
         if (typeNode === undefined || isArrayType(c, getTypeFromTypeNode(c, typeNode)))
             return;
-        c.error(last.name, 1758 /* Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type */, getText(last.name));
+        c.error(last.name, 1778 /* Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type */, getText(last.name));
         return;
     }
     if (!isJs)
@@ -206,10 +214,10 @@ export function checkUnmatchedJSDocParameters(c, node) {
         const name = tag.name;
         if (excludedParameters.has(index) || (name.kind === 79 /* SyntaxKind.Identifier */ && parameters.has(getText(name))))
             continue;
-        if (name.kind === 167 /* SyntaxKind.QualifiedName */)
-            c.error(name, 1761 /* Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1 */, entityNameToString(name), entityNameToString(name.left));
+        if (name.kind === 168 /* SyntaxKind.QualifiedName */)
+            c.error(name, 1781 /* Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1 */, entityNameToString(name), entityNameToString(name.left));
         else if (!tag.isNameFirst)
-            c.error(name, 1753 /* Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name */, getText(name));
+            c.error(name, 1773 /* Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name */, getText(name));
     }
 }
 /** Finds a reference to `arguments` outside nested functions and types. */
@@ -223,19 +231,19 @@ class ArgumentsReferenceFinder extends NodeVisitor {
         switch (node.kind) {
             case 79 /* SyntaxKind.Identifier */:
                 return getText(node) === 'arguments' && getResolvedSymbol(this.c, node) === this.c.argumentsSymbol;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */: {
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */: {
                 const name = getName(node);
-                if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+                if (name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
                     return this.visitNode(name);
                 break;
             }
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 return this.visitNode(getExpression(node));
-            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
                 return this.visitNode(getInitializer(node));
         }
         if (startsNewLexicalEnvironment(node) || isTypeNodeKind(node.kind))
@@ -245,15 +253,15 @@ class ArgumentsReferenceFinder extends NodeVisitor {
 }
 function startsNewLexicalEnvironment(node) {
     switch (node.kind) {
-        case 177 /* SyntaxKind.Constructor */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
-        case 307 /* SyntaxKind.SourceFile */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 308 /* SyntaxKind.SourceFile */:
             return true;
     }
     return false;
@@ -280,41 +288,42 @@ function containsArgumentsReference(c, node) {
 function getIdentifierFromEntityNameExpression(node) {
     if (node.kind === 79 /* SyntaxKind.Identifier */)
         return node;
-    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         return getName(node);
     return undefined;
 }
-/** An `@augments` or `@extends` tag naming another class than the `extends` clause. */
-export class AugmentsMismatch {
-    name;
-    tagName;
-    className;
-    extendsName;
-    constructor(name, tagName, className, extendsName) {
-        this.name = name;
-        this.tagName = tagName;
-        this.className = className;
-        this.extendsName = extendsName;
-    }
-}
-/** The `@augments` or `@extends` tag of a class whose class name differs from its `extends` clause. */
-export function findMismatchedAugmentsTag(classLike, extendsType) {
-    const jsDoc = getAttachedJSDoc(classLike);
+/**
+ * Reports an `@augments` or `@extends` tag of a JavaScript class whose class doesn't match the
+ * `extends` clause: for an entity name, a different type; for another expression, a type the base
+ * type isn't assignable to.
+ */
+export function checkJSDocAugmentsTagMatchesExtends(c, node, baseTypeNode, baseType) {
+    if (!isInJSFile(node))
+        return;
+    const jsDoc = getAttachedJSDoc(node);
     if (jsDoc === undefined)
-        return undefined;
+        return;
     for (const j of jsDoc) {
         const tags = j.tags;
         if (tags === undefined)
             continue;
         for (const tag of tags.nodes) {
-            if (tag.kind !== 323 /* SyntaxKind.JSDocAugmentsTag */)
+            if (tag.kind !== 324 /* SyntaxKind.JSDocAugmentsTag */)
                 continue;
             const augments = tag;
-            const targetName = getIdentifierFromEntityNameExpression(extendsType.expression);
+            const sourceType = getTypeFromTypeNode(c, augments.className);
             const sourceName = getIdentifierFromEntityNameExpression(augments.className.expression);
-            if (targetName !== undefined && sourceName !== undefined && getText(targetName) !== getText(sourceName))
-                return new AugmentsMismatch(sourceName, getText(augments.tagName), getText(sourceName), getText(targetName));
+            if (isEntityNameExpression(baseTypeNode.expression, false)) {
+                if (isTypeIdenticalTo(c, sourceType, baseType))
+                    continue;
+                const targetName = getIdentifierFromEntityNameExpression(baseTypeNode.expression);
+                if (targetName !== undefined && sourceName !== undefined)
+                    c.error(sourceName, 1772 /* Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause */, getText(augments.tagName), getText(sourceName), getText(targetName));
+            }
+            else if (sourceName !== undefined && !isTypeAssignableTo(c, baseType, sourceType)) {
+                const expression = baseTypeNode.expression;
+                c.error(sourceName, 1772 /* Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause */, getText(augments.tagName), getText(sourceName), getSourceTextOfNode(getSourceFileOfNode(expression), expression));
+            }
         }
     }
-    return undefined;
 }