diff options
Diffstat (limited to 'js')
| -rw-r--r-- | js/compiler.ts | 418 | ||||
| -rw-r--r-- | js/compiler_test.ts | 273 | ||||
| -rw-r--r-- | js/deno.ts | 3 | ||||
| -rw-r--r-- | js/main.ts | 11 | ||||
| -rw-r--r-- | js/runner.ts | 187 | ||||
| -rw-r--r-- | js/runner_test.ts | 141 | ||||
| -rw-r--r-- | js/unit_tests.ts | 1 |
7 files changed, 509 insertions, 525 deletions
diff --git a/js/compiler.ts b/js/compiler.ts index d87309512..9ba018932 100644 --- a/js/compiler.ts +++ b/js/compiler.ts @@ -1,33 +1,18 @@ // Copyright 2018 the Deno authors. All rights reserved. MIT license. import * as ts from "typescript"; import { MediaType } from "gen/msg_generated"; + import { assetSourceCode } from "./assets"; -// tslint:disable-next-line:no-circular-imports -import * as deno from "./deno"; -import { globalEval } from "./global_eval"; import { libdeno } from "./libdeno"; import * as os from "./os"; +import { CodeProvider } from "./runner"; import { RawSourceMap } from "./types"; import { assert, log, notImplemented } from "./util"; -const window = globalEval("this"); - const EOL = "\n"; const ASSETS = "$asset$"; const LIB_RUNTIME = "lib.deno_runtime.d.ts"; -// tslint:disable:no-any -type AmdCallback = (...args: any[]) => void; -type AmdErrback = (err: any) => void; -export type AmdFactory = (...args: any[]) => object | void; -// tslint:enable:no-any -export type AmdDefine = (deps: ModuleSpecifier[], factory: AmdFactory) => void; -type AMDRequire = ( - deps: ModuleSpecifier[], - callback: AmdCallback, - errback: AmdErrback -) => void; - /** The location that a module is being loaded from. This could be a directory, * like `.`, or it could be a module specifier like * `http://gist.github.com/somefile.ts` @@ -78,11 +63,6 @@ export interface Ts { * the module, not the actual module instance. */ export class ModuleMetaData implements ts.IScriptSnapshot { - public deps?: ModuleFileName[]; - public exports = {}; - public factory?: AmdFactory; - public gatheringDeps = false; - public hasRun = false; public scriptVersion = ""; constructor( @@ -142,8 +122,8 @@ export function jsonAmdTemplate( * with Deno specific APIs to provide an interface for compiling and running * TypeScript and JavaScript modules. */ -export class DenoCompiler - implements ts.LanguageServiceHost, ts.FormatDiagnosticsHost { +export class Compiler + implements ts.LanguageServiceHost, ts.FormatDiagnosticsHost, CodeProvider { // Modules are usually referenced by their ModuleSpecifier and ContainingFile, // and keeping a map of the resolved module file name allows more efficient // future resolution @@ -151,8 +131,6 @@ export class DenoCompiler ContainingFile, Map<ModuleSpecifier, ModuleFileName> >(); - // A reference to global eval, so it can be monkey patched during testing - private _globalEval = globalEval; // Keep track of state of the last module requested via `getGeneratedContents` private _lastModule: ModuleMetaData | undefined; // A reference to the log utility, so it can be monkey patched during testing @@ -177,10 +155,7 @@ export class DenoCompiler // A reference to the `./os.ts` module, so it can be monkey patched during // testing private _os: Os = os; - // Contains a queue of modules that have been resolved, but not yet - // run - private _runQueue: ModuleMetaData[] = []; - // Used to contain the script file we are currently running + // Used to contain the script file we are currently compiling private _scriptFileNames: string[] = []; // A reference to the TypeScript LanguageService instance so it can be // monkey patched during testing @@ -188,84 +163,9 @@ export class DenoCompiler // A reference to `typescript` module so it can be monkey patched during // testing private _ts: Ts = ts; - // A reference to the global scope so it can be monkey patched during - // testing - private _window = window; // Flags forcing recompilation of TS code public recompile = false; - /** Drain the run queue, retrieving the arguments for the module - * factory and calling the module's factory. - */ - private _drainRunQueue(): void { - this._log( - "compiler._drainRunQueue", - this._runQueue.map(metaData => metaData.fileName) - ); - let moduleMetaData: ModuleMetaData | undefined; - while ((moduleMetaData = this._runQueue.shift())) { - assert( - moduleMetaData.factory != null, - "Cannot run module without factory." - ); - assert(moduleMetaData.hasRun === false, "Module has already been run."); - // asserts not tracked by TypeScripts, so using not null operator - const exports = moduleMetaData.factory!( - ...this._getFactoryArguments(moduleMetaData) - ); - // For JSON module support and potential future features. - // TypeScript always imports `exports` and mutates it directly, but the - // AMD specification allows values to be returned from the factory. - if (exports != null) { - moduleMetaData.exports = exports; - } - moduleMetaData.hasRun = true; - } - } - - /** Get the dependencies for a given module, but don't run the module, - * just add the module factory to the run queue. - */ - private _gatherDependencies(moduleMetaData: ModuleMetaData): void { - this._log("compiler._resolveDependencies", moduleMetaData.fileName); - - // if the module has already run, we can short circuit. - // it is intentional though that if we have already resolved dependencies, - // we won't short circuit, as something may have changed, or we might have - // only collected the dependencies to be able to able to obtain the graph of - // dependencies - if (moduleMetaData.hasRun) { - return; - } - - this._window.define = this._makeDefine(moduleMetaData); - this._globalEval(this.compile(moduleMetaData)); - this._window.define = undefined; - } - - /** Retrieve the arguments to pass a module's factory function. */ - // tslint:disable-next-line:no-any - private _getFactoryArguments(moduleMetaData: ModuleMetaData): any[] { - if (!moduleMetaData.deps) { - throw new Error("Cannot get arguments until dependencies resolved."); - } - return moduleMetaData.deps.map(dep => { - if (dep === "require") { - return this._makeLocalRequire(moduleMetaData); - } - if (dep === "exports") { - return moduleMetaData.exports; - } - if (dep in DenoCompiler._builtins) { - return DenoCompiler._builtins[dep]; - } - const dependencyMetaData = this._getModuleMetaData(dep); - assert(dependencyMetaData != null, `Missing dependency "${dep}".`); - // TypeScript does not track assert, therefore using not null operator - return dependencyMetaData!.exports; - }); - } - /** The TypeScript language service often refers to the resolved fileName of * a module, this is a shortcut to avoid unnecessary module resolution logic * for modules that may have been initially resolved by a `moduleSpecifier` @@ -280,70 +180,10 @@ export class DenoCompiler return this._moduleMetaDataMap.has(fileName) ? this._moduleMetaDataMap.get(fileName) : fileName.startsWith(ASSETS) - ? this.resolveModule(fileName, "") + ? this._resolveModule(fileName, "") : undefined; } - /** Create a localized AMD `define` function and return it. */ - private _makeDefine(moduleMetaData: ModuleMetaData): AmdDefine { - return (deps: ModuleSpecifier[], factory: AmdFactory): void => { - this._log("compiler.localDefine", moduleMetaData.fileName); - moduleMetaData.factory = factory; - // when there are circular dependencies, we need to skip recursing the - // dependencies - moduleMetaData.gatheringDeps = true; - // we will recursively resolve the dependencies for any modules - moduleMetaData.deps = deps.map(dep => { - if ( - dep === "require" || - dep === "exports" || - dep in DenoCompiler._builtins - ) { - return dep; - } - const dependencyMetaData = this.resolveModule( - dep, - moduleMetaData.fileName - ); - if (!dependencyMetaData.gatheringDeps) { - this._gatherDependencies(dependencyMetaData); - } - return dependencyMetaData.fileName; - }); - moduleMetaData.gatheringDeps = false; - if (!this._runQueue.includes(moduleMetaData)) { - this._runQueue.push(moduleMetaData); - } - }; - } - - /** Returns a require that specifically handles the resolution of a transpiled - * emit of a dynamic ES `import()` from TypeScript. - */ - private _makeLocalRequire(moduleMetaData: ModuleMetaData): AMDRequire { - return ( - deps: ModuleSpecifier[], - callback: AmdCallback, - errback: AmdErrback - ): void => { - log("localRequire", deps); - assert( - deps.length === 1, - "Local require requires exactly one dependency." - ); - const [moduleSpecifier] = deps; - try { - const requiredMetaData = this.run( - moduleSpecifier, - moduleMetaData.fileName - ); - callback(requiredMetaData.exports); - } catch (e) { - errback(e); - } - }; - } - /** Given a `moduleSpecifier` and `containingFile` retrieve the cached * `fileName` for a given module. If the module has yet to be resolved * this will return `undefined`. @@ -360,6 +200,82 @@ export class DenoCompiler return undefined; } + /** Given a `moduleSpecifier` and `containingFile`, resolve the module and + * return the `ModuleMetaData`. + */ + private _resolveModule( + moduleSpecifier: ModuleSpecifier, + containingFile: ContainingFile + ): ModuleMetaData { + this._log("compiler.resolveModule", { moduleSpecifier, containingFile }); + assert(moduleSpecifier != null && moduleSpecifier.length > 0); + let fileName = this._resolveFileName(moduleSpecifier, containingFile); + if (fileName && this._moduleMetaDataMap.has(fileName)) { + return this._moduleMetaDataMap.get(fileName)!; + } + let moduleId: ModuleId | undefined; + let mediaType = MediaType.Unknown; + let sourceCode: SourceCode | undefined; + let outputCode: OutputCode | undefined; + let sourceMap: SourceMap | undefined; + if ( + moduleSpecifier.startsWith(ASSETS) || + containingFile.startsWith(ASSETS) + ) { + // Assets are compiled into the runtime javascript bundle. + // we _know_ `.pop()` will return a string, but TypeScript doesn't so + // not null assertion + moduleId = moduleSpecifier.split("/").pop()!; + const assetName = moduleId.includes(".") ? moduleId : `${moduleId}.d.ts`; + assert(assetName in assetSourceCode, `No such asset "${assetName}"`); + mediaType = MediaType.TypeScript; + sourceCode = assetSourceCode[assetName]; + fileName = `${ASSETS}/${assetName}`; + outputCode = ""; + sourceMap = ""; + } else { + // We query Rust with a CodeFetch message. It will load the sourceCode, + // and if there is any outputCode cached, will return that as well. + const fetchResponse = this._os.codeFetch(moduleSpecifier, containingFile); + moduleId = fetchResponse.moduleName; + fileName = fetchResponse.filename; + mediaType = fetchResponse.mediaType; + sourceCode = fetchResponse.sourceCode; + outputCode = fetchResponse.outputCode; + sourceMap = + fetchResponse.sourceMap && JSON.parse(fetchResponse.sourceMap); + } + assert(moduleId != null, "No module ID."); + assert(fileName != null, "No file name."); + assert(sourceCode ? sourceCode.length > 0 : false, "No source code."); + assert( + mediaType !== MediaType.Unknown, + `Unknown media type for: "${moduleSpecifier}" from "${containingFile}".` + ); + this._log( + "resolveModule sourceCode length:", + sourceCode && sourceCode.length + ); + this._log("resolveModule has outputCode:", outputCode != null); + this._log("resolveModule has source map:", sourceMap != null); + this._log("resolveModule has media type:", MediaType[mediaType]); + // fileName is asserted above, but TypeScript does not track so not null + this._setFileName(moduleSpecifier, containingFile, fileName!); + if (fileName && this._moduleMetaDataMap.has(fileName)) { + return this._moduleMetaDataMap.get(fileName)!; + } + const moduleMetaData = new ModuleMetaData( + moduleId!, + fileName!, + mediaType, + sourceCode, + outputCode, + sourceMap + ); + this._moduleMetaDataMap.set(fileName!, moduleMetaData); + return moduleMetaData; + } + /** Caches the resolved `fileName` in relationship to the `moduleSpecifier` * and `containingFile` in order to reduce calls to the privileged side * to retrieve the contents of a module. @@ -379,7 +295,7 @@ export class DenoCompiler } private constructor() { - if (DenoCompiler._instance) { + if (Compiler._instance) { throw new TypeError("Attempt to create an additional compiler."); } this._service = this._ts.createLanguageService(this); @@ -470,6 +386,17 @@ export class DenoCompiler return moduleMetaData.outputCode; } + /** Given a module specifier and a containing file, return the filename of the + * module. If the module is not resolvable, the method will throw. + */ + getFilename( + moduleSpecifier: ModuleSpecifier, + containingFile: ContainingFile + ): ModuleFileName { + const moduleMetaData = this._resolveModule(moduleSpecifier, containingFile); + return moduleMetaData.fileName; + } + /** Given a fileName, return what was generated by the compiler. */ getGeneratedContents = (fileName: string): string | RawSourceMap => { this._log("compiler.getGeneratedContents", fileName); @@ -502,125 +429,25 @@ export class DenoCompiler } }; - /** For a given module specifier and containing file, return a list of - * absolute identifiers for dependent modules that are required by this - * module. + /** Get the output code for a module based on its filename. A call to + * `.getFilename()` should occur before attempting to get the output code as + * this ensures the module is loaded. */ - getModuleDependencies( - moduleSpecifier: ModuleSpecifier, - containingFile: ContainingFile - ): ModuleFileName[] { - assert( - this._runQueue.length === 0, - "Cannot get dependencies with modules queued to be run." - ); - const moduleMetaData = this.resolveModule(moduleSpecifier, containingFile); - assert( - !moduleMetaData.hasRun, - "Cannot get dependencies for a module that has already been run." - ); - this._gatherDependencies(moduleMetaData); - const dependencies = this._runQueue.map( - moduleMetaData => moduleMetaData.moduleId - ); - // empty the run queue, to free up references to factories we have collected - // and to ensure that if there is a further invocation of `.run()` the - // factories don't get called - this._runQueue = []; - return dependencies; - } - - /** Given a `moduleSpecifier` and `containingFile`, resolve the module and - * return the `ModuleMetaData`. - */ - resolveModule( - moduleSpecifier: ModuleSpecifier, - containingFile: ContainingFile - ): ModuleMetaData { - this._log("compiler.resolveModule", { moduleSpecifier, containingFile }); - assert(moduleSpecifier != null && moduleSpecifier.length > 0); - let fileName = this._resolveFileName(moduleSpecifier, containingFile); - if (fileName && this._moduleMetaDataMap.has(fileName)) { - return this._moduleMetaDataMap.get(fileName)!; - } - let moduleId: ModuleId | undefined; - let mediaType = MediaType.Unknown; - let sourceCode: SourceCode | undefined; - let outputCode: OutputCode | undefined; - let sourceMap: SourceMap | undefined; - if ( - moduleSpecifier.startsWith(ASSETS) || - containingFile.startsWith(ASSETS) - ) { - // Assets are compiled into the runtime javascript bundle. - // we _know_ `.pop()` will return a string, but TypeScript doesn't so - // not null assertion - moduleId = moduleSpecifier.split("/").pop()!; - const assetName = moduleId.includes(".") ? moduleId : `${moduleId}.d.ts`; - assert(assetName in assetSourceCode, `No such asset "${assetName}"`); - mediaType = MediaType.TypeScript; - sourceCode = assetSourceCode[assetName]; - fileName = `${ASSETS}/${assetName}`; - outputCode = ""; - sourceMap = ""; - } else { - // We query Rust with a CodeFetch message. It will load the sourceCode, - // and if there is any outputCode cached, will return that as well. - const fetchResponse = this._os.codeFetch(moduleSpecifier, containingFile); - moduleId = fetchResponse.moduleName; - fileName = fetchResponse.filename; - mediaType = fetchResponse.mediaType; - sourceCode = fetchResponse.sourceCode; - outputCode = fetchResponse.outputCode; - sourceMap = - fetchResponse.sourceMap && JSON.parse(fetchResponse.sourceMap); - } - assert(moduleId != null, "No module ID."); - assert(fileName != null, "No file name."); - assert(sourceCode ? sourceCode.length > 0 : false, "No source code."); - assert( - mediaType !== MediaType.Unknown, - `Unknown media type for: "${moduleSpecifier}" from "${containingFile}".` - ); - this._log( - "resolveModule sourceCode length:", - sourceCode && sourceCode.length - ); - this._log("resolveModule has outputCode:", outputCode != null); - this._log("resolveModule has source map:", sourceMap != null); - this._log("resolveModule has media type:", MediaType[mediaType]); - // fileName is asserted above, but TypeScript does not track so not null - this._setFileName(moduleSpecifier, containingFile, fileName!); - if (fileName && this._moduleMetaDataMap.has(fileName)) { - return this._moduleMetaDataMap.get(fileName)!; - } - const moduleMetaData = new ModuleMetaData( - moduleId!, - fileName!, - mediaType, - sourceCode, - outputCode, - sourceMap - ); - this._moduleMetaDataMap.set(fileName!, moduleMetaData); - return moduleMetaData; + getOutput(filename: ModuleFileName): OutputCode { + const moduleMetaData = this._getModuleMetaData(filename)!; + assert(moduleMetaData != null, `Module not loaded: "${filename}"`); + this._scriptFileNames = [moduleMetaData.fileName]; + return this.compile(moduleMetaData); } - /** Load and run a module and all of its dependencies based on a module - * specifier and a containing file + /** Get the source code for a module based on its filename. A call to + * `.getFilename()` should occur before attempting to get the output code as + * this ensures the module is loaded. */ - run( - moduleSpecifier: ModuleSpecifier, - containingFile: ContainingFile - ): ModuleMetaData { - this._log("compiler.run", { moduleSpecifier, containingFile }); - const moduleMetaData = this.resolveModule(moduleSpecifier, containingFile); - this._scriptFileNames = [moduleMetaData.fileName]; - if (!moduleMetaData.deps) { - this._gatherDependencies(moduleMetaData); - } - this._drainRunQueue(); - return moduleMetaData; + getSource(filename: ModuleFileName): SourceCode { + const moduleMetaData = this._getModuleMetaData(filename)!; + assert(moduleMetaData != null, `Module not loaded: "${filename}"`); + return moduleMetaData.sourceCode; } // TypeScript Language Service and Format Diagnostic Host API @@ -684,7 +511,7 @@ export class DenoCompiler getDefaultLibFileName(): string { this._log("getDefaultLibFileName()"); const moduleSpecifier = LIB_RUNTIME; - const moduleMetaData = this.resolveModule(moduleSpecifier, ASSETS); + const moduleMetaData = this._resolveModule(moduleSpecifier, ASSETS); return moduleMetaData.fileName; } @@ -714,11 +541,11 @@ export class DenoCompiler let moduleMetaData: ModuleMetaData; if (name === "deno") { // builtin modules are part of the runtime lib - moduleMetaData = this.resolveModule(LIB_RUNTIME, ASSETS); + moduleMetaData = this._resolveModule(LIB_RUNTIME, ASSETS); } else if (name === "typescript") { - moduleMetaData = this.resolveModule("typescript.d.ts", ASSETS); + moduleMetaData = this._resolveModule("typescript.d.ts", ASSETS); } else { - moduleMetaData = this.resolveModule(name, containingFile); + moduleMetaData = this._resolveModule(name, containingFile); } // According to the interface we shouldn't return `undefined` but if we // fail to return the same length of modules to those we cannot resolve @@ -741,23 +568,10 @@ export class DenoCompiler // Deno specific static properties and methods - /** Built in modules which can be returned to external modules - * - * Placed as a private static otherwise we get use before - * declared with the `DenoCompiler` - */ - // tslint:disable-next-line:no-any - private static _builtins: { [mid: string]: any } = { - typescript: ts, - deno - }; - - private static _instance: DenoCompiler | undefined; + private static _instance: Compiler | undefined; /** Returns the instance of `DenoCompiler` or creates a new instance. */ - static instance(): DenoCompiler { - return ( - DenoCompiler._instance || (DenoCompiler._instance = new DenoCompiler()) - ); + static instance(): Compiler { + return Compiler._instance || (Compiler._instance = new Compiler()); } } diff --git a/js/compiler_test.ts b/js/compiler_test.ts index d2a3a2cf2..45c7f775c 100644 --- a/js/compiler_test.ts +++ b/js/compiler_test.ts @@ -1,12 +1,12 @@ // Copyright 2018 the Deno authors. All rights reserved. MIT license. -import { test, assert, assertEqual } from "./test_util.ts"; +import { test, assert, assertEqual } from "./test_util"; import * as deno from "deno"; import * as ts from "typescript"; // We use a silly amount of `any` in these tests... // tslint:disable:no-any -const { DenoCompiler, jsonAmdTemplate } = (deno as any)._compiler; +const { Compiler, jsonAmdTemplate } = (deno as any)._compiler; interface ModuleInfo { moduleName: string | undefined; @@ -17,16 +17,14 @@ interface ModuleInfo { sourceMap: string | undefined; } -const compilerInstance = DenoCompiler.instance(); +const compilerInstance = Compiler.instance(); // References to original items we are going to mock const originals = { - _globalEval: (compilerInstance as any)._globalEval, _log: (compilerInstance as any)._log, _os: (compilerInstance as any)._os, _ts: (compilerInstance as any)._ts, - _service: (compilerInstance as any)._service, - _window: (compilerInstance as any)._window + _service: (compilerInstance as any)._service }; enum MediaType { @@ -244,7 +242,6 @@ const emittedFiles = { "/root/project/foo/qat.ts": "console.log('foo');" }; -let globalEvalStack: string[] = []; let getEmitOutputStack: string[] = []; let logStack: any[][] = []; let codeCacheStack: Array<{ @@ -261,12 +258,6 @@ let codeFetchStack: Array<{ let mockDepsStack: string[][] = []; let mockFactoryStack: any[] = []; -function globalEvalMock(x: string): void { - globalEvalStack.push(x); - if (windowMock.define && mockDepsStack.length && mockFactoryStack.length) { - windowMock.define(mockDepsStack.pop(), mockFactoryStack.pop()); - } -} function logMock(...args: any[]): void { logStack.push(args); } @@ -306,6 +297,7 @@ const osMock = { throw new Error(`Unexpected call to os.exit(${code})`); } }; + const tsMock = { createLanguageService(host: ts.LanguageServiceHost): ts.LanguageService { return {} as ts.LanguageService; @@ -355,14 +347,11 @@ const serviceMock = { ); } }; -const windowMock: { define?: any } = {}; const mocks = { - _globalEval: globalEvalMock, _log: logMock, _os: osMock, _ts: tsMock, - _service: serviceMock, - _window: windowMock + _service: serviceMock }; /** @@ -386,7 +375,6 @@ function teardown() { codeCacheStack = []; logStack = []; getEmitOutputStack = []; - globalEvalStack = []; assertEqual(mockDepsStack.length, 0); assertEqual(mockFactoryStack.length, 0); @@ -405,7 +393,10 @@ test(function testJsonAmdTemplate() { factory = f; } - const code = jsonAmdTemplate(`{ "hello": "world", "foo": "bar" }`); + const code = jsonAmdTemplate( + `{ "hello": "world", "foo": "bar" }`, + "example.json" + ); const result = eval(code); assert(result == null); assertEqual(deps && deps.length, 0); @@ -415,156 +406,51 @@ test(function testJsonAmdTemplate() { }); test(function compilerInstance() { - assert(DenoCompiler != null); - assert(DenoCompiler.instance() != null); + assert(Compiler != null); + assert(Compiler.instance() != null); }); // Testing the internal APIs -test(function compilerRun() { - // equal to `deno foo/bar.ts` +test(function testGetFilename() { setup(); - let factoryRun = false; - mockDepsStack.push(["require", "exports", "deno"]); - mockFactoryStack.push((_require, _exports, _deno) => { - factoryRun = true; - assertEqual(typeof _require, "function"); - assertEqual(typeof _exports, "object"); - assert(_deno === deno); - _exports.foo = "bar"; - }); - const moduleMetaData = compilerInstance.run("foo/bar.ts", "/root/project"); - assert(factoryRun); - assert(moduleMetaData.hasRun); - assertEqual(moduleMetaData.sourceCode, fooBarTsSource); - assertEqual(moduleMetaData.outputCode, fooBarTsOutput); - assertEqual(JSON.stringify(moduleMetaData.sourceMap), fooBarTsSourcemap); - assertEqual(moduleMetaData.exports, { foo: "bar" }); - assertEqual( - codeFetchStack.length, - 1, - "Module should have only been fetched once." + compilerInstance.getFilename("foo/bar.ts", "/root/project"), + "/root/project/foo/bar.ts" ); - assertEqual( - codeCacheStack.length, - 1, - "Compiled code should have only been cached once." - ); - const [codeCacheCall] = codeCacheStack; - assertEqual(codeCacheCall.fileName, "/root/project/foo/bar.ts"); - assertEqual(codeCacheCall.sourceCode, fooBarTsSource); - assertEqual(codeCacheCall.outputCode, fooBarTsOutput); - assertEqual(codeCacheCall.sourceMap, fooBarTsSourcemap); teardown(); }); -test(function compilerRunMultiModule() { - // equal to `deno foo/baz.ts` +test(function testGetOutput() { setup(); - const factoryStack: string[] = []; - const bazDeps = ["require", "exports", "./bar.ts"]; - const bazFactory = (_require, _exports, _bar) => { - factoryStack.push("baz"); - assertEqual(_bar.foo, "bar"); - }; - const barDeps = ["require", "exports", "deno"]; - const barFactory = (_require, _exports, _deno) => { - factoryStack.push("bar"); - _exports.foo = "bar"; - }; - mockDepsStack.push(barDeps); - mockFactoryStack.push(barFactory); - mockDepsStack.push(bazDeps); - mockFactoryStack.push(bazFactory); - compilerInstance.run("foo/baz.ts", "/root/project"); - assertEqual(factoryStack, ["bar", "baz"]); - - assertEqual( - codeFetchStack.length, - 2, - "Modules should have only been fetched once." - ); - assertEqual(codeCacheStack.length, 0, "No code should have been cached."); + const filename = compilerInstance.getFilename("foo/bar.ts", "/root/project"); + assertEqual(compilerInstance.getOutput(filename), fooBarTsOutput); teardown(); }); -test(function compilerRunCircularDependency() { +test(function testGetOutputJson() { setup(); - const factoryStack: string[] = []; - const modADeps = ["require", "exports", "./modB.ts"]; - const modAFactory = (_require, _exports, _modB) => { - assertEqual(_modB.foo, "bar"); - factoryStack.push("modA"); - _exports.bar = "baz"; - _modB.assertModA(); - }; - const modBDeps = ["require", "exports", "./modA.ts"]; - const modBFactory = (_require, _exports, _modA) => { - assertEqual(_modA, {}); - factoryStack.push("modB"); - _exports.foo = "bar"; - _exports.assertModA = () => { - assertEqual(_modA, { - bar: "baz" - }); - }; - }; - mockDepsStack.push(modBDeps); - mockFactoryStack.push(modBFactory); - mockDepsStack.push(modADeps); - mockFactoryStack.push(modAFactory); - compilerInstance.run("modA.ts", "/root/project"); - assertEqual(factoryStack, ["modB", "modA"]); - teardown(); + const filename = compilerInstance.getFilename( + "./config.json", + "/root/project/loadConfig.ts" + ); + assertEqual( + compilerInstance.getOutput(filename), + jsonAmdTemplate(configJsonSource, filename) + ); }); -test(function compilerLoadJsonModule() { +test(function testGetSource() { setup(); - const factoryStack: string[] = []; - const configJsonDeps: string[] = []; - const configJsonFactory = () => { - factoryStack.push("configJson"); - return JSON.parse(configJsonSource); - }; - const loadConfigDeps = ["require", "exports", "./config.json"]; - const loadConfigFactory = (_require, _exports, _config) => { - factoryStack.push("loadConfig"); - assertEqual(_config, JSON.parse(configJsonSource)); - }; - - mockDepsStack.push(configJsonDeps); - mockFactoryStack.push(configJsonFactory); - mockDepsStack.push(loadConfigDeps); - mockFactoryStack.push(loadConfigFactory); - compilerInstance.run("loadConfig.ts", "/root/project"); - assertEqual(factoryStack, ["configJson", "loadConfig"]); - teardown(); + const filename = compilerInstance.getFilename("foo/bar.ts", "/root/project"); + assertEqual(compilerInstance.getSource(filename), fooBarTsSource); }); -test(function compilerResolveModule() { - setup(); - const moduleMetaData = compilerInstance.resolveModule( - "foo/baz.ts", - "/root/project" - ); - assertEqual(moduleMetaData.sourceCode, fooBazTsSource); - assertEqual(moduleMetaData.outputCode, fooBazTsOutput); - assertEqual(JSON.stringify(moduleMetaData.sourceMap), fooBazTsSourcemap); - assert(!moduleMetaData.hasRun); - assert(!moduleMetaData.deps); - assertEqual(moduleMetaData.exports, {}); - assertEqual(moduleMetaData.scriptVersion, "1"); - - assertEqual(codeFetchStack.length, 1, "Only initial module is resolved."); - teardown(); -}); - -test(function compilerResolveModuleUnknownMediaType() { +test(function testGetOutputUnknownMediaType() { setup(); let didThrow = false; try { - compilerInstance.resolveModule("some.txt", "/root/project"); + compilerInstance.getFilename("some.txt", "/root/project"); } catch (e) { assert(e instanceof Error); assertEqual( @@ -577,28 +463,6 @@ test(function compilerResolveModuleUnknownMediaType() { teardown(); }); -test(function compilerGetModuleDependencies() { - setup(); - const bazDeps = ["require", "exports", "./bar.ts"]; - const bazFactory = () => { - throw new Error("Unexpected factory call"); - }; - const barDeps = ["require", "exports", "deno"]; - const barFactory = () => { - throw new Error("Unexpected factory call"); - }; - mockDepsStack.push(barDeps); - mockFactoryStack.push(barFactory); - mockDepsStack.push(bazDeps); - mockFactoryStack.push(bazFactory); - const deps = compilerInstance.getModuleDependencies( - "foo/baz.ts", - "/root/project" - ); - assertEqual(deps, ["/root/project/foo/bar.ts", "/root/project/foo/baz.ts"]); - teardown(); -}); - // TypeScript LanguageServiceHost APIs test(function compilerGetCompilationSettings() { @@ -626,7 +490,8 @@ test(function compilerGetNewLine() { test(function compilerGetScriptFileNames() { setup(); - compilerInstance.run("foo/bar.ts", "/root/project"); + const filename = compilerInstance.getFilename("foo/bar.ts", "/root/project"); + compilerInstance.getOutput(filename); const result = compilerInstance.getScriptFileNames(); assertEqual(result.length, 1, "Expected only a single filename."); assertEqual(result[0], "/root/project/foo/bar.ts"); @@ -635,21 +500,22 @@ test(function compilerGetScriptFileNames() { test(function compilerRecompileFlag() { setup(); - compilerInstance.run("foo/bar.ts", "/root/project"); + const filename = compilerInstance.getFilename("foo/bar.ts", "/root/project"); + compilerInstance.getOutput(filename); assertEqual( getEmitOutputStack.length, 1, "Expected only a single emitted file." ); // running compiler against same file should use cached code - compilerInstance.run("foo/bar.ts", "/root/project"); + compilerInstance.getOutput(filename); assertEqual( getEmitOutputStack.length, 1, "Expected only a single emitted file." ); compilerInstance.recompile = true; - compilerInstance.run("foo/bar.ts", "/root/project"); + compilerInstance.getOutput(filename); assertEqual(getEmitOutputStack.length, 2, "Expected two emitted file."); assert( getEmitOutputStack[0] === getEmitOutputStack[1], @@ -660,43 +526,25 @@ test(function compilerRecompileFlag() { test(function compilerGetScriptKind() { setup(); - compilerInstance.resolveModule("foo.ts", "/moduleKinds"); - compilerInstance.resolveModule("foo.d.ts", "/moduleKinds"); - compilerInstance.resolveModule("foo.js", "/moduleKinds"); - compilerInstance.resolveModule("foo.json", "/moduleKinds"); - compilerInstance.resolveModule("foo.txt", "/moduleKinds"); - assertEqual( - compilerInstance.getScriptKind("/moduleKinds/foo.ts"), - ts.ScriptKind.TS - ); - assertEqual( - compilerInstance.getScriptKind("/moduleKinds/foo.d.ts"), - ts.ScriptKind.TS - ); - assertEqual( - compilerInstance.getScriptKind("/moduleKinds/foo.js"), - ts.ScriptKind.JS - ); - assertEqual( - compilerInstance.getScriptKind("/moduleKinds/foo.json"), - ts.ScriptKind.JSON - ); - assertEqual( - compilerInstance.getScriptKind("/moduleKinds/foo.txt"), - ts.ScriptKind.JS - ); + compilerInstance.getFilename("foo.ts", "/moduleKinds"); + compilerInstance.getFilename("foo.d.ts", "/moduleKinds"); + compilerInstance.getFilename("foo.js", "/moduleKinds"); + compilerInstance.getFilename("foo.json", "/moduleKinds"); + compilerInstance.getFilename("foo.txt", "/moduleKinds"); + assertEqual(compilerInstance.getScriptKind("/moduleKinds/foo.ts"), 3); + assertEqual(compilerInstance.getScriptKind("/moduleKinds/foo.d.ts"), 3); + assertEqual(compilerInstance.getScriptKind("/moduleKinds/foo.js"), 1); + assertEqual(compilerInstance.getScriptKind("/moduleKinds/foo.json"), 6); + assertEqual(compilerInstance.getScriptKind("/moduleKinds/foo.txt"), 1); teardown(); }); test(function compilerGetScriptVersion() { setup(); - const moduleMetaData = compilerInstance.resolveModule( - "foo/bar.ts", - "/root/project" - ); - compilerInstance.compile(moduleMetaData); + const filename = compilerInstance.getFilename("foo/bar.ts", "/root/project"); + compilerInstance.getOutput(filename); assertEqual( - compilerInstance.getScriptVersion(moduleMetaData.fileName), + compilerInstance.getScriptVersion(filename), "1", "Expected known module to have script version of 1" ); @@ -713,11 +561,8 @@ test(function compilerGetScriptVersionUnknown() { test(function compilerGetScriptSnapshot() { setup(); - const moduleMetaData = compilerInstance.resolveModule( - "foo/bar.ts", - "/root/project" - ); - const result = compilerInstance.getScriptSnapshot(moduleMetaData.fileName); + const filename = compilerInstance.getFilename("foo/bar.ts", "/root/project"); + const result = compilerInstance.getScriptSnapshot(filename); assert(result != null, "Expected snapshot to be defined."); assertEqual(result.getLength(), fooBarTsSource.length); assertEqual( @@ -729,11 +574,6 @@ test(function compilerGetScriptSnapshot() { // This is and optional part of the `IScriptSnapshot` API which we don't // define, os checking for the lack of this property. assert(!("dispose" in result)); - - assert( - result === moduleMetaData, - "result should strictly equal moduleMetaData" - ); teardown(); }); @@ -767,11 +607,8 @@ test(function compilerReadFile() { test(function compilerFileExists() { setup(); - const moduleMetaData = compilerInstance.resolveModule( - "foo/bar.ts", - "/root/project" - ); - assert(compilerInstance.fileExists(moduleMetaData.fileName)); + const filename = compilerInstance.getFilename("foo/bar.ts", "/root/project"); + assert(compilerInstance.fileExists(filename)); assert(compilerInstance.fileExists("$asset$/lib.deno_runtime.d.ts")); assertEqual( compilerInstance.fileExists("/root/project/unknown-module.ts"), diff --git a/js/deno.ts b/js/deno.ts index 532357dab..fc1c099d6 100644 --- a/js/deno.ts +++ b/js/deno.ts @@ -48,3 +48,6 @@ export const args: string[] = []; import * as compiler from "./compiler"; // @internal export const _compiler = compiler; +import * as runner from "./runner"; +// @internal +export const _runner = runner; diff --git a/js/main.ts b/js/main.ts index 6f2d0fcfa..241e8d7d1 100644 --- a/js/main.ts +++ b/js/main.ts @@ -6,7 +6,8 @@ import * as flatbuffers from "./flatbuffers"; import * as msg from "gen/msg_generated"; import { assert, log, setLogDebug } from "./util"; import * as os from "./os"; -import { DenoCompiler } from "./compiler"; +import { Compiler } from "./compiler"; +import { Runner } from "./runner"; import { libdeno } from "./libdeno"; import { args } from "./deno"; import { sendSync, handleAsyncMsgFromRust } from "./dispatch"; @@ -17,7 +18,7 @@ import { version } from "typescript"; // Install the source maps handler and do some pre-calculations so all of it is // available in the snapshot -const compiler = DenoCompiler.instance(); +const compiler = Compiler.instance(); sourceMaps.install({ installPrepareStackTrace: true, getGeneratedContents: compiler.getGeneratedContents @@ -70,8 +71,7 @@ export default function denoMain() { // handle `--types` if (startResMsg.typesFlag()) { const defaultLibFileName = compiler.getDefaultLibFileName(); - const defaultLibModule = compiler.resolveModule(defaultLibFileName, ""); - console.log(defaultLibModule.sourceCode); + console.log(compiler.getSource(defaultLibFileName)); os.exit(0); } @@ -94,9 +94,10 @@ export default function denoMain() { const inputFn = args[0]; compiler.recompile = startResMsg.recompileFlag(); + const runner = new Runner(compiler); if (inputFn) { - compiler.run(inputFn, `${cwd}/`); + runner.run(inputFn, `${cwd}/`); } else { replLoop(); } diff --git a/js/runner.ts b/js/runner.ts new file mode 100644 index 000000000..11c47709d --- /dev/null +++ b/js/runner.ts @@ -0,0 +1,187 @@ +// Copyright 2018 the Deno authors. All rights reserved. MIT license. +// tslint:disable-next-line:no-circular-imports +import * as deno from "./deno"; +import { globalEval } from "./global_eval"; +import { assert, log } from "./util"; + +// tslint:disable:no-any +type AmdCallback = (...args: any[]) => void; +type AmdDefine = (deps: ModuleSpecifier[], factory: AmdFactory) => void; +type AmdErrback = (err: any) => void; +type AmdFactory = (...args: any[]) => object | void; +type AmdRequire = ( + deps: ModuleSpecifier[], + callback: AmdCallback, + errback: AmdErrback +) => void; +// tslint:enable:no-any + +// tslint:disable-next-line:no-any +type BuiltinMap = { [moduleSpecifier: string]: any }; + +// Type aliases to make the code more readable +type ContainingFile = string; +type Filename = string; +type ModuleSpecifier = string; +type OutputCode = string; + +/** Internal representation of a module being loaded */ +class Module { + deps?: Filename[]; + factory?: AmdFactory; + + // tslint:disable-next-line:no-any + constructor(public filename: Filename, public exports: any) {} +} + +/** External APIs which the runner depends upon to be able to retrieve + * transpiled modules. + */ +export interface CodeProvider { + /** Given a module specifier and a containing file, return the filename. */ + getFilename( + moduleSpecifier: ModuleSpecifier, + containingFile: ContainingFile + ): Filename; + + /** Given a filename, return the transpiled output code. */ + getOutput(filename: Filename): OutputCode; +} + +const window = globalEval("this"); + +/** A class which can load and run modules into the current environment. */ +export class Runner { + private _globalEval = globalEval; + /** A map of modules indexed by filename. */ + private _modules = new Map<Filename, Module>(); + private _provider: CodeProvider; + /** Modules are placed in here to have their factories run after all the + * the dependencies have been collected. + */ + private _runQueue: Module[] = []; + + private _drainRunQueue(): void { + log("runner._drainRunQueue", this._runQueue.length); + let module: Module | undefined; + while ((module = this._runQueue.shift())) { + assert(module.factory != null, "Cannot run module without factory."); + // TypeScript always imports `exports` and mutates it directly, but the + // AMD specification allows values to be returned from the factory and + // is the case with JSON modules and potentially other future features. + const exports = module.factory!(...this._getFactoryArguments(module)); + if (exports != null) { + module.exports = exports; + } + } + } + + private _gatherDependencies(filename: Filename): void { + log("runner._gatherDependencies", filename); + + if (this._modules.has(filename)) { + log("Module already exists:", filename); + return; + } + + const module = new Module(filename, {}); + this._modules.set(filename, module); + + window.define = this._makeDefine(module); + this._globalEval(this._provider.getOutput(filename)); + window.define = undefined; + } + + // tslint:disable-next-line:no-any + private _getFactoryArguments(module: Module): any[] { + log("runner._getFactoryArguments", module.filename); + assert(module.deps != null, "Missing dependencies for module."); + return module.deps!.map(dep => { + if (dep === "require") { + return this._makeLocalRequire(module); + } + if (dep === "exports") { + return module.exports; + } + if (dep in Runner._builtins) { + return Runner._builtins[dep]; + } + const depModule = this._modules.get(dep)!; + assert(dep != null, `Missing dependency "${dep}"`); + return depModule.exports; + }); + } + + private _makeDefine(module: Module): AmdDefine { + log("runner._makeDefine", module.filename); + return (deps: ModuleSpecifier[], factory: AmdFactory): void => { + module.factory = factory; + module.deps = deps.map(dep => { + if (dep === "require" || dep === "exports" || dep in Runner._builtins) { + return dep; + } + const depFilename = this._provider.getFilename(dep, module.filename); + if (!this._modules.get(depFilename)) { + this._gatherDependencies(depFilename); + } + return depFilename; + }); + if (!this._runQueue.includes(module)) { + this._runQueue.push(module); + } + }; + } + + private _makeLocalRequire(module: Module): AmdRequire { + log("runner._makeLocalRequire", module.filename); + return ( + deps: ModuleSpecifier[], + callback: AmdCallback, + errback: AmdErrback + ): void => { + log("runner._makeLocalRequire", deps); + assert( + deps.length === 1, + "Local require supports exactly one dependency." + ); + const [moduleSpecifier] = deps; + try { + this.run(moduleSpecifier, module.filename); + const requiredFilename = this._provider.getFilename( + moduleSpecifier, + module.filename + ); + const requiredModule = this._modules.get(requiredFilename)!; + assert(requiredModule != null); + callback(requiredModule.exports); + } catch (e) { + errback(e); + } + }; + } + + constructor(provider: CodeProvider) { + this._provider = provider; + } + + /** Given a module specifier and the containing file, resolve the module and + * ensure that it is in the runtime environment, returning the exports of the + * module. + */ + // tslint:disable-next-line:no-any + run(moduleSpecifier: ModuleSpecifier, containingFile: ContainingFile): any { + log("runner.run", moduleSpecifier, containingFile); + const filename = this._provider.getFilename( + moduleSpecifier, + containingFile + ); + if (!this._modules.has(filename)) { + this._gatherDependencies(filename); + this._drainRunQueue(); + } + return this._modules.get(filename)!.exports; + } + + /** Builtin modules which can be loaded by user modules. */ + private static _builtins: BuiltinMap = { deno }; +} diff --git a/js/runner_test.ts b/js/runner_test.ts new file mode 100644 index 000000000..adfb8bc58 --- /dev/null +++ b/js/runner_test.ts @@ -0,0 +1,141 @@ +import { test, assert, assertEqual } from "./test_util"; +import * as deno from "deno"; + +// tslint:disable-next-line:no-any +const Runner = (deno as any)._runner.Runner; + +let mockGetOutputStack: string[] = []; +let mockGetFilenameStack: Array<[string, string]> = []; + +// tslint:disable:max-line-length +const mockOutput = { + "/root/project/foo/bar.ts": `define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.foo = "bar"; +}); +//# sourceMappingURL=bar.js.map +//# sourceURL=/root/project/foo/bar.ts`, + "/root/project/foo/baz.ts": `define(["require", "exports", "./qat.ts"], function (require, exports, qat) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.foo = qat.foo; +}); +//# sourceMappingURL=baz.js.map +//# sourceURL=/root/project/foo/baz.ts`, + "/root/project/foo/qat.ts": `define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.foo = "qat"; +}); +//# sourceMappingURL=qat.js.map +//# sourceURL=/root/project/foo/qat.ts`, + "/root/project/foo/config.json": `define([], function () { + return JSON.parse('{"foo":{"bar": true,"baz": ["qat", 1]}}'); +}); +//# sourceURL=/root/project/foo/config.json`, + "/circular/modA.ts": `define(["require", "exports", "./modB.ts"], function (require, exports, modB) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.foo = modB.foo; +}); +//# sourceMappingURL=modA.js.map +//# sourceURL=/circular/modA.ts`, + "/circular/modB.ts": `define(["require", "exports", "./modA.ts"], function (require, exports, modA) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + if (modA && typeof modA === "object") { + modA; + } else { + throw new Error("Mod A is empty!"); + } + exports.foo = "bar"; +}); +//# sourceMappingURL=modB.js.map +//# sourceURL=/circular/modB.ts` +}; +// tslint:enable + +const mockFilenames = { + "/root/project": { + "foo/bar.ts": "/root/project/foo/bar.ts", + "foo/baz.ts": "/root/project/foo/baz.ts", + "foo/config.json": "/root/project/foo/config.json" + }, + "/root/project/foo/baz.ts": { + "./qat.ts": "/root/project/foo/qat.ts" + }, + "/circular": { + "modA.ts": "/circular/modA.ts" + }, + "/circular/modA.ts": { + "./modB.ts": "/circular/modB.ts" + }, + "/circular/modB.ts": { + "./modA.ts": "/circular/modA.ts" + } +}; + +const mockCodeProvider = { + getOutput(filename: string) { + mockGetOutputStack.push(filename); + if (filename in mockOutput) { + return mockOutput[filename]; + } + throw new Error("Module not found."); + }, + getFilename(moduleSpecifier: string, containingFile: string) { + mockGetFilenameStack.push([moduleSpecifier, containingFile]); + if ( + containingFile in mockFilenames && + moduleSpecifier in mockFilenames[containingFile] + ) { + return mockFilenames[containingFile][moduleSpecifier]; + } + } +}; + +function setup() { + mockGetOutputStack = []; + mockGetFilenameStack = []; + return new Runner(mockCodeProvider); +} + +test(function runnerConstruction() { + const runner = setup(); + assert(runner); +}); + +test(function runnerRun() { + const runner = setup(); + const result = runner.run("foo/bar.ts", "/root/project"); + assertEqual(result, { foo: "bar" }); + assertEqual(mockGetFilenameStack, [["foo/bar.ts", "/root/project"]]); + assertEqual(mockGetOutputStack, ["/root/project/foo/bar.ts"]); +}); + +test(function runnerRunImports() { + const runner = setup(); + const result = runner.run("foo/baz.ts", "/root/project"); + assertEqual(result, { foo: "qat" }); + assertEqual(mockGetFilenameStack, [ + ["foo/baz.ts", "/root/project"], + ["./qat.ts", "/root/project/foo/baz.ts"] + ]); + assertEqual(mockGetOutputStack, [ + "/root/project/foo/baz.ts", + "/root/project/foo/qat.ts" + ]); +}); + +test(function runnerRunExportReturn() { + const runner = setup(); + const result = runner.run("foo/config.json", "/root/project"); + assertEqual(result, { foo: { bar: true, baz: ["qat", 1] } }); +}); + +test(function runnerCircularReference() { + const runner = setup(); + const result = runner.run("modA.ts", "/circular"); + assertEqual(result, { foo: "bar" }); +}); diff --git a/js/unit_tests.ts b/js/unit_tests.ts index 2fcb5cd39..4863b7ac4 100644 --- a/js/unit_tests.ts +++ b/js/unit_tests.ts @@ -28,6 +28,7 @@ import "./read_file_test.ts"; import "./read_link_test.ts"; import "./rename_test.ts"; import "./resources_test.ts"; +import "./runner_test.ts"; import "./stat_test.ts"; import "./symlink_test.ts"; import "./text_encoding_test.ts"; |