test(async function filesToAsyncIterator() {    assertEqual(totalSize, 12); });++testPerm({ write: true }, async function createFile() {+  const tempDir = await deno.makeTempDir();+  const filename = tempDir + "/test.txt";+  let f = await deno.open(filename, deno.OpenMode.Write);+  let fileInfo = deno.statSync(filename);+  assert(fileInfo.isFile());+  assert(fileInfo.len === 0);+  const enc = new TextEncoder();+  const data = enc.encode("Hello");+  await f.write(data);+  fileInfo = deno.statSync(filename);+  assert(fileInfo.len === 5);+  f.close();++  // TODO: test different modes+  await deno.removeAll(tempDir);+});++testPerm({ write: true }, async function openModeWrite() {+  const tempDir = deno.makeTempDirSync();+  const encoder = new TextEncoder();+  const filename = tempDir + "hello.txt";+  const data = encoder.encode("Hello world!\n");++  let file = await deno.open(filename, deno.OpenMode.Write);+  // assert file was created+  let fileInfo = deno.statSync(filename);+  assert(fileInfo.isFile());+  assertEqual(fileInfo.len, 0);+  // write some data+  await file.write(data);+  fileInfo = deno.statSync(filename);+  assertEqual(fileInfo.len, 13);+  // assert we can't read from file+  let thrown = false;+  try {+    const buf = new Uint8Array(20);+    await file.read(buf);+  } catch (e) {+    thrown = true;+  } finally {+    assert(thrown, "OpenMode.Write shouldn't allow to read file");+  }+  file.close();+  // assert that existing file is truncated on open+  file = await deno.open(filename, deno.OpenMode.Write);+  file.close();+  const fileSize = deno.statSync(filename).len;+  assertEqual(fileSize, 0);+  await deno.removeAll(tempDir);+});

 test(async function filesToAsyncIterator() {    assertEqual(totalSize, 12); });++testPerm({ write: true }, async function createFile() {+  const tempDir = await deno.makeTempDir();+  const filename = tempDir + "/test.txt";+  let f = await deno.open(filename, deno.OpenMode.Write);

 export const stdout = new File(1); /** An instance of `File` for stderr. */ export const stderr = new File(2); -// TODO This is just a placeholder - not final API.-export type OpenMode = "r" | "w" | "w+" | "x";+export enum OpenMode {+  /** Read-only, default mode.+   * Starts at beginning of file.+   */+  Read = "r",+  /** Read-write+   * Start at beginning of file.+   */+  ReadWrite = "r+",+  /** Write-only+   * Opens and truncates existing file or creates new one+   * for writing only.+   */+  Write = "w",+  /** Write-read+   * Opens and truncates existing file or creates new one+   * for writing and reading.+   */+  WriteRead = "w+",+  /** Append-only+   * Opens existing file or creates new one.+   * Each write appends content to file and doesn't overwrite+   * already existing content.+   */+  Append = "a",+  /** Append-read+   * Behaves like `OpenMode.Append` and allows to read from file.+   */+  AppendRead = "a+",+  /** Exclusive create+   * Creates new file only if one doesn't exist already.+   * Allows to write to file.+   */+  ExclusiveCreate = "x",+  /** Exclusive create - read+   * Behaves like `OpenMode.ExclusiveCreate` and allows to read from file.+   */+  ExclusiveCreateRead = "x+"+}

 export const stdout = new File(1); /** An instance of `File` for stderr. */ export const stderr = new File(2); -// TODO This is just a placeholder - not final API.-export type OpenMode = "r" | "w" | "w+" | "x";+export enum OpenMode {+  /** Read-only, default mode.+   * Starts at beginning of file.+   */+  Read = "r",+  /** Read-write+   * Start at beginning of file.+   */+  ReadWrite = "r+",+  /** Write-only+   * Opens and truncates existing file or creates new one+   * for writing only.+   */+  Write = "w",+  /** Write-read+   * Opens and truncates existing file or creates new one+   * for writing and reading.+   */+  WriteRead = "w+",

 test(async function filesToAsyncIterator() {    assertEqual(totalSize, 12); });++testPerm({ write: true }, async function createFile() {+  const tempDir = await deno.makeTempDir();+  const filename = tempDir + "/test.txt";+  let f = await deno.open(filename, deno.OpenMode.Write);+  let fileInfo = deno.statSync(filename);+  assert(fileInfo.isFile());+  assert(fileInfo.len === 0);+  const enc = new TextEncoder();+  const data = enc.encode("Hello");+  await f.write(data);+  fileInfo = deno.statSync(filename);+  assert(fileInfo.len === 5);+  f.close();++  // TODO: test different modes+  await deno.removeAll(tempDir);+});++testPerm({ write: true }, async function openModeWrite() {+  const tempDir = deno.makeTempDirSync();+  const encoder = new TextEncoder();+  const filename = tempDir + "hello.txt";+  const data = encoder.encode("Hello world!\n");++  let file = await deno.open(filename, deno.OpenMode.Write);+  // assert file was created+  let fileInfo = deno.statSync(filename);+  assert(fileInfo.isFile());+  assertEqual(fileInfo.len, 0);+  // write some data+  await file.write(data);+  fileInfo = deno.statSync(filename);+  assertEqual(fileInfo.len, 13);+  // assert we can't read from file+  let thrown = false;+  try {+    const buf = new Uint8Array(20);+    await file.read(buf);+  } catch (e) {+    thrown = true;+  } finally {+    assert(thrown, "OpenMode.Write shouldn't allow to read file");+  }+  file.close();+  // assert that existing file is truncated on open+  file = await deno.open(filename, deno.OpenMode.Write);+  file.close();+  const fileSize = deno.statSync(filename).len;+  assertEqual(fileSize, 0);+  await deno.removeAll(tempDir);+});++testPerm({ write: true }, async function openModeWriteRead() {+  const tempDir = deno.makeTempDirSync();+  const encoder = new TextEncoder();+  const filename = tempDir + "hello.txt";+  const data = encoder.encode("Hello world!\n");++  let file = await deno.open(filename, deno.OpenMode.WriteRead);+  // assert file was created+  let fileInfo = deno.statSync(filename);+  assert(fileInfo.isFile());+  assertEqual(fileInfo.len, 0);+  // write some data+  await file.write(data);+  fileInfo = deno.statSync(filename);+  assertEqual(fileInfo.len, 13);++  // TODO: this test is not working, I expect because+  //  file handle points to the end of file, but ATM+  //  deno has no seek implementation on Rust side+  // assert file can be read+  // const buf = new Uint8Array(20);+  // const result = await file.read(buf);+  // console.log(result.eof, result.nread);+  // assertEqual(result.nread, 13);+  // file.close();+

 impl DenoDir {       (source, map_content_type(&p, Some(&content_type)))     } else {       let source = fs::read_to_string(&p)?;-      let content_type = fs::read_to_string(&mt)?;-      (source, map_content_type(&p, Some(&content_type)))+      // .mime file might not exists with bundled deps+      let maybe_content_type_string = fs::read_to_string(&mt).ok();+      // Option<String> -> Option<&str>+      let maybe_content_type_str =+        maybe_content_type_string.as_ref().map(String::as_str);+      (source, map_content_type(&p, maybe_content_type_str))

 export const stdout = new File(1); /** An instance of `File` for stderr. */ export const stderr = new File(2); -// TODO This is just a placeholder - not final API.-export type OpenMode = "r" | "w" | "w+" | "x";+export enum OpenMode {+  /** Read-only, default mode.+   * Starts at beginning of file.+   */+  Read = "r",+  /** Read-write+   * Start at beginning of file.+   */+  ReadWrite = "r+",+  /** Write-only+   * Opens and truncates existing file or creates new one+   * for writing only.+   */+  Write = "w",+  /** Write-read+   * Opens and truncates existing file or creates new one+   * for writing and reading.+   */+  WriteRead = "w+",+  /** Append-only+   * Opens existing file or creates new one.+   * Each write appends content to file and doesn't overwrite+   * already existing content.+   */+  Append = "a",+  /** Append-read+   * Behaves like `OpenMode.Append` and allows to read from file.+   */+  AppendRead = "a+",+  /** Exclusive create+   * Creates new file only if one doesn't exist already.+   * Allows to write to file.+   */+  ExclusiveCreate = "x",+  /** Exclusive create - read+   * Behaves like `OpenMode.ExclusiveCreate` and allows to read from file.+   */+  ExclusiveCreateRead = "x+"+}  /** A factory function for creating instances of `File` associated with the  * supplied file name.  */ export function create(filename: string): Promise<File> {

 NotFound: Cannot resolve module "./non-existent" from "[WILDCARD]/tests/error_006_import_ext_failure.ts"+    at DenoError ([WILDCARD]/js/errors.ts:[WILDCARD])     at maybeError ([WILDCARD]/js/errors.ts:[WILDCARD])     at maybeThrowError ([WILDCARD]/js/errors.ts:[WILDCARD])     at sendSync ([WILDCARD]/js/dispatch.ts:[WILDCARD])-    at Object.codeFetch ([WILDCARD]/js/os.ts:[WILDCARD])-    at Compiler._resolveModule ([WILDCARD]/js/compiler.ts:[WILDCARD])+    at codeFetch ([WILDCARD]/js/os.ts:[WILDCARD])+    at _resolveModule ([WILDCARD]/js/compiler.ts:[WILDCARD])     at moduleNames.map.name ([WILDCARD]/js/compiler.ts:[WILDCARD])-    at Array.map (<anonymous>)

 NotFound: Cannot resolve module "./non-existent" from "[WILDCARD]/tests/error_006_import_ext_failure.ts"+    at DenoError ([WILDCARD]/js/errors.ts:[WILDCARD])     at maybeError ([WILDCARD]/js/errors.ts:[WILDCARD])     at maybeThrowError ([WILDCARD]/js/errors.ts:[WILDCARD])     at sendSync ([WILDCARD]/js/dispatch.ts:[WILDCARD])-    at Object.codeFetch ([WILDCARD]/js/os.ts:[WILDCARD])-    at Compiler._resolveModule ([WILDCARD]/js/compiler.ts:[WILDCARD])+    at codeFetch ([WILDCARD]/js/os.ts:[WILDCARD])+    at _resolveModule ([WILDCARD]/js/compiler.ts:[WILDCARD])     at moduleNames.map.name ([WILDCARD]/js/compiler.ts:[WILDCARD])-    at Array.map (<anonymous>)

 impl DenoDir {       (source, map_content_type(&p, Some(&content_type)))     } else {       let source = fs::read_to_string(&p)?;-      let content_type = fs::read_to_string(&mt)?;-      (source, map_content_type(&p, Some(&content_type)))+      // .mime file might not exists with bundled deps+      let maybe_content_type_string = fs::read_to_string(&mt).ok();+      // Option<String> -> Option<&str>+      let maybe_content_type_str =+        maybe_content_type_string.as_ref().map(String::as_str);+      (source, map_content_type(&p, maybe_content_type_str))

 static inline v8::Local<v8::String> v8_str(const char* x) {       .ToLocalChecked(); } -void HandleExceptionStr(v8::Local<v8::Context> context,-                        v8::Local<v8::Value> exception,-                        std::string* exception_str) {+std::string EncodeExceptionAsJSON(v8::Local<v8::Context> context,+                                  v8::Local<v8::Value> exception) {   auto* isolate = context->GetIsolate();-  DenoIsolate* d = FromIsolate(isolate);-   v8::HandleScope handle_scope(isolate);   v8::Context::Scope context_scope(context);    auto message = v8::Exception::CreateMessage(isolate, exception);   auto stack_trace = message->GetStackTrace();-  auto line =-      v8::Integer::New(isolate, message->GetLineNumber(context).FromJust());-  auto column =-      v8::Integer::New(isolate, message->GetStartColumn(context).FromJust());--  auto global_error_handler_ = d->global_error_handler_.Get(isolate);--  if (!global_error_handler_.IsEmpty()) {-    // global_error_handler_ is set so we try to handle the exception in-    // javascript.-    v8::Local<v8::Value> args[5];-    args[0] = exception->ToString(context).ToLocalChecked();-    args[1] = message->GetScriptResourceName();-    args[2] = line;-    args[3] = column;-    args[4] = exception;-    global_error_handler_->Call(context->Global(), 5, args);-    /* message, source, lineno, colno, error */ -    return;-  }+  // Encode the exception into a JS object, which we will then turn into JSON.+  auto json_obj = v8::Object::New(isolate);++  auto exception_str = exception->ToString(context).ToLocalChecked();+  // Alternate and very similar string. Not sure which is appropriate.

 class DenoIsolate {       isolate_->Dispose();     }     delete array_buffer_allocator_;+    array_buffer_allocator_ = nullptr;+    isolate_ = nullptr;+    shared_ = empty_buf;+    current_args_ = nullptr;+    snapshot_creator_ = nullptr;+    global_import_buf_ptr_ = nullptr;+    pending_promise_events_ = 0;+    recv_cb_ = nullptr;+    next_req_id_ = 0;+    user_data_ = nullptr;

 import { TextProtoReader } from "./textproto.ts"; import { STATUS_TEXT } from "./http_status"; import { assert } from "./util"; +interface Deferred {+  promise: Promise<{}>;+  resolve: () => void;+  reject: () => void;+}++function deferred(): Deferred {+  let resolve, reject;+  const promise = new Promise((res, rej) => {+    resolve = res;+    reject = rej;+  });+  return {+    promise, resolve, reject,+  };+}++interface ServeEnv {+  reqQueue: ServerRequest[];+  serveDeferred: Deferred;+}++// Continuously read more requests from conn until EOF+// Mutually calling with maybeHandleReq+// TODO: make them async function after this change is done+// https://github.com/tc39/ecma262/pull/1250+// See https://v8.dev/blog/fast-async+export function serveConn(env: ServeEnv, conn: Conn) {+  readRequest(conn).then(maybeHandleReq.bind(null, env, conn));+}+function maybeHandleReq(env: ServeEnv, conn: Conn, maybeReq: any) {

 import { TextProtoReader } from "./textproto.ts"; import { STATUS_TEXT } from "./http_status"; import { assert } from "./util"; +interface Deferred {+  promise: Promise<{}>;+  resolve: () => void;+  reject: () => void;+}++function deferred(): Deferred {+  let resolve, reject;+  const promise = new Promise((res, rej) => {+    resolve = res;+    reject = rej;+  });+  return {+    promise, resolve, reject,+  };+}+ export async function* serve(addr: string) {   const listener = listen("tcp", addr);-  while (true) {-    const c = await listener.accept();-    yield* serveConn(c);+  let serveDeferred = deferred();+  let reqQueue: ServerRequest[] = []; // in case multiple promises are ready++  // Continuously read more requests from conn until EOF+  // Mutually calling with handleReq+  const readRequestsFromConn = async (conn: Conn) => {+    const [req, _err] = await readRequest(conn);+    if (_err) {+      conn.close(); // assume EOF, for now+      return;+    }+    handleReq(conn, req);+  }+  const handleReq = (conn: Conn, req: ServerRequest) => {+    reqQueue.push(req); // push req to queue+    readRequestsFromConn(conn); // try read more (reusing connection)+    serveDeferred.resolve(); // signal while loop to process it   }-  listener.close();-} -export async function* serveConn(c: Conn) {-  let bufr = new BufReader(c);-  let bufw = new BufWriter(c);-  try {-    while (true) {-      const [req, err] = await readRequest(bufr);-      if (err == "EOF") {-        break;-      }-      if (err == "ShortWrite") {-        console.log("ShortWrite error");-        break;-      }-      if (err) {-        throw err;-      }-      req.w = bufw;-      yield req;+  // Routine that keeps calling accept+  const acceptRoutine = () => {+    const handleConn = (conn: Conn) => {+      readRequestsFromConn(conn); // don't block+      scheduleAccept(); // schedule next accept+    }+    const scheduleAccept = () => {+      listener.accept().then(handleConn);+    }+    scheduleAccept();+  }++  acceptRoutine();++  // Loop hack to allow yield (yield won't work in callbacks)

 import { TextProtoReader } from "./textproto.ts"; import { STATUS_TEXT } from "./http_status"; import { assert } from "./util"; +interface Deferred {+  promise: Promise<{}>;+  resolve: () => void;+  reject: () => void;+}++function deferred(): Deferred {+  let resolve, reject;+  const promise = new Promise((res, rej) => {+    resolve = res;+    reject = rej;+  });+  return {+    promise, resolve, reject,+  };+}+ export async function* serve(addr: string) {   const listener = listen("tcp", addr);-  while (true) {-    const c = await listener.accept();-    yield* serveConn(c);+  let serveDeferred = deferred();+  let reqQueue: ServerRequest[] = []; // in case multiple promises are ready++  // Continuously read more requests from conn until EOF+  // Mutually calling with handleReq+  const readRequestsFromConn = async (conn: Conn) => {

 impl log::Log for Logger {   fn flush(&self) {} } +fn print_err_and_exit(err: js_errors::JSError) {+  // TODO Currently tests depend on exception going to stdout. It should go+  // to stderr.+  println!("{}", err.to_string());+  std::process::exit(1);

 void PromiseRejectCallback(v8::PromiseRejectMessage promise_reject_message) {   DenoIsolate* d = static_cast<DenoIsolate*>(isolate->GetData(0));   DCHECK_EQ(d->isolate_, isolate);   v8::HandleScope handle_scope(d->isolate_);-  auto exception = promise_reject_message.GetValue();+  auto error = promise_reject_message.GetValue();   auto context = d->context_.Get(d->isolate_);   auto promise = promise_reject_message.GetPromise();-  auto event = promise_reject_message.GetEvent();    v8::Context::Scope context_scope(context);-  auto promise_reject_handler = d->promise_reject_handler_.Get(isolate);--  if (!promise_reject_handler.IsEmpty()) {-    v8::Local<v8::Value> args[3];-    args[1] = v8_str(PromiseRejectStr(event));-    args[2] = promise;-    /* error, event, promise */-    if (event == v8::PromiseRejectEvent::kPromiseRejectWithNoHandler) {-      d->pending_promise_events_++;-      // exception only valid for kPromiseRejectWithNoHandler-      args[0] = exception;-    } else if (event ==-               v8::PromiseRejectEvent::kPromiseHandlerAddedAfterReject) {-      d->pending_promise_events_--;  // unhandled event cancelled-      if (d->pending_promise_events_ < 0) {-        d->pending_promise_events_ = 0;-      }-      // Placeholder, not actually used-      args[0] = v8_str("Promise handler added");-    } else if (event == v8::PromiseRejectEvent::kPromiseResolveAfterResolved) {-      d->pending_promise_events_++;-      args[0] = v8_str("Promise resolved after resolved");-    } else if (event == v8::PromiseRejectEvent::kPromiseRejectAfterResolved) {-      d->pending_promise_events_++;-      args[0] = v8_str("Promise rejected after resolved");-    }-    promise_reject_handler->Call(context->Global(), 3, args);-    return;++  int promise_id = promise->GetIdentityHash();+  switch (promise_reject_message.GetEvent()) {+    case v8::kPromiseRejectWithNoHandler:+      // Insert the error into the pending_promise_map_ using the promise's id+      // as the key.+      d->pending_promise_map_.emplace(std::piecewise_construct,+                                      std::make_tuple(promise_id),+                                      std::make_tuple(d->isolate_, error));+      // rejectMap.set(promise, (error as Error).stack ||+      // "RejectWithNoHandler");+      break;++    case v8::kPromiseHandlerAddedAfterReject:+      // unhandled event cancelled+      d->pending_promise_map_.erase(promise_id);+      // rejectMap.delete(promise);+      break;++    case v8::kPromiseRejectAfterResolved:+      // Should not warn. See #1272

 NotFound: Cannot resolve module "bad-module.ts" from "[WILDCARD]/tests/error_005_missing_dynamic_import.ts"+    at DenoError ([WILDCARD]/js/errors.ts:[WILDCARD])     at maybeError ([WILDCARD]/js/errors.ts:[WILDCARD])     at maybeThrowError ([WILDCARD]/js/errors.ts:[WILDCARD])     at sendSync ([WILDCARD]/js/dispatch.ts:[WILDCARD])-    at Object.codeFetch ([WILDCARD]/js/os.ts:[WILDCARD])-    at Compiler._resolveModule ([WILDCARD]/js/compiler.ts:[WILDCARD])+    at codeFetch ([WILDCARD]/js/os.ts:[WILDCARD])+    at _resolveModule ([WILDCARD]/js/compiler.ts:[WILDCARD])     at moduleNames.map.name ([WILDCARD]/js/compiler.ts:[WILDCARD])-    at Array.map (<anonymous>)-    at Compiler.resolveModuleNames ([WILDCARD]/js/compiler.ts:[WILDCARD])-    at Object.compilerHost.resolveModuleNames (<anonymous>)-    at resolveModuleNamesWorker (<anonymous>)+    at resolveModuleNames ([WILDCARD]/js/compiler.ts:[WILDCARD])+    at compilerHost.resolveModuleNames ([WILDCARD])

+// Copyright 2018 the Deno authors. All rights reserved. MIT license.++// Note that source_map_mappings requires 0-indexed line and column numbers but+// V8 Exceptions are 1-indexed.++#![allow(dead_code)]