Revert "Deno.bundle supports targets < ES2017. (#6328)" (#6342)

This reverts commit 75bb9dbdfc7f8b4e8d17978808ae575e61843aef.

2 files changed, 126 insertions, 176 deletions

diff --git a/cli/tests/bundle.test.out b/cli/tests/bundle.test.out
index eba439424..b286dad48 100644
--- a/cli/tests/bundle.test.out
+++ b/cli/tests/bundle.test.out
@@ -1,5 +1,6 @@
 [WILDCARD]
-let System, __instantiate;
+let System, __instantiateAsync, __instantiate;
+[WILDCARD]
 (() => {
 [WILDCARD]
 })();
@@ -14,7 +15,7 @@ System.register("mod1", ["subdir2/mod2"], function (exports_3, context_3) {
 [WILDCARD]
 });
 
-const __exp = __instantiate("mod1", false);
+const __exp = __instantiate("mod1");
 export const returnsHi = __exp["returnsHi"];
 export const returnsFoo2 = __exp["returnsFoo2"];
 export const printHello3 = __exp["printHello3"];
diff --git a/cli/tests/compiler_api_test.ts b/cli/tests/compiler_api_test.ts
index 274f1b98d..967220cb4 100644
--- a/cli/tests/compiler_api_test.ts
+++ b/cli/tests/compiler_api_test.ts
@@ -1,201 +1,150 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 import { assert, assertEquals } from "../../std/testing/asserts.ts";
 
-Deno.test({
-  name: "Deno.compile() - sources provided",
-  async fn() {
-    const [diagnostics, actual] = await Deno.compile("/foo.ts", {
-      "/foo.ts": `import * as bar from "./bar.ts";\n\nconsole.log(bar);\n`,
-      "/bar.ts": `export const bar = "bar";\n`,
-    });
-    assert(diagnostics == null);
-    assert(actual);
-    assertEquals(Object.keys(actual), [
-      "/bar.js.map",
-      "/bar.js",
-      "/foo.js.map",
-      "/foo.js",
-    ]);
-  },
+Deno.test("compilerApiCompileSources", async function () {
+  const [diagnostics, actual] = await Deno.compile("/foo.ts", {
+    "/foo.ts": `import * as bar from "./bar.ts";\n\nconsole.log(bar);\n`,
+    "/bar.ts": `export const bar = "bar";\n`,
+  });
+  assert(diagnostics == null);
+  assert(actual);
+  assertEquals(Object.keys(actual), [
+    "/bar.js.map",
+    "/bar.js",
+    "/foo.js.map",
+    "/foo.js",
+  ]);
 });
 
-Deno.test({
-  name: "Deno.compile() - no sources provided",
-  async fn() {
-    const [diagnostics, actual] = await Deno.compile("./subdir/mod1.ts");
-    assert(diagnostics == null);
-    assert(actual);
-    const keys = Object.keys(actual);
-    assertEquals(keys.length, 6);
-    assert(keys[0].endsWith("print_hello.js.map"));
-    assert(keys[1].endsWith("print_hello.js"));
-  },
+Deno.test("compilerApiCompileNoSources", async function () {
+  const [diagnostics, actual] = await Deno.compile("./subdir/mod1.ts");
+  assert(diagnostics == null);
+  assert(actual);
+  const keys = Object.keys(actual);
+  assertEquals(keys.length, 6);
+  assert(keys[0].endsWith("print_hello.js.map"));
+  assert(keys[1].endsWith("print_hello.js"));
 });
 
-Deno.test({
-  name: "Deno.compile() - compiler options effects imit",
-  async fn() {
-    const [diagnostics, actual] = await Deno.compile(
-      "/foo.ts",
-      {
-        "/foo.ts": `export const foo = "foo";`,
-      },
-      {
-        module: "amd",
-        sourceMap: false,
-      }
-    );
-    assert(diagnostics == null);
-    assert(actual);
-    assertEquals(Object.keys(actual), ["/foo.js"]);
-    assert(actual["/foo.js"].startsWith("define("));
-  },
+Deno.test("compilerApiCompileOptions", async function () {
+  const [diagnostics, actual] = await Deno.compile(
+    "/foo.ts",
+    {
+      "/foo.ts": `export const foo = "foo";`,
+    },
+    {
+      module: "amd",
+      sourceMap: false,
+    }
+  );
+  assert(diagnostics == null);
+  assert(actual);
+  assertEquals(Object.keys(actual), ["/foo.js"]);
+  assert(actual["/foo.js"].startsWith("define("));
 });
 
-Deno.test({
-  name: "Deno.compile() - pass lib in compiler options",
-  async fn() {
-    const [diagnostics, actual] = await Deno.compile(
-      "/foo.ts",
-      {
-        "/foo.ts": `console.log(document.getElementById("foo"));
+Deno.test("compilerApiCompileLib", async function () {
+  const [diagnostics, actual] = await Deno.compile(
+    "/foo.ts",
+    {
+      "/foo.ts": `console.log(document.getElementById("foo"));
         console.log(Deno.args);`,
-      },
-      {
-        lib: ["dom", "es2018", "deno.ns"],
-      }
-    );
-    assert(diagnostics == null);
-    assert(actual);
-    assertEquals(Object.keys(actual), ["/foo.js.map", "/foo.js"]);
-  },
-});
-
-Deno.test({
-  name: "Deno.compile() - properly handles .d.ts files",
-  async fn() {
-    const [diagnostics, actual] = await Deno.compile(
-      "/foo.ts",
-      {
-        "/foo.ts": `console.log(Foo.bar);`,
-      },
-      {
-        types: ["./subdir/foo_types.d.ts"],
-      }
-    );
-    assert(diagnostics == null);
-    assert(actual);
-    assertEquals(Object.keys(actual), ["/foo.js.map", "/foo.js"]);
-  },
+    },
+    {
+      lib: ["dom", "es2018", "deno.ns"],
+    }
+  );
+  assert(diagnostics == null);
+  assert(actual);
+  assertEquals(Object.keys(actual), ["/foo.js.map", "/foo.js"]);
 });
 
-Deno.test({
-  name: "Deno.transpileOnly()",
-  async fn() {
-    const actual = await Deno.transpileOnly({
-      "foo.ts": `export enum Foo { Foo, Bar, Baz };\n`,
-    });
-    assert(actual);
-    assertEquals(Object.keys(actual), ["foo.ts"]);
-    assert(actual["foo.ts"].source.startsWith("export var Foo;"));
-    assert(actual["foo.ts"].map);
-  },
+Deno.test("compilerApiCompileTypes", async function () {
+  const [diagnostics, actual] = await Deno.compile(
+    "/foo.ts",
+    {
+      "/foo.ts": `console.log(Foo.bar);`,
+    },
+    {
+      types: ["./subdir/foo_types.d.ts"],
+    }
+  );
+  assert(diagnostics == null);
+  assert(actual);
+  assertEquals(Object.keys(actual), ["/foo.js.map", "/foo.js"]);
 });
 
-Deno.test({
-  name: "Deno.transpileOnly() - config effects commit",
-  async fn() {
-    const actual = await Deno.transpileOnly(
-      {
-        "foo.ts": `export enum Foo { Foo, Bar, Baz };\n`,
-      },
-      {
-        sourceMap: false,
-        module: "amd",
-      }
-    );
-    assert(actual);
-    assertEquals(Object.keys(actual), ["foo.ts"]);
-    assert(actual["foo.ts"].source.startsWith("define("));
-    assert(actual["foo.ts"].map == null);
-  },
+Deno.test("transpileOnlyApi", async function () {
+  const actual = await Deno.transpileOnly({
+    "foo.ts": `export enum Foo { Foo, Bar, Baz };\n`,
+  });
+  assert(actual);
+  assertEquals(Object.keys(actual), ["foo.ts"]);
+  assert(actual["foo.ts"].source.startsWith("export var Foo;"));
+  assert(actual["foo.ts"].map);
 });
 
-Deno.test({
-  name: "Deno.bundle() - sources passed",
-  async fn() {
-    const [diagnostics, actual] = await Deno.bundle("/foo.ts", {
-      "/foo.ts": `export * from "./bar.ts";\n`,
-      "/bar.ts": `export const bar = "bar";\n`,
-    });
-    assert(diagnostics == null);
-    assert(actual.includes(`__instantiate("foo", false)`));
-    assert(actual.includes(`__exp["bar"]`));
-  },
+Deno.test("transpileOnlyApiConfig", async function () {
+  const actual = await Deno.transpileOnly(
+    {
+      "foo.ts": `export enum Foo { Foo, Bar, Baz };\n`,
+    },
+    {
+      sourceMap: false,
+      module: "amd",
+    }
+  );
+  assert(actual);
+  assertEquals(Object.keys(actual), ["foo.ts"]);
+  assert(actual["foo.ts"].source.startsWith("define("));
+  assert(actual["foo.ts"].map == null);
 });
 
-Deno.test({
-  name: "Deno.bundle() - no sources passed",
-  async fn() {
-    const [diagnostics, actual] = await Deno.bundle("./subdir/mod1.ts");
-    assert(diagnostics == null);
-    assert(actual.includes(`__instantiate("mod1", false)`));
-    assert(actual.includes(`__exp["printHello3"]`));
-  },
+Deno.test("bundleApiSources", async function () {
+  const [diagnostics, actual] = await Deno.bundle("/foo.ts", {
+    "/foo.ts": `export * from "./bar.ts";\n`,
+    "/bar.ts": `export const bar = "bar";\n`,
+  });
+  assert(diagnostics == null);
+  assert(actual.includes(`__instantiate("foo")`));
+  assert(actual.includes(`__exp["bar"]`));
 });
 
-Deno.test({
-  name: "Deno.bundle() - compiler config effects emit",
-  async fn() {
-    const [diagnostics, actual] = await Deno.bundle(
-      "/foo.ts",
-      {
-        "/foo.ts": `// random comment\nexport * from "./bar.ts";\n`,
-        "/bar.ts": `export const bar = "bar";\n`,
-      },
-      {
-        removeComments: true,
-      }
-    );
-    assert(diagnostics == null);
-    assert(!actual.includes(`random`));
-  },
+Deno.test("bundleApiNoSources", async function () {
+  const [diagnostics, actual] = await Deno.bundle("./subdir/mod1.ts");
+  assert(diagnostics == null);
+  assert(actual.includes(`__instantiate("mod1")`));
+  assert(actual.includes(`__exp["printHello3"]`));
 });
 
-Deno.test({
-  name: "Deno.bundle() - JS Modules included",
-  async fn() {
-    const [diagnostics, actual] = await Deno.bundle("/foo.js", {
-      "/foo.js": `export * from "./bar.js";\n`,
-      "/bar.js": `export const bar = "bar";\n`,
-    });
-    assert(diagnostics == null);
-    assert(actual.includes(`System.register("bar",`));
-  },
+Deno.test("bundleApiConfig", async function () {
+  const [diagnostics, actual] = await Deno.bundle(
+    "/foo.ts",
+    {
+      "/foo.ts": `// random comment\nexport * from "./bar.ts";\n`,
+      "/bar.ts": `export const bar = "bar";\n`,
+    },
+    {
+      removeComments: true,
+    }
+  );
+  assert(diagnostics == null);
+  assert(!actual.includes(`random`));
 });
 
-Deno.test({
-  name: "Deno.bundle - pre ES2017 uses ES5 loader",
-  async fn() {
-    const [diagnostics, actual] = await Deno.bundle(
-      "/foo.ts",
-      {
-        "/foo.ts": `console.log("hello world!")\n`,
-      },
-      { target: "es2015" }
-    );
-    assert(diagnostics == null);
-    assert(actual.includes(`var __awaiter = `));
-  },
+Deno.test("bundleApiJsModules", async function () {
+  const [diagnostics, actual] = await Deno.bundle("/foo.js", {
+    "/foo.js": `export * from "./bar.js";\n`,
+    "/bar.js": `export const bar = "bar";\n`,
+  });
+  assert(diagnostics == null);
+  assert(actual.includes(`System.register("bar",`));
 });
 
-Deno.test({
-  name: "runtime compiler APIs diagnostics",
-  async fn() {
-    const [diagnostics] = await Deno.compile("/foo.ts", {
-      "/foo.ts": `document.getElementById("foo");`,
-    });
-    assert(Array.isArray(diagnostics));
-    assert(diagnostics.length === 1);
-  },
+Deno.test("diagnosticsTest", async function () {
+  const [diagnostics] = await Deno.compile("/foo.ts", {
+    "/foo.ts": `document.getElementById("foo");`,
+  });
+  assert(Array.isArray(diagnostics));
+  assert(diagnostics.length === 1);
 });