Merge branch 'main' into fix-unique-symbol-dts

Author: Akshit222

Herebyfile.mjs

@@ -52,7 +52,7 @@ const libs = memoize(() => {
     /** @type {{ libs: string[]; paths: Record<string, string | undefined>; }} */
     const libraries = readJson("./src/lib/libs.json");
     const libs = libraries.libs.map(lib => {
-        const relativeSources = ["header.d.ts", lib + ".d.ts"];
+        const relativeSources = [lib + ".d.ts"];
         const relativeTarget = libraries.paths && libraries.paths[lib] || ("lib." + lib + ".d.ts");
         const sources = relativeSources.map(s => path.posix.join("src/lib", s));
         const target = `built/local/${relativeTarget}`;

src/compiler/builder.ts

@@ -412,7 +412,7 @@ function createBuilderProgramState(
 
             if (canCopySemanticDiagnostics) {
                 if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics) return;
-                if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics) return;
+                if (newProgram.isSourceFileDefaultLibrary(sourceFile) && !copyLibFileDiagnostics) return;
 
                 // Unchanged file copy diagnostics
                 const diagnostics = oldState!.semanticDiagnosticsPerFile.get(sourceFilePath);

src/compiler/checker.ts

@@ -1531,7 +1531,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
     var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
     var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
-    var noUncheckedSideEffectImports = !!compilerOptions.noUncheckedSideEffectImports;
+    var noUncheckedSideEffectImports = compilerOptions.noUncheckedSideEffectImports !== false;
 
     var checkBinaryExpression = createCheckBinaryExpression();
     var emitResolver = createResolver();
@@ -4684,9 +4684,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
     }
 
-    function resolveExternalModuleName(location: Node, moduleReferenceExpression: Expression, ignoreErrors?: boolean): Symbol | undefined {
+    function resolveExternalModuleName(location: Node, moduleReferenceExpression: Expression, ignoreErrors?: boolean, errorMessage?: DiagnosticMessage): Symbol | undefined {
         const isClassic = getEmitModuleResolutionKind(compilerOptions) === ModuleResolutionKind.Classic;
-        const errorMessage = isClassic ?
+        errorMessage ??= isClassic ?
             Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option
             : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
         return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? undefined : errorMessage, ignoreErrors);
@@ -21504,15 +21504,15 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         let issuedElaboration = false;
                         if (!targetProp) {
                             const indexInfo = getApplicableIndexInfo(target, nameType);
-                            if (indexInfo && indexInfo.declaration && !getSourceFileOfNode(indexInfo.declaration).hasNoDefaultLib) {
+                            if (indexInfo && indexInfo.declaration && !host.isSourceFileDefaultLibrary(getSourceFileOfNode(indexInfo.declaration))) {
                                 issuedElaboration = true;
                                 addRelatedInfo(reportedDiag, createDiagnosticForNode(indexInfo.declaration, Diagnostics.The_expected_type_comes_from_this_index_signature));
                             }
                         }
 
                         if (!issuedElaboration && (targetProp && length(targetProp.declarations) || target.symbol && length(target.symbol.declarations))) {
                             const targetNode = targetProp && length(targetProp.declarations) ? targetProp.declarations![0] : target.symbol.declarations![0];
-                            if (!getSourceFileOfNode(targetNode).hasNoDefaultLib) {
+                            if (!host.isSourceFileDefaultLibrary(getSourceFileOfNode(targetNode))) {
                                 addRelatedInfo(
                                     reportedDiag,
                                     createDiagnosticForNode(
@@ -24460,13 +24460,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             if (isObjectLiteralType(target)) {
                 for (const sourceProp of excludeProperties(getPropertiesOfType(source), excludedProperties)) {
                     if (!getPropertyOfObjectType(target, sourceProp.escapedName)) {
-                        const sourceType = getTypeOfSymbol(sourceProp);
-                        if (!(sourceType.flags & TypeFlags.Undefined)) {
-                            if (reportErrors) {
-                                reportError(Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target));
-                            }
-                            return Ternary.False;
+                        if (reportErrors) {
+                            reportError(Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target));
                         }
+                        return Ternary.False;
                     }
                 }
             }
@@ -27888,24 +27885,22 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         for (const type of types) {
             if (type.flags & (TypeFlags.Object | TypeFlags.Intersection | TypeFlags.InstantiableNonPrimitive)) {
                 const discriminant = getTypeOfPropertyOfType(type, name);
-                if (discriminant) {
-                    if (!isLiteralType(discriminant)) {
-                        return undefined;
-                    }
-                    let duplicate = false;
-                    forEachType(discriminant, t => {
-                        const id = getTypeId(getRegularTypeOfLiteralType(t));
-                        const existing = map.get(id);
-                        if (!existing) {
-                            map.set(id, type);
-                        }
-                        else if (existing !== unknownType) {
-                            map.set(id, unknownType);
-                            duplicate = true;
-                        }
-                    });
-                    if (!duplicate) count++;
+                if (!discriminant || !isLiteralType(discriminant)) {
+                    return undefined;
                 }
+                let duplicate = false;
+                forEachType(discriminant, t => {
+                    const id = getTypeId(getRegularTypeOfLiteralType(t));
+                    const existing = map.get(id);
+                    if (!existing) {
+                        map.set(id, type);
+                    }
+                    else if (existing !== unknownType) {
+                        map.set(id, unknownType);
+                        duplicate = true;
+                    }
+                });
+                if (!duplicate) count++;
             }
         }
         return count >= 10 && count * 2 >= types.length ? map : undefined;
@@ -38003,7 +37998,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         const exprType = checkExpression(expression, checkMode);
         if (isConstTypeReference(type)) {
             if (!isValidConstAssertionArgument(expression)) {
-                error(expression, Diagnostics.A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals);
+                error(expression, Diagnostics.A_const_assertion_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals);
             }
             return getRegularTypeOfLiteralType(exprType);
         }
@@ -48516,7 +48511,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 }
             }
             else if (noUncheckedSideEffectImports && !importClause) {
-                void resolveExternalModuleName(node, node.moduleSpecifier);
+                void resolveExternalModuleName(node, node.moduleSpecifier, /*ignoreErrors*/ undefined, Diagnostics.Cannot_find_module_or_type_declarations_for_side_effect_import_of_0);
             }
         }
         checkImportAttributes(node);

src/compiler/commandLineParser.ts

@@ -1243,7 +1243,7 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [
         affectsBuildInfo: true,
         category: Diagnostics.Modules,
         description: Diagnostics.Check_side_effect_imports,
-        defaultValueDescription: false,
+        defaultValueDescription: true,
     },
 
     // Source Maps

src/compiler/diagnosticMessages.json

@@ -1155,7 +1155,7 @@
         "category": "Error",
         "code": 1354
     },
-    "A 'const' assertions can only be applied to references to enum members, or string, number, boolean, array, or object literals.": {
+    "A 'const' assertion can only be applied to references to enum members, or string, number, boolean, array, or object literals.": {
         "category": "Error",
         "code": 1355
     },
@@ -4007,6 +4007,10 @@
         "category": "Error",
         "code": 2881
     },
+    "Cannot find module or type declarations for side-effect import of '{0}'.": {
+        "category": "Error",
+        "code": 2882
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -4286,18 +4286,14 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
     }
 
     function emitSyntheticTripleSlashReferencesIfNeeded(node: Bundle) {
-        emitTripleSlashDirectives(!!node.hasNoDefaultLib, node.syntheticFileReferences || [], node.syntheticTypeReferences || [], node.syntheticLibReferences || []);
+        emitTripleSlashDirectives(node.syntheticFileReferences || [], node.syntheticTypeReferences || [], node.syntheticLibReferences || []);
     }
 
     function emitTripleSlashDirectivesIfNeeded(node: SourceFile) {
-        if (node.isDeclarationFile) emitTripleSlashDirectives(node.hasNoDefaultLib, node.referencedFiles, node.typeReferenceDirectives, node.libReferenceDirectives);
+        if (node.isDeclarationFile) emitTripleSlashDirectives(node.referencedFiles, node.typeReferenceDirectives, node.libReferenceDirectives);
     }
 
-    function emitTripleSlashDirectives(hasNoDefaultLib: boolean, files: readonly FileReference[], types: readonly FileReference[], libs: readonly FileReference[]) {
-        if (hasNoDefaultLib) {
-            writeComment(`/// <reference no-default-lib="true"/>`);
-            writeLine();
-        }
+    function emitTripleSlashDirectives(files: readonly FileReference[], types: readonly FileReference[], libs: readonly FileReference[]) {
         if (currentSourceFile && currentSourceFile.moduleName) {
             writeComment(`/// <amd-module name="${currentSourceFile.moduleName}" />`);
             writeLine();

src/compiler/factory/nodeFactory.ts

@@ -6181,16 +6181,15 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         isDeclarationFile = node.isDeclarationFile,
         referencedFiles = node.referencedFiles,
         typeReferenceDirectives = node.typeReferenceDirectives,
-        hasNoDefaultLib = node.hasNoDefaultLib,
+        _hasNoDefaultLib = false,
         libReferenceDirectives = node.libReferenceDirectives,
     ) {
         return node.statements !== statements
                 || node.isDeclarationFile !== isDeclarationFile
                 || node.referencedFiles !== referencedFiles
                 || node.typeReferenceDirectives !== typeReferenceDirectives
-                || node.hasNoDefaultLib !== hasNoDefaultLib
                 || node.libReferenceDirectives !== libReferenceDirectives
-            ? update(cloneSourceFileWithChanges(node, statements, isDeclarationFile, referencedFiles, typeReferenceDirectives, hasNoDefaultLib, libReferenceDirectives), node)
+            ? update(cloneSourceFileWithChanges(node, statements, isDeclarationFile, referencedFiles, typeReferenceDirectives, /*hasNoDefaultLib*/ false, libReferenceDirectives), node)
             : node;
     }
 
@@ -6201,7 +6200,6 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         node.syntheticFileReferences = undefined;
         node.syntheticTypeReferences = undefined;
         node.syntheticLibReferences = undefined;
-        node.hasNoDefaultLib = undefined;
         return node;
     }
 

src/compiler/moduleNameResolver.ts

@@ -2812,7 +2812,9 @@ function getLoadModuleFromTargetExportOrImport(extensions: Extensions, state: Mo
                         const subTarget = (target as MapLike<unknown>)[condition];
                         const result = loadModuleFromTargetExportOrImport(subTarget, subpath, pattern, key);
                         if (result) {
-                            traceIfEnabled(state, Diagnostics.Resolved_under_condition_0, condition);
+                            if (result.value) {
+                                traceIfEnabled(state, Diagnostics.Resolved_under_condition_0, condition);
+                            }
                             traceIfEnabled(state, Diagnostics.Exiting_conditional_exports);
                             return result;
                         }
@@ -2846,7 +2848,7 @@ function getLoadModuleFromTargetExportOrImport(extensions: Extensions, state: Mo
             if (state.traceEnabled) {
                 trace(state.host, Diagnostics.package_json_scope_0_explicitly_maps_specifier_1_to_null, scope.packageDirectory, moduleName);
             }
-            return toSearchResult(/*value*/ undefined);
+            return { value: undefined };
         }
         if (state.traceEnabled) {
             trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);

src/compiler/parser.ts

@@ -10617,7 +10617,6 @@ export function processPragmasIntoFields(context: PragmaContext, reportDiagnosti
     context.typeReferenceDirectives = [];
     context.libReferenceDirectives = [];
     context.amdDependencies = [];
-    context.hasNoDefaultLib = false;
     context.pragmas!.forEach((entryOrList, key) => { // TODO: GH#18217
         // TODO: The below should be strongly type-guarded and not need casts/explicit annotations, since entryOrList is related to
         // key and key is constrained to a union; but it's not (see GH#21483 for at least partial fix) :(
@@ -10630,7 +10629,7 @@ export function processPragmasIntoFields(context: PragmaContext, reportDiagnosti
                     const { types, lib, path, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
                     const preserve = _preserve === "true" ? true : undefined;
                     if (arg.arguments["no-default-lib"] === "true") {
-                        context.hasNoDefaultLib = true;
+                        // This has been removed; parse but ignore it.
                     }
                     else if (types) {
                         const parsed = parseResolutionMode(res, types.pos, types.end, reportDiagnostic);