tsc-ts 0.0.9 → 0.1.0

package/src/compiler/checker-iteration.ts

@@ -17,6 +17,7 @@ import {
   TypeFlags,
   ObjectFlags,
   type TypeReference,
+  getMappedType,
 } from './checker-types.js';
 import {
   createTypeFromGenericGlobalType,
@@ -127,30 +128,18 @@ function anyIterationTypes(c: Checker): IterationTypes {
   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 {
-  readonly errorNode: Node;
-  readonly type: Type;
-  readonly allowAsyncIterables: boolean;
-  readonly related: Diagnostic[];
-
-  constructor(errorNode: Node, type: Type, allowAsyncIterables: boolean, related: Diagnostic[]) {
-    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: Checker): void {
-  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) diagnostic.addRelatedInfo(d);
-  }
+/** Defers a not-iterable error, so printing its type can't resolve types that are being resolved. */
+function deferTypeNotIterableError(
+  c: Checker,
+  errorNode: Node,
+  t: Type,
+  allowAsyncIterables: boolean,
+  related: Diagnostic[],
+): void {
+  c.deferDiagnostic(errorNode, () => {
+    const diagnostic = reportTypeNotIterableError(c, errorNode, t, allowAsyncIterables);
+    for (const d of related) diagnostic.addRelatedInfo(d);
+  });
 }
 
 // ---- Global types
@@ -493,8 +482,7 @@ function getIterationTypesOfIterableWorker(
     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);
@@ -524,8 +512,7 @@ function getIterationTypesOfIterableWorker(
       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();
 }
 
@@ -725,9 +712,9 @@ function getIterationTypesOfMethod(
       const mapper = (methodType as ObjectType).mapper;
       if (mapper !== undefined)
         return new IterationTypes(
-          mapper.map(typeParameters[0]!),
-          mapper.map(typeParameters[1]!),
-          methodName === 'next' ? mapper.map(typeParameters[2]!) : undefined,
+          getMappedType(typeParameters[0]!, mapper),
+          getMappedType(typeParameters[1]!, mapper),
+          methodName === 'next' ? getMappedType(typeParameters[2]!, mapper) : undefined,
         );
     }
   }

package/src/compiler/checker-javascript.ts

@@ -406,7 +406,7 @@ export function isCommonJSRequire(c: Checker, node: Node): boolean {
 
 /** The type of the module a `require("m")` call names. */
 export function resolveExternalModuleTypeByLiteral(c: Checker, name: Node): Type {
-  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) return getTypeOfSymbol(c, resolved);

package/src/compiler/checker-jsdoc.ts

@@ -24,7 +24,13 @@ import {
   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 { Diagnostics } from './diagnostics.js';
@@ -44,6 +50,7 @@ import {
 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: Checker, node: Node): Type | undefined {
@@ -142,6 +149,12 @@ export function getReturnTypeOfFullSignature(c: Checker, fn: Node): Type | undef
   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: Checker, fn: Node): void {
+  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: Checker, fn: Node): void {
   const typeNode = getFullSignatureTypeNode(fn);
@@ -322,39 +335,49 @@ function getIdentifierFromEntityNameExpression(node: Node): Node | undefined {
   return undefined;
 }
 
-/** An `@augments` or `@extends` tag naming another class than the `extends` clause. */
-export class AugmentsMismatch {
-  readonly name: Node;
-  readonly tagName: string;
-  readonly className: string;
-  readonly extendsName: string;
-
-  constructor(name: Node, tagName: string, className: string, extendsName: string) {
-    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: Node,
-  extendsType: ExpressionWithTypeArguments,
-): AugmentsMismatch | undefined {
-  const jsDoc = getAttachedJSDoc(classLike);
-  if (jsDoc === undefined) return 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 function checkJSDocAugmentsTagMatchesExtends(
+  c: Checker,
+  node: Node,
+  baseTypeNode: ExpressionWithTypeArguments,
+  baseType: Type,
+): void {
+  if (!isInJSFile(node)) return;
+  const jsDoc = getAttachedJSDoc(node);
+  if (jsDoc === undefined) return;
   for (const j of jsDoc) {
     const tags = (j as JSDoc).tags;
     if (tags === undefined) continue;
     for (const tag of tags.nodes) {
       if (tag.kind !== SyntaxKind.JSDocAugmentsTag) continue;
       const augments = tag as JSDocAugmentsTag;
-      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,
+            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,
+          Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause,
+          getText(augments.tagName),
+          getText(sourceName),
+          getSourceTextOfNode(getSourceFileOfNode(expression), expression),
+        );
+      }
     }
   }
-  return undefined;
 }

package/src/compiler/checker-jsx.ts

@@ -1,5 +1,5 @@
 // JSX: element and fragment types, the `JSX` namespace, intrinsic elements, attributes and children.
-import { checkDeprecatedJsxAttribute, checkDeprecatedSignature } from './checker-deprecation.js';
+import { checkDeprecatedSignature } from './checker-deprecation.js';
 import {
   type BinaryExpression,
   type JsxAttribute,
@@ -14,6 +14,7 @@ import {
   type JsxText,
   type Node,
   type NodeList,
+  NodeVisitor,
   type PropertyAccessExpression,
   type QualifiedName,
   type SourceFile,
@@ -287,7 +288,7 @@ function entityNameToString(node: Node): string {
       return entityNameToString(access.expression) + '.' + entityNameToString(access.name);
     }
     case SyntaxKind.QualifiedName:
-      return entityNameToString((node as QualifiedName).left) + '.' + (node as QualifiedName).right.text;
+      return entityNameToString((node as QualifiedName).left) + '.' + getText((node as QualifiedName).right);
     case SyntaxKind.JsxNamespacedName:
       return jsxNameText(node);
   }
@@ -450,13 +451,17 @@ export function getJsxNamespaceContainerForImplicitImport(c: Checker, location:
     links.jsxImplicitImportContainer = c.unknownSymbol;
     return undefined;
   }
+  // A missing module is reported once, at the first JSX tag of the file, whichever tag is checked first.
+  const finder = new FirstJsxTagFinder();
+  file.forEachChild(finder);
   const mod = resolveExternalModule(
     c,
     specifier,
     getText(specifier),
     Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed,
-    location,
+    finder.tag ?? location,
     false,
+    undefined,
   );
   const resolved = mod !== undefined && mod !== c.unknownSymbol ? resolveSymbol(c, mod) : undefined;
   const result = resolved !== undefined ? getMergedSymbol(c, resolved) : undefined;
@@ -464,6 +469,23 @@ export function getJsxNamespaceContainerForImplicitImport(c: Checker, location:
   return result;
 }
 
+/** The first JSX element or self-closing element of a file, or the opening tag of its first fragment. */
+class FirstJsxTagFinder extends NodeVisitor {
+  tag: Node | undefined = undefined;
+
+  visitNode(node: Node): boolean {
+    if (node.kind === SyntaxKind.JsxElement || node.kind === SyntaxKind.JsxSelfClosingElement) {
+      this.tag = node;
+      return true;
+    }
+    if (node.kind === SyntaxKind.JsxFragment) {
+      this.tag = (node as JsxFragment).openingFragment;
+      return true;
+    }
+    return node.forEachChild(this);
+  }
+}
+
 /** The `JSX` namespace for `location`: the factory's, the runtime module's, or the global one. */
 export function getJsxNamespaceAt(c: Checker, location: Node): Symbol | undefined {
   const links = elementLinks(c, location);
@@ -967,7 +989,6 @@ export function createJsxAttributesTypeFromAttributesProperty(
         if (allAttributesTable !== undefined) allAttributesTable.set(attributeSymbol.name, attributeSymbol);
         if (jsxNameText((attributeDecl as JsxAttribute).name) === jsxChildrenPropertyName)
           explicitlySpecifyChildrenAttribute = true;
-        if (contextualType !== undefined) checkDeprecatedJsxAttribute(c, contextualType, attributeDecl as JsxAttribute);
         if (
           contextualType !== undefined &&
           (checkMode & CheckMode.Inferential) !== 0 &&
@@ -1343,6 +1364,7 @@ export function checkJsx(c: Checker, node: Node, checkMode: CheckMode): Type {
     case SyntaxKind.JsxFragment:
       return checkJsxFragment(c, node as JsxFragment);
     case SyntaxKind.JsxAttributes:
+      checkNodeDeferred(c, node);
       return createJsxAttributesTypeFromAttributesProperty(c, node.parent!, checkMode);
   }
   return c.errorType;