tsc-ts 0.0.9 → 0.1.0

package/src/compiler/checker-emit-resolver.ts

@@ -84,7 +84,7 @@ import { isArrayType, isErrorType, isFreshLiteralType, isTupleType } from './che
 import { isTypeAssignableToKind } from './checker-type-operators.js';
 import { type IndexInfo, type LiteralType, SignatureKind, type Type, TypeFlags } from './checker-types.js';
 import { hasLateBindableName } from './checker-utilities.js';
-import { NodeBuilder, isEntityNameVisible, isOptionalParameter } from './node-builder.js';
+import { NodeBuilder, NodeBuilderCaches, isEntityNameVisible, isOptionalParameter } from './node-builder.js';
 import {
   getRegularTypeOfExpression,
   newPseudoChecker,
@@ -92,7 +92,7 @@ import {
 } from './node-builder-pseudo.js';
 import { symbolToExpression } from './node-builder-names.js';
 import { tryReuseExistingNode } from './node-builder-reuse.js';
-import type { CompilerOptions, ModuleKind } from './options.js';
+import type { CompilerOptions } from './options.js';
 import type { EmitContext } from './printer/emit-context.js';
 import { isTypeIdenticalTo } from './relations.js';
 import {
@@ -115,6 +115,7 @@ import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
 import type { Evaluation, ReferenceResolver } from './transformers/reference-resolver.js';
 import { TypeReferenceSerializationKind } from './transformers/type-serialization.js';
 import { TokenFlags } from './types.js';
+import { getSignatureOfFullSignatureType } from './checker-jsdoc.js';
 import { CheckFlags, declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 const declarationEmitInternalFlags = NodeBuilderInternalFlags.AllowUnresolvedNames;
@@ -125,12 +126,17 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
   /** Answers the queries that don't need types. */
   private readonly syntactic: SyntacticDeclarationEmitResolver;
   private readonly aliasesMarked: Set<SourceFile>;
+  /** The emit context of the last node builder, and the caches the builders for it share. */
+  private builderContext: EmitContext | undefined;
+  private builderCaches: NodeBuilderCaches | undefined;
 
   constructor(checker: Checker, syntactic: SyntacticDeclarationEmitResolver) {
     super();
     this.checker = checker;
     this.syntactic = syntactic;
     this.aliasesMarked = new Set<SourceFile>();
+    this.builderContext = undefined;
+    this.builderCaches = undefined;
   }
 
   // JavaScript emit
@@ -284,6 +290,8 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     const signatures = getSignaturesOfSymbol(c, getSymbolOfDeclaration(c, node));
     if (signatures.length > 1) return true;
     if (signatures.length === 1) {
+      // A JSDoc `@type` signature of the function itself is not an overload.
+      if (signatures[0] === getSignatureOfFullSignatureType(c, node)) return false;
       const declaration = signatures[0].declaration;
       if (declaration !== node && declaration !== undefined && (declaration.flags & NodeFlags.JSDoc) === 0) return true;
     }
@@ -359,10 +367,6 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     return getPropertiesOfType(c, getTypeOfSymbol(c, symbol));
   }
 
-  getResolutionModeOverride(node: Node): ModuleKind | undefined {
-    return this.syntactic.getResolutionModeOverride(node);
-  }
-
   getSourceFileFromReference(file: SourceFile, reference: FileReference): SourceFile | undefined {
     return this.syntactic.getSourceFileFromReference(file, reference);
   }
@@ -419,6 +423,12 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     );
     b.pseudo = newPseudoChecker(this.checker);
     b.declarationOrder = true;
+    // tsgo's emit resolver, one per emit context, keeps one node builder for all its requests.
+    if (context !== this.builderContext || this.builderCaches === undefined) {
+      this.builderContext = context;
+      this.builderCaches = new NodeBuilderCaches();
+    }
+    b.useCaches(this.builderCaches);
     return b;
   }
 

package/src/compiler/checker-expressions.ts

@@ -61,7 +61,7 @@ import { skipTrivia } from './scanner.js';
 import { Diagnostic, Diagnostics } from './diagnostics.js';
 import { type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
-import { type Checker } from './checker.js';
+import { type Checker, createDiagnosticForNode } from './checker.js';
 import {
   checkSuperExpression,
   checkThisBeforeSuper,
@@ -129,7 +129,7 @@ import {
   resolveEntityName,
   resolveName,
   getFirstIdentifier,
-  getCannotFindNameDiagnosticForName,
+  cannotFindNameAtLocation,
   getDeclarationOfAliasSymbol,
   TypeSystemPropertyName,
   popTypeResolution,
@@ -153,9 +153,6 @@ import {
   isGenericIndexType,
   isGenericMappedType,
   isGenericType,
-  getMappedTypeNameTypeKind,
-  MappedTypeNameTypeKind,
-  getIndexForMappedType,
   getIndexTypeEx,
   getMappedTypeModifiers,
   MappedTypeModifiers,
@@ -211,8 +208,10 @@ import {
   checkDeleteExpression,
   checkPostfixUnaryExpression,
   checkPrefixUnaryExpression,
+  grammarErrorOnNode,
   isTypeAssertion,
 } from './checker-operators.js';
+import { fileExtensionIsOneOf } from './path.js';
 import { checkJsx } from './checker-jsx.js';
 import { getRegularTypeOfObjectLiteral } from './checker-literals.js';
 import {
@@ -448,8 +447,10 @@ function getReturnTypeOfSingleNonGenericSignature(c: Checker, funcType: Type, ki
 }
 
 export function checkComputedPropertyName(c: Checker, node: Node): Type {
-  const nodeId = (node as ComputedPropertyName).expression.id;
+  const nodeId = node.id;
   if (c.resolvedTypes.get(nodeId) === undefined) {
+    // A reference to the name while its expression is checked sees a circular type.
+    c.resolvedTypes.set(nodeId, c.circularConstraintType);
     const expression = (node as ComputedPropertyName).expression;
     const container = node.parent!.parent!;
     // `[x in y]` in a type member is a mapped type written in the wrong place, reported by the parser.
@@ -552,14 +553,14 @@ export function getResolvedSymbol(c: Checker, node: Node): Symbol {
   const cached = c.resolvedSymbols.get(node.id);
   if (cached !== undefined) return cached;
   let symbol = c.unknownSymbol;
-  if (getText(node) !== '') {
-    const text = getText(node);
+  const text = getText(node);
+  if (text !== '') {
     const found = resolveName(
       c,
       node,
       text,
       SymbolFlags.Value | SymbolFlags.ExportValue,
-      getCannotFindNameDiagnosticForName(c, node),
+      cannotFindNameAtLocation,
       !isWriteOnlyAccess(node),
       false,
     );
@@ -970,8 +971,21 @@ export function checkThisExpression(c: Checker, node: Node): Type {
     const globalThisType = getTypeOfSymbol(c, c.globalThisSymbol);
     if (t === globalThisType && capturedByArrowFunction)
       c.error(node, Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this);
-    else if (t === undefined)
-      c.error(node, Diagnostics.X_this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);
+    else if (t === undefined) {
+      // The related information goes on the reported diagnostic after it is added, as tsgo attaches it,
+      // so a later equal report compares unequal to it and is kept.
+      const diagnostic = c.error(
+        node,
+        Diagnostics.X_this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation,
+      );
+      if (container.kind !== SyntaxKind.SourceFile) {
+        const outsideThis = tryGetThisTypeAt(c, container, getThisContainer(container, false, false));
+        if (outsideThis !== undefined && outsideThis !== globalThisType)
+          diagnostic.addRelatedInfo(
+            createDiagnosticForNode(container, Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container, []),
+          );
+      }
+    }
   }
   return t ?? c.anyType;
 }
@@ -1210,7 +1224,8 @@ export function isTupleLikeType(c: Checker, t: Type): boolean {
 export function isMutableArrayLikeType(c: Checker, t: Type): boolean {
   return (
     isMutableArrayOrTuple(c, t) ||
-    ((t.flags & (TypeFlags.Any | TypeFlags.Nullable)) === 0 && isTypeAssignableTo(c, t, c.anyArrayType))
+    ((t.flags & (TypeFlags.Any | TypeFlags.Nullable | TypeFlags.Never)) === 0 &&
+      isTypeAssignableTo(c, t, c.anyArrayType))
   );
 }
 
@@ -1248,10 +1263,31 @@ export function getPropertyNameOfObjectLiteralElement(c: Checker, element: Node)
   return undefined;
 }
 
+/** Whether `node` is the object literal of the `with` property of an `import()` call's options argument. */
+function isInlineImportAttributes(node: Node): boolean {
+  const property = node.parent!;
+  if (
+    node.kind !== SyntaxKind.ObjectLiteralExpression ||
+    property.kind !== SyntaxKind.PropertyAssignment ||
+    getInitializer(property) !== node
+  )
+    return false;
+  const name = getName(property)!;
+  if ((name.kind !== SyntaxKind.Identifier && !isStringLiteralLike(name)) || getText(name) !== 'with') return false;
+  const options = property.parent!;
+  if (options.kind !== SyntaxKind.ObjectLiteralExpression) return false;
+  let importCall: Node | undefined = options;
+  while (importCall !== undefined && !isImportCall(importCall)) importCall = importCall.parent;
+  if (importCall === undefined) return false;
+  const args = (importCall as CallExpression).arguments.nodes;
+  return args.length > 1 && skipParentheses(args[1]!) === options;
+}
+
 /** Whether `node` is in an `as const` context, where literals keep their types. */
 export function isConstContext(c: Checker, node: Node): boolean {
   const parent = node.parent;
   if (parent === undefined) return false;
+  if (isInlineImportAttributes(node)) return true;
   // Literals contextually typed by a `const` type parameter are in a const context.
   if (isValidConstAssertionArgument(c, node) && isConstTypeVariable(c, getContextualType(c, node), 0)) return true;
   switch (parent.kind) {
@@ -1468,7 +1504,7 @@ export function entityNameToString(node: Node): string {
     }
     case SyntaxKind.QualifiedName: {
       const q = node as QualifiedName;
-      return entityNameToString(q.left) + '.' + q.right.text;
+      return entityNameToString(q.left) + '.' + getText(q.right);
     }
   }
   return getText(node);
@@ -1535,32 +1571,25 @@ export function getFlowTypeOfAccessExpression(
     return propType;
   if (propType === c.autoType) return getFlowTypeOfAutoTypedProperty(c, node, prop);
   propType = getNarrowableTypeForReference(c, propType, node, checkMode);
-  // `this.x` in the constructor of x's class starts out uninitialized under strictPropertyInitialization.
+  // `this.x` in the constructor of x's class starts out uninitialized under strictPropertyInitialization,
+  // and a JavaScript `this.x = …` declaration is unassigned before it in its own function.
   let assumeUninitialized = false;
-  const expression = getExpression(node);
-  if (
-    c.strictNullChecks &&
-    c.strictPropertyInitialization &&
-    expression !== undefined &&
-    expression.kind === SyntaxKind.ThisKeyword &&
-    prop !== undefined
-  ) {
+  if (c.strictNullChecks && prop !== undefined) {
     const declaration = prop.valueDeclaration;
-    if (declaration !== undefined && isPropertyWithoutInitializer(declaration) && !isStatic(declaration)) {
-      const flowContainer = getControlFlowContainer(node);
+    const expression = getExpression(node);
+    if (c.strictPropertyInitialization && expression !== undefined && expression.kind === SyntaxKind.ThisKeyword) {
+      if (declaration !== undefined && isPropertyWithoutInitializer(declaration) && !isStatic(declaration)) {
+        const flowContainer = getControlFlowContainer(node);
+        assumeUninitialized =
+          flowContainer.kind === SyntaxKind.Constructor &&
+          flowContainer.parent === declaration.parent &&
+          (declaration.flags & NodeFlags.Ambient) === 0;
+      }
+    } else
       assumeUninitialized =
-        flowContainer.kind === SyntaxKind.Constructor &&
-        flowContainer.parent === declaration.parent &&
-        (declaration.flags & NodeFlags.Ambient) === 0;
-    }
-  }
-  // A JavaScript `this.x = …` declaration is unassigned before it in its own function.
-  if (c.strictNullChecks && prop !== undefined && !assumeUninitialized) {
-    const declaration = prop.valueDeclaration;
-    assumeUninitialized =
-      declaration instanceof BinaryExpression &&
-      declaration.left.kind === SyntaxKind.PropertyAccessExpression &&
-      getControlFlowContainer(node) === getControlFlowContainer(declaration);
+        declaration instanceof BinaryExpression &&
+        declaration.left.kind === SyntaxKind.PropertyAccessExpression &&
+        getControlFlowContainer(node) === getControlFlowContainer(declaration);
   }
   const initialType = assumeUninitialized ? getOptionalType(c, propType, false) : propType;
   const flowType = getFlowTypeOfReference(c, node, propType, initialType, undefined);
@@ -1620,18 +1649,13 @@ export function checkIndexedAccessIndexType(c: Checker, t: Type, accessNode: Nod
   if ((t.flags & TypeFlags.IndexedAccess) === 0) return t;
   const objectType = (t as IndexedAccessType).objectType;
   const indexType = (t as IndexedAccessType).indexType;
-  // Remapping mapped types don't defer their index types.
-  const objectIndexType =
-    isGenericMappedType(c, objectType) &&
-    getMappedTypeNameTypeKind(c, objectType as MappedType) === MappedTypeNameTypeKind.Remapping
-      ? getIndexForMappedType(c, objectType as MappedType, IndexFlags.None)
-      : getIndexTypeEx(c, objectType, IndexFlags.None);
   const hasNumberIndexInfo = getIndexInfoOfType(c, objectType, c.numberType) !== undefined;
   if (
     everyType(
       indexType,
       (u) =>
-        isTypeAssignableTo(c, u, objectIndexType) || (hasNumberIndexInfo && isApplicableIndexType(c, u, c.numberType)),
+        isTypeAssignableTo(c, u, getIndexTypeEx(c, objectType, IndexFlags.None)) ||
+        (hasNumberIndexInfo && isApplicableIndexType(c, u, c.numberType)),
     )
   ) {
     if (
@@ -1737,6 +1761,15 @@ function hasNumericPropertyNames(c: Checker, t: Type): boolean {
 // ---- Assertions
 
 function checkAssertion(c: Checker, node: Node, checkMode: CheckMode): Type {
+  if (node.kind === SyntaxKind.TypeAssertionExpression) {
+    const file = getSourceFileOfNode(node);
+    if (fileExtensionIsOneOf(file.fileName, ['.mts', '.cts']))
+      grammarErrorOnNode(
+        c,
+        node,
+        Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead,
+      );
+  }
   // `<T>expr`, over `<T>`.
   if (node.kind === SyntaxKind.TypeAssertionExpression && shouldCheckErasableSyntax(c, node)) {
     const file = getSourceFileOfNode(node);
@@ -1750,8 +1783,10 @@ function checkAssertion(c: Checker, node: Node, checkMode: CheckMode): Type {
       ),
     );
   }
+  const exprType = checkExpressionEx(c, getExpression(node)!, checkMode);
+  // The type node is checked in every case, including the `const` of `x as const`.
+  checkTypeNodeIfPresent(c, getType(node));
   if (isConstTypeReference(getType(node)!)) {
-    const exprType = checkExpressionEx(c, getExpression(node)!, checkMode);
     if (!isValidConstAssertionArgument(c, getExpression(node)!))
       c.error(
         getExpression(node)!,
@@ -1759,10 +1794,8 @@ function checkAssertion(c: Checker, node: Node, checkMode: CheckMode): Type {
       );
     return getRegularTypeOfLiteralType(c, exprType);
   }
-  const exprType = checkExpressionEx(c, getExpression(node)!, checkMode);
   // The operand is compared with the asserted type once, after the last check of the operand.
   c.nodeLinks(node).assertionExpressionType = exprType;
-  checkTypeNodeIfPresent(c, getType(node));
   checkNodeDeferred(c, node);
   return getTypeFromTypeNode(c, getType(node)!);
 }

package/src/compiler/checker-functions.ts

@@ -54,6 +54,7 @@ import {
   reportErrorsFromWidening,
   reportImplicitAny,
   WideningKind,
+  getWidenedTypeForVariableLikeDeclaration,
 } from './checker-symbol-types.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
 import {
@@ -105,7 +106,12 @@ import {
   getInferenceContext,
   instantiateContextualType,
 } from './checker-contextual.js';
-import { checkJSDocFullSignature, checkUnmatchedJSDocParameters, getFullSignatureTypeNode } from './checker-jsdoc.js';
+import {
+  checkJSDocFullSignature,
+  checkJSDocFullSignatureType,
+  checkUnmatchedJSDocParameters,
+  getFullSignatureTypeNode,
+} from './checker-jsdoc.js';
 import { getEffectiveCheckNode, isFunctionLike, nodeIsMissing } from './ast-utilities.js';
 import {
   getFlowTypeOfReferenceAt,
@@ -144,6 +150,7 @@ import {
 
 export function checkFunctionExpressionOrObjectLiteralMethod(c: Checker, node: Node, checkMode: CheckMode): Type {
   checkNodeDeferred(c, node);
+  checkJSDocFullSignatureType(c, node);
   if (node.kind === SyntaxKind.FunctionExpression) checkCollisionsForDeclarationName(c, node, getName(node));
   if (node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor) return c.anyType;
   if ((checkMode & CheckMode.SkipContextSensitive) !== 0 && isContextSensitive(c, node)) {
@@ -238,7 +245,8 @@ function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(c: Checker, no
     getType(node) === undefined &&
     resolvedReturnTypeOf(c, signature) === undefined
   ) {
-    const returnType = getReturnTypeFromBodyEx(c, node, checkMode);
+    // The resolved return type is cached, so it is computed without SkipContextSensitive to keep anyFunctionType out of it.
+    const returnType = getReturnTypeFromBodyEx(c, node, checkMode & ~CheckMode.SkipContextSensitive);
     if (resolvedReturnTypeOf(c, signature) === undefined) signatureSideOf(c, signature).resolvedReturnType = returnType;
   }
   checkFunctionLikeSignature(c, node);
@@ -328,7 +336,12 @@ function assignParameterSymbolType(c: Checker, parameter: Symbol, contextualType
   if (c.symbolTypes.get(id) !== undefined) return;
   const declaration = parameter.valueDeclaration;
   if (contextualType === undefined) {
-    c.symbolTypes.set(id, getTypeOfSymbol(c, parameter));
+    c.symbolTypes.set(
+      id,
+      declaration !== undefined
+        ? getWidenedTypeForVariableLikeDeclaration(c, declaration, true)
+        : getTypeOfSymbol(c, parameter),
+    );
     return;
   }
   c.symbolTypes.set(
@@ -574,6 +587,9 @@ export function checkAwaitExpression(c: Checker, node: Node): Type {
 export function checkYieldExpression(c: Checker, node: Node): Type {
   checkGrammarYieldOfExpression(c, node);
   const yieldExpr = node as YieldExpression;
+  // The operand is checked also outside a generator.
+  const operand = yieldExpr.expression;
+  const yieldExpressionType = operand !== undefined ? checkExpression(c, operand) : c.undefinedWideningType;
   const func = getContainingFunctionLike(node);
   if (func === undefined) return c.anyType;
   const functionFlags = getFunctionFlags(func);
@@ -593,8 +609,6 @@ export function checkYieldExpression(c: Checker, node: Node): Type {
     returnType !== undefined ? getIterationTypesOfGeneratorFunctionReturnType(c, returnType, isAsync) : undefined;
   const signatureYieldType = iterationTypes?.yieldType ?? c.anyType;
   const signatureNextType = iterationTypes?.nextType ?? c.anyType;
-  const operand = yieldExpr.expression;
-  const yieldExpressionType = operand !== undefined ? checkExpression(c, operand) : c.undefinedWideningType;
   const yieldedType = getYieldedTypeOfYieldExpression(c, yieldExpr, yieldExpressionType, signatureNextType, isAsync);
   if (returnType !== undefined && yieldedType !== undefined)
     checkTypeAssignableToAndOptionallyElaborate(c, yieldedType, signatureYieldType, operand ?? node, operand);
@@ -1266,7 +1280,8 @@ function assignParameterType(c: Checker, declaration: Node): void {
   if (symbol === undefined) return;
   const id = getSymbolId(symbol);
   if (c.symbolTypes.get(id) !== undefined) return;
-  const t = getTypeOfSymbol(c, symbol);
+  // Without a context, the parameter's own type, reporting its implicit any errors.
+  const t = getWidenedTypeForVariableLikeDeclaration(c, declaration, true);
   c.symbolTypes.set(
     id,
     addOptionality(c, t, false, getInitializer(declaration) === undefined && isOptionalDeclaration(declaration)),

package/src/compiler/checker-generated-code.ts

@@ -20,15 +20,6 @@ import { ModuleKind, ScriptTarget, getEmitModuleKind, getUseDefineForClassFields
 import { moduleKindName } from './program-utilities.js';
 import { SyntaxKind } from './syntax-kind.js';
 
-/** A collision check that waits until the file is checked, when the flags it reads are complete. */
-export class DeferredCollisionCheck {
-  constructor(
-    readonly node: Node,
-    /** `Reflect` rather than `WeakMap` and `WeakSet`. */
-    readonly reflect: boolean,
-  ) {}
-}
-
 /** An error that is not reported under noEmit, since it is about the emitted code. */
 export function errorSkippedOnNoEmit(
   c: Checker,
@@ -51,9 +42,9 @@ export function checkCollisionsForDeclarationName(c: Checker, node: Node, name:
     c.languageVersion <= ScriptTarget.ES2021 &&
     (needCollisionCheckForIdentifier(node, name, 'WeakMap') || needCollisionCheckForIdentifier(node, name, 'WeakSet'))
   )
-    c.deferredCollisionChecks.push(new DeferredCollisionCheck(node, false));
+    c.deferDiagnostic(node, () => checkWeakMapSetCollision(c, node));
   if (c.languageVersion <= ScriptTarget.ES2021 && needCollisionCheckForIdentifier(node, name, 'Reflect'))
-    c.deferredCollisionChecks.push(new DeferredCollisionCheck(node, true));
+    c.deferDiagnostic(node, () => checkReflectCollision(c, node));
   if (isClassLike(node) && (node.flags & NodeFlags.Ambient) === 0 && getText(name) === 'Object') {
     if (c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(name)) < ModuleKind.ES2015)
       c.error(
@@ -174,17 +165,6 @@ export function markSuperPropertyInStaticInitializer(c: Checker, node: Node): vo
       c.nodeLinks(scope).flags |= NodeCheckFlags.ContainsSuperPropertyInStaticInitializer;
 }
 
-/** Reports the `WeakMap`, `WeakSet` and `Reflect` collisions found while checking the file. */
-export function produceDeferredCollisionChecks(c: Checker): void {
-  const checks = c.deferredCollisionChecks;
-  if (checks.length === 0) return;
-  c.deferredCollisionChecks = [];
-  for (const check of checks) {
-    if (check.reflect) checkReflectCollision(c, check.node);
-    else checkWeakMapSetCollision(c, check.node);
-  }
-}
-
 function checkWeakMapSetCollision(c: Checker, node: Node): void {
   const scope = getEnclosingBlockScopeContainer(node);
   if (scope === undefined || (c.nodeLinks(scope).flags & NodeCheckFlags.ContainsClassWithPrivateIdentifiers) === 0)