From d8ada4d3fcc5dfe7f76103399a1d765fbab2ee45 Mon Sep 17 00:00:00 2001 From: Ryan Dahl Date: Mon, 26 Aug 2019 10:58:44 -0400 Subject: [PATCH] Port readSync/writeSync ops to minimal This removes dispatch_flatbuffers as it is now unused. There are still a few places where msg_generated is used: ErrorKind and MediaType. These will be dealt with later. --- cli/BUILD.gn | 1 - cli/msg.fbs | 61 ------- cli/ops/dispatch_flatbuffers.rs | 128 --------------- cli/ops/dispatch_minimal.rs | 8 +- cli/ops/files.rs | 90 ----------- cli/ops/mod.rs | 3 - js/compiler.ts | 5 +- js/dispatch.ts | 5 - js/dispatch_flatbuffers.ts | 151 ------------------ js/dispatch_minimal.ts | 16 ++ js/files.ts | 62 ++----- tests/error_004_missing_module.ts.out | 2 +- tests/error_005_missing_dynamic_import.ts.out | 2 +- tests/error_006_import_ext_failure.ts.out | 2 +- tests/error_011_bad_module_specifier.ts.out | 2 +- ...or_012_bad_dynamic_import_specifier.ts.out | 2 +- 16 files changed, 46 insertions(+), 494 deletions(-) delete mode 100644 cli/ops/dispatch_flatbuffers.rs delete mode 100644 js/dispatch_flatbuffers.ts diff --git a/cli/BUILD.gn b/cli/BUILD.gn index 08050ae06a..8b8790386f 100644 --- a/cli/BUILD.gn +++ b/cli/BUILD.gn @@ -82,7 +82,6 @@ ts_sources = [ "../js/diagnostics.ts", "../js/dir.ts", "../js/dispatch.ts", - "../js/dispatch_flatbuffers.ts", "../js/dispatch_json.ts", "../js/dispatch_minimal.ts", "../js/dom_file.ts", diff --git a/cli/msg.fbs b/cli/msg.fbs index b5fc524836..ad0a6274bf 100644 --- a/cli/msg.fbs +++ b/cli/msg.fbs @@ -1,11 +1,3 @@ -union Any { - Read, - ReadRes, - Seek, - Write, - WriteRes, -} - enum ErrorKind: byte { NoError = 0, @@ -73,62 +65,9 @@ enum ErrorKind: byte { JSError, } -table Cwd {} - -table CwdRes { - cwd: string; -} - enum MediaType: byte { JavaScript = 0, TypeScript, Json, Unknown } - -table Base { - cmd_id: uint32; - sync: bool = false; - error_kind: ErrorKind = NoError; - error: string; - inner: Any; -} - -table FormatError { - error: string; -} - -table FormatErrorRes { - error: string; -} - -table KeyValue { - key: string; - value: string; -} - -table Read { - rid: uint32; - // (ptr, len) is passed as second parameter to Deno.core.send(). -} - -table ReadRes { - nread: uint; - eof: bool; -} - -table Write { - rid: uint32; -} - -table WriteRes { - nbyte: uint; -} - -table Seek { - rid: uint32; - offset: int; - whence: uint; -} - -root_type Base; diff --git a/cli/ops/dispatch_flatbuffers.rs b/cli/ops/dispatch_flatbuffers.rs deleted file mode 100644 index edec777034..0000000000 --- a/cli/ops/dispatch_flatbuffers.rs +++ /dev/null @@ -1,128 +0,0 @@ -use super::utils::CliOpResult; -use crate::deno_error::GetErrorKind; -use crate::msg; -use crate::state::ThreadSafeState; -use deno::*; -use flatbuffers::FlatBufferBuilder; -use hyper::rt::Future; - -type CliDispatchFn = fn( - state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option, -) -> CliOpResult; - -use super::files::{op_read, op_write}; - -/// Processes raw messages from JavaScript. -/// This functions invoked every time Deno.core.dispatch() is called. -/// control corresponds to the first argument of Deno.core.dispatch(). -/// data corresponds to the second argument of Deno.core.dispatch(). -pub fn dispatch( - state: &ThreadSafeState, - control: &[u8], - zero_copy: Option, -) -> CoreOp { - let base = msg::get_root_as_base(&control); - let inner_type = base.inner_type(); - let is_sync = base.sync(); - let cmd_id = base.cmd_id(); - - debug!( - "msg_from_js {} sync {}", - msg::enum_name_any(inner_type), - is_sync - ); - - let op_func: CliDispatchFn = match op_selector_std(inner_type) { - Some(v) => v, - None => panic!("Unhandled message {}", msg::enum_name_any(inner_type)), - }; - - let op_result = op_func(state, &base, zero_copy); - - match op_result { - Ok(Op::Sync(buf)) => Op::Sync(buf), - Ok(Op::Async(fut)) => { - let result_fut = Box::new( - fut - .or_else(move |err: ErrBox| -> Result { - debug!("op err {}", err); - // No matter whether we got an Err or Ok, we want a serialized message to - // send back. So transform the DenoError into a Buf. - let builder = &mut FlatBufferBuilder::new(); - let errmsg_offset = builder.create_string(&format!("{}", err)); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - error: Some(errmsg_offset), - error_kind: err.kind(), - ..Default::default() - }, - )) - }) - .and_then(move |buf: Buf| -> Result { - // Handle empty responses. For sync responses we just want - // to send null. For async we want to send a small message - // with the cmd_id. - let buf = if buf.len() > 0 { - buf - } else { - let builder = &mut FlatBufferBuilder::new(); - serialize_response( - cmd_id, - builder, - msg::BaseArgs { - ..Default::default() - }, - ) - }; - Ok(buf) - }) - .map_err(|err| panic!("unexpected error {:?}", err)), - ); - Op::Async(result_fut) - } - Err(err) => { - debug!("op err {}", err); - // No matter whether we got an Err or Ok, we want a serialized message to - // send back. So transform the DenoError into a Buf. - let builder = &mut FlatBufferBuilder::new(); - let errmsg_offset = builder.create_string(&format!("{}", err)); - let response_buf = serialize_response( - cmd_id, - builder, - msg::BaseArgs { - error: Some(errmsg_offset), - error_kind: err.kind(), - ..Default::default() - }, - ); - Op::Sync(response_buf) - } - } -} - -pub fn serialize_response( - cmd_id: u32, - builder: &mut FlatBufferBuilder<'_>, - mut args: msg::BaseArgs<'_>, -) -> Buf { - args.cmd_id = cmd_id; - let base = msg::Base::create(builder, &args); - msg::finish_base_buffer(builder, base); - let data = builder.finished_data(); - // println!("serialize_response {:x?}", data); - data.into() -} - -/// Standard ops set for most isolates -pub fn op_selector_std(inner_type: msg::Any) -> Option { - match inner_type { - msg::Any::Read => Some(op_read), - msg::Any::Write => Some(op_write), - - _ => None, - } -} diff --git a/cli/ops/dispatch_minimal.rs b/cli/ops/dispatch_minimal.rs index 22d0a92f87..f52893951a 100644 --- a/cli/ops/dispatch_minimal.rs +++ b/cli/ops/dispatch_minimal.rs @@ -80,9 +80,6 @@ pub fn dispatch( ) -> CoreOp { let mut record = parse_min_record(control).unwrap(); let is_sync = record.promise_id == 0; - // TODO(ry) Currently there aren't any sync minimal ops. This is just a sanity - // check. Remove later. - assert!(!is_sync); let rid = record.arg; let min_op = d(rid, zero_copy); @@ -102,6 +99,11 @@ pub fn dispatch( })); if is_sync { + // Warning! Possible deadlocks can occur if we try to wait for a future + // while in a future. The safe but expensive alternative is to use + // tokio_util::block_on. + // This block is only exercised for readSync and writeSync, which I think + // works since they're simple polling futures. Op::Sync(fut.wait().unwrap()) } else { Op::Async(fut) diff --git a/cli/ops/files.rs b/cli/ops/files.rs index c02a69b9c6..4afe00fc00 100644 --- a/cli/ops/files.rs +++ b/cli/ops/files.rs @@ -1,15 +1,10 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; use super::dispatch_json::{Deserialize, JsonOp, Value}; -use super::utils::*; use crate::deno_error; use crate::fs as deno_fs; -use crate::msg; use crate::resources; use crate::state::ThreadSafeState; -use crate::tokio_write; use deno::*; -use flatbuffers::FlatBufferBuilder; use futures::Future; use std; use std::convert::From; @@ -118,91 +113,6 @@ pub fn op_close( } } -pub fn op_read( - _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option, -) -> CliOpResult { - let cmd_id = base.cmd_id(); - let inner = base.inner_as_read().unwrap(); - let rid = inner.rid(); - - match resources::lookup(rid) { - None => Err(deno_error::bad_resource()), - Some(resource) => { - let op = tokio::io::read(resource, data.unwrap()) - .map_err(ErrBox::from) - .and_then(move |(_resource, _buf, nread)| { - let builder = &mut FlatBufferBuilder::new(); - let inner = msg::ReadRes::create( - builder, - &msg::ReadResArgs { - nread: nread as u32, - eof: nread == 0, - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::ReadRes, - ..Default::default() - }, - )) - }); - if base.sync() { - let buf = op.wait()?; - Ok(Op::Sync(buf)) - } else { - Ok(Op::Async(Box::new(op))) - } - } - } -} - -pub fn op_write( - _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option, -) -> CliOpResult { - let cmd_id = base.cmd_id(); - let inner = base.inner_as_write().unwrap(); - let rid = inner.rid(); - - match resources::lookup(rid) { - None => Err(deno_error::bad_resource()), - Some(resource) => { - let op = tokio_write::write(resource, data.unwrap()) - .map_err(ErrBox::from) - .and_then(move |(_resource, _buf, nwritten)| { - let builder = &mut FlatBufferBuilder::new(); - let inner = msg::WriteRes::create( - builder, - &msg::WriteResArgs { - nbyte: nwritten as u32, - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::WriteRes, - ..Default::default() - }, - )) - }); - if base.sync() { - let buf = op.wait()?; - Ok(Op::Sync(buf)) - } else { - Ok(Op::Async(Box::new(op))) - } - } - } -} - #[derive(Deserialize)] #[serde(rename_all = "camelCase")] struct SeekArgs { diff --git a/cli/ops/mod.rs b/cli/ops/mod.rs index 1a853e992a..d254f34d2d 100644 --- a/cli/ops/mod.rs +++ b/cli/ops/mod.rs @@ -3,7 +3,6 @@ use crate::state::ThreadSafeState; use deno::*; mod compiler; -mod dispatch_flatbuffers; mod dispatch_json; mod dispatch_minimal; mod errors; @@ -26,7 +25,6 @@ mod workers; // Warning! These values are duplicated in the TypeScript code (js/dispatch.ts), // update with care. -pub const OP_FLATBUFFER: OpId = 100; pub const OP_READ: OpId = 1; pub const OP_WRITE: OpId = 2; pub const OP_EXIT: OpId = 3; @@ -296,7 +294,6 @@ pub fn dispatch( dispatch_json::dispatch(fs::op_make_temp_dir, state, control, zero_copy) } OP_CWD => dispatch_json::dispatch(fs::op_cwd, state, control, zero_copy), - OP_FLATBUFFER => dispatch_flatbuffers::dispatch(state, control, zero_copy), _ => panic!("bad op_id"), }; diff --git a/js/compiler.ts b/js/compiler.ts index 5399d59ad3..60fe49701e 100644 --- a/js/compiler.ts +++ b/js/compiler.ts @@ -1,6 +1,5 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. import * as ts from "typescript"; - import { assetSourceCode } from "./assets"; import { bold, cyan, yellow } from "./colors"; import { Console } from "./console"; @@ -9,7 +8,6 @@ import { Diagnostic, fromTypeScriptDiagnostic } from "./diagnostics"; import { cwd } from "./dir"; import * as dispatch from "./dispatch"; import { sendSync } from "./dispatch_json"; -import { msg } from "./dispatch_flatbuffers"; import * as os from "./os"; import { TextEncoder } from "./text_encoding"; import { getMappedModuleName, parseTypeDirectives } from "./type_directives"; @@ -19,6 +17,9 @@ import { window } from "./window"; import { postMessage, workerClose, workerMain } from "./workers"; import { writeFileSync } from "./write_file"; +// TODO(ry) msg_generated import will be removed soon. +import * as msg from "gen/cli/msg_generated"; + // Startup boilerplate. This is necessary because the compiler has its own // snapshot. (It would be great if we could remove these things or centralize // them somewhere else.) diff --git a/js/dispatch.ts b/js/dispatch.ts index 2416c19e29..dfa276cda8 100644 --- a/js/dispatch.ts +++ b/js/dispatch.ts @@ -1,10 +1,8 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. import * as minimal from "./dispatch_minimal"; -import * as flatbuffers from "./dispatch_flatbuffers"; import * as json from "./dispatch_json"; // These consts are shared with Rust. Update with care. -export const OP_FLATBUFFER = 100; export const OP_READ = 1; export const OP_WRITE = 2; export const OP_EXIT = 3; @@ -64,9 +62,6 @@ export const OP_CWD = 56; export function asyncMsgFromRust(opId: number, ui8: Uint8Array): void { switch (opId) { - case OP_FLATBUFFER: - flatbuffers.asyncMsgFromRust(opId, ui8); - break; case OP_WRITE: case OP_READ: minimal.asyncMsgFromRust(opId, ui8); diff --git a/js/dispatch_flatbuffers.ts b/js/dispatch_flatbuffers.ts deleted file mode 100644 index 0e375dbdf5..0000000000 --- a/js/dispatch_flatbuffers.ts +++ /dev/null @@ -1,151 +0,0 @@ -// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -import * as flatbuffers from "./flatbuffers"; -import { DenoError } from "./errors"; -import { core } from "./core"; -import * as msg from "gen/cli/msg_generated"; -import * as util from "./util"; -import { OP_FLATBUFFER } from "./dispatch"; -export { msg, flatbuffers }; - -const promiseTable = new Map>(); -let _nextPromiseId = 1; - -export function nextPromiseId(): number { - return _nextPromiseId++; -} - -interface FlatbufferRecord { - promiseId: number; - base: msg.Base; -} - -export function asyncMsgFromRust(opId: number, ui8: Uint8Array): void { - let { promiseId, base } = flatbufferRecordFromBuf(ui8); - const promise = promiseTable.get(promiseId); - util.assert(promise != null, `Expecting promise in table. ${promiseId}`); - promiseTable.delete(promiseId); - const err = maybeError(base); - if (err != null) { - promise!.reject(err); - } else { - promise!.resolve(base); - } -} - -function flatbufferRecordFromBuf(buf: Uint8Array): FlatbufferRecord { - const bb = new flatbuffers.ByteBuffer(buf); - const base = msg.Base.getRootAsBase(bb); - return { - promiseId: base.cmdId(), - base - }; -} - -function ui8FromArrayBufferView(abv: ArrayBufferView): Uint8Array { - return new Uint8Array(abv.buffer, abv.byteOffset, abv.byteLength); -} - -function sendInternal( - builder: flatbuffers.Builder, - innerType: msg.Any, - inner: flatbuffers.Offset, - zeroCopy: undefined | ArrayBufferView, - isSync: true -): Uint8Array; -function sendInternal( - builder: flatbuffers.Builder, - innerType: msg.Any, - inner: flatbuffers.Offset, - zeroCopy: undefined | ArrayBufferView, - isSync: false -): Promise; -function sendInternal( - builder: flatbuffers.Builder, - innerType: msg.Any, - inner: flatbuffers.Offset, - zeroCopy: undefined | ArrayBufferView, - isSync: boolean -): Promise | Uint8Array { - const cmdId = nextPromiseId(); - msg.Base.startBase(builder); - msg.Base.addInner(builder, inner); - msg.Base.addInnerType(builder, innerType); - msg.Base.addSync(builder, isSync); - msg.Base.addCmdId(builder, cmdId); - builder.finish(msg.Base.endBase(builder)); - - const control = builder.asUint8Array(); - - const response = core.dispatch( - OP_FLATBUFFER, // TODO(ry) Use actual opId later. - control, - zeroCopy ? ui8FromArrayBufferView(zeroCopy) : undefined - ); - - builder.inUse = false; - - if (response == null) { - util.assert(!isSync); - const promise = util.createResolvable(); - promiseTable.set(cmdId, promise); - return promise; - } else { - if (!isSync) { - // We can easily and correctly allow for sync responses to async calls - // by creating and returning a promise from the sync response. - const bb = new flatbuffers.ByteBuffer(response); - const base = msg.Base.getRootAsBase(bb); - const err = maybeError(base); - if (err != null) { - return Promise.reject(err); - } else { - return Promise.resolve(base); - } - } - return response; - } -} - -// @internal -export function sendAsync( - builder: flatbuffers.Builder, - innerType: msg.Any, - inner: flatbuffers.Offset, - data?: ArrayBufferView -): Promise { - return sendInternal(builder, innerType, inner, data, false); -} - -// @internal -export function sendSync( - builder: flatbuffers.Builder, - innerType: msg.Any, - inner: flatbuffers.Offset, - data?: ArrayBufferView -): null | msg.Base { - const response = sendInternal(builder, innerType, inner, data, true); - if (response!.length === 0) { - return null; - } else { - const bb = new flatbuffers.ByteBuffer(response!); - const baseRes = msg.Base.getRootAsBase(bb); - maybeThrowError(baseRes); - return baseRes; - } -} - -function maybeError(base: msg.Base): null | DenoError { - const kind = base.errorKind(); - if (kind === msg.ErrorKind.NoError) { - return null; - } else { - return new DenoError(kind, base.error()!); - } -} - -function maybeThrowError(base: msg.Base): void { - const err = maybeError(base); - if (err != null) { - throw err; - } -} diff --git a/js/dispatch_minimal.ts b/js/dispatch_minimal.ts index 9a310fd220..3df888e77e 100644 --- a/js/dispatch_minimal.ts +++ b/js/dispatch_minimal.ts @@ -4,6 +4,9 @@ import * as util from "./util"; import { core } from "./core"; const promiseTableMin = new Map>(); +// Note it's important that promiseId starts at 1 instead of 0, because sync +// messages are indicated with promiseId 0. If we ever add wrap around logic for +// overflows, this should be taken into account. let _nextPromiseId = 1; function nextPromiseId(): number { @@ -63,3 +66,16 @@ export function sendAsyncMinimal( core.dispatch(opId, scratchBytes, zeroCopy); return promise; } + +export function sendSyncMinimal( + opId: number, + arg: number, + zeroCopy: Uint8Array +): number { + scratch32[0] = 0; // promiseId 0 indicates sync + scratch32[1] = arg; + const res = core.dispatch(opId, scratchBytes, zeroCopy)!; + const res32 = new Int32Array(res.buffer, res.byteOffset, 3); + const resRecord = recordFromBufMinimal(opId, res32); + return resRecord.result; +} diff --git a/js/files.ts b/js/files.ts index 4eff17aac2..0335056b33 100644 --- a/js/files.ts +++ b/js/files.ts @@ -10,15 +10,12 @@ import { SyncWriter, SyncSeeker } from "./io"; -import { sendAsyncMinimal } from "./dispatch_minimal"; -import { assert } from "./util"; +import { sendAsyncMinimal, sendSyncMinimal } from "./dispatch_minimal"; import * as dispatch from "./dispatch"; import { sendSync as sendSyncJson, sendAsync as sendAsyncJson } from "./dispatch_json"; -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; -import { OP_READ, OP_WRITE } from "./dispatch"; /** Open a file and return an instance of the `File` object * synchronously. @@ -44,26 +41,6 @@ export async function open( return new File(rid); } -function reqRead( - rid: number, - p: Uint8Array -): [flatbuffers.Builder, msg.Any, flatbuffers.Offset, Uint8Array] { - const builder = flatbuffers.createBuilder(); - const inner = msg.Read.createRead(builder, rid); - return [builder, msg.Any.Read, inner, p]; -} - -function resRead(baseRes: null | msg.Base): number | EOF { - assert(baseRes != null); - assert(msg.Any.ReadRes === baseRes!.innerType()); - const res = new msg.ReadRes(); - assert(baseRes!.inner(res) != null); - if (res.eof()) { - return EOF; - } - return res.nread(); -} - /** Read synchronously from a file ID into an array buffer. * * Return `number | EOF` for the operation. @@ -75,7 +52,14 @@ function resRead(baseRes: null | msg.Base): number | EOF { * */ export function readSync(rid: number, p: Uint8Array): number | EOF { - return resRead(sendSync(...reqRead(rid, p))); + const nread = sendSyncMinimal(dispatch.OP_READ, rid, p); + if (nread < 0) { + throw new Error("read error"); + } else if (nread == 0) { + return EOF; + } else { + return nread; + } } /** Read from a file ID into an array buffer. @@ -90,7 +74,7 @@ export function readSync(rid: number, p: Uint8Array): number | EOF { * })(); */ export async function read(rid: number, p: Uint8Array): Promise { - const nread = await sendAsyncMinimal(OP_READ, rid, p); + const nread = await sendAsyncMinimal(dispatch.OP_READ, rid, p); if (nread < 0) { throw new Error("read error"); } else if (nread == 0) { @@ -100,23 +84,6 @@ export async function read(rid: number, p: Uint8Array): Promise { } } -function reqWrite( - rid: number, - p: Uint8Array -): [flatbuffers.Builder, msg.Any, flatbuffers.Offset, Uint8Array] { - const builder = flatbuffers.createBuilder(); - const inner = msg.Write.createWrite(builder, rid); - return [builder, msg.Any.Write, inner, p]; -} - -function resWrite(baseRes: null | msg.Base): number { - assert(baseRes != null); - assert(msg.Any.WriteRes === baseRes!.innerType()); - const res = new msg.WriteRes(); - assert(baseRes!.inner(res) != null); - return res.nbyte(); -} - /** Write synchronously to the file ID the contents of the array buffer. * * Resolves with the number of bytes written. @@ -127,7 +94,12 @@ function resWrite(baseRes: null | msg.Base): number { * Deno.writeSync(file.rid, data); */ export function writeSync(rid: number, p: Uint8Array): number { - return resWrite(sendSync(...reqWrite(rid, p))); + const result = sendSyncMinimal(dispatch.OP_WRITE, rid, p); + if (result < 0) { + throw new Error("write error"); + } else { + return result; + } } /** Write to the file ID the contents of the array buffer. @@ -143,7 +115,7 @@ export function writeSync(rid: number, p: Uint8Array): number { * */ export async function write(rid: number, p: Uint8Array): Promise { - let result = await sendAsyncMinimal(OP_WRITE, rid, p); + let result = await sendAsyncMinimal(dispatch.OP_WRITE, rid, p); if (result < 0) { throw new Error("write error"); } else { diff --git a/tests/error_004_missing_module.ts.out b/tests/error_004_missing_module.ts.out index e8d6727396..261d0a97bc 100644 --- a/tests/error_004_missing_module.ts.out +++ b/tests/error_004_missing_module.ts.out @@ -2,7 +2,7 @@ [WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) at toDenoError (js/dispatch_json.ts:[WILDCARD]) - at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) + at sendSync[WILDCARD] (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD] diff --git a/tests/error_005_missing_dynamic_import.ts.out b/tests/error_005_missing_dynamic_import.ts.out index 2f39dc853d..6574705313 100644 --- a/tests/error_005_missing_dynamic_import.ts.out +++ b/tests/error_005_missing_dynamic_import.ts.out @@ -2,7 +2,7 @@ [WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) at toDenoError (js/dispatch_json.ts:[WILDCARD]) - at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) + at sendSync[WILDCARD] (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD] diff --git a/tests/error_006_import_ext_failure.ts.out b/tests/error_006_import_ext_failure.ts.out index b381fa96d2..6ccee7e13b 100644 --- a/tests/error_006_import_ext_failure.ts.out +++ b/tests/error_006_import_ext_failure.ts.out @@ -2,7 +2,7 @@ [WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) at toDenoError (js/dispatch_json.ts:[WILDCARD]) - at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) + at sendSync[WILDCARD] (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD] diff --git a/tests/error_011_bad_module_specifier.ts.out b/tests/error_011_bad_module_specifier.ts.out index 1d8e8c97e4..3b7baa2414 100644 --- a/tests/error_011_bad_module_specifier.ts.out +++ b/tests/error_011_bad_module_specifier.ts.out @@ -2,7 +2,7 @@ [WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) at toDenoError (js/dispatch_json.ts:[WILDCARD]) - at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) + at sendSync[WILDCARD] (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD] diff --git a/tests/error_012_bad_dynamic_import_specifier.ts.out b/tests/error_012_bad_dynamic_import_specifier.ts.out index 1d8e8c97e4..3b7baa2414 100644 --- a/tests/error_012_bad_dynamic_import_specifier.ts.out +++ b/tests/error_012_bad_dynamic_import_specifier.ts.out @@ -2,7 +2,7 @@ [WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) at toDenoError (js/dispatch_json.ts:[WILDCARD]) - at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) + at sendSync[WILDCARD] (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD]