From 7a71887c23a110009bc974f626245f03066e6926 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Tue, 13 Nov 2018 14:07:54 -0800 Subject: [PATCH] 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 | 82 ++++++++++++++++++- src/compiler/diagnosticMessages.json | 4 + src/compiler/moduleSpecifiers.ts | 2 +- src/compiler/transformers/declarations.ts | 9 ++ src/compiler/types.ts | 11 ++- .../reference/api/tsserverlibrary.d.ts | 3 +- tests/baselines/reference/api/typescript.d.ts | 3 +- ...mitCommonJsModuleReferencedType.errors.txt | 28 +++++++ ...arationEmitCommonJsModuleReferencedType.js | 5 -- ...clarationEmitReexportedSymlinkReference.js | 64 +++++++++++++++ ...tionEmitReexportedSymlinkReference.symbols | 63 ++++++++++++++ ...rationEmitReexportedSymlinkReference.types | 52 ++++++++++++ ...larationEmitReexportedSymlinkReference2.js | 67 +++++++++++++++ ...ionEmitReexportedSymlinkReference2.symbols | 70 ++++++++++++++++ ...ationEmitReexportedSymlinkReference2.types | 59 +++++++++++++ ...EmitReexportedSymlinkReference3.errors.txt | 60 ++++++++++++++ ...larationEmitReexportedSymlinkReference3.js | 61 ++++++++++++++ ...ionEmitReexportedSymlinkReference3.symbols | 65 +++++++++++++++ ...ationEmitReexportedSymlinkReference3.types | 54 ++++++++++++ ...eactTransitiveImportHasValidDeclaration.js | 2 +- ...tTransitiveImportHasValidDeclaration.types | 12 +-- .../symbolLinkDeclarationEmitModuleNames.js | 2 +- ...symbolLinkDeclarationEmitModuleNames.types | 8 +- ...olLinkDeclarationEmitModuleNamesRootDir.js | 2 +- ...inkDeclarationEmitModuleNamesRootDir.types | 8 +- ...onEmit.multiFileBackReferenceToUnmapped.js | 4 +- ...clarationEmitReexportedSymlinkReference.ts | 56 +++++++++++++ ...larationEmitReexportedSymlinkReference2.ts | 59 +++++++++++++ ...larationEmitReexportedSymlinkReference3.ts | 56 +++++++++++++ 29 files changed, 937 insertions(+), 34 deletions(-) create mode 100644 tests/baselines/reference/declarationEmitCommonJsModuleReferencedType.errors.txt create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference.js create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference.symbols create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference.types create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference2.js create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference2.symbols create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference2.types create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference3.errors.txt create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference3.js create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference3.symbols create mode 100644 tests/baselines/reference/declarationEmitReexportedSymlinkReference3.types create mode 100644 tests/cases/compiler/declarationEmitReexportedSymlinkReference.ts create mode 100644 tests/cases/compiler/declarationEmitReexportedSymlinkReference2.ts create mode 100644 tests/cases/compiler/declarationEmitReexportedSymlinkReference3.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 23161e69d4..a59abf22f1 100644 --- a/src/compiler/checker.ts +++ b/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("") diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 59516ffc3f..9078395a15 100644 --- a/src/compiler/diagnosticMessages.json +++ b/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", diff --git a/src/compiler/moduleSpecifiers.ts b/src/compiler/moduleSpecifiers.ts index f28bc43e61..1913ee90b2 100644 --- a/src/compiler/moduleSpecifiers.ts +++ b/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++; diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts index 968b61198a..973b9db618 100644 --- a/src/compiler/transformers/declarations.ts +++ b/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; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 65a04d4394..897bfb0087 100644 --- a/src/compiler/types.ts +++ b/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; // 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; // 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, getCommonSourceDirectory(): string }; trackReferencedAmbientModule?(decl: ModuleDeclaration, symbol: Symbol): void; trackExternalModuleSymbolOfImportTypeNode?(symbol: Symbol): void; diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index ac36533a09..132d523abc 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/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, diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 83a5cab6a5..ebfb65b7ab 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/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, diff --git a/tests/baselines/reference/declarationEmitCommonJsModuleReferencedType.errors.txt b/tests/baselines/reference/declarationEmitCommonJsModuleReferencedType.errors.txt new file mode 100644 index 0000000000..d2dcd236ad --- /dev/null +++ b/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(); + \ No newline at end of file diff --git a/tests/baselines/reference/declarationEmitCommonJsModuleReferencedType.js b/tests/baselines/reference/declarationEmitCommonJsModuleReferencedType.js index 1e32c5c4c2..5f1d474f75 100644 --- a/tests/baselines/reference/declarationEmitCommonJsModuleReferencedType.js +++ b/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; diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference.js b/tests/baselines/reference/declarationEmitReexportedSymlinkReference.js new file mode 100644 index 0000000000..0683f21cd5 --- /dev/null +++ b/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 { + readonly key: string; + private constructor(); + toString(): string; + static create(key: string): MetadataAccessor; +} +//// [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('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; +//// [index.d.ts] +export * from './keys'; diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference.symbols b/tests/baselines/reference/declarationEmitReexportedSymlinkReference.symbols new file mode 100644 index 0000000000..4006ea88a8 --- /dev/null +++ b/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 { +>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(key: string): MetadataAccessor; +>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('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)) + diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference.types b/tests/baselines/reference/declarationEmitReexportedSymlinkReference.types new file mode 100644 index 0000000000..50c770d525 --- /dev/null +++ b/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 { +>MetadataAccessor : MetadataAccessor + + readonly key: string; +>key : string + + private constructor(); + toString(): string; +>toString : () => string + + static create(key: string): MetadataAccessor; +>create : (key: string) => MetadataAccessor +>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('1'); +>ADMIN : MetadataAccessor +>MetadataAccessor.create('1') : MetadataAccessor +>MetadataAccessor.create : (key: string) => MetadataAccessor +>MetadataAccessor : typeof MetadataAccessor +>create : (key: string) => MetadataAccessor +>'1' : "1" + diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.js b/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.js new file mode 100644 index 0000000000..5403cb95ef --- /dev/null +++ b/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 { + readonly key: string; + private constructor(); + toString(): string; + static create(key: string): MetadataAccessor; +} +//// [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('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; +//// [index.d.ts] +export * from './keys'; diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.symbols b/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.symbols new file mode 100644 index 0000000000..683969e356 --- /dev/null +++ b/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 { +>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(key: string): MetadataAccessor; +>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('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)) + diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.types b/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.types new file mode 100644 index 0000000000..1ecb9e7592 --- /dev/null +++ b/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 { +>MetadataAccessor : MetadataAccessor + + readonly key: string; +>key : string + + private constructor(); + toString(): string; +>toString : () => string + + static create(key: string): MetadataAccessor; +>create : (key: string) => MetadataAccessor +>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('1'); +>ADMIN : MetadataAccessor +>MetadataAccessor.create('1') : MetadataAccessor +>MetadataAccessor.create : (key: string) => MetadataAccessor +>MetadataAccessor : typeof MetadataAccessor +>create : (key: string) => MetadataAccessor +>'1' : "1" + diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.errors.txt b/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.errors.txt new file mode 100644 index 0000000000..1981ce63c9 --- /dev/null +++ b/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 { + readonly key: string; + private constructor(); + toString(): string; + static create(key: string): MetadataAccessor; + } +==== 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('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. \ No newline at end of file diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.js b/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.js new file mode 100644 index 0000000000..2ac5a9fffb --- /dev/null +++ b/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 { + readonly key: string; + private constructor(); + toString(): string; + static create(key: string): MetadataAccessor; +} +//// [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('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'; diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.symbols b/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.symbols new file mode 100644 index 0000000000..df33b515a8 --- /dev/null +++ b/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 { +>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(key: string): MetadataAccessor; +>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('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)) + diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.types b/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.types new file mode 100644 index 0000000000..e3f8347888 --- /dev/null +++ b/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 { +>MetadataAccessor : MetadataAccessor + + readonly key: string; +>key : string + + private constructor(); + toString(): string; +>toString : () => string + + static create(key: string): MetadataAccessor; +>create : (key: string) => MetadataAccessor +>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('1'); +>ADMIN : MetadataAccessor +>MetadataAccessor.create('1') : MetadataAccessor +>MetadataAccessor.create : (key: string) => MetadataAccessor +>MetadataAccessor : typeof MetadataAccessor +>create : (key: string) => MetadataAccessor +>'1' : "1" + diff --git a/tests/baselines/reference/reactTransitiveImportHasValidDeclaration.js b/tests/baselines/reference/reactTransitiveImportHasValidDeclaration.js index 4cd606eae0..526240701e 100644 --- a/tests/baselines/reference/reactTransitiveImportHasValidDeclaration.js +++ b/tests/baselines/reference/reactTransitiveImportHasValidDeclaration.js @@ -44,5 +44,5 @@ exports["default"] = Form; //// [index.d.ts] /// -declare const Form: import("create-emotion-styled/types/react").StyledOtherComponent<{}, import("react").DetailedHTMLProps, HTMLDivElement>, any>; +declare const Form: import("create-emotion-styled").StyledOtherComponent<{}, import("react").DetailedHTMLProps, HTMLDivElement>, any>; export default Form; diff --git a/tests/baselines/reference/reactTransitiveImportHasValidDeclaration.types b/tests/baselines/reference/reactTransitiveImportHasValidDeclaration.types index b50eb1e30b..07eacfb8f4 100644 --- a/tests/baselines/reference/reactTransitiveImportHasValidDeclaration.types +++ b/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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, HTMLDivElement>, any> diff --git a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.js b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.js index a154c443de..8cf2fab6fb 100644 --- a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.js +++ b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.js @@ -72,4 +72,4 @@ import { Constructor } from "@loopback/context"; export declare type ControllerClass = Constructor; //// [usage.d.ts] import { BindingKey } from '@loopback/context'; -export declare const CONTROLLER_CLASS: BindingKey>; +export declare const CONTROLLER_CLASS: BindingKey>; diff --git a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.types b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.types index 1101327b28..d9f60d9545 100644 --- a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.types +++ b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.types @@ -13,11 +13,11 @@ import { BindingKey } from '@loopback/context'; >BindingKey : typeof BindingKey export const CONTROLLER_CLASS = BindingKey.create(null as any); // line in question ->CONTROLLER_CLASS : BindingKey> ->BindingKey.create(null as any) : BindingKey> ->BindingKey.create : >(ctor: T) => BindingKey +>CONTROLLER_CLASS : BindingKey> +>BindingKey.create(null as any) : BindingKey> +>BindingKey.create : >(ctor: T) => BindingKey >BindingKey : typeof BindingKey ->create : >(ctor: T) => BindingKey +>create : >(ctor: T) => BindingKey >null as any : any >null : null diff --git a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.js b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.js index 124e8420d7..95b2452695 100644 --- a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.js +++ b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.js @@ -39,4 +39,4 @@ import { Constructor } from "@loopback/context"; export declare type ControllerClass = Constructor; //// [usage.d.ts] import { BindingKey } from '@loopback/context'; -export declare const CONTROLLER_CLASS: BindingKey>; +export declare const CONTROLLER_CLASS: BindingKey>; diff --git a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.types b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.types index 7011a700ab..bb6a91a129 100644 --- a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.types +++ b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.types @@ -37,11 +37,11 @@ import { BindingKey } from '@loopback/context'; >BindingKey : typeof BindingKey export const CONTROLLER_CLASS = BindingKey.create(null as any); // line in question ->CONTROLLER_CLASS : BindingKey> ->BindingKey.create(null as any) : BindingKey> ->BindingKey.create : >(ctor: T) => BindingKey +>CONTROLLER_CLASS : BindingKey> +>BindingKey.create(null as any) : BindingKey> +>BindingKey.create : >(ctor: T) => BindingKey >BindingKey : typeof BindingKey ->create : >(ctor: T) => BindingKey +>create : >(ctor: T) => BindingKey >null as any : any >null : null diff --git a/tests/baselines/reference/typesVersionsDeclarationEmit.multiFileBackReferenceToUnmapped.js b/tests/baselines/reference/typesVersionsDeclarationEmit.multiFileBackReferenceToUnmapped.js index fb7dfd74b2..b7cfdf92a6 100644 --- a/tests/baselines/reference/typesVersionsDeclarationEmit.multiFileBackReferenceToUnmapped.js +++ b/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; diff --git a/tests/cases/compiler/declarationEmitReexportedSymlinkReference.ts b/tests/cases/compiler/declarationEmitReexportedSymlinkReference.ts new file mode 100644 index 0000000000..d0f58e2ede --- /dev/null +++ b/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 { + readonly key: string; + private constructor(); + toString(): string; + static create(key: string): MetadataAccessor; +} +// @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('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 diff --git a/tests/cases/compiler/declarationEmitReexportedSymlinkReference2.ts b/tests/cases/compiler/declarationEmitReexportedSymlinkReference2.ts new file mode 100644 index 0000000000..764a2c3f0b --- /dev/null +++ b/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 { + readonly key: string; + private constructor(); + toString(): string; + static create(key: string): MetadataAccessor; +} +// @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('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 diff --git a/tests/cases/compiler/declarationEmitReexportedSymlinkReference3.ts b/tests/cases/compiler/declarationEmitReexportedSymlinkReference3.ts new file mode 100644 index 0000000000..e65b752a3a --- /dev/null +++ b/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 { + readonly key: string; + private constructor(); + toString(): string; + static create(key: string): MetadataAccessor; +} +// @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('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