typescript 5.4.0-dev.20231212 → 5.4.0-dev.20231214

package/lib/lib.es2016.intl.d.ts

@@ -27,5 +27,5 @@ declare namespace Intl {
      * @param locale A list of String values for which to get the canonical locale names
      * @returns An array containing the canonical and validated locale names.
      */
-    function getCanonicalLocales(locale?: string | string[]): string[];
+    function getCanonicalLocales(locale?: string | readonly string[]): string[];
 }

package/lib/lib.es2018.intl.d.ts

@@ -48,9 +48,9 @@ declare namespace Intl {
     }
 
     interface PluralRulesConstructor {
-        new (locales?: string | string[], options?: PluralRulesOptions): PluralRules;
-        (locales?: string | string[], options?: PluralRulesOptions): PluralRules;
-        supportedLocalesOf(locales: string | string[], options?: { localeMatcher?: "lookup" | "best fit"; }): string[];
+        new (locales?: string | readonly string[], options?: PluralRulesOptions): PluralRules;
+        (locales?: string | readonly string[], options?: PluralRulesOptions): PluralRules;
+        supportedLocalesOf(locales: string | readonly string[], options?: { localeMatcher?: "lookup" | "best fit"; }): string[];
     }
 
     const PluralRules: PluralRulesConstructor;

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231212`;
+var version = `${versionMajorMinor}.0-dev.20231214`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6672,6 +6672,7 @@ var Diagnostics = {
   A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values: diag(2863, 1 /* Error */, "A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values_2863", "A class cannot extend a primitive type like '{0}'. Classes can only extend constructable values."),
   A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types: diag(2864, 1 /* Error */, "A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types_2864", "A class cannot implement a primitive type like '{0}'. It can only implement other named object types."),
   Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled: diag(2865, 1 /* Error */, "Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_2865", "Import '{0}' conflicts with local value, so must be declared with a type-only import when 'isolatedModules' is enabled."),
+  Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled: diag(2866, 1 /* Error */, "Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_w_2866", "Import '{0}' conflicts with global value used in this file, so must be declared with a type-only import when 'isolatedModules' is enabled."),
   Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
   Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
   Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -45345,6 +45346,7 @@ function createTypeChecker(host) {
     }
     if (nameNotFoundMessage) {
       addLazyDiagnostic(() => {
+        var _a2;
         if (errorLocation && (meaning & 2 /* BlockScopedVariable */ || (meaning & 32 /* Class */ || meaning & 384 /* Enum */) && (meaning & 111551 /* Value */) === 111551 /* Value */)) {
           const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
           if (exportOrLocalSymbol.flags & 2 /* BlockScopedVariable */ || exportOrLocalSymbol.flags & 32 /* Class */ || exportOrLocalSymbol.flags & 384 /* Enum */) {
@@ -45378,6 +45380,16 @@ function createTypeChecker(host) {
             );
           }
         }
+        if (compilerOptions.isolatedModules && result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */) {
+          const isGlobal = lookup(globals, name, meaning) === result;
+          const nonValueSymbol = isGlobal && isSourceFile(lastLocation) && lastLocation.locals && lookup(lastLocation.locals, name, ~111551 /* Value */);
+          if (nonValueSymbol) {
+            const importDecl = (_a2 = nonValueSymbol.declarations) == null ? void 0 : _a2.find((d) => d.kind === 276 /* ImportSpecifier */ || d.kind === 273 /* ImportClause */ || d.kind === 274 /* NamespaceImport */ || d.kind === 271 /* ImportEqualsDeclaration */);
+            if (importDecl && !isTypeOnlyImportDeclaration(importDecl)) {
+              error(importDecl, Diagnostics.Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled, unescapeLeadingUnderscores(name));
+            }
+          }
+        }
       });
     }
     return result;
@@ -47707,12 +47719,16 @@ function createTypeChecker(host) {
   }
   function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) {
     let aliasesToMakeVisible;
+    let bindingElementToMakeVisible;
     if (!every(filter(symbol.declarations, (d) => d.kind !== 80 /* Identifier */), getIsDeclarationVisible)) {
       return void 0;
     }
-    return { accessibility: 0 /* Accessible */, aliasesToMakeVisible };
+    return { accessibility: 0 /* Accessible */, aliasesToMakeVisible, bindingElementToMakeVisible };
     function getIsDeclarationVisible(declaration) {
       var _a, _b;
+      if (isBindingElement(declaration) && findAncestor(declaration, isParameter)) {
+        bindingElementToMakeVisible = declaration;
+      }
       if (!isDeclarationVisible(declaration)) {
         const anyImportSyntax = getAnyImportSyntax(declaration);
         if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 32 /* Export */) && // import clause without export
@@ -68960,7 +68976,7 @@ function createTypeChecker(host) {
       /*contextFlags*/
       void 0
     );
-    const inTupleContext = isSpreadIntoCallOrNew(node) || !!contextualType && someType(contextualType, isTupleLikeType);
+    const inTupleContext = isSpreadIntoCallOrNew(node) || !!contextualType && someType(contextualType, (t) => isTupleLikeType(t) || isGenericMappedType(t) && !t.nameType && !!getHomomorphicTypeVariable(t.target || t));
     let hasOmittedExpression = false;
     for (let i = 0; i < elementCount; i++) {
       const e = elements[i];
@@ -107964,6 +107980,7 @@ function transformDeclarations(context) {
   let lateStatementReplacementMap;
   let suppressNewDiagnosticContexts;
   let exportedModulesFromDeclarationEmit;
+  const usedBindingElementAliases = /* @__PURE__ */ new Map();
   const { factory: factory2 } = context;
   const host = context.getEmitHost();
   const symbolTracker = {
@@ -108020,7 +108037,7 @@ function transformDeclarations(context) {
   }
   function handleSymbolAccessibilityError(symbolAccessibilityResult) {
     if (symbolAccessibilityResult.accessibility === 0 /* Accessible */) {
-      if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) {
+      if (symbolAccessibilityResult.aliasesToMakeVisible) {
         if (!lateMarkedStatements) {
           lateMarkedStatements = symbolAccessibilityResult.aliasesToMakeVisible;
         } else {
@@ -108029,6 +108046,17 @@ function transformDeclarations(context) {
           }
         }
       }
+      if (symbolAccessibilityResult.bindingElementToMakeVisible) {
+        const bindingElement = symbolAccessibilityResult.bindingElementToMakeVisible;
+        const parameter = findAncestor(bindingElement, isParameter);
+        Debug.assert(parameter !== void 0);
+        const parent = getOriginalNode(parameter.parent);
+        let aliases = usedBindingElementAliases.get(parent);
+        if (!aliases) {
+          usedBindingElementAliases.set(parent, aliases = /* @__PURE__ */ new Map());
+        }
+        aliases.set(getOriginalNode(bindingElement), bindingElement.name);
+      }
     } else {
       const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
       if (errorInfo) {
@@ -108378,7 +108406,7 @@ function transformDeclarations(context) {
       if (elem.propertyName && isComputedPropertyName(elem.propertyName) && isEntityNameExpression(elem.propertyName.expression)) {
         checkEntityNameVisibility(elem.propertyName.expression, enclosingDeclaration);
       }
-      if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !elem.symbol.isReferenced && !isIdentifierANonContextualKeyword(elem.propertyName)) {
+      if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !isIdentifierANonContextualKeyword(elem.propertyName)) {
         return factory2.updateBindingElement(
           elem,
           elem.dotDotDotToken,
@@ -108397,6 +108425,161 @@ function transformDeclarations(context) {
       );
     }
   }
+  function ensureBindingAliasesInParameterList(input, updatedNode) {
+    const original = getOriginalNode(input);
+    const params = updatedNode.parameters;
+    const aliases = usedBindingElementAliases.get(original);
+    if (!aliases) {
+      return updatedNode;
+    }
+    usedBindingElementAliases.delete(original);
+    const newParams = map(params, addUsedBindingPatternsToParameter);
+    const newParamsNodeArray = factory2.createNodeArray(newParams, params.hasTrailingComma);
+    switch (updatedNode.kind) {
+      case 174 /* MethodDeclaration */:
+        return factory2.updateMethodDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.asteriskToken,
+          updatedNode.name,
+          updatedNode.questionToken,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type,
+          updatedNode.body
+        );
+      case 176 /* Constructor */:
+        return factory2.updateConstructorDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          newParamsNodeArray,
+          updatedNode.body
+        );
+      case 177 /* GetAccessor */:
+        return factory2.updateGetAccessorDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.name,
+          newParamsNodeArray,
+          updatedNode.type,
+          updatedNode.body
+        );
+      case 178 /* SetAccessor */:
+        return factory2.updateSetAccessorDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.name,
+          newParamsNodeArray,
+          updatedNode.body
+        );
+      case 219 /* ArrowFunction */:
+        return factory2.updateArrowFunction(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type,
+          updatedNode.equalsGreaterThanToken,
+          updatedNode.body
+        );
+      case 262 /* FunctionDeclaration */:
+        return factory2.updateFunctionDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.asteriskToken,
+          updatedNode.name,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type,
+          updatedNode.body
+        );
+      case 179 /* CallSignature */:
+        return factory2.updateCallSignature(
+          updatedNode,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      case 173 /* MethodSignature */:
+        return factory2.updateMethodSignature(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.name,
+          updatedNode.questionToken,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      case 180 /* ConstructSignature */:
+        return factory2.updateConstructSignature(
+          updatedNode,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      case 184 /* FunctionType */:
+        return factory2.updateFunctionTypeNode(
+          updatedNode,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      case 185 /* ConstructorType */:
+        return factory2.updateConstructorTypeNode(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      default:
+        Debug.assertNever(updatedNode);
+    }
+    function addUsedBindingPatternsToParameter(p) {
+      return factory2.updateParameterDeclaration(
+        p,
+        p.modifiers,
+        p.dotDotDotToken,
+        addUsedBindingPatternAliases(p.name),
+        p.questionToken,
+        p.type,
+        p.initializer
+      );
+    }
+    function addUsedBindingPatternAliases(name) {
+      if (name.kind === 80 /* Identifier */) {
+        return name;
+      } else {
+        if (name.kind === 207 /* ArrayBindingPattern */) {
+          return factory2.updateArrayBindingPattern(name, visitNodes2(name.elements, visitBindingElement, isArrayBindingElement));
+        } else {
+          return factory2.updateObjectBindingPattern(name, visitNodes2(name.elements, visitBindingElement, isBindingElement));
+        }
+      }
+      function visitBindingElement(elem) {
+        if (elem.kind === 232 /* OmittedExpression */) {
+          return elem;
+        }
+        const usedAlias = aliases.get(getOriginalNode(elem));
+        if (usedAlias && !elem.propertyName) {
+          return factory2.updateBindingElement(
+            elem,
+            elem.dotDotDotToken,
+            elem.name,
+            usedAlias,
+            elem.initializer
+          );
+        }
+        return factory2.updateBindingElement(
+          elem,
+          elem.dotDotDotToken,
+          elem.propertyName,
+          addUsedBindingPatternAliases(elem.name),
+          elem.initializer
+        );
+      }
+    }
+  }
   function ensureParameter(p, modifierMask, type) {
     let oldDiag;
     if (!suppressNewDiagnosticContexts) {
@@ -108783,19 +108966,25 @@ function transformDeclarations(context) {
           return cleanup(factory2.updateTypeReferenceNode(node, node.typeName, node.typeArguments));
         }
         case 180 /* ConstructSignature */:
-          return cleanup(factory2.updateConstructSignature(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureTypeParams(input, input.typeParameters),
-            updateParamsList(input, input.parameters),
-            ensureType(input, input.type)
+            factory2.updateConstructSignature(
+              input,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type)
+            )
           ));
         case 176 /* Constructor */: {
-          const ctor = factory2.createConstructorDeclaration(
-            /*modifiers*/
-            ensureModifiers(input),
-            updateParamsList(input, input.parameters, 0 /* None */),
-            /*body*/
-            void 0
+          const ctor = ensureBindingAliasesInParameterList(
+            input,
+            factory2.createConstructorDeclaration(
+              /*modifiers*/
+              ensureModifiers(input),
+              updateParamsList(input, input.parameters, 0 /* None */),
+              /*body*/
+              void 0
+            )
           );
           return cleanup(ctor);
         }
@@ -108806,17 +108995,20 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          const sig = factory2.createMethodDeclaration(
-            ensureModifiers(input),
-            /*asteriskToken*/
-            void 0,
-            input.name,
-            input.questionToken,
-            ensureTypeParams(input, input.typeParameters),
-            updateParamsList(input, input.parameters),
-            ensureType(input, input.type),
-            /*body*/
-            void 0
+          const sig = ensureBindingAliasesInParameterList(
+            input,
+            factory2.createMethodDeclaration(
+              ensureModifiers(input),
+              /*asteriskToken*/
+              void 0,
+              input.name,
+              input.questionToken,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type),
+              /*body*/
+              void 0
+            )
           );
           return cleanup(sig);
         }
@@ -108828,14 +109020,17 @@ function transformDeclarations(context) {
             );
           }
           const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
-          return cleanup(factory2.updateGetAccessorDeclaration(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureModifiers(input),
-            input.name,
-            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
-            ensureType(input, accessorType),
-            /*body*/
-            void 0
+            factory2.updateGetAccessorDeclaration(
+              input,
+              ensureModifiers(input),
+              input.name,
+              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
+              ensureType(input, accessorType),
+              /*body*/
+              void 0
+            )
           ));
         }
         case 178 /* SetAccessor */: {
@@ -108845,13 +109040,16 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          return cleanup(factory2.updateSetAccessorDeclaration(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureModifiers(input),
-            input.name,
-            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
-            /*body*/
-            void 0
+            factory2.updateSetAccessorDeclaration(
+              input,
+              ensureModifiers(input),
+              input.name,
+              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
+              /*body*/
+              void 0
+            )
           ));
         }
         case 172 /* PropertyDeclaration */:
@@ -108890,22 +109088,28 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          return cleanup(factory2.updateMethodSignature(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureModifiers(input),
-            input.name,
-            input.questionToken,
-            ensureTypeParams(input, input.typeParameters),
-            updateParamsList(input, input.parameters),
-            ensureType(input, input.type)
+            factory2.updateMethodSignature(
+              input,
+              ensureModifiers(input),
+              input.name,
+              input.questionToken,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type)
+            )
           ));
         }
         case 179 /* CallSignature */: {
-          return cleanup(factory2.updateCallSignature(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureTypeParams(input, input.typeParameters),
-            updateParamsList(input, input.parameters),
-            ensureType(input, input.type)
+            factory2.updateCallSignature(
+              input,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type)
+            )
           ));
         }
         case 181 /* IndexSignature */: {
@@ -108960,10 +109164,27 @@ function transformDeclarations(context) {
           return cleanup(factory2.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
         }
         case 184 /* FunctionType */: {
-          return cleanup(factory2.updateFunctionTypeNode(input, visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration), updateParamsList(input, input.parameters), Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))));
+          return cleanup(ensureBindingAliasesInParameterList(
+            input,
+            factory2.updateFunctionTypeNode(
+              input,
+              visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+              updateParamsList(input, input.parameters),
+              Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
+            )
+          ));
         }
         case 185 /* ConstructorType */: {
-          return cleanup(factory2.updateConstructorTypeNode(input, ensureModifiers(input), visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration), updateParamsList(input, input.parameters), Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))));
+          return cleanup(ensureBindingAliasesInParameterList(
+            input,
+            factory2.updateConstructorTypeNode(
+              input,
+              ensureModifiers(input),
+              visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+              updateParamsList(input, input.parameters),
+              Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
+            )
+          ));
         }
         case 205 /* ImportType */: {
           if (!isLiteralImportTypeNode(input))
@@ -109148,17 +109369,20 @@ function transformDeclarations(context) {
         ));
       }
       case 262 /* FunctionDeclaration */: {
-        const clean2 = cleanup(factory2.updateFunctionDeclaration(
+        const clean2 = cleanup(ensureBindingAliasesInParameterList(
           input,
-          ensureModifiers(input),
-          /*asteriskToken*/
-          void 0,
-          input.name,
-          ensureTypeParams(input, input.typeParameters),
-          updateParamsList(input, input.parameters),
-          ensureType(input, input.type),
-          /*body*/
-          void 0
+          factory2.updateFunctionDeclaration(
+            input,
+            ensureModifiers(input),
+            /*asteriskToken*/
+            void 0,
+            input.name,
+            ensureTypeParams(input, input.typeParameters),
+            updateParamsList(input, input.parameters),
+            ensureType(input, input.type),
+            /*body*/
+            void 0
+          )
         ));
         if (clean2 && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) {
           const props = resolver.getPropertiesOfContainerFunction(input);