[WIP] wasm support #2113
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -11,6 +11,7 @@ import { normalize, resolve, extname, dirname, relative, basename } from './util | |
| import { RawSourceMap } from 'source-map'; | ||
| import Graph from './Graph'; | ||
| import ExternalModule from './ExternalModule'; | ||
| import WasmModule from './WasmModule'; | ||
| import { isExportDefaultVariable } from './ast/variables/ExportDefaultVariable'; | ||
| import Variable from './ast/variables/Variable'; | ||
| import NamespaceVariable from './ast/variables/NamespaceVariable'; | ||
|
|
@@ -478,6 +479,8 @@ export default class Chunk { | |
| } else if (resolution instanceof ExternalModule) { | ||
| node.renderFinalResolution(code, `"${resolution.id}"`); | ||
| // AST Node -> source replacement | ||
| } else if (resolution instanceof WasmModule) { | ||
| node.renderFinalResolution(code, `"${resolution.id}"`); | ||
|
There was a problem hiding this comment. Currently the generated code is Promise.resolve(require("/foobar/sventest/addTwo/src/addTwo.wasm")).then(({addTwo}) => {
console.log("addTwo(1, 2)", addTwo(1, 2));
});
function then(resolve) {
// ...
}
var addTwo = /*#__PURE__*/Object.freeze({
then: then
});I believe I need to change the resolution to return the There was a problem hiding this comment. The inlining decision for dynamic imports is made here - https://github.com/rollup/rollup/pull/2113/files#diff-8c6f11349cc1bb370bdd557ed2bcbe7dR443. Can that be extended to a WASM check? |
||
| } else { | ||
| node.renderFinalResolution(code, resolution); | ||
| } | ||
|
|
||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,193 @@ | ||
| import { decode } from '@webassemblyjs/wasm-parser'; | ||
| import ast from '@webassemblyjs/ast'; | ||
|
|
||
| import Graph from './Graph'; | ||
| import { IdMap, ModuleJSON, WebAssemblyJSAst } from './rollup/types'; | ||
|
|
||
| import { makeLegal } from './utils/identifierHelpers'; | ||
| import { RenderOptions } from './utils/renderHelpers'; | ||
| import { basename, extname } from './utils/path'; | ||
|
|
||
| import ExternalModule from './ExternalModule'; | ||
| import Module from './Module'; | ||
|
|
||
| import ModuleScope from './ast/scopes/ModuleScope'; | ||
| import Variable from './ast/variables/Variable'; | ||
| import NamespaceVariable from './ast/variables/NamespaceVariable'; | ||
|
|
||
| const decoderOpts = { | ||
| ignoreCodeSection: true, | ||
| ignoreDataSection: true | ||
| }; | ||
|
|
||
| const buildLoader = ({ URL, IMPORT_OBJECT }) => ` | ||
| function then(resolve) { | ||
| if (typeof WebAssembly.instantiateStreaming !== 'function') { | ||
| throw new Error('WebAssembly.instantiateStreaming is not supported'); | ||
| } | ||
|
|
||
| if (typeof window.fetch !== 'function') { | ||
| throw new Error('window.fetch is not supported'); | ||
| } | ||
|
|
||
| const req = window.fetch('${URL}'); | ||
|
|
||
| WebAssembly | ||
| .instantiateStreaming(req, ${IMPORT_OBJECT || '{}'}) | ||
| .then(res => res.instance.exports) | ||
| .then(resolve) | ||
| .catch(resolve); | ||
| } | ||
| `; | ||
|
There was a problem hiding this comment. Can this be treated as the "dynamic import mechanism" as is used in the JS Chunk.ts file that does the import to the associated wasmChunk.ts file? There was a problem hiding this comment. (and let me know if that would handle the issue you raised now?) There was a problem hiding this comment. I guess it would need to be a The point being that we are handling this in the There was a problem hiding this comment. Sorry but i'm really not sure to understand that.
Yes, that's the code behind
You mean the binding conflict issue? |
||
|
|
||
| export interface ExportDescription { | ||
| localName: string; | ||
| identifier?: string; | ||
| } | ||
|
|
||
| export interface ImportDescription { | ||
| source: string; | ||
| name: string; | ||
| module: Module | ExternalModule | null; | ||
| } | ||
|
|
||
| export default class WasmModule { | ||
| id: string; | ||
| graph: Graph; | ||
| code: Buffer; | ||
|
|
||
| scope: ModuleScope; | ||
|
|
||
| ast: WebAssemblyJSAst.Program; | ||
|
There was a problem hiding this comment. We could provide the same AST manipulation logic to plugins as with JS. There was a problem hiding this comment. Forgot to mention that we can enable AST diffing + wasm module manipulation using this API. Which could be useful for plugin (mutable global import polyfilling for ex 💯 ). |
||
|
|
||
| sources: string[]; | ||
| resolvedIds: IdMap; | ||
|
|
||
| dynamicImportResolutions: { | ||
| alias: string; | ||
| resolution: Module | ExternalModule | string | void; | ||
| }[]; | ||
| dependencies: (Module | ExternalModule | WasmModule)[]; | ||
|
|
||
| imports: { [name: string]: ImportDescription }; | ||
| exports: { [name: string]: ExportDescription }; | ||
|
|
||
| // this is unused on Module, | ||
| // only used for namespace and then ExternalExport.declarations | ||
| declarations: { | ||
| '*'?: NamespaceVariable; | ||
| [name: string]: Variable | undefined; | ||
| }; | ||
|
|
||
| isExternal: false; | ||
|
|
||
| constructor(graph: Graph, id: string) { | ||
| this.id = id; | ||
| this.graph = graph; | ||
| this.code = new Buffer(''); | ||
|
|
||
| this.ast = null; | ||
|
|
||
| // imports and exports, indexed by local name | ||
| this.imports = Object.create(null); | ||
| this.exports = Object.create(null); | ||
| this.resolvedIds = Object.create(null); | ||
| this.declarations = Object.create(null); | ||
|
|
||
| // all dependencies | ||
| this.dynamicImportResolutions = []; | ||
| this.sources = []; | ||
| this.dependencies = []; | ||
|
|
||
| this.scope = new ModuleScope(this); | ||
|
There was a problem hiding this comment. I would like to remove the scope but a lot of code depends on it. There was a problem hiding this comment. As far as I can see the only outside usages of |
||
|
|
||
| // expose Thenable | ||
| this.exports.then = { | ||
| localName: 'then' | ||
| }; | ||
| } | ||
|
|
||
| render(options: RenderOptions) { | ||
| const URL = 'foo'; | ||
| const content = buildLoader({ URL }); | ||
|
|
||
| return { trim() {}, content }; | ||
|
There was a problem hiding this comment. I'm not sure how to constructor the MagicString object in that case. There was a problem hiding this comment. WasmModule.render must return a Buffer surely? I think we should handle the distinction in the caller sites. There was a problem hiding this comment. Following my comment #2113 (comment), since i'm writing the file myself I bypass this logic actually, but I use it to inject the loader needed on the JS module. Does it make sense to you? |
||
| } | ||
|
There was a problem hiding this comment. If we have WasmChunk calling render, then it will be ok for the render method to return a binary (plus binary source map in due course). |
||
|
|
||
| getDynamicImportExpressions(): (string | Node)[] { | ||
| // FIXME(sven): consider ModuleImport as dynamicImports? | ||
| return []; | ||
| } | ||
|
There was a problem hiding this comment. It won't be possible for WASM to dynamically import another module, so these things all can then be removed. There was a problem hiding this comment. I agree, it was more an implementation detail about how to declare the imports. The static imports are better. |
||
|
|
||
| markExports() {} | ||
|
|
||
| // TODO(sven): what is this? | ||
| namespace(): NamespaceVariable { | ||
| if (!this.declarations['*']) { | ||
| this.declarations['*'] = new NamespaceVariable(this); | ||
| } | ||
|
|
||
| return this.declarations['*']; | ||
| } | ||
|
|
||
| basename() { | ||
| const base = basename(this.id); | ||
| const ext = extname(this.id); | ||
|
|
||
| return makeLegal(ext ? base.slice(0, -ext.length) : base); | ||
| } | ||
|
|
||
| getExports() { | ||
| return Object.keys(this.exports); | ||
| } | ||
|
|
||
| getReexports() { | ||
| return []; | ||
| } | ||
|
|
||
| includeInBundle() { | ||
| return false; | ||
| } | ||
|
|
||
| linkDependencies() { | ||
| const { imports, exports } = this; | ||
|
|
||
| ast.traverse(this.ast, { | ||
| // ModuleImport({node}: any) { | ||
| // const source = node.module | ||
| // const name = node.name; | ||
| // imports[`${source}.${name}`] = { source, name, module: null }; | ||
| // }, | ||
| // ModuleExport({node}: any) { | ||
| // const name = node.name; | ||
| // exports[name] = { | ||
| // localName: name | ||
| // }; | ||
| // } | ||
| }); | ||
| } | ||
|
|
||
| bindReferences() {} | ||
|
|
||
| toJSON(): ModuleJSON { | ||
| return { | ||
| id: this.id, | ||
| dependencies: this.dependencies.map(module => module.id), | ||
| code: this.code, | ||
| originalCode: '', | ||
| originalSourcemap: undefined, | ||
| ast: this.ast, | ||
| sourcemapChain: null, | ||
| resolvedIds: this.resolvedIds | ||
| }; | ||
| } | ||
|
|
||
| traceExport(name: string): Variable { | ||
| return new Variable(name); | ||
| } | ||
|
|
||
| setSource(bin: Buffer) { | ||
| this.code = bin; | ||
| this.ast = decode(bin, decoderOpts); | ||
| } | ||
| } | ||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I've been thinking perhaps we need to create WasmChunk.ts as well as Chunk is effectively designed to mimic the output graph, so having the two source types would be the best model to match.... this will likely have some complexities on the types like with Module, but I tend to think those are the problems we should be solving here.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Then as well, just like with Module, an abstract Chunk class would likely make sense to share between both implementations, ideally providing the same sort of interface for src/rollup.index.ts as far as possible, although for the actual render, the output value would be a different interface representing the binary which could be split handled at that point.