Skip to content

Commit 97c3c60

Browse files
weswighamweswigham
committed
fix symlink tag, support arbitrary (ie, directory) links via @link
Introduce indirect symlink lookup to specifier deriver Use fileset, move exec vfs path resolution :shakes fist: Apply files symlink relative to dirname Use directory function
1 parent 14da064 commit 97c3c60

File tree

11 files changed

+350
-19
lines changed

11 files changed

+350
-19
lines changed

‎src/compiler/checker.ts

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4093,7 +4093,14 @@ namespace ts {
40934093
}
40944094
else {
40954095
const contextFile = getSourceFileOfNode(getOriginalNode(context!.enclosingDeclaration))!;
4096-
return `"${file.moduleName || moduleSpecifiers.getModuleSpecifier(compilerOptions, contextFile, contextFile.path, file.path, context!.tracker.moduleResolverHost!)}"`;
4096+
return `"${file.moduleName || moduleSpecifiers.getModuleSpecifiers(
4097+
symbol,
4098+
compilerOptions,
4099+
contextFile,
4100+
context!.tracker.moduleResolverHost!,
4101+
context!.tracker.moduleResolverHost!.getSourceFiles!(),
4102+
{ importModuleSpecifierPreference: "non-relative" }
4103+
)[0]}"`;
40974104
}
40984105
}
40994106
const declaration = symbol.declarations[0];

‎src/compiler/moduleSpecifiers.ts

Lines changed: 52 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -15,17 +15,20 @@ namespace ts.moduleSpecifiers {
1515
// For each symlink/original for a module, returns a list of ways to import that file.
1616
export function getModuleSpecifiers(
1717
moduleSymbol: Symbol,
18-
program: Program,
18+
compilerOptions: CompilerOptions,
1919
importingSourceFile: SourceFile,
2020
host: ModuleSpecifierResolutionHost,
21+
files: ReadonlyArray<SourceFile>,
2122
preferences: ModuleSpecifierPreferences,
2223
): ReadonlyArray<ReadonlyArray<string>> {
2324
const ambient = tryGetModuleNameFromAmbientModule(moduleSymbol);
2425
if (ambient) return [[ambient]];
2526

26-
const compilerOptions = program.getCompilerOptions();
27-
const info = getInfo(compilerOptions, importingSourceFile, importingSourceFile.fileName, host);
28-
const modulePaths = getAllModulePaths(program, getSourceFileOfNode(moduleSymbol.valueDeclaration));
27+
const info = getInfo(compilerOptions, importingSourceFile, importingSourceFile.path, host);
28+
if (!files) {
29+
return Debug.fail("Files list must be present to resolve symlinks in specifier resolution");
30+
}
31+
const modulePaths = getAllModulePaths(files, getSourceFileOfNode(moduleSymbol.valueDeclaration), info.getCanonicalFileName, host);
2932

3033
const global = mapDefined(modulePaths, moduleFileName => getGlobalModuleSpecifier(moduleFileName, info, host, compilerOptions));
3134
return global.length ? global.map(g => [g]) : modulePaths.map(moduleFileName =>
@@ -130,15 +133,57 @@ namespace ts.moduleSpecifiers {
130133
return firstDefined(imports, ({ text }) => pathIsRelative(text) ? fileExtensionIs(text, Extension.Js) : undefined) || false;
131134
}
132135

136+
function discoverProbableSymlinks(files: ReadonlyArray<SourceFile>) {
137+
const symlinks = mapDefined(files, sf =>
138+
sf.resolvedModules && firstDefinedIterator(sf.resolvedModules.values(), res =>
139+
res && res.originalPath && res.resolvedFileName !== res.originalPath ? [res.resolvedFileName, res.originalPath] : undefined));
140+
const result = createMap<string>();
141+
if (symlinks) {
142+
for (const [resolvedPath, originalPath] of symlinks) {
143+
const resolvedParts = getPathComponents(resolvedPath);
144+
const originalParts = getPathComponents(originalPath);
145+
while (resolvedParts[resolvedParts.length - 1] === originalParts[originalParts.length - 1]) {
146+
resolvedParts.pop();
147+
originalParts.pop();
148+
}
149+
result.set(getPathFromPathComponents(originalParts), getPathFromPathComponents(resolvedParts));
150+
}
151+
}
152+
return result;
153+
}
154+
155+
function getAllModulePathsUsingIndirectSymlinks(files: ReadonlyArray<SourceFile>, target: string, getCanonicalFileName: (file: string) => string, host: ModuleSpecifierResolutionHost) {
156+
const links = discoverProbableSymlinks(files);
157+
const paths = arrayFrom(links.keys());
158+
let options: string[] | undefined;
159+
for (const path of paths) {
160+
const resolved = links.get(path)!;
161+
if (startsWith(target, resolved + "/")) {
162+
const relative = getRelativePathFromDirectory(resolved, target, getCanonicalFileName);
163+
const option = resolvePath(path, relative);
164+
if (!host.fileExists || host.fileExists(option)) {
165+
if (!options) options = [];
166+
options.push(option);
167+
}
168+
}
169+
}
170+
const resolvedtarget = host.getCurrentDirectory ? resolvePath(host.getCurrentDirectory(), target) : target;
171+
if (options) {
172+
options.push(resolvedtarget); // Since these are speculative, we also include the original resolved name as a possibility
173+
return options;
174+
}
175+
return [resolvedtarget];
176+
}
177+
133178
/**
134179
* Looks for a existing imports that use symlinks to this module.
135180
* Only if no symlink is available, the real path will be used.
136181
*/
137-
function getAllModulePaths(program: Program, { fileName }: SourceFile): ReadonlyArray<string> {
138-
const symlinks = mapDefined(program.getSourceFiles(), sf =>
182+
function getAllModulePaths(files: ReadonlyArray<SourceFile>, { fileName }: SourceFile, getCanonicalFileName: (file: string) => string, host: ModuleSpecifierResolutionHost): ReadonlyArray<string> {
183+
const symlinks = mapDefined(files, sf =>
139184
sf.resolvedModules && firstDefinedIterator(sf.resolvedModules.values(), res =>
140185
res && res.resolvedFileName === fileName ? res.originalPath : undefined));
141-
return symlinks.length === 0 ? [fileName] : symlinks;
186+
return symlinks.length === 0 ? getAllModulePathsUsingIndirectSymlinks(files, fileName, getCanonicalFileName, host) : symlinks;
142187
}
143188

144189
function getRelativePathNParents(relativePath: string): number {

‎src/compiler/types.ts

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5284,6 +5284,7 @@ namespace ts {
52845284
useCaseSensitiveFileNames?(): boolean;
52855285
fileExists?(path: string): boolean;
52865286
readFile?(path: string): string | undefined;
5287+
getSourceFiles?(): ReadonlyArray<SourceFile>; // Used for cached resolutions to find symlinks without traversing the fs (again)
52875288
}
52885289

52895290
/** @deprecated See comment on SymbolWriter */

‎src/harness/compilerRunner.ts

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -187,7 +187,9 @@ class CompilerTest {
187187
this.otherFiles,
188188
this.harnessSettings,
189189
/*options*/ tsConfigOptions,
190-
/*currentDirectory*/ this.harnessSettings.currentDirectory);
190+
/*currentDirectory*/ this.harnessSettings.currentDirectory,
191+
testCaseContent.symlinks
192+
);
191193

192194
this.options = this.result.options;
193195
}

‎src/harness/harness.ts

Lines changed: 20 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1138,6 +1138,7 @@ namespace Harness {
11381138
{ name: "noImplicitReferences", type: "boolean" },
11391139
{ name: "currentDirectory", type: "string" },
11401140
{ name: "symlink", type: "string" },
1141+
{ name: "link", type: "string" },
11411142
// Emitted js baseline will print full paths for every output file
11421143
{ name: "fullEmitPaths", type: "boolean" }
11431144
];
@@ -1209,7 +1210,9 @@ namespace Harness {
12091210
harnessSettings: TestCaseParser.CompilerSettings,
12101211
compilerOptions: ts.CompilerOptions,
12111212
// Current directory is needed for rwcRunner to be able to use currentDirectory defined in json file
1212-
currentDirectory: string): compiler.CompilationResult {
1213+
currentDirectory: string | undefined,
1214+
symlinks?: vfs.FileSet
1215+
): compiler.CompilationResult {
12131216
const options: ts.CompilerOptions & HarnessOptions = compilerOptions ? ts.cloneCompilerOptions(compilerOptions) : { noResolve: false };
12141217
options.target = options.target || ts.ScriptTarget.ES3;
12151218
options.newLine = options.newLine || ts.NewLineKind.CarriageReturnLineFeed;
@@ -1246,6 +1249,9 @@ namespace Harness {
12461249

12471250
const docs = inputFiles.concat(otherFiles).map(documents.TextDocument.fromTestFile);
12481251
const fs = vfs.createFromFileSystem(IO, !useCaseSensitiveFileNames, { documents: docs, cwd: currentDirectory });
1252+
if (symlinks) {
1253+
fs.apply(symlinks);
1254+
}
12491255
const host = new fakes.CompilerHost(fs, options);
12501256
return compiler.compileFiles(host, programFileNames, options);
12511257
}
@@ -1858,6 +1864,7 @@ namespace Harness {
18581864

18591865
// Regex for parsing options in the format "@Alpha: Value of any sort"
18601866
const optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*([^\r\n]*)/gm; // multiple matches on multiple lines
1867+
const linkRegex = /^[\/]{2}\s*@link\s*:\s*([^\r\n]*)\s*->\s*([^\r\n]*)/gm; // multiple matches on multiple lines
18611868

18621869
export function extractCompilerSettings(content: string): CompilerSettings {
18631870
const opts: CompilerSettings = {};
@@ -1875,8 +1882,9 @@ namespace Harness {
18751882
export interface TestCaseContent {
18761883
settings: CompilerSettings;
18771884
testUnitData: TestUnitData[];
1878-
tsConfig: ts.ParsedCommandLine;
1879-
tsConfigFileUnitData: TestUnitData;
1885+
tsConfig: ts.ParsedCommandLine | undefined;
1886+
tsConfigFileUnitData: TestUnitData | undefined;
1887+
symlinks?: vfs.FileSet;
18801888
}
18811889

18821890
/** Given a test file containing // @FileName directives, return an array of named units of code to be added to an existing compiler instance */
@@ -1891,10 +1899,16 @@ namespace Harness {
18911899
let currentFileOptions: any = {};
18921900
let currentFileName: any;
18931901
let refs: string[] = [];
1902+
let symlinks: vfs.FileSet | undefined;
18941903

18951904
for (const line of lines) {
1896-
const testMetaData = optionRegex.exec(line);
1897-
if (testMetaData) {
1905+
let testMetaData: RegExpExecArray | null;
1906+
const linkMetaData = linkRegex.exec(line);
1907+
if (linkMetaData) {
1908+
if (!symlinks) symlinks = {};
1909+
symlinks[linkMetaData[2].trim()] = new vfs.Symlink(linkMetaData[1].trim());
1910+
}
1911+
else if (testMetaData = optionRegex.exec(line)) {
18981912
// Comment line, check for global/file @options and record them
18991913
optionRegex.lastIndex = 0;
19001914
const metaDataName = testMetaData[1].toLowerCase();
@@ -1983,7 +1997,7 @@ namespace Harness {
19831997
break;
19841998
}
19851999
}
1986-
return { settings, testUnitData, tsConfig, tsConfigFileUnitData };
2000+
return { settings, testUnitData, tsConfig, tsConfigFileUnitData, symlinks };
19872001
}
19882002
}
19892003

‎src/harness/vfs.ts

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -883,7 +883,7 @@ namespace vfs {
883883
if (this.stringComparer(vpath.dirname(path), path) === 0) {
884884
throw new TypeError("Roots cannot be symbolic links.");
885885
}
886-
this.symlinkSync(entry.symlink, path);
886+
this.symlinkSync(vpath.resolve(dirname, entry.symlink), path);
887887
this._applyFileExtendedOptions(path, entry);
888888
}
889889
else if (entry instanceof Link) {
@@ -1050,8 +1050,7 @@ namespace vfs {
10501050
if (symlink) {
10511051
for (const link of symlink.split(",").map(link => link.trim())) {
10521052
fs.mkdirpSync(vpath.dirname(link));
1053-
fs.symlinkSync(document.file, link);
1054-
fs.filemeta(link).set("document", document);
1053+
fs.symlinkSync(vpath.resolve(fs.cwd(), document.file), link);
10551054
}
10561055
}
10571056
}

‎src/services/codefixes/importFixes.ts

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -237,7 +237,7 @@ namespace ts.codefix {
237237
preferences: UserPreferences,
238238
): ReadonlyArray<NewImportInfo> {
239239
const choicesForEachExportingModule = flatMap<SymbolExportInfo, NewImportInfo[]>(moduleSymbols, ({ moduleSymbol, importKind }) => {
240-
const modulePathsGroups = moduleSpecifiers.getModuleSpecifiers(moduleSymbol, program, sourceFile, host, preferences);
240+
const modulePathsGroups = moduleSpecifiers.getModuleSpecifiers(moduleSymbol, program.getCompilerOptions(), sourceFile, host, program.getSourceFiles(), preferences);
241241
return modulePathsGroups.map(group => group.map(moduleSpecifier => ({ moduleSpecifier, importKind })));
242242
});
243243
// Sort to keep the shortest paths first, but keep [relativePath, importRelativeToBaseUrl] groups together

‎tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.js

Lines changed: 116 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
1+
//// [tests/cases/compiler/symbolLinkDeclarationEmitModuleNames.ts] ////
2+
3+
//// [application.ts]
4+
import { Constructor } from "@loopback/context";
5+
export type ControllerClass = Constructor<any>;
6+
//// [usage.ts]
7+
import { ControllerClass } from './application';
8+
import { BindingKey } from '@loopback/context';
9+
10+
export const CONTROLLER_CLASS = BindingKey.create<ControllerClass>(null as any); // line in question
11+
//// [value-promise.ts]
12+
export type Constructor<T> = (...args: any[]) => T;
13+
//// [bindingkey.ts]
14+
import { Constructor } from "@loopback/context"
15+
export class BindingKey<T> {
16+
readonly __type: T;
17+
static create<T extends Constructor<any>>(ctor: T) {
18+
return new BindingKey<T>();
19+
}
20+
}
21+
22+
//// [index.ts]
23+
export * from "./src/value-promise";
24+
export * from "./src/bindingkey";
25+
26+
27+
//// [value-promise.js]
28+
"use strict";
29+
exports.__esModule = true;
30+
//// [bindingkey.js]
31+
"use strict";
32+
exports.__esModule = true;
33+
var BindingKey = /** @class */ (function () {
34+
function BindingKey() {
35+
}
36+
BindingKey.create = function (ctor) {
37+
return new BindingKey();
38+
};
39+
return BindingKey;
40+
}());
41+
exports.BindingKey = BindingKey;
42+
//// [index.js]
43+
"use strict";
44+
function __export(m) {
45+
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
46+
}
47+
exports.__esModule = true;
48+
__export(require("./src/bindingkey"));
49+
//// [application.js]
50+
"use strict";
51+
exports.__esModule = true;
52+
//// [usage.js]
53+
"use strict";
54+
exports.__esModule = true;
55+
var context_1 = require("@loopback/context");
56+
exports.CONTROLLER_CLASS = context_1.BindingKey.create(null); // line in question
57+
58+
59+
//// [value-promise.d.ts]
60+
export declare type Constructor<T> = (...args: any[]) => T;
61+
//// [bindingkey.d.ts]
62+
import { Constructor } from "@loopback/context";
63+
export declare class BindingKey<T> {
64+
readonly __type: T;
65+
static create<T extends Constructor<any>>(ctor: T): BindingKey<T>;
66+
}
67+
//// [index.d.ts]
68+
export * from "./src/value-promise";
69+
export * from "./src/bindingkey";
70+
//// [application.d.ts]
71+
import { Constructor } from "@loopback/context";
72+
export declare type ControllerClass = Constructor<any>;
73+
//// [usage.d.ts]
74+
import { BindingKey } from '@loopback/context';
75+
export declare const CONTROLLER_CLASS: BindingKey<import("@loopback/context/src/value-promise").Constructor<any>>;
76+
77+
78+
//// [DtsFileErrors]
79+
80+
81+
tests/cases/compiler/monorepo/context/src/bindingkey.d.ts(1,29): error TS2307: Cannot find module '@loopback/context'.
82+
tests/cases/compiler/monorepo/core/src/application.d.ts(1,29): error TS2307: Cannot find module '@loopback/context'.
83+
tests/cases/compiler/monorepo/core/src/usage.d.ts(1,28): error TS2307: Cannot find module '@loopback/context'.
84+
tests/cases/compiler/monorepo/core/src/usage.d.ts(2,51): error TS2307: Cannot find module '@loopback/context/src/value-promise'.
85+
86+
87+
==== tests/cases/compiler/monorepo/core/src/application.d.ts (1 errors) ====
88+
import { Constructor } from "@loopback/context";
89+
~~~~~~~~~~~~~~~~~~~
90+
!!! error TS2307: Cannot find module '@loopback/context'.
91+
export declare type ControllerClass = Constructor<any>;
92+
93+
==== tests/cases/compiler/monorepo/core/src/usage.d.ts (2 errors) ====
94+
import { BindingKey } from '@loopback/context';
95+
~~~~~~~~~~~~~~~~~~~
96+
!!! error TS2307: Cannot find module '@loopback/context'.
97+
export declare const CONTROLLER_CLASS: BindingKey<import("@loopback/context/src/value-promise").Constructor<any>>;
98+
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
99+
!!! error TS2307: Cannot find module '@loopback/context/src/value-promise'.
100+
101+
==== /.src/tests/cases/compiler/monorepo/context/src/value-promise.d.ts (0 errors) ====
102+
export declare type Constructor<T> = (...args: any[]) => T;
103+
104+
==== /.src/tests/cases/compiler/monorepo/context/src/bindingkey.d.ts (1 errors) ====
105+
import { Constructor } from "@loopback/context";
106+
~~~~~~~~~~~~~~~~~~~
107+
!!! error TS2307: Cannot find module '@loopback/context'.
108+
export declare class BindingKey<T> {
109+
readonly __type: T;
110+
static create<T extends Constructor<any>>(ctor: T): BindingKey<T>;
111+
}
112+
113+
==== /.src/tests/cases/compiler/monorepo/context/index.d.ts (0 errors) ====
114+
export * from "./src/value-promise";
115+
export * from "./src/bindingkey";
116+

0 commit comments

Comments
 (0)