Add require-await lint rule (denoland#4401)

.eslintrc.json

@@ -22,7 +22,8 @@
     ],
     "@typescript-eslint/ban-ts-ignore": ["off"],
     "@typescript-eslint/no-empty-function": ["off"],
-    "no-return-await": "error"
+    "no-return-await": "error",
+    "require-await": "error"
   },
   "overrides": [
     {

cli/js/buffer.ts

@@ -106,7 +106,7 @@ export class Buffer implements Reader, SyncReader, Writer, SyncWriter {
     return nread;
   }
 
-  async read(p: Uint8Array): Promise<number | EOF> {
+  read(p: Uint8Array): Promise<number | EOF> {
     const rr = this.readSync(p);
     return Promise.resolve(rr);
   }
@@ -116,7 +116,7 @@ export class Buffer implements Reader, SyncReader, Writer, SyncWriter {
     return copyBytes(this.buf, p, m);
   }
 
-  async write(p: Uint8Array): Promise<number> {
+  write(p: Uint8Array): Promise<number> {
     const n = this.writeSync(p);
     return Promise.resolve(n);
   }

cli/js/compiler.ts

@@ -302,7 +302,7 @@ async function runtimeCompile(
   }
 }
 
-async function runtimeTranspile(
+function runtimeTranspile(
   request: CompilerRequestRuntimeTranspile
 ): Promise<Record<string, TranspileOnlyResult>> {
   const result: Record<string, TranspileOnlyResult> = {};
@@ -325,7 +325,7 @@ async function runtimeTranspile(
     );
     result[fileName] = { source, map };
   }
-  return result;
+  return Promise.resolve(result);
 }
 
 async function tsCompilerOnMessage({

cli/js/ops/fetch.ts

@@ -15,7 +15,7 @@ export interface FetchResponse {
   headers: Array<[string, string]>;
 }
 
-export async function fetch(
+export function fetch(
   args: FetchRequest,
   body: ArrayBufferView | undefined
 ): Promise<FetchResponse> {

cli/js/ops/fs/make_temp.ts

@@ -11,18 +11,14 @@ export function makeTempDirSync(options: MakeTempOptions = {}): string {
   return sendSync("op_make_temp_dir", options);
 }
 
-export async function makeTempDir(
-  options: MakeTempOptions = {}
-): Promise<string> {
+export function makeTempDir(options: MakeTempOptions = {}): Promise<string> {
   return sendAsync("op_make_temp_dir", options);
 }
 
 export function makeTempFileSync(options: MakeTempOptions = {}): string {
   return sendSync("op_make_temp_file", options);
 }
 
-export async function makeTempFile(
-  options: MakeTempOptions = {}
-): Promise<string> {
+export function makeTempFile(options: MakeTempOptions = {}): Promise<string> {
   return sendAsync("op_make_temp_file", options);
 }

cli/js/ops/fs/open.ts

@@ -26,7 +26,7 @@ export function openSync(
   return sendSync("op_open", { path, options, openMode, mode });
 }
 
-export async function open(
+export function open(
   path: string,
   openMode: OpenMode | undefined,
   options: OpenOptions | undefined

cli/js/ops/fs/read_link.ts

@@ -5,6 +5,6 @@ export function readlinkSync(path: string): string {
   return sendSync("op_read_link", { path });
 }
 
-export async function readlink(path: string): Promise<string> {
+export function readlink(path: string): Promise<string> {
   return sendAsync("op_read_link", { path });
 }

cli/js/ops/fs/realpath.ts

@@ -5,6 +5,6 @@ export function realpathSync(path: string): string {
   return sendSync("op_realpath", { path });
 }
 
-export async function realpath(path: string): Promise<string> {
+export function realpath(path: string): Promise<string> {
   return sendAsync("op_realpath", { path });
 }

cli/js/ops/fs/seek.ts

@@ -10,7 +10,7 @@ export function seekSync(
   return sendSync("op_seek", { rid, offset, whence });
 }
 
-export async function seek(
+export function seek(
   rid: number,
   offset: number,
   whence: SeekMode

cli/js/ops/fs_events.ts

@@ -15,15 +15,15 @@ class FsEvents implements AsyncIterableIterator<FsEvent> {
     this.rid = sendSync("op_fs_events_open", { recursive, paths });
   }
 
-  async next(): Promise<IteratorResult<FsEvent>> {
+  next(): Promise<IteratorResult<FsEvent>> {
     return sendAsync("op_fs_events_poll", {
       rid: this.rid
     });
   }
 
-  async return(value?: FsEvent): Promise<IteratorResult<FsEvent>> {
+  return(value?: FsEvent): Promise<IteratorResult<FsEvent>> {
     close(this.rid);
-    return { value, done: true };
+    return Promise.resolve({ value, done: true });
   }
 
   [Symbol.asyncIterator](): AsyncIterableIterator<FsEvent> {

cli/js/ops/net.ts

@@ -31,7 +31,7 @@ interface AcceptResponse {
   };
 }
 
-export async function accept(rid: number): Promise<AcceptResponse> {
+export function accept(rid: number): Promise<AcceptResponse> {
   return sendAsync("op_accept", { rid });
 }
 
@@ -74,7 +74,7 @@ export interface ConnectRequest {
   port: number;
 }
 
-export async function connect(args: ConnectRequest): Promise<ConnectResponse> {
+export function connect(args: ConnectRequest): Promise<ConnectResponse> {
   return sendAsync("op_connect", args);
 }
 
@@ -87,7 +87,7 @@ interface ReceiveResponse {
   };
 }
 
-export async function receive(
+export function receive(
   rid: number,
   zeroCopy: Uint8Array
 ): Promise<ReceiveResponse> {

cli/js/ops/process.ts

@@ -12,7 +12,7 @@ interface RunStatusResponse {
   exitSignal: number;
 }
 
-export async function runStatus(rid: number): Promise<RunStatusResponse> {
+export function runStatus(rid: number): Promise<RunStatusResponse> {
   return sendAsync("op_run_status", { rid });
 }
 

cli/js/ops/repl.ts

@@ -6,6 +6,6 @@ export function startRepl(historyFile: string): number {
   return sendSync("op_repl_start", { historyFile });
 }
 
-export async function readline(rid: number, prompt: string): Promise<string> {
+export function readline(rid: number, prompt: string): Promise<string> {
   return sendAsync("op_repl_readline", { rid, prompt });
 }

cli/js/ops/runtime_compiler.ts

@@ -9,7 +9,7 @@ interface CompileRequest {
   bundle: boolean;
 }
 
-export async function compile(request: CompileRequest): Promise<string> {
+export function compile(request: CompileRequest): Promise<string> {
   return sendAsync("op_compile", request);
 }
 
@@ -18,6 +18,6 @@ interface TranspileRequest {
   options?: string;
 }
 
-export async function transpile(request: TranspileRequest): Promise<string> {
+export function transpile(request: TranspileRequest): Promise<string> {
   return sendAsync("op_transpile", request);
 }

cli/js/ops/signal.ts

@@ -5,7 +5,7 @@ export function bindSignal(signo: number): { rid: number } {
   return sendSync("op_signal_bind", { signo });
 }
 
-export async function pollSignal(rid: number): Promise<{ done: boolean }> {
+export function pollSignal(rid: number): Promise<{ done: boolean }> {
   return sendAsync("op_signal_poll", { rid });
 }
 

cli/js/ops/tls.ts

@@ -23,7 +23,7 @@ interface ConnectTLSResponse {
   };
 }
 
-export async function connectTLS(
+export function connectTLS(
   args: ConnectTLSRequest
 ): Promise<ConnectTLSResponse> {
   return sendAsync("op_connect_tls", args);
@@ -43,7 +43,7 @@ interface AcceptTLSResponse {
   };
 }
 
-export async function acceptTLS(rid: number): Promise<AcceptTLSResponse> {
+export function acceptTLS(rid: number): Promise<AcceptTLSResponse> {
   return sendAsync("op_accept_tls", { rid });
 }
 

cli/js/ops/worker_host.ts

@@ -24,6 +24,6 @@ export function hostPostMessage(id: number, data: Uint8Array): void {
   sendSync("op_host_post_message", { id }, data);
 }
 
-export async function hostGetMessage(id: number): Promise<any> {
+export function hostGetMessage(id: number): Promise<any> {
   return sendAsync("op_host_get_message", { id });
 }

cli/js/permissions.ts

@@ -47,19 +47,19 @@ export class PermissionStatus {
 }
 
 export class Permissions {
-  async query(desc: PermissionDescriptor): Promise<PermissionStatus> {
+  query(desc: PermissionDescriptor): Promise<PermissionStatus> {
     const state = permissionsOps.query(desc);
-    return new PermissionStatus(state);
+    return Promise.resolve(new PermissionStatus(state));
   }
 
-  async revoke(desc: PermissionDescriptor): Promise<PermissionStatus> {
+  revoke(desc: PermissionDescriptor): Promise<PermissionStatus> {
     const state = permissionsOps.revoke(desc);
-    return new PermissionStatus(state);
+    return Promise.resolve(new PermissionStatus(state));
   }
 
-  async request(desc: PermissionDescriptor): Promise<PermissionStatus> {
+  request(desc: PermissionDescriptor): Promise<PermissionStatus> {
     const state = permissionsOps.request(desc);
-    return new PermissionStatus(state);
+    return Promise.resolve(new PermissionStatus(state));
   }
 }
 

cli/js/process.ts

@@ -55,7 +55,7 @@ export class Process {
     }
   }
 
-  async status(): Promise<ProcessStatus> {
+  status(): Promise<ProcessStatus> {
     return runStatus(this.rid);
   }
 

cli/js/testing.ts

@@ -289,7 +289,7 @@ export class ConsoleTestReporter implements TestReporter {
     this.encoder = new TextEncoder();
   }
 
-  private log(msg: string, noNewLine = false): void {
+  private log(msg: string, noNewLine = false): Promise<void> {
     if (!noNewLine) {
       msg += "\n";
     }
@@ -298,19 +298,22 @@ export class ConsoleTestReporter implements TestReporter {
     // compared to `console.log`; `core.print` on the other hand
     // is line-buffered and doesn't output message without newline
     stdout.writeSync(this.encoder.encode(msg));
+    return Promise.resolve();
   }
 
-  async start(event: TestEventStart): Promise<void> {
+  start(event: TestEventStart): Promise<void> {
     this.log(`running ${event.tests} tests`);
+    return Promise.resolve();
   }
 
-  async testStart(event: TestEventTestStart): Promise<void> {
+  testStart(event: TestEventTestStart): Promise<void> {
     const { name } = event;
 
     this.log(`test ${name} ... `, true);
+    return Promise.resolve();
   }
 
-  async testEnd(event: TestEventTestEnd): Promise<void> {
+  testEnd(event: TestEventTestEnd): Promise<void> {
     const { result } = event;
 
     switch (result.status) {
@@ -324,9 +327,11 @@ export class ConsoleTestReporter implements TestReporter {
         this.log(`${YELLOW_IGNORED} ${formatDuration(result.duration)}`);
         break;
     }
+
+    return Promise.resolve();
   }
 
-  async end(event: TestEventEnd): Promise<void> {
+  end(event: TestEventEnd): Promise<void> {
     const { stats, duration, results } = event;
     // Attempting to match the output of Rust's test runner.
     const failedTests = results.filter(r => r.error);
@@ -354,6 +359,8 @@ export class ConsoleTestReporter implements TestReporter {
         `${stats.filtered} filtered out ` +
         `${formatDuration(duration)}\n`
     );
+
+    return Promise.resolve();
   }
 }
 

cli/js/tests/dispatch_json_test.ts

@@ -19,7 +19,7 @@ unitTest(
   }
 );
 
-unitTest(async function malformedJsonControlBuffer(): Promise<void> {
+unitTest(function malformedJsonControlBuffer(): void {
   // @ts-ignore
   const opId = Deno.core.ops()["op_open"];
   // @ts-ignore

cli/js/tests/dispatch_minimal_test.ts

@@ -25,7 +25,7 @@ unitTest(async function sendAsyncStackTrace(): Promise<void> {
   }
 });
 
-unitTest(async function malformedMinimalControlBuffer(): Promise<void> {
+unitTest(function malformedMinimalControlBuffer(): void {
   // @ts-ignore
   const readOpId = Deno.core.ops()["op_read"];
   // @ts-ignore

cli/js/tests/event_target_test.ts

@@ -185,7 +185,7 @@ unitTest(function eventTargetShouldAcceptAsyncFunction(): void {
   const event = new Event("foo", { bubbles: true, cancelable: false });
   let callCount = 0;
 
-  const listener = async (e: Event): Promise<void> => {
+  const listener = (e: Event): void => {
     assertEquals(e, event);
     ++callCount;
   };
@@ -210,7 +210,7 @@ unitTest(
     let callCount = 0;
 
     const listener = {
-      async handleEvent(e: Event): Promise<void> {
+      handleEvent(e: Event): void {
         assertEquals(e, event);
         ++callCount;
       }

cli/js/tests/files_test.ts

@@ -51,16 +51,16 @@ unitTest(async function readerToAsyncIterator(): Promise<void> {
 
     constructor(private readonly s: string) {}
 
-    async read(p: Uint8Array): Promise<number | Deno.EOF> {
+    read(p: Uint8Array): Promise<number | Deno.EOF> {
       const n = Math.min(p.byteLength, this.buf.byteLength - this.offset);
       p.set(this.buf.slice(this.offset, this.offset + n));
       this.offset += n;
 
       if (n === 0) {
-        return Deno.EOF;
+        return Promise.resolve(Deno.EOF);
       }
 
-      return n;
+      return Promise.resolve(n);
     }
   }
 

cli/js/tests/process_test.ts

@@ -359,9 +359,7 @@ if (Deno.build.os !== "win") {
     p.close();
   });
 
-  unitTest({ perms: { run: true } }, async function killFailed(): Promise<
-    void
-  > {
+  unitTest({ perms: { run: true } }, function killFailed(): void {
     const p = run({
       args: ["python", "-c", "from time import sleep; sleep(10000)"]
     });

cli/js/tests/read_link_test.ts

@@ -18,9 +18,7 @@ unitTest(
   }
 );
 
-unitTest({ perms: { read: false } }, async function readlinkSyncPerm(): Promise<
-  void
-> {
+unitTest({ perms: { read: false } }, function readlinkSyncPerm(): void {
   let caughtError = false;
   try {
     Deno.readlinkSync("/symlink");