Add declaration transform stage that combines repeated import type nodes into single import declarations

src/compiler/checker.ts

@@ -6268,12 +6268,16 @@ namespace ts {
                             const lastId = isIdentifier(nonRootParts) ? nonRootParts : nonRootParts.right;
                             lastId.typeArguments = undefined;
                         }
-                        return factory.createImportTypeNode(lit, assertion, nonRootParts as EntityName, typeParameterNodes as readonly TypeNode[], isTypeOf);
+                        const node = factory.createImportTypeNode(lit, assertion, nonRootParts as EntityName, typeParameterNodes as readonly TypeNode[], isTypeOf);
+                        node.nextContainer = context.enclosingDeclaration; // `nextContainer` is used in the binder to track containers - reuse it on import types to smuggle out original context info
+                        return node;
                     }
                     else {
                         const splitNode = getTopmostIndexedAccessType(nonRootParts);
                         const qualifier = (splitNode.objectType as TypeReferenceNode).typeName;
-                        return factory.createIndexedAccessTypeNode(factory.createImportTypeNode(lit, assertion, qualifier, typeParameterNodes as readonly TypeNode[], isTypeOf), splitNode.indexType);
+                        const node = factory.createImportTypeNode(lit, assertion, qualifier, typeParameterNodes as readonly TypeNode[], isTypeOf);
+                        node.nextContainer = context.enclosingDeclaration; // `nextContainer` is used in the binder to track containers - reuse it on import types to smuggle out original context info
+                        return factory.createIndexedAccessTypeNode(node, splitNode.indexType);
                     }
                 }
 
@@ -43273,6 +43277,9 @@ namespace ts {
                 createLiteralConstValue,
                 isSymbolAccessible,
                 isEntityNameVisible,
+                resolveName(name, location, meaning, excludeGlobals) {
+                    return resolveName(getParseTreeNode(location), escapeLeadingUnderscores(name), meaning, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false, excludeGlobals);
+                },
                 getConstantValue: nodeIn => {
                     const node = getParseTreeNode(nodeIn, canHaveConstantValue);
                     return node ? getConstantValue(node) : undefined;

src/compiler/commandLineParser.ts

@@ -510,6 +510,16 @@ namespace ts {
             defaultValueDescription: false,
             description: Diagnostics.Create_sourcemaps_for_d_ts_files
         },
+        {
+            name: "prettyDeclaration",
+            type: "boolean",
+            affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
+            category: Diagnostics.Emit,
+            transpileOptionValue: undefined,
+            description: Diagnostics.Enable_extra_transform_stages_that_make_declaration_emit_output_prettier,
+            defaultValueDescription: Diagnostics.true_if_declaration_is_true_false_otherwise,
+        },
         {
             name: "emitDeclarationOnly",
             type: "boolean",

src/compiler/diagnosticMessages.json

@@ -5835,6 +5835,14 @@
         "category": "Message",
         "code": 6803
     },
+    "Enable extra transform stages that make declaration emit output prettier.": {
+        "category": "Message",
+        "code": 6804
+    },
+    "true if declaration is true, false otherwise.": {
+        "category": "Message",
+        "code": 6805
+    },
 
     "one of:": {
         "category": "Message",

src/compiler/emitter.ts

@@ -686,6 +686,7 @@ namespace ts {
         createLiteralConstValue: notImplemented,
         isSymbolAccessible: notImplemented,
         isEntityNameVisible: notImplemented,
+        resolveName: notImplemented,
         // Returns the constant value this property access resolves to: notImplemented, or 'undefined' for a non-constant
         getConstantValue: notImplemented,
         getReferencedValueDeclaration: notImplemented,

src/compiler/factory/nodeFactory.ts

@@ -5354,10 +5354,16 @@ namespace ts {
 
         // @api
         function updateBundle(node: Bundle, sourceFiles: readonly SourceFile[], prepends: readonly (UnparsedSource | InputFiles)[] = emptyArray) {
-            return node.sourceFiles !== sourceFiles
-                || node.prepends !== prepends
-                ? update(createBundle(sourceFiles, prepends), node)
-                : node;
+            if (node.sourceFiles !== sourceFiles
+                || node.prepends !== prepends) {
+                const newNode = update(createBundle(sourceFiles, prepends), node);
+                newNode.syntheticFileReferences = node.syntheticFileReferences;
+                newNode.syntheticLibReferences = node.syntheticLibReferences;
+                newNode.syntheticTypeReferences = node.syntheticTypeReferences;
+                newNode.hasNoDefaultLib = node.hasNoDefaultLib;
+                return newNode;
+            }
+            return node;
         }
 
         // @api

src/compiler/transformer.ts

@@ -34,7 +34,7 @@ namespace ts {
     export function getTransformers(compilerOptions: CompilerOptions, customTransformers?: CustomTransformers, emitOnlyDtsFiles?: boolean): EmitTransformers {
         return {
             scriptTransformers: getScriptTransformers(compilerOptions, customTransformers, emitOnlyDtsFiles),
-            declarationTransformers: getDeclarationTransformers(customTransformers),
+            declarationTransformers: getDeclarationTransformers(compilerOptions, customTransformers),
         };
     }
 
@@ -100,9 +100,12 @@ namespace ts {
         return transformers;
     }
 
-    function getDeclarationTransformers(customTransformers?: CustomTransformers) {
+    function getDeclarationTransformers(compilerOptions: CompilerOptions, customTransformers?: CustomTransformers) {
         const transformers: TransformerFactory<SourceFile | Bundle>[] = [];
         transformers.push(transformDeclarations);
+        if (getEmitPrettyDeclarations(compilerOptions)) {
+            transformers.push(transformCoalesceImports);
+        }
         addRange(transformers, customTransformers && map(customTransformers.afterDeclarations, wrapDeclarationTransformerFactory));
         return transformers;
     }