BREAKING: Remove Deno.EOF, use null instead (#4953)

7 files changed, 80 insertions, 70 deletions

diff --git a/std/http/file_server_test.ts b/std/http/file_server_test.ts
index eff47c41b..8be35621c 100644
--- a/std/http/file_server_test.ts
+++ b/std/http/file_server_test.ts
@@ -25,7 +25,7 @@ async function startFileServer(): Promise<void> {
   assert(fileServer.stdout != null);
   const r = new TextProtoReader(new BufReader(fileServer.stdout));
   const s = await r.readLine();
-  assert(s !== Deno.EOF && s.includes("server listening"));
+  assert(s !== null && s.includes("server listening"));
 }
 
 function killFileServer(): void {
@@ -114,7 +114,7 @@ test("servePermissionDenied", async function (): Promise<void> {
   assert(deniedServer.stderr != null);
   const errReader = new TextProtoReader(new BufReader(deniedServer.stderr));
   const s = await reader.readLine();
-  assert(s !== Deno.EOF && s.includes("server listening"));
+  assert(s !== null && s.includes("server listening"));
 
   try {
     const res = await fetch("http://localhost:4500/");
@@ -138,7 +138,7 @@ test("printHelp", async function (): Promise<void> {
   assert(helpProcess.stdout != null);
   const r = new TextProtoReader(new BufReader(helpProcess.stdout));
   const s = await r.readLine();
-  assert(s !== Deno.EOF && s.includes("Deno File Server"));
+  assert(s !== null && s.includes("Deno File Server"));
   helpProcess.close();
   helpProcess.stdout.close();
 });
diff --git a/std/http/io.ts b/std/http/io.ts
index d87a03306..fbce44342 100644
--- a/std/http/io.ts
+++ b/std/http/io.ts
@@ -7,8 +7,8 @@ import { STATUS_TEXT } from "./http_status.ts";
 
 export function emptyReader(): Deno.Reader {
   return {
-    read(_: Uint8Array): Promise<number | Deno.EOF> {
-      return Promise.resolve(Deno.EOF);
+    read(_: Uint8Array): Promise<number | null> {
+      return Promise.resolve(null);
     },
   };
 }
@@ -16,9 +16,9 @@ export function emptyReader(): Deno.Reader {
 export function bodyReader(contentLength: number, r: BufReader): Deno.Reader {
   let totalRead = 0;
   let finished = false;
-  async function read(buf: Uint8Array): Promise<number | Deno.EOF> {
-    if (finished) return Deno.EOF;
-    let result: number | Deno.EOF;
+  async function read(buf: Uint8Array): Promise<number | null> {
+    if (finished) return null;
+    let result: number | null;
     const remaining = contentLength - totalRead;
     if (remaining >= buf.byteLength) {
       result = await r.read(buf);
@@ -26,7 +26,7 @@ export function bodyReader(contentLength: number, r: BufReader): Deno.Reader {
       const readBuf = buf.subarray(0, remaining);
       result = await r.read(readBuf);
     }
-    if (result !== Deno.EOF) {
+    if (result !== null) {
       totalRead += result;
     }
     finished = totalRead === contentLength;
@@ -43,8 +43,8 @@ export function chunkedBodyReader(h: Headers, r: BufReader): Deno.Reader {
     offset: number;
     data: Uint8Array;
   }> = [];
-  async function read(buf: Uint8Array): Promise<number | Deno.EOF> {
-    if (finished) return Deno.EOF;
+  async function read(buf: Uint8Array): Promise<number | null> {
+    if (finished) return null;
     const [chunk] = chunks;
     if (chunk) {
       const chunkRemaining = chunk.data.byteLength - chunk.offset;
@@ -56,14 +56,14 @@ export function chunkedBodyReader(h: Headers, r: BufReader): Deno.Reader {
       if (chunk.offset === chunk.data.byteLength) {
         chunks.shift();
         // Consume \r\n;
-        if ((await tp.readLine()) === Deno.EOF) {
+        if ((await tp.readLine()) === null) {
           throw new Deno.errors.UnexpectedEof();
         }
       }
       return readLength;
     }
     const line = await tp.readLine();
-    if (line === Deno.EOF) throw new Deno.errors.UnexpectedEof();
+    if (line === null) throw new Deno.errors.UnexpectedEof();
     // TODO: handle chunk extension
     const [chunkSizeString] = line.split(";");
     const chunkSize = parseInt(chunkSizeString, 16);
@@ -73,12 +73,12 @@ export function chunkedBodyReader(h: Headers, r: BufReader): Deno.Reader {
     if (chunkSize > 0) {
       if (chunkSize > buf.byteLength) {
         let eof = await r.readFull(buf);
-        if (eof === Deno.EOF) {
+        if (eof === null) {
           throw new Deno.errors.UnexpectedEof();
         }
         const restChunk = new Uint8Array(chunkSize - buf.byteLength);
         eof = await r.readFull(restChunk);
-        if (eof === Deno.EOF) {
+        if (eof === null) {
           throw new Deno.errors.UnexpectedEof();
         } else {
           chunks.push({
@@ -90,11 +90,11 @@ export function chunkedBodyReader(h: Headers, r: BufReader): Deno.Reader {
       } else {
         const bufToFill = buf.subarray(0, chunkSize);
         const eof = await r.readFull(bufToFill);
-        if (eof === Deno.EOF) {
+        if (eof === null) {
           throw new Deno.errors.UnexpectedEof();
         }
         // Consume \r\n
-        if ((await tp.readLine()) === Deno.EOF) {
+        if ((await tp.readLine()) === null) {
           throw new Deno.errors.UnexpectedEof();
         }
         return chunkSize;
@@ -102,12 +102,12 @@ export function chunkedBodyReader(h: Headers, r: BufReader): Deno.Reader {
     } else {
       assert(chunkSize === 0);
       // Consume \r\n
-      if ((await r.readLine()) === Deno.EOF) {
+      if ((await r.readLine()) === null) {
         throw new Deno.errors.UnexpectedEof();
       }
       await readTrailers(h, r);
       finished = true;
-      return Deno.EOF;
+      return null;
     }
   }
   return { read };
@@ -131,7 +131,7 @@ export async function readTrailers(
   if (!keys) return;
   const tp = new TextProtoReader(r);
   const result = await tp.readMIMEHeader();
-  assert(result != Deno.EOF, "trailer must be set");
+  assert(result !== null, "trailer must be set");
   for (const [k, v] of result) {
     if (!keys.has(k)) {
       throw new Error("Undeclared trailer field");
@@ -332,12 +332,12 @@ export function parseHTTPVersion(vers: string): [number, number] {
 export async function readRequest(
   conn: Deno.Conn,
   bufr: BufReader
-): Promise<ServerRequest | Deno.EOF> {
+): Promise<ServerRequest | null> {
   const tp = new TextProtoReader(bufr);
   const firstLine = await tp.readLine(); // e.g. GET /index.html HTTP/1.0
-  if (firstLine === Deno.EOF) return Deno.EOF;
+  if (firstLine === null) return null;
   const headers = await tp.readMIMEHeader();
-  if (headers === Deno.EOF) throw new Deno.errors.UnexpectedEof();
+  if (headers === null) throw new Deno.errors.UnexpectedEof();
 
   const req = new ServerRequest();
   req.conn = conn;
diff --git a/std/http/io_test.ts b/std/http/io_test.ts
index 0fe70730b..b9bb56f11 100644
--- a/std/http/io_test.ts
+++ b/std/http/io_test.ts
@@ -3,7 +3,6 @@ import {
   assertThrowsAsync,
   assertEquals,
   assert,
-  assertNotEOF,
   assertNotEquals,
 } from "../testing/asserts.ts";
 import {
@@ -43,11 +42,11 @@ test("chunkedBodyReader", async () => {
   ].join("");
   const h = new Headers();
   const r = chunkedBodyReader(h, new BufReader(new Buffer(encode(body))));
-  let result: number | Deno.EOF;
+  let result: number | null;
   // Use small buffer as some chunks exceed buffer size
   const buf = new Uint8Array(5);
   const dest = new Buffer();
-  while ((result = await r.read(buf)) !== Deno.EOF) {
+  while ((result = await r.read(buf)) !== null) {
     const len = Math.min(buf.byteLength, result);
     await dest.write(buf.subarray(0, len));
   }
@@ -223,25 +222,28 @@ test("writeUint8ArrayResponse", async function (): Promise<void> {
   const decoder = new TextDecoder("utf-8");
   const reader = new BufReader(buf);
 
-  let r: ReadLineResult;
-  r = assertNotEOF(await reader.readLine());
+  let r: ReadLineResult | null = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), "HTTP/1.1 200 OK");
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), `content-length: ${shortText.length}`);
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(r.line.byteLength, 0);
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), shortText);
   assertEquals(r.more, false);
 
   const eof = await reader.readLine();
-  assertEquals(eof, Deno.EOF);
+  assertEquals(eof, null);
 });
 
 test("writeStringResponse", async function (): Promise<void> {
@@ -255,25 +257,28 @@ test("writeStringResponse", async function (): Promise<void> {
   const decoder = new TextDecoder("utf-8");
   const reader = new BufReader(buf);
 
-  let r: ReadLineResult;
-  r = assertNotEOF(await reader.readLine());
+  let r: ReadLineResult | null = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), "HTTP/1.1 200 OK");
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), `content-length: ${body.length}`);
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(r.line.byteLength, 0);
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), body);
   assertEquals(r.more, false);
 
   const eof = await reader.readLine();
-  assertEquals(eof, Deno.EOF);
+  assertEquals(eof, null);
 });
 
 test("writeStringReaderResponse", async function (): Promise<void> {
@@ -288,28 +293,33 @@ test("writeStringReaderResponse", async function (): Promise<void> {
   const decoder = new TextDecoder("utf-8");
   const reader = new BufReader(buf);
 
-  let r: ReadLineResult;
-  r = assertNotEOF(await reader.readLine());
+  let r: ReadLineResult | null = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), "HTTP/1.1 200 OK");
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), "transfer-encoding: chunked");
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(r.line.byteLength, 0);
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), shortText.length.toString());
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), shortText);
   assertEquals(r.more, false);
 
-  r = assertNotEOF(await reader.readLine());
+  r = await reader.readLine();
+  assert(r !== null);
   assertEquals(decoder.decode(r.line), "0");
   assertEquals(r.more, false);
 });
@@ -372,7 +382,7 @@ test("testReadRequestError", async function (): Promise<void> {
       in: "GET / HTTP/1.1\r\nheader:foo\r\n",
       err: Deno.errors.UnexpectedEof,
     },
-    { in: "", err: Deno.EOF },
+    { in: "", eof: true },
     {
       in: "HEAD / HTTP/1.1\r\nContent-Length:4\r\n\r\n",
       err: "http: method cannot contain a Content-Length",
@@ -427,14 +437,14 @@ test("testReadRequestError", async function (): Promise<void> {
   for (const test of testCases) {
     const reader = new BufReader(new StringReader(test.in));
     let err;
-    let req: ServerRequest | Deno.EOF | undefined;
+    let req: ServerRequest | null = null;
     try {
       req = await readRequest(mockConn(), reader);
     } catch (e) {
       err = e;
     }
-    if (test.err === Deno.EOF) {
-      assertEquals(req, Deno.EOF);
+    if (test.eof) {
+      assertEquals(req, null);
     } else if (typeof test.err === "string") {
       assertEquals(err.message, test.err);
     } else if (test.err) {
@@ -443,7 +453,7 @@ test("testReadRequestError", async function (): Promise<void> {
       assert(req instanceof ServerRequest);
       assert(test.headers);
       assertEquals(err, undefined);
-      assertNotEquals(req, Deno.EOF);
+      assertNotEquals(req, null);
       for (const h of test.headers) {
         assertEquals(req.headers.get(h.key), h.value);
       }
diff --git a/std/http/mock.ts b/std/http/mock.ts
index 64bd3fcb9..f373b4214 100644
--- a/std/http/mock.ts
+++ b/std/http/mock.ts
@@ -14,7 +14,7 @@ export function mockConn(base: Partial<Deno.Conn> = {}): Deno.Conn {
     rid: -1,
     closeRead: (): void => {},
     closeWrite: (): void => {},
-    read: (): Promise<number | Deno.EOF> => {
+    read: (): Promise<number | null> => {
       return Promise.resolve(0);
     },
     write: (): Promise<number> => {
diff --git a/std/http/racing_server_test.ts b/std/http/racing_server_test.ts
index d80072e7d..90961f7f8 100644
--- a/std/http/racing_server_test.ts
+++ b/std/http/racing_server_test.ts
@@ -13,7 +13,7 @@ async function startServer(): Promise<void> {
   assert(server.stdout != null);
   const r = new TextProtoReader(new BufReader(server.stdout));
   const s = await r.readLine();
-  assert(s !== Deno.EOF && s.includes("Racing server listening..."));
+  assert(s !== null && s.includes("Racing server listening..."));
 }
 function killServer(): void {
   server.close();
diff --git a/std/http/server.ts b/std/http/server.ts
index bc48d4628..9c678ad3d 100644
--- a/std/http/server.ts
+++ b/std/http/server.ts
@@ -60,7 +60,7 @@ export class ServerRequest {
    *     let totRead = 0;
    *     while (true) {
    *       const nread = await req.body.read(bufSlice);
-   *       if (nread === Deno.EOF) break;
+   *       if (nread === null) break;
    *       totRead += nread;
    *       if (totRead >= req.contentLength) break;
    *       bufSlice = bufSlice.subarray(nread);
@@ -117,7 +117,7 @@ export class ServerRequest {
     // Consume unread body
     const body = this.body;
     const buf = new Uint8Array(1024);
-    while ((await body.read(buf)) !== Deno.EOF) {}
+    while ((await body.read(buf)) !== null) {}
     this.finalized = true;
   }
 }
@@ -151,7 +151,7 @@ export class Server implements AsyncIterable<ServerRequest> {
     const writer = new BufWriter(conn);
 
     while (!this.closing) {
-      let request: ServerRequest | Deno.EOF;
+      let request: ServerRequest | null;
       try {
         request = await readRequest(conn, reader);
       } catch (error) {
@@ -167,7 +167,7 @@ export class Server implements AsyncIterable<ServerRequest> {
         }
         break;
       }
-      if (request == Deno.EOF) {
+      if (request === null) {
         break;
       }
 
diff --git a/std/http/server_test.ts b/std/http/server_test.ts
index 939e79600..4e7b4b69e 100644
--- a/std/http/server_test.ts
+++ b/std/http/server_test.ts
@@ -10,7 +10,6 @@ import {
   assert,
   assertEquals,
   assertMatch,
-  assertNotEOF,
   assertStrContains,
   assertThrowsAsync,
 } from "../testing/asserts.ts";
@@ -108,7 +107,7 @@ interface TotalReader extends Deno.Reader {
 }
 function totalReader(r: Deno.Reader): TotalReader {
   let _total = 0;
-  async function read(p: Uint8Array): Promise<number | Deno.EOF> {
+  async function read(p: Uint8Array): Promise<number | null> {
     const result = await r.read(p);
     if (typeof result === "number") {
       _total += result;
@@ -252,13 +251,13 @@ test("requestBodyReaderWithContentLength", async function (): Promise<void> {
     let offset = 0;
     while (offset < shortText.length) {
       const nread = await req.body.read(readBuf);
-      assertNotEOF(nread);
+      assert(nread !== null);
       const s = decode(readBuf.subarray(0, nread as number));
       assertEquals(shortText.substr(offset, nread as number), s);
       offset += nread as number;
     }
     const nread = await req.body.read(readBuf);
-    assertEquals(nread, Deno.EOF);
+    assertEquals(nread, null);
   }
 
   // Larger than given buf
@@ -273,13 +272,13 @@ test("requestBodyReaderWithContentLength", async function (): Promise<void> {
     let offset = 0;
     while (offset < longText.length) {
       const nread = await req.body.read(readBuf);
-      assertNotEOF(nread);
+      assert(nread !== null);
       const s = decode(readBuf.subarray(0, nread as number));
       assertEquals(longText.substr(offset, nread as number), s);
       offset += nread as number;
     }
     const nread = await req.body.read(readBuf);
-    assertEquals(nread, Deno.EOF);
+    assertEquals(nread, null);
   }
 });
 
@@ -307,13 +306,13 @@ test("requestBodyReaderWithTransferEncoding", async function (): Promise<void> {
     let offset = 0;
     while (offset < shortText.length) {
       const nread = await req.body.read(readBuf);
-      assertNotEOF(nread);
+      assert(nread !== null);
       const s = decode(readBuf.subarray(0, nread as number));
       assertEquals(shortText.substr(offset, nread as number), s);
       offset += nread as number;
     }
     const nread = await req.body.read(readBuf);
-    assertEquals(nread, Deno.EOF);
+    assertEquals(nread, null);
   }
 
   // Larger than internal buf
@@ -340,13 +339,13 @@ test("requestBodyReaderWithTransferEncoding", async function (): Promise<void> {
     let offset = 0;
     while (offset < longText.length) {
       const nread = await req.body.read(readBuf);
-      assertNotEOF(nread);
+      assert(nread !== null);
       const s = decode(readBuf.subarray(0, nread as number));
       assertEquals(longText.substr(offset, nread as number), s);
       offset += nread as number;
     }
     const nread = await req.body.read(readBuf);
-    assertEquals(nread, Deno.EOF);
+    assertEquals(nread, null);
   }
 });
 
@@ -372,7 +371,7 @@ test({
     try {
       const r = new TextProtoReader(new BufReader(p.stdout!));
       const s = await r.readLine();
-      assert(s !== Deno.EOF && s.includes("server listening"));
+      assert(s !== null && s.includes("server listening"));
       await delay(100);
       // Reqeusts to the server and immediately closes the connection
       const conn = await Deno.connect({ port: 4502 });
@@ -419,7 +418,7 @@ test({
       const r = new TextProtoReader(new BufReader(p.stdout!));
       const s = await r.readLine();
       assert(
-        s !== Deno.EOF && s.includes("server listening"),
+        s !== null && s.includes("server listening"),
         "server must be started"
       );
       // Requests to the server and immediately closes the connection
@@ -433,7 +432,8 @@ test({
         new TextEncoder().encode("GET / HTTP/1.0\r\n\r\n")
       );
       const res = new Uint8Array(100);
-      const nread = assertNotEOF(await conn.read(res));
+      const nread = await conn.read(res);
+      assert(nread !== null);
       conn.close();
       const resStr = new TextDecoder().decode(res.subarray(0, nread));
       assert(resStr.includes("Hello HTTPS"));
@@ -476,7 +476,7 @@ test({
     );
     const res = new Uint8Array(100);
     const nread = await conn.read(res);
-    assert(nread !== Deno.EOF);
+    assert(nread !== null);
     const resStr = new TextDecoder().decode(res.subarray(0, nread));
     assertStrContains(resStr, "/hello");
     server.close();