Build better import paths for declaration emit/typeToString from reexports if possible (#27340)

* Build better import paths from reexports if possible, issue error on node_modules import generation

* Small refactorings

* Add file-by-file cacheing

* Minor cleanups

* Adjust error message

src/compiler/checker.ts

@@ -2599,6 +2599,44 @@ namespace ts {
             return getMergedSymbol(symbol.parent && getLateBoundSymbol(symbol.parent));
         }
 
+        function getAlternativeContainingModules(symbol: Symbol, enclosingDeclaration: Node): Symbol[] {
+            const containingFile = getSourceFileOfNode(enclosingDeclaration);
+            const id = "" + getNodeId(containingFile);
+            const links = getSymbolLinks(symbol);
+            let results: Symbol[] | undefined;
+            if (links.extendedContainersByFile && (results = links.extendedContainersByFile.get(id))) {
+                return results;
+            }
+            if (containingFile && containingFile.imports) {
+                // Try to make an import using an import already in the enclosing file, if possible
+                for (const importRef of containingFile.imports) {
+                    if (nodeIsSynthesized(importRef)) continue; // Synthetic names can't be resolved by `resolveExternalModuleName` - they'll cause a debug assert if they error
+                    const resolvedModule = resolveExternalModuleName(enclosingDeclaration, importRef);
+                    if (!resolvedModule) continue;
+                    const ref = getAliasForSymbolInContainer(resolvedModule, symbol);
+                    if (!ref) continue;
+                    results = append(results, resolvedModule);
+                }
+                if (length(results)) {
+                    (links.extendedContainersByFile || (links.extendedContainersByFile = createMap())).set(id, results!);
+                    return results!;
+                }
+            }
+            if (links.extendedContainers) {
+                return links.extendedContainers;
+            }
+            // No results from files already being imported by this file - expand search (expensive, but not location-specific, so cached)
+            const otherFiles = host.getSourceFiles();
+            for (const file of otherFiles) {
+                if (!isExternalModule(file)) continue;
+                const sym = getSymbolOfNode(file);
+                const ref = getAliasForSymbolInContainer(sym, symbol);
+                if (!ref) continue;
+                results = append(results, sym);
+            }
+            return links.extendedContainers = results || emptyArray;
+        }
+
         /**
          * Attempts to find the symbol corresponding to the container a symbol is in - usually this
          * is just its' `.parent`, but for locals, this value is `undefined`
@@ -2607,10 +2645,12 @@ namespace ts {
             const container = getParentOfSymbol(symbol);
             if (container) {
                 const additionalContainers = mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
+                const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
                 if (enclosingDeclaration && getAccessibleSymbolChain(container, enclosingDeclaration, SymbolFlags.Namespace, /*externalOnly*/ false)) {
-                    return concatenate([container], additionalContainers); // This order expresses a preference for the real container if it is in scope
+                    return concatenate(concatenate([container], additionalContainers), reexportContainers); // This order expresses a preference for the real container if it is in scope
                 }
-                return append(additionalContainers, container);
+                const res = append(additionalContainers, container);
+                return concatenate(res, reexportContainers);
             }
             const candidates = mapDefined(symbol.declarations, d => !isAmbientModule(d) && d.parent && hasNonGlobalAugmentationExternalModuleSymbol(d.parent) ? getSymbolOfNode(d.parent) : undefined);
             if (!length(candidates)) {
@@ -3981,14 +4021,21 @@ namespace ts {
                 /** @param endOfChain Set to false for recursive calls; non-recursive calls should always output something. */
                 function getSymbolChain(symbol: Symbol, meaning: SymbolFlags, endOfChain: boolean): Symbol[] | undefined {
                     let accessibleSymbolChain = getAccessibleSymbolChain(symbol, context.enclosingDeclaration, meaning, !!(context.flags & NodeBuilderFlags.UseOnlyExternalAliasing));
-
+                    let parentSpecifiers: (string | undefined)[];
                     if (!accessibleSymbolChain ||
                         needsQualification(accessibleSymbolChain[0], context.enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {
 
                         // Go up and add our parent.
                         const parents = getContainersOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol, context.enclosingDeclaration);
                         if (length(parents)) {
-                            for (const parent of parents!) {
+                            parentSpecifiers = parents!.map(symbol =>
+                                some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)
+                                    ? getSpecifierForModuleSymbol(symbol, context)
+                                    : undefined);
+                            const indices = parents!.map((_, i) => i);
+                            indices.sort(sortByBestName);
+                            const sortedParents = indices.map(i => parents![i]);
+                            for (const parent of sortedParents) {
                                 const parentChain = getSymbolChain(parent, getQualifiedLeftMeaning(meaning), /*endOfChain*/ false);
                                 if (parentChain) {
                                     accessibleSymbolChain = parentChain.concat(accessibleSymbolChain || [getAliasForSymbolInContainer(parent, symbol) || symbol]);
@@ -4012,6 +4059,25 @@ namespace ts {
                         }
                         return [symbol];
                     }
+
+                    function sortByBestName(a: number, b: number) {
+                        const specifierA = parentSpecifiers[a];
+                        const specifierB = parentSpecifiers[b];
+                        if (specifierA && specifierB) {
+                            const isBRelative = pathIsRelative(specifierB);
+                            if (pathIsRelative(specifierA) === isBRelative) {
+                                // Both relative or both non-relative, sort by number of parts
+                                return moduleSpecifiers.countPathComponents(specifierA) - moduleSpecifiers.countPathComponents(specifierB);
+                            }
+                            if (isBRelative) {
+                                // A is non-relative, B is relative: prefer A
+                                return -1;
+                            }
+                            // A is relative, B is non-relative: prefer B
+                            return 1;
+                        }
+                        return 0;
+                    }
                 }
             }
 
@@ -4115,6 +4181,14 @@ namespace ts {
                     const nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(chain, chain.length - 1, 1) : undefined;
                     const typeParameterNodes = overrideTypeArguments || lookupTypeParameterNodes(chain, 0, context);
                     const specifier = getSpecifierForModuleSymbol(chain[0], context);
+                    if (!(context.flags & NodeBuilderFlags.AllowNodeModulesRelativePaths) && getEmitModuleResolutionKind(compilerOptions) === ModuleResolutionKind.NodeJs && specifier.indexOf("/node_modules/") >= 0) {
+                        // If ultimately we can only name the symbol with a reference that dives into a `node_modules` folder, we should error
+                        // since declaration files with these kinds of references are liable to fail when published :(
+                        context.encounteredError = true;
+                        if (context.tracker.reportLikelyUnsafeImportRequiredError) {
+                            context.tracker.reportLikelyUnsafeImportRequiredError(specifier);
+                        }
+                    }
                     const lit = createLiteralTypeNode(createLiteral(specifier));
                     if (context.tracker.trackExternalModuleSymbolOfImportTypeNode) context.tracker.trackExternalModuleSymbolOfImportTypeNode(chain[0]);
                     context.approximateLength += specifier.length + 10; // specifier + import("")

src/compiler/diagnosticMessages.json

@@ -2525,6 +2525,10 @@
         "category": "Error",
         "code": 2741
     },
+    "The inferred type of '{0}' cannot be named without a reference to '{1}'. This is likely not portable. A type annotation is necessary.": {
+        "category": "Error",
+        "code": 2742
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/moduleSpecifiers.ts

@@ -139,7 +139,7 @@ namespace ts.moduleSpecifiers {
         return isPathRelativeToParent(nonRelative) || countPathComponents(relativePath) < countPathComponents(nonRelative) ? relativePath : nonRelative;
     }
 
-    function countPathComponents(path: string): number {
+    export function countPathComponents(path: string): number {
         let count = 0;
         for (let i = startsWith(path, "./") ? 2 : 0; i < path.length; i++) {
             if (path.charCodeAt(i) === CharacterCodes.slash) count++;

src/compiler/transformers/declarations.ts

@@ -45,6 +45,7 @@ namespace ts {
             reportInaccessibleThisError,
             reportInaccessibleUniqueSymbolError,
             reportPrivateInBaseOfClassExpression,
+            reportLikelyUnsafeImportRequiredError,
             moduleResolverHost: host,
             trackReferencedAmbientModule,
             trackExternalModuleSymbolOfImportTypeNode
@@ -153,6 +154,14 @@ namespace ts {
             }
         }
 
+        function reportLikelyUnsafeImportRequiredError(specifier: string) {
+            if (errorNameNode) {
+                context.addDiagnostic(createDiagnosticForNode(errorNameNode, Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary,
+                    declarationNameToString(errorNameNode),
+                    specifier));
+            }
+        }
+
         function transformRoot(node: Bundle): Bundle;
         function transformRoot(node: SourceFile): SourceFile;
         function transformRoot(node: SourceFile | Bundle): SourceFile | Bundle;

src/compiler/types.ts

@@ -3261,15 +3261,17 @@ namespace ts {
         AllowUniqueESSymbolType                 = 1 << 20,
         AllowEmptyIndexInfoType                 = 1 << 21,
 
-        IgnoreErrors = AllowThisInObjectLiteral | AllowQualifedNameInPlaceOfIdentifier | AllowAnonymousIdentifier | AllowEmptyUnionOrIntersection | AllowEmptyTuple | AllowEmptyIndexInfoType,
+        // Errors (cont.)
+        AllowNodeModulesRelativePaths           = 1 << 26,
+        /* @internal */ DoNotIncludeSymbolChain = 1 << 27,    // Skip looking up and printing an accessible symbol chain
+
+        IgnoreErrors = AllowThisInObjectLiteral | AllowQualifedNameInPlaceOfIdentifier | AllowAnonymousIdentifier | AllowEmptyUnionOrIntersection | AllowEmptyTuple | AllowEmptyIndexInfoType | AllowNodeModulesRelativePaths,
 
         // State
         InObjectTypeLiteral                     = 1 << 22,
         InTypeAlias                             = 1 << 23,    // Writing type in type alias declaration
         InInitialEntityName                     = 1 << 24,    // Set when writing the LHS of an entity name or entity name expression
         InReverseMappedType                     = 1 << 25,
-
-        /* @internal */ DoNotIncludeSymbolChain                 = 1 << 26,    // Skip looking up and printing an accessible symbol chain
     }
 
     // Ensure the shared flags between this and `NodeBuilderFlags` stay in alignment
@@ -3650,6 +3652,8 @@ namespace ts {
         originatingImport?: ImportDeclaration | ImportCall; // Import declaration which produced the symbol, present if the symbol is marked as uncallable but had call signatures in `resolveESModuleSymbol`
         lateSymbol?: Symbol;                // Late-bound symbol for a computed property
         specifierCache?: Map<string>;     // For symbols corresponding to external modules, a cache of incoming path -> module specifier name mappings
+        extendedContainers?: Symbol[];      // Containers (other than the parent) which this symbol is aliased in
+        extendedContainersByFile?: Map<Symbol[]>;      // Containers (other than the parent) which this symbol is aliased in
         variances?: Variance[];             // Alias symbol type argument variance cache
     }
 
@@ -5576,6 +5580,7 @@ namespace ts {
         reportInaccessibleThisError?(): void;
         reportPrivateInBaseOfClassExpression?(propertyName: string): void;
         reportInaccessibleUniqueSymbolError?(): void;
+        reportLikelyUnsafeImportRequiredError?(specifier: string): void;
         moduleResolverHost?: ModuleSpecifierResolutionHost & { getSourceFiles(): ReadonlyArray<SourceFile>, getCommonSourceDirectory(): string };
         trackReferencedAmbientModule?(decl: ModuleDeclaration, symbol: Symbol): void;
         trackExternalModuleSymbolOfImportTypeNode?(symbol: Symbol): void;

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -1976,7 +1976,8 @@ declare namespace ts {
         AllowEmptyTuple = 524288,
         AllowUniqueESSymbolType = 1048576,
         AllowEmptyIndexInfoType = 2097152,
-        IgnoreErrors = 3112960,
+        AllowNodeModulesRelativePaths = 67108864,
+        IgnoreErrors = 70221824,
         InObjectTypeLiteral = 4194304,
         InTypeAlias = 8388608,
         InInitialEntityName = 16777216,

tests/baselines/reference/api/typescript.d.ts

@@ -1976,7 +1976,8 @@ declare namespace ts {
         AllowEmptyTuple = 524288,
         AllowUniqueESSymbolType = 1048576,
         AllowEmptyIndexInfoType = 2097152,
-        IgnoreErrors = 3112960,
+        AllowNodeModulesRelativePaths = 67108864,
+        IgnoreErrors = 70221824,
         InObjectTypeLiteral = 4194304,
         InTypeAlias = 8388608,
         InInitialEntityName = 16777216,

tests/baselines/reference/declarationEmitCommonJsModuleReferencedType.errors.txt

@@ -0,0 +1,28 @@
+tests/cases/compiler/r/entry.ts(3,14): error TS2742: The inferred type of 'x' cannot be named without a reference to 'foo/node_modules/nested'. This is likely not portable. A type annotation is necessary.
+
+
+==== tests/cases/compiler/r/node_modules/foo/node_modules/nested/index.d.ts (0 errors) ====
+    export interface NestedProps {}
+==== tests/cases/compiler/r/node_modules/foo/other/index.d.ts (0 errors) ====
+    export interface OtherIndexProps {}
+==== tests/cases/compiler/r/node_modules/foo/other.d.ts (0 errors) ====
+    export interface OtherProps {}
+==== tests/cases/compiler/r/node_modules/foo/index.d.ts (0 errors) ====
+    import { OtherProps } from "./other";
+    import { OtherIndexProps } from "./other/index";
+    import { NestedProps } from "nested";
+    export interface SomeProps {}
+    
+    export function foo(): [SomeProps, OtherProps, OtherIndexProps, NestedProps];
+==== tests/cases/compiler/node_modules/root/index.d.ts (0 errors) ====
+    export interface RootProps {}
+    
+    export function bar(): RootProps;
+==== tests/cases/compiler/r/entry.ts (1 errors) ====
+    import { foo } from "foo";
+    import { bar } from "root";
+    export const x = foo();
+                 ~
+!!! error TS2742: The inferred type of 'x' cannot be named without a reference to 'foo/node_modules/nested'. This is likely not portable. A type annotation is necessary.
+    export const y = bar();
+    

tests/baselines/reference/declarationEmitCommonJsModuleReferencedType.js

@@ -31,8 +31,3 @@ var foo_1 = require("foo");
 var root_1 = require("root");
 exports.x = foo_1.foo();
 exports.y = root_1.bar();
-
-
-//// [entry.d.ts]
-export declare const x: [import("foo").SomeProps, import("foo/other").OtherProps, import("foo/other/index").OtherIndexProps, import("foo/node_modules/nested").NestedProps];
-export declare const y: import("root").RootProps;

tests/baselines/reference/declarationEmitReexportedSymlinkReference.js

@@ -0,0 +1,64 @@
+//// [tests/cases/compiler/declarationEmitReexportedSymlinkReference.ts] ////
+
+//// [index.d.ts]
+export * from './types';
+//// [types.d.ts]
+export declare type A = {
+    id: string;
+};
+export declare type B = {
+    id: number;
+};
+export declare type IdType = A | B;
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+    readonly key: string;
+    private constructor();
+    toString(): string;
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+}
+//// [package.json]
+{
+    "name": "@raymondfeng/pkg1",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+//// [index.d.ts]
+export * from './types';
+//// [types.d.ts]
+export * from '@raymondfeng/pkg1';
+//// [package.json]
+{
+    "name": "@raymondfeng/pkg2",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+//// [index.ts]
+export * from './keys';
+//// [keys.ts]
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+
+//// [keys.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var pkg2_1 = require("@raymondfeng/pkg2");
+exports.ADMIN = pkg2_1.MetadataAccessor.create('1');
+//// [index.js]
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./keys"));
+
+
+//// [keys.d.ts]
+import { MetadataAccessor } from "@raymondfeng/pkg2";
+export declare const ADMIN: MetadataAccessor<boolean, import("@raymondfeng/pkg2").IdType>;
+//// [index.d.ts]
+export * from './keys';

tests/baselines/reference/declarationEmitReexportedSymlinkReference.symbols

@@ -0,0 +1,63 @@
+=== tests/cases/compiler/monorepo/pkg1/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts ===
+export declare type A = {
+>A : Symbol(A, Decl(types.d.ts, 0, 0))
+
+    id: string;
+>id : Symbol(id, Decl(types.d.ts, 0, 25))
+
+};
+export declare type B = {
+>B : Symbol(B, Decl(types.d.ts, 2, 2))
+
+    id: number;
+>id : Symbol(id, Decl(types.d.ts, 3, 25))
+
+};
+export declare type IdType = A | B;
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>A : Symbol(A, Decl(types.d.ts, 0, 0))
+>B : Symbol(B, Decl(types.d.ts, 2, 2))
+
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(types.d.ts, 6, 35))
+>T : Symbol(T, Decl(types.d.ts, 7, 38))
+>D : Symbol(D, Decl(types.d.ts, 7, 40))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+
+    readonly key: string;
+>key : Symbol(MetadataAccessor.key, Decl(types.d.ts, 7, 69))
+
+    private constructor();
+    toString(): string;
+>toString : Symbol(MetadataAccessor.toString, Decl(types.d.ts, 9, 26))
+
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+>create : Symbol(MetadataAccessor.create, Decl(types.d.ts, 10, 23))
+>T : Symbol(T, Decl(types.d.ts, 11, 18))
+>D : Symbol(D, Decl(types.d.ts, 11, 20))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>key : Symbol(key, Decl(types.d.ts, 11, 48))
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(types.d.ts, 6, 35))
+>T : Symbol(T, Decl(types.d.ts, 11, 18))
+>D : Symbol(D, Decl(types.d.ts, 11, 20))
+}
+=== tests/cases/compiler/monorepo/pkg2/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg2/dist/types.d.ts ===
+export * from '@raymondfeng/pkg1';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg3/src/index.ts ===
+export * from './keys';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg3/src/keys.ts ===
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(keys.ts, 0, 8))
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+>ADMIN : Symbol(ADMIN, Decl(keys.ts, 2, 12))
+>MetadataAccessor.create : Symbol(MetadataAccessor.create, Decl(types.d.ts, 10, 23))
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(keys.ts, 0, 8))
+>create : Symbol(MetadataAccessor.create, Decl(types.d.ts, 10, 23))
+

tests/baselines/reference/declarationEmitReexportedSymlinkReference.types

@@ -0,0 +1,52 @@
+=== tests/cases/compiler/monorepo/pkg1/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts ===
+export declare type A = {
+>A : A
+
+    id: string;
+>id : string
+
+};
+export declare type B = {
+>B : B
+
+    id: number;
+>id : number
+
+};
+export declare type IdType = A | B;
+>IdType : IdType
+
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+>MetadataAccessor : MetadataAccessor<T, D>
+
+    readonly key: string;
+>key : string
+
+    private constructor();
+    toString(): string;
+>toString : () => string
+
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+>create : <T, D extends IdType = IdType>(key: string) => MetadataAccessor<T, D>
+>key : string
+}
+=== tests/cases/compiler/monorepo/pkg2/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg2/dist/types.d.ts ===
+export * from '@raymondfeng/pkg1';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg3/src/index.ts ===
+export * from './keys';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg3/src/keys.ts ===
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+>MetadataAccessor : typeof MetadataAccessor
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+>ADMIN : MetadataAccessor<boolean, import("tests/cases/compiler/monorepo/pkg2/dist/index").IdType>
+>MetadataAccessor.create<boolean>('1') : MetadataAccessor<boolean, import("tests/cases/compiler/monorepo/pkg2/dist/index").IdType>
+>MetadataAccessor.create : <T, D extends import("tests/cases/compiler/monorepo/pkg2/dist/index").IdType = import("tests/cases/compiler/monorepo/pkg2/dist/index").IdType>(key: string) => MetadataAccessor<T, D>
+>MetadataAccessor : typeof MetadataAccessor
+>create : <T, D extends import("tests/cases/compiler/monorepo/pkg2/dist/index").IdType = import("tests/cases/compiler/monorepo/pkg2/dist/index").IdType>(key: string) => MetadataAccessor<T, D>
+>'1' : "1"
+

tests/baselines/reference/declarationEmitReexportedSymlinkReference2.js

@@ -0,0 +1,67 @@
+//// [tests/cases/compiler/declarationEmitReexportedSymlinkReference2.ts] ////
+
+//// [index.d.ts]
+export * from './types';
+//// [types.d.ts]
+export declare type A = {
+    id: string;
+};
+export declare type B = {
+    id: number;
+};
+export declare type IdType = A | B;
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+    readonly key: string;
+    private constructor();
+    toString(): string;
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+}
+//// [package.json]
+{
+    "name": "@raymondfeng/pkg1",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+//// [index.d.ts]
+import "./secondary";
+export * from './types';
+//// [types.d.ts]
+export {MetadataAccessor} from '@raymondfeng/pkg1';
+//// [secondary.d.ts]
+export {IdType} from '@raymondfeng/pkg1';
+//// [package.json]
+{
+    "name": "@raymondfeng/pkg2",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+//// [index.ts]
+export * from './keys';
+//// [keys.ts]
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+
+//// [keys.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var pkg2_1 = require("@raymondfeng/pkg2");
+exports.ADMIN = pkg2_1.MetadataAccessor.create('1');
+//// [index.js]
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./keys"));
+
+
+//// [keys.d.ts]
+import { MetadataAccessor } from "@raymondfeng/pkg2";
+export declare const ADMIN: MetadataAccessor<boolean, import("@raymondfeng/pkg2/dist/secondary").IdType>;
+//// [index.d.ts]
+export * from './keys';

tests/baselines/reference/declarationEmitReexportedSymlinkReference2.symbols

@@ -0,0 +1,70 @@
+=== tests/cases/compiler/monorepo/pkg1/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts ===
+export declare type A = {
+>A : Symbol(A, Decl(types.d.ts, 0, 0))
+
+    id: string;
+>id : Symbol(id, Decl(types.d.ts, 0, 25))
+
+};
+export declare type B = {
+>B : Symbol(B, Decl(types.d.ts, 2, 2))
+
+    id: number;
+>id : Symbol(id, Decl(types.d.ts, 3, 25))
+
+};
+export declare type IdType = A | B;
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>A : Symbol(A, Decl(types.d.ts, 0, 0))
+>B : Symbol(B, Decl(types.d.ts, 2, 2))
+
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(types.d.ts, 6, 35))
+>T : Symbol(T, Decl(types.d.ts, 7, 38))
+>D : Symbol(D, Decl(types.d.ts, 7, 40))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+
+    readonly key: string;
+>key : Symbol(MetadataAccessor.key, Decl(types.d.ts, 7, 69))
+
+    private constructor();
+    toString(): string;
+>toString : Symbol(MetadataAccessor.toString, Decl(types.d.ts, 9, 26))
+
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+>create : Symbol(MetadataAccessor.create, Decl(types.d.ts, 10, 23))
+>T : Symbol(T, Decl(types.d.ts, 11, 18))
+>D : Symbol(D, Decl(types.d.ts, 11, 20))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>key : Symbol(key, Decl(types.d.ts, 11, 48))
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(types.d.ts, 6, 35))
+>T : Symbol(T, Decl(types.d.ts, 11, 18))
+>D : Symbol(D, Decl(types.d.ts, 11, 20))
+}
+=== tests/cases/compiler/monorepo/pkg2/dist/index.d.ts ===
+import "./secondary";
+No type information for this code.export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg2/dist/types.d.ts ===
+export {MetadataAccessor} from '@raymondfeng/pkg1';
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(types.d.ts, 0, 8))
+
+=== tests/cases/compiler/monorepo/pkg2/dist/secondary.d.ts ===
+export {IdType} from '@raymondfeng/pkg1';
+>IdType : Symbol(IdType, Decl(secondary.d.ts, 0, 8))
+
+=== tests/cases/compiler/monorepo/pkg3/src/index.ts ===
+export * from './keys';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg3/src/keys.ts ===
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(keys.ts, 0, 8))
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+>ADMIN : Symbol(ADMIN, Decl(keys.ts, 2, 12))
+>MetadataAccessor.create : Symbol(MetadataAccessor.create, Decl(types.d.ts, 10, 23))
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(keys.ts, 0, 8))
+>create : Symbol(MetadataAccessor.create, Decl(types.d.ts, 10, 23))
+

tests/baselines/reference/declarationEmitReexportedSymlinkReference2.types

@@ -0,0 +1,59 @@
+=== tests/cases/compiler/monorepo/pkg1/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts ===
+export declare type A = {
+>A : A
+
+    id: string;
+>id : string
+
+};
+export declare type B = {
+>B : B
+
+    id: number;
+>id : number
+
+};
+export declare type IdType = A | B;
+>IdType : IdType
+
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+>MetadataAccessor : MetadataAccessor<T, D>
+
+    readonly key: string;
+>key : string
+
+    private constructor();
+    toString(): string;
+>toString : () => string
+
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+>create : <T, D extends IdType = IdType>(key: string) => MetadataAccessor<T, D>
+>key : string
+}
+=== tests/cases/compiler/monorepo/pkg2/dist/index.d.ts ===
+import "./secondary";
+No type information for this code.export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg2/dist/types.d.ts ===
+export {MetadataAccessor} from '@raymondfeng/pkg1';
+>MetadataAccessor : typeof import("tests/cases/compiler/monorepo/pkg1/dist/index").MetadataAccessor
+
+=== tests/cases/compiler/monorepo/pkg2/dist/secondary.d.ts ===
+export {IdType} from '@raymondfeng/pkg1';
+>IdType : any
+
+=== tests/cases/compiler/monorepo/pkg3/src/index.ts ===
+export * from './keys';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg3/src/keys.ts ===
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+>MetadataAccessor : typeof MetadataAccessor
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+>ADMIN : MetadataAccessor<boolean, import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType>
+>MetadataAccessor.create<boolean>('1') : MetadataAccessor<boolean, import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType>
+>MetadataAccessor.create : <T, D extends import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType = import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType>(key: string) => MetadataAccessor<T, D>
+>MetadataAccessor : typeof MetadataAccessor
+>create : <T, D extends import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType = import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType>(key: string) => MetadataAccessor<T, D>
+>'1' : "1"
+

tests/baselines/reference/declarationEmitReexportedSymlinkReference3.errors.txt

@@ -0,0 +1,60 @@
+tests/cases/compiler/monorepo/pkg3/src/keys.ts(3,14): error TS2742: The inferred type of 'ADMIN' cannot be named without a reference to '../../pkg2/node_modules/@raymondfeng/pkg1/dist'. This is likely not portable. A type annotation is necessary.
+
+
+==== tests/cases/compiler/monorepo/pkg3/tsconfig.json (0 errors) ====
+    {
+        "compilerOptions": {
+          "outDir": "dist",
+          "rootDir": "src",
+          "target": "es5",
+          "module": "commonjs",
+          "strict": true,
+          "esModuleInterop": true,
+          "declaration": true
+        }
+    }
+    
+==== tests/cases/compiler/monorepo/pkg1/dist/index.d.ts (0 errors) ====
+    export * from './types';
+==== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts (0 errors) ====
+    export declare type A = {
+        id: string;
+    };
+    export declare type B = {
+        id: number;
+    };
+    export declare type IdType = A | B;
+    export declare class MetadataAccessor<T, D extends IdType = IdType> {
+        readonly key: string;
+        private constructor();
+        toString(): string;
+        static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+    }
+==== tests/cases/compiler/monorepo/pkg1/package.json (0 errors) ====
+    {
+        "name": "@raymondfeng/pkg1",
+        "version": "1.0.0",
+        "description": "",
+        "main": "dist/index.js",
+        "typings": "dist/index.d.ts"
+    }
+==== tests/cases/compiler/monorepo/pkg2/dist/index.d.ts (0 errors) ====
+    export * from './types';
+==== tests/cases/compiler/monorepo/pkg2/dist/types.d.ts (0 errors) ====
+    export {MetadataAccessor} from '@raymondfeng/pkg1';
+==== tests/cases/compiler/monorepo/pkg2/package.json (0 errors) ====
+    {
+        "name": "@raymondfeng/pkg2",
+        "version": "1.0.0",
+        "description": "",
+        "main": "dist/index.js",
+        "typings": "dist/index.d.ts"
+    }
+==== tests/cases/compiler/monorepo/pkg3/src/index.ts (0 errors) ====
+    export * from './keys';
+==== tests/cases/compiler/monorepo/pkg3/src/keys.ts (1 errors) ====
+    import {MetadataAccessor} from "@raymondfeng/pkg2";
+    
+    export const ADMIN = MetadataAccessor.create<boolean>('1');
+                 ~~~~~
+!!! error TS2742: The inferred type of 'ADMIN' cannot be named without a reference to '../../pkg2/node_modules/@raymondfeng/pkg1/dist'. This is likely not portable. A type annotation is necessary.

tests/baselines/reference/declarationEmitReexportedSymlinkReference3.js

@@ -0,0 +1,61 @@
+//// [tests/cases/compiler/declarationEmitReexportedSymlinkReference3.ts] ////
+
+//// [index.d.ts]
+export * from './types';
+//// [types.d.ts]
+export declare type A = {
+    id: string;
+};
+export declare type B = {
+    id: number;
+};
+export declare type IdType = A | B;
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+    readonly key: string;
+    private constructor();
+    toString(): string;
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+}
+//// [package.json]
+{
+    "name": "@raymondfeng/pkg1",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+//// [index.d.ts]
+export * from './types';
+//// [types.d.ts]
+export {MetadataAccessor} from '@raymondfeng/pkg1';
+//// [package.json]
+{
+    "name": "@raymondfeng/pkg2",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+//// [index.ts]
+export * from './keys';
+//// [keys.ts]
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+
+//// [keys.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var pkg2_1 = require("@raymondfeng/pkg2");
+exports.ADMIN = pkg2_1.MetadataAccessor.create('1');
+//// [index.js]
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./keys"));
+
+
+//// [index.d.ts]
+export * from './keys';

tests/baselines/reference/declarationEmitReexportedSymlinkReference3.symbols

@@ -0,0 +1,65 @@
+=== tests/cases/compiler/monorepo/pkg1/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts ===
+export declare type A = {
+>A : Symbol(A, Decl(types.d.ts, 0, 0))
+
+    id: string;
+>id : Symbol(id, Decl(types.d.ts, 0, 25))
+
+};
+export declare type B = {
+>B : Symbol(B, Decl(types.d.ts, 2, 2))
+
+    id: number;
+>id : Symbol(id, Decl(types.d.ts, 3, 25))
+
+};
+export declare type IdType = A | B;
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>A : Symbol(A, Decl(types.d.ts, 0, 0))
+>B : Symbol(B, Decl(types.d.ts, 2, 2))
+
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(types.d.ts, 6, 35))
+>T : Symbol(T, Decl(types.d.ts, 7, 38))
+>D : Symbol(D, Decl(types.d.ts, 7, 40))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+
+    readonly key: string;
+>key : Symbol(MetadataAccessor.key, Decl(types.d.ts, 7, 69))
+
+    private constructor();
+    toString(): string;
+>toString : Symbol(MetadataAccessor.toString, Decl(types.d.ts, 9, 26))
+
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+>create : Symbol(MetadataAccessor.create, Decl(types.d.ts, 10, 23))
+>T : Symbol(T, Decl(types.d.ts, 11, 18))
+>D : Symbol(D, Decl(types.d.ts, 11, 20))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>IdType : Symbol(IdType, Decl(types.d.ts, 5, 2))
+>key : Symbol(key, Decl(types.d.ts, 11, 48))
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(types.d.ts, 6, 35))
+>T : Symbol(T, Decl(types.d.ts, 11, 18))
+>D : Symbol(D, Decl(types.d.ts, 11, 20))
+}
+=== tests/cases/compiler/monorepo/pkg2/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg2/dist/types.d.ts ===
+export {MetadataAccessor} from '@raymondfeng/pkg1';
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(types.d.ts, 0, 8))
+
+=== tests/cases/compiler/monorepo/pkg3/src/index.ts ===
+export * from './keys';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg3/src/keys.ts ===
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(keys.ts, 0, 8))
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+>ADMIN : Symbol(ADMIN, Decl(keys.ts, 2, 12))
+>MetadataAccessor.create : Symbol(MetadataAccessor.create, Decl(types.d.ts, 10, 23))
+>MetadataAccessor : Symbol(MetadataAccessor, Decl(keys.ts, 0, 8))
+>create : Symbol(MetadataAccessor.create, Decl(types.d.ts, 10, 23))
+

tests/baselines/reference/declarationEmitReexportedSymlinkReference3.types

@@ -0,0 +1,54 @@
+=== tests/cases/compiler/monorepo/pkg1/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts ===
+export declare type A = {
+>A : A
+
+    id: string;
+>id : string
+
+};
+export declare type B = {
+>B : B
+
+    id: number;
+>id : number
+
+};
+export declare type IdType = A | B;
+>IdType : IdType
+
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+>MetadataAccessor : MetadataAccessor<T, D>
+
+    readonly key: string;
+>key : string
+
+    private constructor();
+    toString(): string;
+>toString : () => string
+
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+>create : <T, D extends IdType = IdType>(key: string) => MetadataAccessor<T, D>
+>key : string
+}
+=== tests/cases/compiler/monorepo/pkg2/dist/index.d.ts ===
+export * from './types';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg2/dist/types.d.ts ===
+export {MetadataAccessor} from '@raymondfeng/pkg1';
+>MetadataAccessor : typeof import("tests/cases/compiler/monorepo/pkg1/dist/index").MetadataAccessor
+
+=== tests/cases/compiler/monorepo/pkg3/src/index.ts ===
+export * from './keys';
+No type information for this code.=== tests/cases/compiler/monorepo/pkg3/src/keys.ts ===
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+>MetadataAccessor : typeof MetadataAccessor
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+>ADMIN : MetadataAccessor<boolean, import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType>
+>MetadataAccessor.create<boolean>('1') : MetadataAccessor<boolean, import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType>
+>MetadataAccessor.create : <T, D extends import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType = import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType>(key: string) => MetadataAccessor<T, D>
+>MetadataAccessor : typeof MetadataAccessor
+>create : <T, D extends import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType = import("tests/cases/compiler/monorepo/pkg1/dist/index").IdType>(key: string) => MetadataAccessor<T, D>
+>'1' : "1"
+

tests/baselines/reference/reactTransitiveImportHasValidDeclaration.js

@@ -44,5 +44,5 @@ exports["default"] = Form;
 
 //// [index.d.ts]
 /// <reference types="react" />
-declare const Form: import("create-emotion-styled/types/react").StyledOtherComponent<{}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>;
+declare const Form: import("create-emotion-styled").StyledOtherComponent<{}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>;
 export default Form;

tests/baselines/reference/reactTransitiveImportHasValidDeclaration.types

@@ -42,18 +42,18 @@ export default function styled(tag: string): (o: object) => StyledOtherComponent
 
 === tests/cases/compiler/index.ts ===
 import styled from "react-emotion"
->styled : (tag: string) => (o: object) => import("tests/cases/compiler/node_modules/create-emotion-styled/types/react/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
+>styled : (tag: string) => (o: object) => import("tests/cases/compiler/node_modules/create-emotion-styled/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
 
 const Form = styled('div')({ color: "red" })
->Form : import("tests/cases/compiler/node_modules/create-emotion-styled/types/react/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
->styled('div')({ color: "red" }) : import("tests/cases/compiler/node_modules/create-emotion-styled/types/react/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
->styled('div') : (o: object) => import("tests/cases/compiler/node_modules/create-emotion-styled/types/react/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
->styled : (tag: string) => (o: object) => import("tests/cases/compiler/node_modules/create-emotion-styled/types/react/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
+>Form : import("tests/cases/compiler/node_modules/create-emotion-styled/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
+>styled('div')({ color: "red" }) : import("tests/cases/compiler/node_modules/create-emotion-styled/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
+>styled('div') : (o: object) => import("tests/cases/compiler/node_modules/create-emotion-styled/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
+>styled : (tag: string) => (o: object) => import("tests/cases/compiler/node_modules/create-emotion-styled/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
 >'div' : "div"
 >{ color: "red" } : { color: string; }
 >color : string
 >"red" : "red"
 
 export default Form
->Form : import("tests/cases/compiler/node_modules/create-emotion-styled/types/react/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
+>Form : import("tests/cases/compiler/node_modules/create-emotion-styled/index").StyledOtherComponent<{}, import("tests/cases/compiler/node_modules/react/index.d.ts").DetailedHTMLProps<import("tests/cases/compiler/node_modules/react/index.d.ts").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any>
 

tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.js

@@ -72,4 +72,4 @@ import { Constructor } from "@loopback/context";
 export declare type ControllerClass = Constructor<any>;
 //// [usage.d.ts]
 import { BindingKey } from '@loopback/context';
-export declare const CONTROLLER_CLASS: BindingKey<import("@loopback/context/src/value-promise").Constructor<any>>;
+export declare const CONTROLLER_CLASS: BindingKey<import("@loopback/context").Constructor<any>>;

tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.types

@@ -13,11 +13,11 @@ import { BindingKey } from '@loopback/context';
 >BindingKey : typeof BindingKey
 
 export const CONTROLLER_CLASS = BindingKey.create<ControllerClass>(null as any); // line in question
->CONTROLLER_CLASS : BindingKey<import("tests/cases/compiler/monorepo/context/src/value-promise").Constructor<any>>
->BindingKey.create<ControllerClass>(null as any) : BindingKey<import("tests/cases/compiler/monorepo/context/src/value-promise").Constructor<any>>
->BindingKey.create : <T extends import("tests/cases/compiler/monorepo/context/src/value-promise").Constructor<any>>(ctor: T) => BindingKey<T>
+>CONTROLLER_CLASS : BindingKey<import("tests/cases/compiler/monorepo/context/index").Constructor<any>>
+>BindingKey.create<ControllerClass>(null as any) : BindingKey<import("tests/cases/compiler/monorepo/context/index").Constructor<any>>
+>BindingKey.create : <T extends import("tests/cases/compiler/monorepo/context/index").Constructor<any>>(ctor: T) => BindingKey<T>
 >BindingKey : typeof BindingKey
->create : <T extends import("tests/cases/compiler/monorepo/context/src/value-promise").Constructor<any>>(ctor: T) => BindingKey<T>
+>create : <T extends import("tests/cases/compiler/monorepo/context/index").Constructor<any>>(ctor: T) => BindingKey<T>
 >null as any : any
 >null : null
 

tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.js

@@ -39,4 +39,4 @@ import { Constructor } from "@loopback/context";
 export declare type ControllerClass = Constructor<any>;
 //// [usage.d.ts]
 import { BindingKey } from '@loopback/context';
-export declare const CONTROLLER_CLASS: BindingKey<import("@loopback/context/src/value-promise").Constructor<any>>;
+export declare const CONTROLLER_CLASS: BindingKey<import("@loopback/context").Constructor<any>>;

tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.types

@@ -37,11 +37,11 @@ import { BindingKey } from '@loopback/context';
 >BindingKey : typeof BindingKey
 
 export const CONTROLLER_CLASS = BindingKey.create<ControllerClass>(null as any); // line in question
->CONTROLLER_CLASS : BindingKey<import("tests/cases/compiler/monorepo/context/src/value-promise").Constructor<any>>
->BindingKey.create<ControllerClass>(null as any) : BindingKey<import("tests/cases/compiler/monorepo/context/src/value-promise").Constructor<any>>
->BindingKey.create : <T extends import("tests/cases/compiler/monorepo/context/src/value-promise").Constructor<any>>(ctor: T) => BindingKey<T>
+>CONTROLLER_CLASS : BindingKey<import("tests/cases/compiler/monorepo/context/index").Constructor<any>>
+>BindingKey.create<ControllerClass>(null as any) : BindingKey<import("tests/cases/compiler/monorepo/context/index").Constructor<any>>
+>BindingKey.create : <T extends import("tests/cases/compiler/monorepo/context/index").Constructor<any>>(ctor: T) => BindingKey<T>
 >BindingKey : typeof BindingKey
->create : <T extends import("tests/cases/compiler/monorepo/context/src/value-promise").Constructor<any>>(ctor: T) => BindingKey<T>
+>create : <T extends import("tests/cases/compiler/monorepo/context/index").Constructor<any>>(ctor: T) => BindingKey<T>
 >null as any : any
 >null : null
 

tests/baselines/reference/typesVersionsDeclarationEmit.multiFileBackReferenceToUnmapped.js

@@ -41,5 +41,5 @@ exports.va2 = other_1.fa();
 
 
 //// [main.d.ts]
-export declare const va: import("ext/other").A2;
-export declare const va2: import("ext/other").A2;
+export declare const va: import("ext").A2;
+export declare const va2: import("ext").A2;

tests/cases/compiler/declarationEmitReexportedSymlinkReference.ts

@@ -0,0 +1,56 @@
+// @filename: monorepo/pkg1/dist/index.d.ts
+export * from './types';
+// @filename: monorepo/pkg1/dist/types.d.ts
+export declare type A = {
+    id: string;
+};
+export declare type B = {
+    id: number;
+};
+export declare type IdType = A | B;
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+    readonly key: string;
+    private constructor();
+    toString(): string;
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+}
+// @filename: monorepo/pkg1/package.json
+{
+    "name": "@raymondfeng/pkg1",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+// @filename: monorepo/pkg2/dist/index.d.ts
+export * from './types';
+// @filename: monorepo/pkg2/dist/types.d.ts
+export * from '@raymondfeng/pkg1';
+// @filename: monorepo/pkg2/package.json
+{
+    "name": "@raymondfeng/pkg2",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+// @filename: monorepo/pkg3/src/index.ts
+export * from './keys';
+// @filename: monorepo/pkg3/src/keys.ts
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+// @filename: monorepo/pkg3/tsconfig.json
+{
+    "compilerOptions": {
+      "outDir": "dist",
+      "rootDir": "src",
+      "target": "es5",
+      "module": "commonjs",
+      "strict": true,
+      "esModuleInterop": true,
+      "declaration": true
+    }
+}
+// @link: tests/cases/compiler/monorepo/pkg1 -> tests/cases/compiler/monorepo/pkg2/node_modules/@raymondfeng/pkg1
+// @link: tests/cases/compiler/monorepo/pkg2 -> tests/cases/compiler/monorepo/pkg3/node_modules/@raymondfeng/pkg2

tests/cases/compiler/declarationEmitReexportedSymlinkReference2.ts

@@ -0,0 +1,59 @@
+// @filename: monorepo/pkg1/dist/index.d.ts
+export * from './types';
+// @filename: monorepo/pkg1/dist/types.d.ts
+export declare type A = {
+    id: string;
+};
+export declare type B = {
+    id: number;
+};
+export declare type IdType = A | B;
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+    readonly key: string;
+    private constructor();
+    toString(): string;
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+}
+// @filename: monorepo/pkg1/package.json
+{
+    "name": "@raymondfeng/pkg1",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+// @filename: monorepo/pkg2/dist/index.d.ts
+import "./secondary";
+export * from './types';
+// @filename: monorepo/pkg2/dist/types.d.ts
+export {MetadataAccessor} from '@raymondfeng/pkg1';
+// @filename: monorepo/pkg2/dist/secondary.d.ts
+export {IdType} from '@raymondfeng/pkg1';
+// @filename: monorepo/pkg2/package.json
+{
+    "name": "@raymondfeng/pkg2",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+// @filename: monorepo/pkg3/src/index.ts
+export * from './keys';
+// @filename: monorepo/pkg3/src/keys.ts
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+// @filename: monorepo/pkg3/tsconfig.json
+{
+    "compilerOptions": {
+      "outDir": "dist",
+      "rootDir": "src",
+      "target": "es5",
+      "module": "commonjs",
+      "strict": true,
+      "esModuleInterop": true,
+      "declaration": true
+    }
+}
+// @link: tests/cases/compiler/monorepo/pkg1 -> tests/cases/compiler/monorepo/pkg2/node_modules/@raymondfeng/pkg1
+// @link: tests/cases/compiler/monorepo/pkg2 -> tests/cases/compiler/monorepo/pkg3/node_modules/@raymondfeng/pkg2

tests/cases/compiler/declarationEmitReexportedSymlinkReference3.ts

@@ -0,0 +1,56 @@
+// @filename: monorepo/pkg1/dist/index.d.ts
+export * from './types';
+// @filename: monorepo/pkg1/dist/types.d.ts
+export declare type A = {
+    id: string;
+};
+export declare type B = {
+    id: number;
+};
+export declare type IdType = A | B;
+export declare class MetadataAccessor<T, D extends IdType = IdType> {
+    readonly key: string;
+    private constructor();
+    toString(): string;
+    static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+}
+// @filename: monorepo/pkg1/package.json
+{
+    "name": "@raymondfeng/pkg1",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+// @filename: monorepo/pkg2/dist/index.d.ts
+export * from './types';
+// @filename: monorepo/pkg2/dist/types.d.ts
+export {MetadataAccessor} from '@raymondfeng/pkg1';
+// @filename: monorepo/pkg2/package.json
+{
+    "name": "@raymondfeng/pkg2",
+    "version": "1.0.0",
+    "description": "",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+}
+// @filename: monorepo/pkg3/src/index.ts
+export * from './keys';
+// @filename: monorepo/pkg3/src/keys.ts
+import {MetadataAccessor} from "@raymondfeng/pkg2";
+
+export const ADMIN = MetadataAccessor.create<boolean>('1');
+// @filename: monorepo/pkg3/tsconfig.json
+{
+    "compilerOptions": {
+      "outDir": "dist",
+      "rootDir": "src",
+      "target": "es5",
+      "module": "commonjs",
+      "strict": true,
+      "esModuleInterop": true,
+      "declaration": true
+    }
+}
+// @link: tests/cases/compiler/monorepo/pkg1 -> tests/cases/compiler/monorepo/pkg2/node_modules/@raymondfeng/pkg1
+// @link: tests/cases/compiler/monorepo/pkg2 -> tests/cases/compiler/monorepo/pkg3/node_modules/@raymondfeng/pkg2