microsoft
diff --git a/‎src/compiler/checker.ts
Copy file name to clipboard
+62-15Lines changed: 62 additions & 15 deletions b/‎src/compiler/checker.ts
Copy file name to clipboard
+62-15Lines changed: 62 additions & 15 deletions
diff --git a/‎src/compiler/commandLineParser.ts
Copy file name to clipboard
+9-1Lines changed: 9 additions & 1 deletion b/‎src/compiler/commandLineParser.ts
Copy file name to clipboard
+9-1Lines changed: 9 additions & 1 deletion
diff --git a/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+20Lines changed: 20 additions & 0 deletions b/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+20Lines changed: 20 additions & 0 deletions
diff --git a/‎src/compiler/program.ts
Copy file name to clipboard
+7-3Lines changed: 7 additions & 3 deletions b/‎src/compiler/program.ts
Copy file name to clipboard
+7-3Lines changed: 7 additions & 3 deletions
diff --git a/‎src/compiler/transformers/ts.ts
Copy file name to clipboard
+17-15Lines changed: 17 additions & 15 deletions b/‎src/compiler/transformers/ts.ts
Copy file name to clipboard
+17-15Lines changed: 17 additions & 15 deletions
diff --git a/‎src/compiler/types.ts
Copy file name to clipboard
+10-1Lines changed: 10 additions & 1 deletion b/‎src/compiler/types.ts
Copy file name to clipboard
+10-1Lines changed: 10 additions & 1 deletion
diff --git a/‎src/compiler/utilitiesPublic.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎src/compiler/utilitiesPublic.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
@@ -2198,17 +2198,25 @@ namespace ts {
                     const message = isExport
                         ? Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type
                         : Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
-                    const relatedMessage = isExport
-                        ? Diagnostics._0_was_exported_here
-                        : Diagnostics._0_was_imported_here;
                     const unescapedName = unescapeLeadingUnderscores(name);
-                    addRelatedInfo(
+                    addTypeOnlyDeclarationRelatedInfo(
                         error(useSite, message, unescapedName),
-                        createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, unescapedName));
+                        typeOnlyDeclaration,
+                        unescapedName);
                 }
             }
         }
 
+        function addTypeOnlyDeclarationRelatedInfo(diagnostic: Diagnostic, typeOnlyDeclaration: TypeOnlyCompatibleAliasDeclaration | undefined, unescapedName: string) {
+            if (!typeOnlyDeclaration) return diagnostic;
+            return addRelatedInfo(
+                diagnostic,
+                createDiagnosticForNode(
+                    typeOnlyDeclaration,
+                    typeOnlyDeclarationIsExport(typeOnlyDeclaration) ? Diagnostics._0_was_exported_here : Diagnostics._0_was_imported_here,
+                    unescapedName));
+        }
+
         function getIsDeferredContext(location: Node, lastLocation: Node | undefined): boolean {
             if (location.kind !== SyntaxKind.ArrowFunction && location.kind !== SyntaxKind.FunctionExpression) {
                 // initializers in instance property declaration of class like entities are executed in constructor and thus deferred
@@ -38813,13 +38821,49 @@ namespace ts {
                     error(node, message, symbolToString(symbol));
                 }
 
-                // Don't allow to re-export something with no value side when `--isolatedModules` is set.
                 if (compilerOptions.isolatedModules
-                    && node.kind === SyntaxKind.ExportSpecifier
-                    && !node.parent.parent.isTypeOnly
-                    && !(target.flags & SymbolFlags.Value)
+                    && !isTypeOnlyImportOrExportDeclaration(node)
                     && !(node.flags & NodeFlags.Ambient)) {
-                    error(node, Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type);
+                    const typeOnlyAlias = getTypeOnlyAliasDeclaration(symbol);
+                    const isType = !(target.flags & SymbolFlags.Value);
+                    if (isType || typeOnlyAlias) {
+                        switch (node.kind) {
+                            case SyntaxKind.ImportClause:
+                            case SyntaxKind.ImportSpecifier:
+                            case SyntaxKind.ImportEqualsDeclaration: {
+                                if (compilerOptions.preserveValueImports) {
+                                    Debug.assertIsDefined(node.name, "An ImportClause with a symbol should have a name");
+                                    const message = isType
+                                        ? Diagnostics._0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled
+                                        : Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled;
+                                    const name = idText(node.kind === SyntaxKind.ImportSpecifier ? node.propertyName || node.name : node.name);
+                                    addTypeOnlyDeclarationRelatedInfo(
+                                        error(node, message, name),
+                                        isType ? undefined : typeOnlyAlias,
+                                        name
+                                    );
+                                }
+                                break;
+                            }
+                            case SyntaxKind.ExportSpecifier: {
+                                // Don't allow re-exporting an export that will be elided when `--isolatedModules` is set.
+                                // The exception is that `import type { A } from './a'; export { A }` is allowed
+                                // because single-file analysis can determine that the export should be dropped.
+                                if (getSourceFileOfNode(typeOnlyAlias) !== getSourceFileOfNode(node)) {
+                                    const message = isType
+                                        ? Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type
+                                        : Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isolatedModules_is_enabled;
+                                    const name = idText(node.propertyName || node.name);
+                                    addTypeOnlyDeclarationRelatedInfo(
+                                        error(node, message, name),
+                                        isType ? undefined : typeOnlyAlias,
+                                        name
+                                    );
+                                    return;
+                                }
+                            }
+                        }
+                    }
                 }
 
                 if (isImportSpecifier(node) && target.declarations?.every(d => !!(getCombinedNodeFlags(d) & NodeFlags.Deprecated))) {
@@ -40600,13 +40644,13 @@ namespace ts {
         function isValueAliasDeclaration(node: Node): boolean {
             switch (node.kind) {
                 case SyntaxKind.ImportEqualsDeclaration:
-                    return isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol);
+                    return isAliasResolvedToValue(getSymbolOfNode(node));
                 case SyntaxKind.ImportClause:
                 case SyntaxKind.NamespaceImport:
                 case SyntaxKind.ImportSpecifier:
                 case SyntaxKind.ExportSpecifier:
-                    const symbol = getSymbolOfNode(node) || unknownSymbol;
-                    return isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol);
+                    const symbol = getSymbolOfNode(node);
+                    return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol);
                 case SyntaxKind.ExportDeclaration:
                     const exportClause = (node as ExportDeclaration).exportClause;
                     return !!exportClause && (
@@ -40615,7 +40659,7 @@ namespace ts {
                     );
                 case SyntaxKind.ExportAssignment:
                     return (node as ExportAssignment).expression && (node as ExportAssignment).expression.kind === SyntaxKind.Identifier ?
-                        isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol) :
+                        isAliasResolvedToValue(getSymbolOfNode(node)) :
                         true;
             }
             return false;
@@ -40632,7 +40676,10 @@ namespace ts {
             return isValue && node.moduleReference && !nodeIsMissing(node.moduleReference);
         }
 
-        function isAliasResolvedToValue(symbol: Symbol): boolean {
+        function isAliasResolvedToValue(symbol: Symbol | undefined): boolean {
+            if (!symbol) {
+                return false;
+            }
             const target = resolveAlias(symbol);
             if (target === unknownSymbol) {
                 return true;
 
@@ -571,7 +571,7 @@ namespace ts {
             type: new Map(getEntries({
                 remove: ImportsNotUsedAsValues.Remove,
                 preserve: ImportsNotUsedAsValues.Preserve,
-                error: ImportsNotUsedAsValues.Error
+                error: ImportsNotUsedAsValues.Error,
             })),
             affectsEmit: true,
             affectsSemanticDiagnostics: true,
@@ -1169,6 +1169,14 @@ namespace ts {
             description: Diagnostics.Emit_ECMAScript_standard_compliant_class_fields,
             defaultValueDescription: Diagnostics.true_for_ES2022_and_above_including_ESNext
         },
+        {
+            name: "preserveValueImports",
+            type: "boolean",
+            affectsEmit: true,
+            category: Diagnostics.Emit,
+            description: Diagnostics.Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed,
+        },
+
         {
             name: "keyofStringsOnly",
             type: "boolean",
 
@@ -1372,6 +1372,22 @@
         "category": "Error",
         "code": 1443
     },
+    "'{0}' is a type and must be imported using a type-only import when 'preserveValueImports' and 'isolatedModules' are both enabled.": {
+        "category": "Error",
+        "code": 1444
+    },
+    "'{0}' resolves to a type-only declaration and must be imported using a type-only import when 'preserveValueImports' and 'isolatedModules' are both enabled.": {
+        "category": "Error",
+        "code": 1446
+    },
+    "'{0}' resolves to a type-only declaration and must be re-exported using a type-only re-export when 'isolatedModules' is enabled.": {
+        "category": "Error",
+        "code": 1448
+    },
+    "Preserve unused imported values in the JavaScript output that would otherwise be removed.": {
+        "category": "Message",
+        "code": 1449
+    },
 
     "The types of '{0}' are incompatible between these types.": {
         "category": "Error",
@@ -3910,6 +3926,10 @@
         "category": "Error",
         "code": 5094
     },
+    "Option 'preserveValueImports' can only be used when 'module' is set to 'es2015' or later.": {
+        "category": "Error",
+        "code": 5095
+    },
 
     "Generates a sourcemap for each corresponding '.d.ts' file.": {
         "category": "Message",
 
@@ -3305,6 +3305,10 @@ namespace ts {
                 }
             }
 
+            if (options.preserveValueImports && getEmitModuleKind(options) < ModuleKind.ES2015) {
+                createOptionValueDiagnostic("importsNotUsedAsValues", Diagnostics.Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later);
+            }
+
             // If the emit is enabled make sure that every output file is unique and not overwriting any of the input files
             if (!options.noEmit && !options.suppressOutputPathCheck) {
                 const emitHost = getEmitHost();
@@ -3575,7 +3579,7 @@ namespace ts {
             createDiagnosticForOption(/*onKey*/ true, option1, option2, message, option1, option2, option3);
         }
 
-        function createOptionValueDiagnostic(option1: string, message: DiagnosticMessage, arg0: string) {
+        function createOptionValueDiagnostic(option1: string, message: DiagnosticMessage, arg0?: string) {
             createDiagnosticForOption(/*onKey*/ false, option1, /*option2*/ undefined, message, arg0);
         }
 
@@ -3590,7 +3594,7 @@ namespace ts {
             }
         }
 
-        function createDiagnosticForOption(onKey: boolean, option1: string, option2: string | undefined, message: DiagnosticMessage, arg0: string | number, arg1?: string | number, arg2?: string | number) {
+        function createDiagnosticForOption(onKey: boolean, option1: string, option2: string | undefined, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number) {
             const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
             const needCompilerDiagnostic = !compilerOptionsObjectLiteralSyntax ||
                 !createOptionDiagnosticInObjectLiteralSyntax(compilerOptionsObjectLiteralSyntax, onKey, option1, option2, message, arg0, arg1, arg2);
@@ -3616,7 +3620,7 @@ namespace ts {
             return _compilerOptionsObjectLiteralSyntax || undefined;
         }
 
-        function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral: ObjectLiteralExpression, onKey: boolean, key1: string, key2: string | undefined, message: DiagnosticMessage, arg0: string | number, arg1?: string | number, arg2?: string | number): boolean {
+        function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral: ObjectLiteralExpression, onKey: boolean, key1: string, key2: string | undefined, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number): boolean {
             const props = getPropertyAssignment(objectLiteral, key1, key2);
             for (const prop of props) {
                 programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile!, onKey ? prop.name : prop.initializer, message, arg0, arg1, arg2));
 
@@ -2791,7 +2791,7 @@ namespace ts {
         }
 
         /**
-         * Visits an import declaration, eliding it if it is not referenced and `importsNotUsedAsValues` is not 'preserve'.
+         * Visits an import declaration, eliding it if it is type-only or if it has an import clause that may be elided.
          *
          * @param node The import declaration node.
          */
@@ -2821,29 +2821,27 @@ namespace ts {
         }
 
         /**
-         * Visits an import clause, eliding it if it is not referenced.
+         * Visits an import clause, eliding it if its `name` and `namedBindings` may both be elided.
          *
          * @param node The import clause node.
          */
         function visitImportClause(node: ImportClause): VisitResult<ImportClause> {
-            if (node.isTypeOnly) {
-                return undefined;
-            }
+            Debug.assert(!node.isTypeOnly);
             // Elide the import clause if we elide both its name and its named bindings.
-            const name = resolver.isReferencedAliasDeclaration(node) ? node.name : undefined;
+            const name = shouldEmitAliasDeclaration(node) ? node.name : undefined;
             const namedBindings = visitNode(node.namedBindings, visitNamedImportBindings, isNamedImportBindings);
             return (name || namedBindings) ? factory.updateImportClause(node, /*isTypeOnly*/ false, name, namedBindings) : undefined;
         }
 
         /**
-         * Visits named import bindings, eliding it if it is not referenced.
+         * Visits named import bindings, eliding them if their targets, their references, and the compilation settings allow.
          *
          * @param node The named import bindings node.
          */
         function visitNamedImportBindings(node: NamedImportBindings): VisitResult<NamedImportBindings> {
             if (node.kind === SyntaxKind.NamespaceImport) {
                 // Elide a namespace import if it is not referenced.
-                return resolver.isReferencedAliasDeclaration(node) ? node : undefined;
+                return shouldEmitAliasDeclaration(node) ? node : undefined;
             }
             else {
                 // Elide named imports if all of its import specifiers are elided.
@@ -2853,13 +2851,12 @@ namespace ts {
         }
 
         /**
-         * Visits an import specifier, eliding it if it is not referenced.
+         * Visits an import specifier, eliding it if its target, its references, and the compilation settings allow.
          *
          * @param node The import specifier node.
          */
         function visitImportSpecifier(node: ImportSpecifier): VisitResult<ImportSpecifier> {
-            // Elide an import specifier if it is not referenced.
-            return resolver.isReferencedAliasDeclaration(node) ? node : undefined;
+            return shouldEmitAliasDeclaration(node) ? node : undefined;
         }
 
         /**
@@ -2876,8 +2873,7 @@ namespace ts {
         }
 
         /**
-         * Visits an export declaration, eliding it if it does not contain a clause that resolves
-         * to a value.
+         * Visits an export declaration, eliding it if it does not contain a clause that resolves to a value.
          *
          * @param node The export declaration node.
          */
@@ -2950,7 +2946,7 @@ namespace ts {
             // preserve old compiler's behavior: emit 'var' for import declaration (even if we do not consider them referenced) when
             // - current file is not external module
             // - import declaration is top level and target is value imported by entity name
-            return resolver.isReferencedAliasDeclaration(node)
+            return shouldEmitAliasDeclaration(node)
                 || (!isExternalModule(currentSourceFile)
                     && resolver.isTopLevelValueImportEqualsWithEntityName(node));
         }
@@ -2967,7 +2963,7 @@ namespace ts {
             }
 
             if (isExternalModuleImportEqualsDeclaration(node)) {
-                const isReferenced = resolver.isReferencedAliasDeclaration(node);
+                const isReferenced = shouldEmitAliasDeclaration(node);
                 // If the alias is unreferenced but we want to keep the import, replace with 'import "mod"'.
                 if (!isReferenced && compilerOptions.importsNotUsedAsValues === ImportsNotUsedAsValues.Preserve) {
                     return setOriginalNode(
@@ -3358,5 +3354,11 @@ namespace ts {
 
             return isPropertyAccessExpression(node) || isElementAccessExpression(node) ? resolver.getConstantValue(node) : undefined;
         }
+
+        function shouldEmitAliasDeclaration(node: Node): boolean {
+            return compilerOptions.preserveValueImports
+                ? resolver.isValueAliasDeclaration(node)
+                : resolver.isReferencedAliasDeclaration(node);
+        }
     }
 }
@@ -3109,6 +3109,14 @@ namespace ts {
         | ImportOrExportSpecifier
         ;
 
+    export type TypeOnlyAliasDeclaration =
+        | ImportClause & { readonly isTypeOnly: true, readonly name: Identifier }
+        | ImportEqualsDeclaration & { readonly isTypeOnly: true }
+        | NamespaceImport & { readonly parent: ImportClause & { readonly isTypeOnly: true } }
+        | ImportSpecifier & { readonly parent: NamedImports & { readonly parent: ImportClause & { readonly isTypeOnly: true } } }
+        | ExportSpecifier & { readonly parent: NamedExports & { readonly parent: ExportDeclaration & { readonly isTypeOnly: true } } }
+        ;
+
     /**
      * This is either an `export =` or an `export default` declaration.
      * Unless `isExportEquals` is set, this node was parsed as an `export default`.
@@ -6057,6 +6065,7 @@ namespace ts {
         preserveConstEnums?: boolean;
         noImplicitOverride?: boolean;
         preserveSymlinks?: boolean;
+        preserveValueImports?: boolean;
         /* @internal */ preserveWatchOutput?: boolean;
         project?: string;
         /* @internal */ pretty?: boolean;
@@ -6150,7 +6159,7 @@ namespace ts {
     export const enum ImportsNotUsedAsValues {
         Remove,
         Preserve,
-        Error
+        Error,
     }
 
     export const enum NewLineKind {
 
@@ -1126,7 +1126,7 @@ namespace ts {
         return isImportSpecifier(node) || isExportSpecifier(node);
     }
 
-    export function isTypeOnlyImportOrExportDeclaration(node: Node): node is TypeOnlyCompatibleAliasDeclaration {
+    export function isTypeOnlyImportOrExportDeclaration(node: Node): node is TypeOnlyAliasDeclaration {
         switch (node.kind) {
             case SyntaxKind.ImportSpecifier:
             case SyntaxKind.ExportSpecifier:
Original file line number	Diff line number	Diff line change
`@@ -3305,6 +3305,10 @@ namespace ts {`
`3305`	`3305`	`}`
`3306`	`3306`	`}`
`3307`	`3307`
	`3308`	`+ if (options.preserveValueImports && getEmitModuleKind(options) < ModuleKind.ES2015) {`
	`3309`	`+ createOptionValueDiagnostic("importsNotUsedAsValues", Diagnostics.Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later);`
	`3310`	`+ }`
	`3311`	`+`
`3308`	`3312`	`// If the emit is enabled make sure that every output file is unique and not overwriting any of the input files`
`3309`	`3313`	`if (!options.noEmit && !options.suppressOutputPathCheck) {`
`3310`	`3314`	`const emitHost = getEmitHost();`
`@@ -3575,7 +3579,7 @@ namespace ts {`
`3575`	`3579`	`createDiagnosticForOption(/onKey/ true, option1, option2, message, option1, option2, option3);`
`3576`	`3580`	`}`
`3577`	`3581`
`3578`		`- function createOptionValueDiagnostic(option1: string, message: DiagnosticMessage, arg0: string) {`
	`3582`	`+ function createOptionValueDiagnostic(option1: string, message: DiagnosticMessage, arg0?: string) {`
`3579`	`3583`	`createDiagnosticForOption(/onKey/ false, option1, /option2/ undefined, message, arg0);`
`3580`	`3584`	`}`
`3581`	`3585`
`@@ -3590,7 +3594,7 @@ namespace ts {`
`3590`	`3594`	`}`
`3591`	`3595`	`}`
`3592`	`3596`
`3593`		`- function createDiagnosticForOption(onKey: boolean, option1: string, option2: string \| undefined, message: DiagnosticMessage, arg0: string \| number, arg1?: string \| number, arg2?: string \| number) {`
	`3597`	`+ function createDiagnosticForOption(onKey: boolean, option1: string, option2: string \| undefined, message: DiagnosticMessage, arg0?: string \| number, arg1?: string \| number, arg2?: string \| number) {`
`3594`	`3598`	`const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();`
`3595`	`3599`	`const needCompilerDiagnostic = !compilerOptionsObjectLiteralSyntax \|\|`
`3596`	`3600`	`!createOptionDiagnosticInObjectLiteralSyntax(compilerOptionsObjectLiteralSyntax, onKey, option1, option2, message, arg0, arg1, arg2);`
`@@ -3616,7 +3620,7 @@ namespace ts {`
`3616`	`3620`	`return _compilerOptionsObjectLiteralSyntax \|\| undefined;`
`3617`	`3621`	`}`
`3618`	`3622`
`3619`		`- function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral: ObjectLiteralExpression, onKey: boolean, key1: string, key2: string \| undefined, message: DiagnosticMessage, arg0: string \| number, arg1?: string \| number, arg2?: string \| number): boolean {`
	`3623`	`+ function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral: ObjectLiteralExpression, onKey: boolean, key1: string, key2: string \| undefined, message: DiagnosticMessage, arg0?: string \| number, arg1?: string \| number, arg2?: string \| number): boolean {`
`3620`	`3624`	`const props = getPropertyAssignment(objectLiteral, key1, key2);`
`3621`	`3625`	`for (const prop of props) {`
`3622`	`3626`	`programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile!, onKey ? prop.name : prop.initializer, message, arg0, arg1, arg2));`
Original file line number	Diff line number	Diff line change
`@@ -2791,7 +2791,7 @@ namespace ts {`
`2791`	`2791`	`}`
`2792`	`2792`
`2793`	`2793`	`/**`
`2794`		- * Visits an import declaration, eliding it if it is not referenced and `importsNotUsedAsValues` is not 'preserve'.
	`2794`	`+ * Visits an import declaration, eliding it if it is type-only or if it has an import clause that may be elided.`
`2795`	`2795`	`*`
`2796`	`2796`	`* @param node The import declaration node.`
`2797`	`2797`	`*/`
`@@ -2821,29 +2821,27 @@ namespace ts {`
`2821`	`2821`	`}`
`2822`	`2822`
`2823`	`2823`	`/**`
`2824`		`- * Visits an import clause, eliding it if it is not referenced.`
	`2824`	+ * Visits an import clause, eliding it if its `name` and `namedBindings` may both be elided.
`2825`	`2825`	`*`
`2826`	`2826`	`* @param node The import clause node.`
`2827`	`2827`	`*/`
`2828`	`2828`	`function visitImportClause(node: ImportClause): VisitResult<ImportClause> {`
`2829`		`- if (node.isTypeOnly) {`
`2830`		`- return undefined;`
`2831`		`- }`
	`2829`	`+ Debug.assert(!node.isTypeOnly);`
`2832`	`2830`	`// Elide the import clause if we elide both its name and its named bindings.`
`2833`		`- const name = resolver.isReferencedAliasDeclaration(node) ? node.name : undefined;`
	`2831`	`+ const name = shouldEmitAliasDeclaration(node) ? node.name : undefined;`
`2834`	`2832`	`const namedBindings = visitNode(node.namedBindings, visitNamedImportBindings, isNamedImportBindings);`
`2835`	`2833`	`return (name \|\| namedBindings) ? factory.updateImportClause(node, /isTypeOnly/ false, name, namedBindings) : undefined;`
`2836`	`2834`	`}`
`2837`	`2835`
`2838`	`2836`	`/**`
`2839`		`- * Visits named import bindings, eliding it if it is not referenced.`
	`2837`	`+ * Visits named import bindings, eliding them if their targets, their references, and the compilation settings allow.`
`2840`	`2838`	`*`
`2841`	`2839`	`* @param node The named import bindings node.`
`2842`	`2840`	`*/`
`2843`	`2841`	`function visitNamedImportBindings(node: NamedImportBindings): VisitResult<NamedImportBindings> {`
`2844`	`2842`	`if (node.kind === SyntaxKind.NamespaceImport) {`
`2845`	`2843`	`// Elide a namespace import if it is not referenced.`
`2846`		`- return resolver.isReferencedAliasDeclaration(node) ? node : undefined;`
	`2844`	`+ return shouldEmitAliasDeclaration(node) ? node : undefined;`
`2847`	`2845`	`}`
`2848`	`2846`	`else {`
`2849`	`2847`	`// Elide named imports if all of its import specifiers are elided.`
`@@ -2853,13 +2851,12 @@ namespace ts {`
`2853`	`2851`	`}`
`2854`	`2852`
`2855`	`2853`	`/**`
`2856`		`- * Visits an import specifier, eliding it if it is not referenced.`
	`2854`	`+ * Visits an import specifier, eliding it if its target, its references, and the compilation settings allow.`
`2857`	`2855`	`*`
`2858`	`2856`	`* @param node The import specifier node.`
`2859`	`2857`	`*/`
`2860`	`2858`	`function visitImportSpecifier(node: ImportSpecifier): VisitResult<ImportSpecifier> {`
`2861`		`- // Elide an import specifier if it is not referenced.`
`2862`		`- return resolver.isReferencedAliasDeclaration(node) ? node : undefined;`
	`2859`	`+ return shouldEmitAliasDeclaration(node) ? node : undefined;`
`2863`	`2860`	`}`
`2864`	`2861`
`2865`	`2862`	`/**`
`@@ -2876,8 +2873,7 @@ namespace ts {`
`2876`	`2873`	`}`
`2877`	`2874`
`2878`	`2875`	`/**`
`2879`		`- * Visits an export declaration, eliding it if it does not contain a clause that resolves`
`2880`		`- * to a value.`
	`2876`	`+ * Visits an export declaration, eliding it if it does not contain a clause that resolves to a value.`
`2881`	`2877`	`*`
`2882`	`2878`	`* @param node The export declaration node.`
`2883`	`2879`	`*/`
`@@ -2950,7 +2946,7 @@ namespace ts {`
`2950`	`2946`	`// preserve old compiler's behavior: emit 'var' for import declaration (even if we do not consider them referenced) when`
`2951`	`2947`	`// - current file is not external module`
`2952`	`2948`	`// - import declaration is top level and target is value imported by entity name`
`2953`		`- return resolver.isReferencedAliasDeclaration(node)`
	`2949`	`+ return shouldEmitAliasDeclaration(node)`
`2954`	`2950`	`\|\| (!isExternalModule(currentSourceFile)`
`2955`	`2951`	`&& resolver.isTopLevelValueImportEqualsWithEntityName(node));`
`2956`	`2952`	`}`
`@@ -2967,7 +2963,7 @@ namespace ts {`
`2967`	`2963`	`}`
`2968`	`2964`
`2969`	`2965`	`if (isExternalModuleImportEqualsDeclaration(node)) {`
`2970`		`- const isReferenced = resolver.isReferencedAliasDeclaration(node);`
	`2966`	`+ const isReferenced = shouldEmitAliasDeclaration(node);`
`2971`	`2967`	`// If the alias is unreferenced but we want to keep the import, replace with 'import "mod"'.`
`2972`	`2968`	`if (!isReferenced && compilerOptions.importsNotUsedAsValues === ImportsNotUsedAsValues.Preserve) {`
`2973`	`2969`	`return setOriginalNode(`
`@@ -3358,5 +3354,11 @@ namespace ts {`
`3358`	`3354`
`3359`	`3355`	`return isPropertyAccessExpression(node) \|\| isElementAccessExpression(node) ? resolver.getConstantValue(node) : undefined;`
`3360`	`3356`	`}`
	`3357`	`+`
	`3358`	`+ function shouldEmitAliasDeclaration(node: Node): boolean {`
	`3359`	`+ return compilerOptions.preserveValueImports`
	`3360`	`+ ? resolver.isValueAliasDeclaration(node)`
	`3361`	`+ : resolver.isReferencedAliasDeclaration(node);`
	`3362`	`+ }`
`3361`	`3363`	`}`
`3362`	`3364`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1126,7 +1126,7 @@ namespace ts {`
`1126`	`1126`	`return isImportSpecifier(node) \|\| isExportSpecifier(node);`
`1127`	`1127`	`}`
`1128`	`1128`
`1129`		`- export function isTypeOnlyImportOrExportDeclaration(node: Node): node is TypeOnlyCompatibleAliasDeclaration {`
	`1129`	`+ export function isTypeOnlyImportOrExportDeclaration(node: Node): node is TypeOnlyAliasDeclaration {`
`1130`	`1130`	`switch (node.kind) {`
`1131`	`1131`	`case SyntaxKind.ImportSpecifier:`
`1132`	`1132`	`case SyntaxKind.ExportSpecifier:`