typescript 5.0.0-dev.20230111 → 5.0.0-dev.20230112

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230111`;
+var version = `${versionMajorMinor}.0-dev.20230112`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -8404,7 +8404,8 @@ function isIdentifierStart(ch, languageVersion) {
   return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
 }
 function isIdentifierPart(ch, languageVersion, identifierVariant) {
-  return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
+  return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || // "-" and ":" are valid in JSX Identifiers
+  (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
 }
 function isIdentifierText(name, languageVersion, identifierVariant) {
   let ch = codePointAt(name, 0);
@@ -34297,7 +34298,8 @@ function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue,
         if (returnValue) {
           result[keyText] = value;
         }
-        if (jsonConversionNotifier && (parentOption || isRootOptionMap(knownOptions))) {
+        if (jsonConversionNotifier && // Current callbacks are only on known parent option or if we are setting values in the root
+        (parentOption || isRootOptionMap(knownOptions))) {
           const isValidOptionValue = isCompilerOptionsValue(option, value);
           if (parentOption) {
             if (isValidOptionValue) {
@@ -40575,8 +40577,12 @@ function createBinder() {
       return false;
     }
     if (currentFlow === unreachableFlow) {
-      const reportError = isStatementButNotDeclaration(node) && node.kind !== 239 /* EmptyStatement */ || // report error on class declarations
-      node.kind === 260 /* ClassDeclaration */ || node.kind === 264 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node);
+      const reportError = (
+        // report error on all statements except empty ones
+        isStatementButNotDeclaration(node) && node.kind !== 239 /* EmptyStatement */ || // report error on class declarations
+        node.kind === 260 /* ClassDeclaration */ || // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
+        node.kind === 264 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node)
+      );
       if (reportError) {
         currentFlow = reportedUnreachableFlow;
         if (!options.allowUnreachableCode) {
@@ -46382,7 +46388,8 @@ function createTypeChecker(host) {
           const isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) && (symbol.parent || // is exported function symbol
           forEach(symbol.declarations, (declaration) => declaration.parent.kind === 308 /* SourceFile */ || declaration.parent.kind === 265 /* ModuleBlock */));
           if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
-            return (!!(context.flags & 4096 /* UseTypeOfFunction */) || ((_a4 = context.visitedTypes) == null ? void 0 : _a4.has(typeId))) && (!(context.flags & 8 /* UseStructuralFallback */) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
+            return (!!(context.flags & 4096 /* UseTypeOfFunction */) || ((_a4 = context.visitedTypes) == null ? void 0 : _a4.has(typeId))) && // it is type of the symbol uses itself recursively
+            (!(context.flags & 8 /* UseStructuralFallback */) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
           }
         }
       }
@@ -46474,7 +46481,9 @@ function createTypeChecker(host) {
         const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
         if (some(abstractSignatures)) {
           const types = map(abstractSignatures, getOrCreateTypeFromSignature);
-          const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
+          const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per
+          // the logic in `createTypeNodesFromResolvedType`.
+          (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
           if (typeElementCount) {
             types.push(getResolvedTypeWithoutAbstractConstructSignatures(resolved));
           }
@@ -47136,9 +47145,11 @@ function createTypeChecker(host) {
         if (accessibleSymbolChain) {
           return accessibleSymbolChain;
         }
-        if (// If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols.
-        endOfChain || // If a parent symbol is an anonymous type, don't write it.
-        !(symbol2.flags & (2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */))) {
+        if (
+          // If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols.
+          endOfChain || // If a parent symbol is an anonymous type, don't write it.
+          !(symbol2.flags & (2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */))
+        ) {
           if (!endOfChain && !yieldModuleSymbol && !!forEach(symbol2.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
             return;
           }
@@ -47760,7 +47771,8 @@ function createTypeChecker(host) {
         }
         if (isLiteralImportTypeNode(node)) {
           const nodeSymbol = getNodeLinks(node).resolvedSymbol;
-          if (isInJSDoc(node) && nodeSymbol && (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
+          if (isInJSDoc(node) && nodeSymbol && // The import type resolved using jsdoc fallback logic
+          (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
           !(length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) {
             return setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
           }
@@ -49277,8 +49289,10 @@ function createTypeChecker(host) {
     }
   }
   function getNameOfSymbolAsWritten(symbol, context) {
-    if (context && symbol.escapedName === "default" /* Default */ && !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */) && (!(context.flags & 16777216 /* InInitialEntityName */) || // if the symbol is synthesized, it will only be referenced externally it must print as `default`
-    !symbol.declarations || context.enclosingDeclaration && findAncestor(symbol.declarations[0], isDefaultBindingContext) !== findAncestor(context.enclosingDeclaration, isDefaultBindingContext))) {
+    if (context && symbol.escapedName === "default" /* Default */ && !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */) && // If it's not the first part of an entity name, it must print as `default`
+    (!(context.flags & 16777216 /* InInitialEntityName */) || // if the symbol is synthesized, it will only be referenced externally it must print as `default`
+    !symbol.declarations || // if not in the same binding context (source file, module declaration), it must print as `default`
+    context.enclosingDeclaration && findAncestor(symbol.declarations[0], isDefaultBindingContext) !== findAncestor(context.enclosingDeclaration, isDefaultBindingContext))) {
       return "default";
     }
     if (symbol.declarations && symbol.declarations.length) {
@@ -50605,7 +50619,10 @@ function createTypeChecker(host) {
   function getWriteTypeOfSymbol(symbol) {
     const checkFlags = getCheckFlags(symbol);
     if (symbol.flags & 4 /* Property */) {
-      return checkFlags & 2 /* SyntheticProperty */ ? checkFlags & 65536 /* DeferredType */ ? getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) : symbol.links.writeType || symbol.links.type : getTypeOfSymbol(symbol);
+      return checkFlags & 2 /* SyntheticProperty */ ? checkFlags & 65536 /* DeferredType */ ? getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) : (
+        // NOTE: cast to TransientSymbol should be safe because only TransientSymbols can have CheckFlags.SyntheticProperty
+        symbol.links.writeType || symbol.links.type
+      ) : getTypeOfSymbol(symbol);
     }
     if (symbol.flags & 98304 /* Accessor */) {
       return checkFlags & 1 /* Instantiated */ ? getWriteTypeOfInstantiatedSymbol(symbol) : getWriteTypeOfAccessors(symbol);
@@ -59022,7 +59039,11 @@ function createTypeChecker(host) {
         if (variances === emptyArray) {
           return 1 /* Unknown */;
         }
-        const varianceResult = relateVariances(source2.aliasTypeArguments, target2.aliasTypeArguments, variances, intersectionState);
+        const params = getSymbolLinks(source2.aliasSymbol).typeParameters;
+        const minParams = getMinTypeArgumentCount(params);
+        const sourceTypes = fillMissingTypeArguments(source2.aliasTypeArguments, params, minParams, isInJSFile(source2.aliasSymbol.valueDeclaration));
+        const targetTypes = fillMissingTypeArguments(target2.aliasTypeArguments, params, minParams, isInJSFile(source2.aliasSymbol.valueDeclaration));
+        const varianceResult = relateVariances(sourceTypes, targetTypes, variances, intersectionState);
         if (varianceResult !== void 0) {
           return varianceResult;
         }
@@ -61479,7 +61500,11 @@ function createTypeChecker(host) {
       }
       if (source.aliasSymbol && source.aliasSymbol === target.aliasSymbol) {
         if (source.aliasTypeArguments) {
-          inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
+          const params = getSymbolLinks(source.aliasSymbol).typeParameters;
+          const minParams = getMinTypeArgumentCount(params);
+          const sourceTypes = fillMissingTypeArguments(source.aliasTypeArguments, params, minParams, isInJSFile(source.aliasSymbol.valueDeclaration));
+          const targetTypes = fillMissingTypeArguments(target.aliasTypeArguments, params, minParams, isInJSFile(source.aliasSymbol.valueDeclaration));
+          inferFromTypeArguments(sourceTypes, targetTypes, getAliasVariances(source.aliasSymbol));
         }
         return;
       }
@@ -63886,18 +63911,20 @@ function createTypeChecker(host) {
       return narrowTypeByTypeFacts(type, nonPrimitiveType, 128 /* TypeofEQHostObject */);
     }
     function narrowTypeByTypeFacts(type, impliedType, facts) {
-      return mapType(type, (t) => // We first check if a constituent is a subtype of the implied type. If so, we either keep or eliminate
-      // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
-      // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
-      // but are classified as "function" according to `typeof`.
-      isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : (
-        // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
-        // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
-        isTypeSubtypeOf(impliedType, t) ? impliedType : (
-          // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
-          // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
-          // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
-          getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType
+      return mapType(type, (t) => (
+        // We first check if a constituent is a subtype of the implied type. If so, we either keep or eliminate
+        // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
+        // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
+        // but are classified as "function" according to `typeof`.
+        isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : (
+          // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
+          // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
+          isTypeSubtypeOf(impliedType, t) ? impliedType : (
+            // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
+            // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
+            // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
+            getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType
+          )
         )
       ));
     }
@@ -71468,7 +71495,8 @@ function createTypeChecker(host) {
       }
     }
     function isIndirectCall(node) {
-      return node.parent.kind === 214 /* ParenthesizedExpression */ && isNumericLiteral(node.left) && node.left.text === "0" && (isCallExpression(node.parent.parent) && node.parent.parent.expression === node.parent || node.parent.parent.kind === 212 /* TaggedTemplateExpression */) && (isAccessExpression(node.right) || isIdentifier(node.right) && node.right.escapedText === "eval");
+      return node.parent.kind === 214 /* ParenthesizedExpression */ && isNumericLiteral(node.left) && node.left.text === "0" && (isCallExpression(node.parent.parent) && node.parent.parent.expression === node.parent || node.parent.parent.kind === 212 /* TaggedTemplateExpression */) && // special-case for "eval" because it's the only non-access case where an indirect call actually affects behavior.
+      (isAccessExpression(node.right) || isIdentifier(node.right) && node.right.escapedText === "eval");
     }
     function checkForDisallowedESSymbolOperand(operator2) {
       const offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 12288 /* ESSymbolLike */) ? left : maybeTypeOfKindConsideringBaseConstraint(rightType, 12288 /* ESSymbolLike */) ? right : void 0;
@@ -78553,7 +78581,12 @@ function createTypeChecker(host) {
         return false;
       const symbol = getSymbolOfDeclaration(node);
       const signaturesOfSymbol = getSignaturesOfSymbol(symbol);
-      return signaturesOfSymbol.length > 1 || signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node;
+      return signaturesOfSymbol.length > 1 || // If there is single signature for the symbol, it is overload if that signature isn't coming from the node
+      // e.g.: function foo(a: string): string;
+      //       function foo(a: any) { // This is implementation of the overloads
+      //           return a;
+      //       }
+      signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node;
     }
     return false;
   }
@@ -108966,7 +108999,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     const oldSourceFiles = oldProgram.getSourceFiles();
     for (const oldSourceFile of oldSourceFiles) {
       const newFile = getSourceFileByPath(oldSourceFile.resolvedPath);
-      if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat || oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path) {
+      if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat || // old file wasn't redirect but new file is
+      oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path) {
         host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));
       }
     }
@@ -113662,7 +113696,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       const name = loader.nameAndMode.getName(entry);
       const mode = loader.nameAndMode.getMode(entry, containingSourceFile);
       let resolution = resolutionsInFile.get(name, mode);
-      if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
+      if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || // If the name is unresolved import that was invalidated, recalculate
+      hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
         const existingResolution = resolution;
         resolution = loader.resolve(name, mode);
         if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {