typescript 5.6.0-dev.20240719 → 5.6.0-dev.20240721

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240719`;
+var version = `${versionMajorMinor}.0-dev.20240721`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6124,6 +6124,7 @@ var Diagnostics = {
   Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended_as_an_escape_sequence_use_the_syntax_0_instead: diag(1536, 1 /* Error */, "Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended__1536", "Octal escape sequences and backreferences are not allowed in a character class. If this was intended as an escape sequence, use the syntax '{0}' instead."),
   Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class: diag(1537, 1 /* Error */, "Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_1537", "Decimal escape sequences and backreferences are not allowed in a character class."),
   Unicode_escape_sequences_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set: diag(1538, 1 /* Error */, "Unicode_escape_sequences_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_se_1538", "Unicode escape sequences are only available when the Unicode (u) flag or the Unicode Sets (v) flag is set."),
+  A_bigint_literal_cannot_be_used_as_a_property_name: diag(1539, 1 /* Error */, "A_bigint_literal_cannot_be_used_as_a_property_name_1539", "A 'bigint' literal cannot be used as a property name."),
   The_types_of_0_are_incompatible_between_these_types: diag(2200, 1 /* Error */, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
   The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, 1 /* Error */, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
   Call_signature_return_types_0_and_1_are_incompatible: diag(
@@ -7365,9 +7366,11 @@ var Diagnostics = {
   Require_undeclared_properties_from_index_signatures_to_use_element_accesses: diag(6717, 3 /* Message */, "Require_undeclared_properties_from_index_signatures_to_use_element_accesses_6717", "Require undeclared properties from index signatures to use element accesses."),
   Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, 3 /* Message */, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."),
   Require_sufficient_annotation_on_exports_so_other_tools_can_trivially_generate_declaration_files: diag(6719, 3 /* Message */, "Require_sufficient_annotation_on_exports_so_other_tools_can_trivially_generate_declaration_files_6719", "Require sufficient annotation on exports so other tools can trivially generate declaration files."),
+  Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any: diag(6720, 3 /* Message */, "Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any_6720", "Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'."),
   Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, 3 /* Message */, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."),
   Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting: diag(6804, 3 /* Message */, "Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_i_6804", "Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting."),
   Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported: diag(6805, 3 /* Message */, "Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported_6805", "Disable full type checking (only critical parse and emit errors will be reported)."),
+  Check_side_effect_imports: diag(6806, 3 /* Message */, "Check_side_effect_imports_6806", "Check side effect imports."),
   one_of_Colon: diag(6900, 3 /* Message */, "one_of_Colon_6900", "one of:"),
   one_or_more_Colon: diag(6901, 3 /* Message */, "one_or_more_Colon_6901", "one or more:"),
   type_Colon: diag(6902, 3 /* Message */, "type_Colon_6902", "type:"),
@@ -13532,6 +13535,7 @@ function tryGetTextOfPropertyName(name) {
       return ((_a = name.emitNode) == null ? void 0 : _a.autoGenerate) ? void 0 : name.escapedText;
     case 11 /* StringLiteral */:
     case 9 /* NumericLiteral */:
+    case 10 /* BigIntLiteral */:
     case 15 /* NoSubstitutionTemplateLiteral */:
       return escapeLeadingUnderscores(name.text);
     case 167 /* ComputedPropertyName */:
@@ -15496,6 +15500,7 @@ function getPropertyNameForPropertyNameNode(name) {
     case 11 /* StringLiteral */:
     case 15 /* NoSubstitutionTemplateLiteral */:
     case 9 /* NumericLiteral */:
+    case 10 /* BigIntLiteral */:
       return escapeLeadingUnderscores(name.text);
     case 167 /* ComputedPropertyName */:
       const nameExpression = name.expression;
@@ -17795,6 +17800,12 @@ var computedOptions = createComputedCompilerOptions({
       return getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
     }
   },
+  strictBuiltinIteratorReturn: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictBuiltinIteratorReturn");
+    }
+  },
   alwaysStrict: {
     dependencies: ["strict"],
     computeValue: (compilerOptions) => {
@@ -19467,6 +19478,10 @@ function hasInferredType(node) {
       return false;
   }
 }
+function isSideEffectImport(node) {
+  const ancestor = findAncestor(node, isImportDeclaration);
+  return !!ancestor && !ancestor.importClause;
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -29055,13 +29070,13 @@ var Parser;
     return createIdentifier(tokenIsIdentifierOrKeyword(token()));
   }
   function isLiteralPropertyName() {
-    return tokenIsIdentifierOrKeyword(token()) || token() === 11 /* StringLiteral */ || token() === 9 /* NumericLiteral */;
+    return tokenIsIdentifierOrKeyword(token()) || token() === 11 /* StringLiteral */ || token() === 9 /* NumericLiteral */ || token() === 10 /* BigIntLiteral */;
   }
   function isImportAttributeName2() {
     return tokenIsIdentifierOrKeyword(token()) || token() === 11 /* StringLiteral */;
   }
   function parsePropertyNameWorker(allowComputedPropertyNames) {
-    if (token() === 11 /* StringLiteral */ || token() === 9 /* NumericLiteral */) {
+    if (token() === 11 /* StringLiteral */ || token() === 9 /* NumericLiteral */ || token() === 10 /* BigIntLiteral */) {
       const node = parseLiteralNode();
       node.text = internIdentifier(node.text);
       return node;
@@ -33288,7 +33303,7 @@ var Parser;
     if (isIndexSignature()) {
       return parseIndexSignatureDeclaration(pos, hasJSDoc, modifiers);
     }
-    if (tokenIsIdentifierOrKeyword(token()) || token() === 11 /* StringLiteral */ || token() === 9 /* NumericLiteral */ || token() === 42 /* AsteriskToken */ || token() === 23 /* OpenBracketToken */) {
+    if (tokenIsIdentifierOrKeyword(token()) || token() === 11 /* StringLiteral */ || token() === 9 /* NumericLiteral */ || token() === 10 /* BigIntLiteral */ || token() === 42 /* AsteriskToken */ || token() === 23 /* OpenBracketToken */) {
       const isAmbient = some(modifiers, isDeclareModifier);
       if (isAmbient) {
         for (const m of modifiers) {
@@ -35604,6 +35619,7 @@ var libEntries = [
   ["esnext.array", "lib.esnext.array.d.ts"],
   ["esnext.regexp", "lib.esnext.regexp.d.ts"],
   ["esnext.string", "lib.esnext.string.d.ts"],
+  ["esnext.iterator", "lib.esnext.iterator.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -36255,6 +36271,16 @@ var commandOptionsWithoutBuild = [
     description: Diagnostics.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor,
     defaultValueDescription: Diagnostics.false_unless_strict_is_set
   },
+  {
+    name: "strictBuiltinIteratorReturn",
+    type: "boolean",
+    affectsSemanticDiagnostics: true,
+    affectsBuildInfo: true,
+    strictFlag: true,
+    category: Diagnostics.Type_Checking,
+    description: Diagnostics.Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any,
+    defaultValueDescription: Diagnostics.false_unless_strict_is_set
+  },
   {
     name: "noImplicitThis",
     type: "boolean",
@@ -36530,6 +36556,15 @@ var commandOptionsWithoutBuild = [
     category: Diagnostics.Modules,
     description: Diagnostics.Conditions_to_set_in_addition_to_the_resolver_specific_defaults_when_resolving_imports
   },
+  {
+    name: "noUncheckedSideEffectImports",
+    type: "boolean",
+    affectsSemanticDiagnostics: true,
+    affectsBuildInfo: true,
+    category: Diagnostics.Modules,
+    description: Diagnostics.Check_side_effect_imports,
+    defaultValueDescription: false
+  },
   // Source Maps
   {
     name: "sourceRoot",
@@ -45282,10 +45317,12 @@ function createTypeChecker(host) {
   var strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes");
   var strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply");
   var strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
+  var strictBuiltinIteratorReturn = getStrictOptionValue(compilerOptions, "strictBuiltinIteratorReturn");
   var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
   var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
   var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
   var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
+  var noUncheckedSideEffectImports = !!compilerOptions.noUncheckedSideEffectImports;
   var checkBinaryExpression = createCheckBinaryExpression();
   var emitResolver = createResolver();
   var nodeBuilder = createNodeBuilder();
@@ -45614,13 +45651,13 @@ function createTypeChecker(host) {
       /*reportErrors*/
       false
     ),
-    getAsyncIterableType: () => {
+    getAnyAsyncIterableType: () => {
       const type = getGlobalAsyncIterableType(
         /*reportErrors*/
         false
       );
       if (type === emptyGenericType) return void 0;
-      return type;
+      return createTypeReference(type, [anyType, anyType, anyType]);
     },
     isSymbolAccessible,
     isArrayType,
@@ -46092,8 +46129,6 @@ function createTypeChecker(host) {
     }
   };
   var anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
-  var anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
-  var defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType);
   var asyncIterationTypesResolver = {
     iterableCacheKey: "iterationTypesOfAsyncIterable",
     iteratorCacheKey: "iterationTypesOfAsyncIterator",
@@ -46101,6 +46136,7 @@ function createTypeChecker(host) {
     getGlobalIteratorType: getGlobalAsyncIteratorType,
     getGlobalIterableType: getGlobalAsyncIterableType,
     getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
+    getGlobalBuiltinIteratorType: getGlobalAsyncBuiltinIteratorType,
     getGlobalGeneratorType: getGlobalAsyncGeneratorType,
     resolveIterationType: (type, errorNode) => getAwaitedType(type, errorNode, Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member),
     mustHaveANextMethodDiagnostic: Diagnostics.An_async_iterator_must_have_a_next_method,
@@ -46114,6 +46150,7 @@ function createTypeChecker(host) {
     getGlobalIteratorType,
     getGlobalIterableType,
     getGlobalIterableIteratorType,
+    getGlobalBuiltinIteratorType,
     getGlobalGeneratorType,
     resolveIterationType: (type, _errorNode) => type,
     mustHaveANextMethodDiagnostic: Diagnostics.An_iterator_must_have_a_next_method,
@@ -46152,12 +46189,14 @@ function createTypeChecker(host) {
   var deferredGlobalIterableType;
   var deferredGlobalIteratorType;
   var deferredGlobalIterableIteratorType;
+  var deferredGlobalBuiltinIteratorType;
   var deferredGlobalGeneratorType;
   var deferredGlobalIteratorYieldResultType;
   var deferredGlobalIteratorReturnResultType;
   var deferredGlobalAsyncIterableType;
   var deferredGlobalAsyncIteratorType;
   var deferredGlobalAsyncIterableIteratorType;
+  var deferredGlobalAsyncBuiltinIteratorType;
   var deferredGlobalAsyncGeneratorType;
   var deferredGlobalTemplateStringsArrayType;
   var deferredGlobalImportMetaType;
@@ -48270,7 +48309,7 @@ function createTypeChecker(host) {
         }
         return getMergedSymbol(sourceFile.symbol);
       }
-      if (errorNode && moduleNotFoundError) {
+      if (errorNode && moduleNotFoundError && !isSideEffectImport(errorNode)) {
         error(errorNode, Diagnostics.File_0_is_not_a_module, sourceFile.fileName);
       }
       return void 0;
@@ -48355,6 +48394,9 @@ function createTypeChecker(host) {
     }
   }
   function errorOnImplicitAnyModule(isError, errorNode, sourceFile, mode, { packageId, resolvedFileName }, moduleReference) {
+    if (isSideEffectImport(errorNode)) {
+      return;
+    }
     let errorInfo;
     if (!isExternalModuleNameRelative(moduleReference) && packageId) {
       errorInfo = createModuleNotFoundChain(sourceFile, host, moduleReference, mode, packageId.name);
@@ -50183,7 +50225,35 @@ function createTypeChecker(host) {
           }
           let typeArgumentNodes;
           if (typeArguments.length > 0) {
-            const typeParameterCount = (type2.target.typeParameters || emptyArray).length;
+            let typeParameterCount = 0;
+            if (type2.target.typeParameters) {
+              typeParameterCount = Math.min(type2.target.typeParameters.length, typeArguments.length);
+              if (isReferenceToType(type2, getGlobalIterableType(
+                /*reportErrors*/
+                false
+              )) || isReferenceToType(type2, getGlobalIterableIteratorType(
+                /*reportErrors*/
+                false
+              )) || isReferenceToType(type2, getGlobalAsyncIterableType(
+                /*reportErrors*/
+                false
+              )) || isReferenceToType(type2, getGlobalAsyncIterableIteratorType(
+                /*reportErrors*/
+                false
+              ))) {
+                if (!type2.node || !isTypeReferenceNode(type2.node) || !type2.node.typeArguments || type2.node.typeArguments.length < typeParameterCount) {
+                  while (typeParameterCount > 0) {
+                    const typeArgument = typeArguments[typeParameterCount - 1];
+                    const typeParameter = type2.target.typeParameters[typeParameterCount - 1];
+                    const defaultType = getDefaultFromTypeParameter(typeParameter);
+                    if (!defaultType || !isTypeIdenticalTo(typeArgument, defaultType)) {
+                      break;
+                    }
+                    typeParameterCount--;
+                  }
+                }
+              }
+            }
             typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context);
           }
           const flags = context.flags;
@@ -55628,6 +55698,9 @@ function createTypeChecker(host) {
           links.instantiations = /* @__PURE__ */ new Map();
           links.instantiations.set(getTypeListId(typeParameters), type);
         }
+        if (type === intrinsicMarkerType && symbol.escapedName === "BuiltinIteratorReturn") {
+          type = strictBuiltinIteratorReturn ? undefinedType : anyType;
+        }
       } else {
         type = errorType;
         if (declaration.kind === 340 /* JSDocEnumTag */) {
@@ -58905,7 +58978,7 @@ function createTypeChecker(host) {
     return deferredGlobalAsyncIterableType || (deferredGlobalAsyncIterableType = getGlobalType(
       "AsyncIterable",
       /*arity*/
-      1,
+      3,
       reportErrors2
     )) || emptyGenericType;
   }
@@ -58921,7 +58994,15 @@ function createTypeChecker(host) {
     return deferredGlobalAsyncIterableIteratorType || (deferredGlobalAsyncIterableIteratorType = getGlobalType(
       "AsyncIterableIterator",
       /*arity*/
-      1,
+      3,
+      reportErrors2
+    )) || emptyGenericType;
+  }
+  function getGlobalAsyncBuiltinIteratorType(reportErrors2) {
+    return deferredGlobalAsyncBuiltinIteratorType || (deferredGlobalAsyncBuiltinIteratorType = getGlobalType(
+      "AsyncBuiltinIterator",
+      /*arity*/
+      3,
       reportErrors2
     )) || emptyGenericType;
   }
@@ -58937,7 +59018,7 @@ function createTypeChecker(host) {
     return deferredGlobalIterableType || (deferredGlobalIterableType = getGlobalType(
       "Iterable",
       /*arity*/
-      1,
+      3,
       reportErrors2
     )) || emptyGenericType;
   }
@@ -58953,7 +59034,15 @@ function createTypeChecker(host) {
     return deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType(
       "IterableIterator",
       /*arity*/
-      1,
+      3,
+      reportErrors2
+    )) || emptyGenericType;
+  }
+  function getGlobalBuiltinIteratorType(reportErrors2) {
+    return deferredGlobalBuiltinIteratorType || (deferredGlobalBuiltinIteratorType = getGlobalType(
+      "BuiltinIterator",
+      /*arity*/
+      3,
       reportErrors2
     )) || emptyGenericType;
   }
@@ -59135,7 +59224,7 @@ function createTypeChecker(host) {
     return createTypeFromGenericGlobalType(getGlobalIterableType(
       /*reportErrors*/
       true
-    ), [iteratedType]);
+    ), [iteratedType, voidType, undefinedType]);
   }
   function createArrayType(elementType, readonly) {
     return createTypeFromGenericGlobalType(readonly ? globalReadonlyArrayType : globalArrayType, [elementType]);
@@ -60495,12 +60584,13 @@ function createTypeChecker(host) {
     }
     if (accessNode) {
       const indexNode = getIndexNodeForAccessExpression(accessNode);
-      if (indexType.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
+      if (indexNode.kind !== 10 /* BigIntLiteral */ && indexType.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
         error(indexNode, Diagnostics.Property_0_does_not_exist_on_type_1, "" + indexType.value, typeToString(objectType));
       } else if (indexType.flags & (4 /* String */ | 8 /* Number */)) {
         error(indexNode, Diagnostics.Type_0_has_no_matching_index_signature_for_type_1, typeToString(objectType), typeToString(indexType));
       } else {
-        error(indexNode, Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
+        const typeString = indexNode.kind === 10 /* BigIntLiteral */ ? "bigint" : typeToString(indexType);
+        error(indexNode, Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeString);
       }
     }
     if (isTypeAny(indexType)) {
@@ -76610,24 +76700,14 @@ function createTypeChecker(host) {
       void 0
     ) || unknownType;
     if (globalGeneratorType === emptyGenericType) {
-      const globalType = resolver.getGlobalIterableIteratorType(
+      const globalIterableIteratorType = resolver.getGlobalIterableIteratorType(
         /*reportErrors*/
         false
       );
-      const iterationTypes = globalType !== emptyGenericType ? getIterationTypesOfGlobalIterableType(globalType, resolver) : void 0;
-      const iterableIteratorReturnType = iterationTypes ? iterationTypes.returnType : anyType;
-      const iterableIteratorNextType = iterationTypes ? iterationTypes.nextType : undefinedType;
-      if (isTypeAssignableTo(returnType, iterableIteratorReturnType) && isTypeAssignableTo(iterableIteratorNextType, nextType)) {
-        if (globalType !== emptyGenericType) {
-          return createTypeFromGenericGlobalType(globalType, [yieldType]);
-        }
-        resolver.getGlobalIterableIteratorType(
-          /*reportErrors*/
-          true
-        );
-        return emptyObjectType;
+      if (globalIterableIteratorType !== emptyGenericType) {
+        return createTypeFromGenericGlobalType(globalIterableIteratorType, [yieldType, returnType, nextType]);
       }
-      resolver.getGlobalGeneratorType(
+      resolver.getGlobalIterableIteratorType(
         /*reportErrors*/
         true
       );
@@ -81067,6 +81147,9 @@ function createTypeChecker(host) {
       checkAliasSymbol(node);
       return;
     }
+    if (node.name.kind === 10 /* BigIntLiteral */) {
+      error(node.name, Diagnostics.A_bigint_literal_cannot_be_used_as_a_property_name);
+    }
     const type = convertAutoToAny(getTypeOfSymbol(symbol));
     if (node === symbol.valueDeclaration) {
       const initializer = hasOnlyExpressionInitializer(node) && getEffectiveInitializer(node);
@@ -81701,41 +81784,17 @@ function createTypeChecker(host) {
   function getIterationTypesOfIterableCached(type, resolver) {
     return getCachedIterationTypes(type, resolver.iterableCacheKey);
   }
-  function getIterationTypesOfGlobalIterableType(globalType, resolver) {
-    const globalIterationTypes = getIterationTypesOfIterableCached(globalType, resolver) || getIterationTypesOfIterableSlow(
-      globalType,
-      resolver,
-      /*errorNode*/
-      void 0,
-      /*errorOutputContainer*/
-      void 0,
-      /*noCache*/
-      false
-    );
-    return globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
-  }
   function getIterationTypesOfIterableFast(type, resolver) {
-    let globalType;
-    if (isReferenceToType(type, globalType = resolver.getGlobalIterableType(
+    if (isReferenceToType(type, resolver.getGlobalIterableType(
       /*reportErrors*/
       false
-    )) || isReferenceToType(type, globalType = resolver.getGlobalIterableIteratorType(
+    )) || isReferenceToType(type, resolver.getGlobalBuiltinIteratorType(
       /*reportErrors*/
       false
-    ))) {
-      const [yieldType] = getTypeArguments(type);
-      const { returnType, nextType } = getIterationTypesOfGlobalIterableType(globalType, resolver);
-      return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(
-        yieldType,
-        /*errorNode*/
-        void 0
-      ) || yieldType, resolver.resolveIterationType(
-        returnType,
-        /*errorNode*/
-        void 0
-      ) || returnType, nextType));
-    }
-    if (isReferenceToType(type, resolver.getGlobalGeneratorType(
+    )) || isReferenceToType(type, resolver.getGlobalIterableIteratorType(
+      /*reportErrors*/
+      false
+    )) || isReferenceToType(type, resolver.getGlobalGeneratorType(
       /*reportErrors*/
       false
     ))) {
@@ -81780,10 +81839,10 @@ function createTypeChecker(host) {
       !!getAwaitedTypeOfPromise(type) || !allowAsyncIterables && isForOfStatement(errorNode.parent) && errorNode.parent.expression === errorNode && getGlobalAsyncIterableType(
         /*reportErrors*/
         false
-      ) !== emptyGenericType && isTypeAssignableTo(type, getGlobalAsyncIterableType(
+      ) !== emptyGenericType && isTypeAssignableTo(type, createTypeFromGenericGlobalType(getGlobalAsyncIterableType(
         /*reportErrors*/
         false
-      ))
+      ), [anyType, anyType, anyType]))
     );
     return errorAndMaybeSuggestAwait(errorNode, suggestAwait, message, typeToString(type));
   }
@@ -81813,26 +81872,13 @@ function createTypeChecker(host) {
     return getCachedIterationTypes(type, resolver.iteratorCacheKey);
   }
   function getIterationTypesOfIteratorFast(type, resolver) {
-    const globalType = resolver.getGlobalIterableIteratorType(
+    if (isReferenceToType(type, resolver.getGlobalBuiltinIteratorType(
       /*reportErrors*/
       false
-    );
-    if (isReferenceToType(type, globalType)) {
-      const [yieldType] = getTypeArguments(type);
-      const globalIterationTypes = getIterationTypesOfIteratorCached(globalType, resolver) || getIterationTypesOfIteratorSlow(
-        globalType,
-        resolver,
-        /*errorNode*/
-        void 0,
-        /*errorOutputContainer*/
-        void 0,
-        /*noCache*/
-        false
-      );
-      const { returnType, nextType } = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
-      return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
-    }
-    if (isReferenceToType(type, resolver.getGlobalIteratorType(
+    )) || isReferenceToType(type, resolver.getGlobalIterableIteratorType(
+      /*reportErrors*/
+      false
+    )) || isReferenceToType(type, resolver.getGlobalIteratorType(
       /*reportErrors*/
       false
     )) || isReferenceToType(type, resolver.getGlobalGeneratorType(
@@ -81909,7 +81955,7 @@ function createTypeChecker(host) {
     }
     const methodType = method && !(methodName === "next" && method.flags & 16777216 /* Optional */) ? methodName === "next" ? getTypeOfSymbol(method) : getTypeWithFacts(getTypeOfSymbol(method), 2097152 /* NEUndefinedOrNull */) : void 0;
     if (isTypeAny(methodType)) {
-      return methodName === "next" ? anyIterationTypes : anyIterationTypesExceptNext;
+      return anyIterationTypes;
     }
     const methodSignatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : emptyArray;
     if (methodSignatures.length === 0) {
@@ -83047,7 +83093,9 @@ function createTypeChecker(host) {
     checkExportsOnMergedDeclarations(node);
     checkTypeParameters(node.typeParameters);
     if (node.type.kind === 141 /* IntrinsicKeyword */) {
-      if (!intrinsicTypeKinds.has(node.name.escapedText) || length(node.typeParameters) !== 1) {
+      const typeParameterCount = length(node.typeParameters);
+      const valid = typeParameterCount === 0 ? node.name.escapedText === "BuiltinIteratorReturn" : typeParameterCount === 1 && intrinsicTypeKinds.has(node.name.escapedText);
+      if (!valid) {
         error(node.type, Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types);
       }
     } else {
@@ -83687,6 +83735,8 @@ function createTypeChecker(host) {
             }
           }
         }
+      } else if (noUncheckedSideEffectImports && !importClause) {
+        void resolveExternalModuleName(node, node.moduleSpecifier);
       }
     }
     checkImportAttributes(node);
@@ -86964,6 +87014,13 @@ function createTypeChecker(host) {
           if (name.kind === 9 /* NumericLiteral */) {
             checkGrammarNumericLiteral(name);
           }
+          if (name.kind === 10 /* BigIntLiteral */) {
+            addErrorOrSuggestion(
+              /*isError*/
+              true,
+              createDiagnosticForNode(name, Diagnostics.A_bigint_literal_cannot_be_used_as_a_property_name)
+            );
+          }
           currentKind = 4 /* PropertyAssignment */;
           break;
         case 174 /* MethodDeclaration */:
@@ -90521,7 +90578,7 @@ function createDestructuringPropertyAccess(flattenContext, value, propertyName)
       propertyName
     );
     return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
-  } else if (isStringOrNumericLiteralLike(propertyName)) {
+  } else if (isStringOrNumericLiteralLike(propertyName) || isBigIntLiteral(propertyName)) {
     const argumentExpression = factory2.cloneNode(propertyName);
     return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
   } else {

package/lib/typescript.d.ts

@@ -4422,7 +4422,7 @@ declare namespace ts {
         readonly right: Identifier;
     }
     type EntityName = Identifier | QualifiedName;
-    type PropertyName = Identifier | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier;
+    type PropertyName = Identifier | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier | BigIntLiteral;
     type MemberName = Identifier | PrivateIdentifier;
     type DeclarationName = PropertyName | JsxAttributeName | StringLiteralLike | ElementAccessExpression | BindingPattern | EntityNameExpression;
     interface Declaration extends Node {
@@ -4773,7 +4773,7 @@ declare namespace ts {
         readonly kind: SyntaxKind.StringLiteral;
     }
     type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;
-    type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral | JsxNamespacedName;
+    type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral | JsxNamespacedName | BigIntLiteral;
     interface TemplateLiteralTypeNode extends TypeNode {
         kind: SyntaxKind.TemplateLiteralType;
         readonly head: TemplateHead;
@@ -7008,6 +7008,7 @@ declare namespace ts {
         strictBindCallApply?: boolean;
         strictNullChecks?: boolean;
         strictPropertyInitialization?: boolean;
+        strictBuiltinIteratorReturn?: boolean;
         stripInternal?: boolean;
         /** @deprecated */
         suppressExcessPropertyErrors?: boolean;
@@ -7016,6 +7017,7 @@ declare namespace ts {
         target?: ScriptTarget;
         traceResolution?: boolean;
         useUnknownInCatchVariables?: boolean;
+        noUncheckedSideEffectImports?: boolean;
         resolveJsonModule?: boolean;
         types?: string[];
         /** Paths used to compute primary types search locations */