--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_deleteHeapSnapshot_03.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_deleteHeapSnapshot_03.js
@@ -7,20 +7,20 @@
 const breakdown = {
   by: "coarseType",
   objects: { by: "count", count: true, bytes: true },
   scripts: { by: "count", count: true, bytes: true },
   strings: { by: "count", count: true, bytes: true },
   other: { by: "count", count: true, bytes: true },
 };
 
-function* createSnapshotAndDominatorTree(client) {
+async function createSnapshotAndDominatorTree(client) {
   let snapshotFilePath = saveNewHeapSnapshot();
-  yield client.readHeapSnapshot(snapshotFilePath);
-  let dominatorTreeId = yield client.computeDominatorTree(snapshotFilePath);
+  await client.readHeapSnapshot(snapshotFilePath);
+  let dominatorTreeId = await client.computeDominatorTree(snapshotFilePath);
   return { dominatorTreeId, snapshotFilePath };
 }
 
 add_task(async function () {
   const client = new HeapAnalysesClient();
 
   let savedSnapshots = [
     await createSnapshotAndDominatorTree(client),

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getCensusIndividuals_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getCensusIndividuals_01.js
@@ -33,21 +33,21 @@ add_task(async function () {
 
   const { report } = await client.takeCensus(snapshotFilePath,
                                              { breakdown: CENSUS_BREAKDOWN },
                                              { asTreeNode: true });
   ok(report, "Should get a report");
 
   let nodesWithLeafIndicesFound = 0;
 
-  await (function* assertCanGetIndividuals(censusNode) {
+  await (async function assertCanGetIndividuals(censusNode) {
     if (censusNode.reportLeafIndex !== undefined) {
       nodesWithLeafIndicesFound++;
 
-      const response = yield client.getCensusIndividuals({
+      const response = await client.getCensusIndividuals({
         dominatorTreeId,
         indices: DevToolsUtils.isSet(censusNode.reportLeafIndex)
           ? censusNode.reportLeafIndex
           : new Set([censusNode.reportLeafIndex]),
         censusBreakdown: CENSUS_BREAKDOWN,
         labelBreakdown: LABEL_BREAKDOWN,
         maxRetainingPaths: 1,
         maxIndividuals: MAX_INDIVIDUALS,
@@ -70,17 +70,17 @@ add_task(async function () {
         ok(individual.shortestPaths.nodes, "individual.shortestPaths.nodes should exist");
         ok(individual.shortestPaths.edges, "individual.shortestPaths.edges should exist");
         ok(individual.label, "individual.label should exist");
       }
     }
 
     if (censusNode.children) {
       for (let child of censusNode.children) {
-        yield* assertCanGetIndividuals(child);
+        await assertCanGetIndividuals(child);
       }
     }
   }(report));
 
   equal(nodesWithLeafIndicesFound, 4, "Should have found a leaf for each coarse type");
 
   client.destroy();
 });

--- a/devtools/shared/system.js
+++ b/devtools/shared/system.js
@@ -41,17 +41,17 @@ const APP_MAP = {
   "{718e30fb-e89b-41dd-9da7-e25a45638b28}": "sunbird",
   "{3c2e2abc-06d4-11e1-ac3b-374f68613e61}": "b2g",
   "{aa3c5121-dab2-40e2-81ca-7ea25febc110}": "mobile/android",
   "{a23983c0-fd0e-11dc-95ff-0800200c9a66}": "mobile/xul"
 };
 
 var CACHED_INFO = null;
 
-function* getSystemInfo() {
+async function getSystemInfo() {
   if (CACHED_INFO) {
     return CACHED_INFO;
   }
 
   let appInfo = Services.appinfo;
   let win = Services.wm.getMostRecentWindow(DebuggerServer.chromeWindowType);
   let [processor, compiler] = appInfo.XPCOMABI.split("-");
   let dpi,
@@ -69,18 +69,18 @@ function* getSystemInfo() {
   let version = "unknown";
 
   // B2G specific
   if (apptype === "b2g") {
     os = "B2G";
     // `getSetting` does not work in child processes on b2g.
     // TODO bug 1205797, make this work in child processes.
     try {
-      hardware = yield exports.getSetting("deviceinfo.hardware");
-      version = yield exports.getSetting("deviceinfo.os");
+      hardware = await exports.getSetting("deviceinfo.hardware");
+      version = await exports.getSetting("deviceinfo.os");
     } catch (e) {
       // Ignore.
     }
   } else {
     // Not B2G
     os = appInfo.OS;
     version = appInfo.version;
   }

--- a/devtools/shared/tests/unit/test_fetch-bom.js
+++ b/devtools/shared/tests/unit/test_fetch-bom.js
@@ -62,15 +62,15 @@ registerCleanupFunction(() => {
 });
 
 add_task(async function () {
   await test_one(serverURL + "/u8", "UTF-8");
   await test_one(serverURL + "/u16be", "UTF-16BE");
   await test_one(serverURL + "/u16le", "UTF-16LE");
 });
 
-function* test_one(url, encoding) {
+async function test_one(url, encoding) {
   // Be sure to set the encoding to something that will yield an
   // invalid result if BOM sniffing is not done.
-  yield DevToolsUtils.fetch(url, { charset: "ISO-8859-1" }).then(({content}) => {
+  await DevToolsUtils.fetch(url, { charset: "ISO-8859-1" }).then(({content}) => {
     Assert.equal(content, "hı", "The content looks correct for " + encoding);
   });
 }

--- a/devtools/shared/transport/tests/unit/test_dbgsocket.js
+++ b/devtools/shared/transport/tests/unit/test_dbgsocket.js
@@ -11,17 +11,17 @@ function run_test() {
 
   add_task(test_socket_conn);
   add_task(test_socket_shutdown);
   add_test(test_pipe_conn);
 
   run_next_test();
 }
 
-function* test_socket_conn() {
+async function test_socket_conn() {
   Assert.equal(DebuggerServer.listeningSockets, 0);
   let AuthenticatorType = DebuggerServer.Authenticators.get("PROMPT");
   let authenticator = new AuthenticatorType.Server();
   authenticator.allowConnection = () => {
     return DebuggerServer.AuthenticationResult.ALLOW;
   };
   let listener = DebuggerServer.createListener();
   Assert.ok(listener);
@@ -35,17 +35,17 @@ function* test_socket_conn() {
   gExtraListener = DebuggerServer.createListener();
   gExtraListener.portOrPath = -1;
   gExtraListener.authenticator = authenticator;
   gExtraListener.open();
   Assert.equal(DebuggerServer.listeningSockets, 2);
 
   info("Starting long and unicode tests at " + new Date().toTimeString());
   let unicodeString = "(╯°□°）╯︵ ┻━┻";
-  let transport = yield DebuggerClient.socketConnect({
+  let transport = await DebuggerClient.socketConnect({
     host: "127.0.0.1",
     port: gPort
   });
 
   // Assert that connection settings are available on transport object
   let settings = transport.connectionSettings;
   Assert.equal(settings.host, "127.0.0.1");
   Assert.equal(settings.port, gPort);
@@ -68,29 +68,29 @@ function* test_socket_conn() {
     onClosed: function (status) {
       closedDeferred.resolve();
     },
   };
   transport.ready();
   return closedDeferred.promise;
 }
 
-function* test_socket_shutdown() {
+async function test_socket_shutdown() {
   Assert.equal(DebuggerServer.listeningSockets, 2);
   gExtraListener.close();
   Assert.equal(DebuggerServer.listeningSockets, 1);
   Assert.ok(DebuggerServer.closeAllListeners());
   Assert.equal(DebuggerServer.listeningSockets, 0);
   // Make sure closing the listener twice does nothing.
   Assert.ok(!DebuggerServer.closeAllListeners());
   Assert.equal(DebuggerServer.listeningSockets, 0);
 
   info("Connecting to a server socket at " + new Date().toTimeString());
   try {
-    yield DebuggerClient.socketConnect({
+    await DebuggerClient.socketConnect({
       host: "127.0.0.1",
       port: gPort
     });
   } catch (e) {
     if (e.result == Cr.NS_ERROR_CONNECTION_REFUSED ||
         e.result == Cr.NS_ERROR_NET_TIMEOUT) {
       // The connection should be refused here, but on slow or overloaded
       // machines it may just time out.

--- a/devtools/shared/transport/tests/unit/test_transport_events.js
+++ b/devtools/shared/transport/tests/unit/test_transport_events.js
@@ -10,66 +10,66 @@ function run_test() {
     await test_transport_events("socket", socket_transport);
     await test_transport_events("local", local_transport);
     DebuggerServer.destroy();
   });
 
   run_next_test();
 }
 
-function* test_transport_events(name, transportFactory) {
+async function test_transport_events(name, transportFactory) {
   info(`Started testing of transport: ${name}`);
 
   Assert.equal(Object.keys(DebuggerServer._connections).length, 0);
 
-  let transport = yield transportFactory();
+  let transport = await transportFactory();
 
   // Transport expects the hooks to be not null
   transport.hooks = {
     onPacket: () => {},
     onClosed: () => {},
   };
 
   let rootReceived = transport.once("packet", (event, packet) => {
     info(`Packet event: ${event} ${JSON.stringify(packet)}`);
     Assert.equal(event, "packet");
     Assert.equal(packet.from, "root");
   });
 
   transport.ready();
-  yield rootReceived;
+  await rootReceived;
 
   let echoSent = transport.once("send", (event, packet) => {
     info(`Send event: ${event} ${JSON.stringify(packet)}`);
     Assert.equal(event, "send");
     Assert.equal(packet.to, "root");
     Assert.equal(packet.type, "echo");
   });
 
   let echoReceived = transport.once("packet", (event, packet) => {
     info(`Packet event: ${event} ${JSON.stringify(packet)}`);
     Assert.equal(event, "packet");
     Assert.equal(packet.from, "root");
     Assert.equal(packet.type, "echo");
   });
 
   transport.send({ to: "root", type: "echo" });
-  yield echoSent;
-  yield echoReceived;
+  await echoSent;
+  await echoReceived;
 
   let clientClosed = transport.once("close", (event) => {
     info(`Close event: ${event}`);
     Assert.equal(event, "close");
   });
 
   let serverClosed = DebuggerServer.once("connectionchange", (event, type) => {
     info(`Server closed`);
     Assert.equal(event, "connectionchange");
     Assert.equal(type, "closed");
   });
 
   transport.close();
 
-  yield clientClosed;
-  yield serverClosed;
+  await clientClosed;
+  await serverClosed;
 
   info(`Finished testing of transport: ${name}`);
 }

--- a/devtools/shared/webconsole/test/test_commands_registration.html
+++ b/devtools/shared/webconsole/test/test_commands_registration.html
@@ -19,18 +19,18 @@ let gState;
 let tests;
 
 let {WebConsoleCommands} = require("devtools/server/actors/webconsole/utils");
 
 function evaluateJS(input) {
   return new Promise((resolve) => gState.client.evaluateJS(input, resolve));
 }
 
-function* evaluateJSAndCheckResult(input, result) {
-  let response = yield evaluateJS(input);
+async function evaluateJSAndCheckResult(input, result) {
+  let response = await evaluateJS(input);
   checkObject(response, {result});
 }
 
 function startTest()
 {
   removeEventListener("load", startTest);
 
   attachConsoleToTab(["PageError"], onAttach);

--- a/devtools/shared/webconsole/test/test_jsterm.html
+++ b/devtools/shared/webconsole/test/test_jsterm.html
@@ -67,167 +67,167 @@ function onAttach(aState, aResponse)
                doEvalWithBinding, doEvalWithBindingFrame,
                forceLexicalInit].map(t => {
                  return Task.async(t);
                });
 
   runTests(tests, testEnd);
 }
 
-function* doSimpleEval() {
+async function doSimpleEval() {
   info("test eval '2+2'");
-  let response = yield evaluateJS("2+2");
+  let response = await evaluateJS("2+2");
   checkObject(response, {
     from: gState.actor,
     input: "2+2",
     result: 4,
   });
 
   ok(!response.exception, "no eval exception");
   ok(!response.helperResult, "no helper result");
 
   nextTest();
 }
 
-function* doWindowEval() {
+async function doWindowEval() {
   info("test eval 'document'");
-  let response = yield evaluateJS("document");
+  let response = await evaluateJS("document");
   checkObject(response, {
     from: gState.actor,
     input: "document",
     result: {
       type: "object",
       class: "XULDocument",
       actor: /[a-z]/,
     },
   });
 
   ok(!response.exception, "no eval exception");
   ok(!response.helperResult, "no helper result");
 
   nextTest();
 }
 
-function* doEvalWithException() {
+async function doEvalWithException() {
   info("test eval with exception");
-  let response = yield evaluateJS("window.doTheImpossible()");
+  let response = await evaluateJS("window.doTheImpossible()");
   checkObject(response, {
     from: gState.actor,
     input: "window.doTheImpossible()",
     result: {
       type: "undefined",
     },
     exceptionMessage: /doTheImpossible/,
   });
 
   ok(response.exception, "js eval exception");
   ok(!response.helperResult, "no helper result");
 
   nextTest();
 }
 
-function* doEvalWithHelper() {
+async function doEvalWithHelper() {
   info("test eval with helper");
-  let response = yield evaluateJS("clear()");
+  let response = await evaluateJS("clear()");
   checkObject(response, {
     from: gState.actor,
     input: "clear()",
     result: {
       type: "undefined",
     },
     helperResult: { type: "clearOutput" },
   });
 
   ok(!response.exception, "no eval exception");
 
   nextTest();
 }
 
-function* doEvalString() {
-  let response = yield evaluateJS("window.foobarObject.strfoo");
+async function doEvalString() {
+  let response = await evaluateJS("window.foobarObject.strfoo");
   checkObject(response, {
     from: gState.actor,
     input: "window.foobarObject.strfoo",
     result: "foobarz",
   });
 
   nextTest();
 }
 
-function* doEvalLongString() {
-  let response = yield evaluateJS("window.foobarObject.omgstr");
+async function doEvalLongString() {
+  let response = await evaluateJS("window.foobarObject.omgstr");
   let str = top.foobarObject.omgstr;
   let initial = str.substring(0, DebuggerServer.LONG_STRING_INITIAL_LENGTH);
 
   checkObject(response, {
     from: gState.actor,
     input: "window.foobarObject.omgstr",
     result: {
       type: "longString",
       initial: initial,
       length: str.length,
     },
   });
 
   nextTest();
 }
 
-function* doEvalWithBinding() {
-  let response = yield evaluateJS("document;");
+async function doEvalWithBinding() {
+  let response = await evaluateJS("document;");
   let documentActor = response.result.actor;
 
   info("running a command with _self as document using bindObjectActor");
-  let bindObjectSame = yield evaluateJS("_self === document", {
+  let bindObjectSame = await evaluateJS("_self === document", {
     bindObjectActor: documentActor
   });
   checkObject(bindObjectSame, {
     result: true
   });
 
   info("running a command with _self as document using selectedObjectActor");
-  let selectedObjectSame = yield evaluateJS("_self === document", {
+  let selectedObjectSame = await evaluateJS("_self === document", {
     selectedObjectActor: documentActor
   });
   checkObject(selectedObjectSame, {
     result: true
   });
 
   nextTest();
 }
 
-function* doEvalWithBindingFrame() {
+async function doEvalWithBindingFrame() {
   let frameWin = top.document.querySelector("iframe").contentWindow;
   frameWin.fooFrame = { bar: 1 };
 
-  let response = yield evaluateJS(
+  let response = await evaluateJS(
     "document.querySelector('iframe').contentWindow.fooFrame"
   );
   let iframeObjectActor = response.result.actor;
   ok(iframeObjectActor, "There is an actor associated with the response");
 
-  let bindObjectGlobal = yield evaluateJS("this.temp0 = _self;", {
+  let bindObjectGlobal = await evaluateJS("this.temp0 = _self;", {
     bindObjectActor: iframeObjectActor
   });
   ok(!top.temp0,
     "Global doesn't match the top global with bindObjectActor");
   ok(frameWin.temp0 && frameWin.temp0.bar === 1,
     "Global matches the object's global with bindObjectActor");
 
-  let selectedObjectGlobal = yield evaluateJS("this.temp1 = _self;", {
+  let selectedObjectGlobal = await evaluateJS("this.temp1 = _self;", {
     selectedObjectActor: iframeObjectActor
   });
   ok(top.temp1 && top.temp1.bar === 1,
     "Global matches the top global with bindObjectActor");
   ok(!frameWin.temp1,
     "Global doesn't match the object's global with bindObjectActor");
 
   nextTest()
 }
 
-function* forceLexicalInit() {
+async function forceLexicalInit() {
   info("test that failed let/const bindings are initialized to undefined");
 
   const testData = [
     {
         stmt: "let foopie = wubbalubadubdub",
         vars: ["foopie"]
     },
     {
@@ -260,25 +260,25 @@ function* forceLexicalInit() {
     },
     {
         stmt: "let {c3pdoh=101} = null",
         vars: ["c3pdoh"]
     }
   ];
 
   for (let data of testData) {
-      let response = yield evaluateJS(data.stmt);
+      let response = await evaluateJS(data.stmt);
       checkObject(response, {
         from: gState.actor,
         input: data.stmt,
         result: undefined,
       });
       ok(response.exception, "expected exception");
       for (let varName of data.vars) {
-          let response2 = yield evaluateJS(varName);
+          let response2 = await evaluateJS(varName);
           checkObject(response2, {
             from: gState.actor,
             input: varName,
             result: undefined,
           });
           ok(!response2.exception, "unexpected exception");
       }
   }

--- a/devtools/shared/webconsole/test/test_jsterm_autocomplete.html
+++ b/devtools/shared/webconsole/test/test_jsterm_autocomplete.html
@@ -79,82 +79,82 @@ let onAttach = async function (aState, r
                doAutocomplete4, doAutocompleteLarge1,
                doAutocompleteLarge2].map(t => {
                  return Task.async(t);
                });
 
   runTests(tests, testEnd);
 };
 
-function* doAutocomplete1() {
+async function doAutocomplete1() {
   info("test autocomplete for 'window.foo'");
-  let response = yield autocompletePromise("window.foo", 10);
+  let response = await autocompletePromise("window.foo", 10);
   let matches = response.matches;
 
   is(response.matchProp, "foo", "matchProp");
   is(matches.length, 1, "matches.length");
   is(matches[0], "foobarObject", "matches[0]");
 
   nextTest();
 }
 
-function* doAutocomplete2() {
+async function doAutocomplete2() {
   info("test autocomplete for 'window.foobarObject.'");
-  let response = yield autocompletePromise("window.foobarObject.", 20);
+  let response = await autocompletePromise("window.foobarObject.", 20);
   let matches = response.matches;
 
   ok(!response.matchProp, "matchProp");
   is(matches.length, 7, "matches.length");
   checkObject(matches,
     ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
 
   nextTest();
 }
 
-function* doAutocomplete3() {
+async function doAutocomplete3() {
   // Check that completion suggestions are offered inside the string.
   info("test autocomplete for 'dump(window.foobarObject.)'");
-  let response = yield autocompletePromise("dump(window.foobarObject.)", 25);
+  let response = await autocompletePromise("dump(window.foobarObject.)", 25);
   let matches = response.matches;
 
   ok(!response.matchProp, "matchProp");
   is(matches.length, 7, "matches.length");
   checkObject(matches,
     ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
 
   nextTest();
 }
 
-function* doAutocomplete4() {
+async function doAutocomplete4() {
   // Check that completion requests can have no suggestions.
   info("test autocomplete for 'dump(window.foobarObject.)'");
-  let response = yield autocompletePromise("dump(window.foobarObject.)", 26);
+  let response = await autocompletePromise("dump(window.foobarObject.)", 26);
   ok(!response.matchProp, "matchProp");
   is(response.matches.length, 0, "matches.length");
 
   nextTest();
 }
 
-function* doAutocompleteLarge1() {
+async function doAutocompleteLarge1() {
   // Check that completion requests with too large objects will
   // have no suggestions.
   info("test autocomplete for 'window.largeObject1.'");
-  let response = yield autocompletePromise("window.largeObject1.", 20);
+  let response = await autocompletePromise("window.largeObject1.", 20);
   ok(!response.matchProp, "matchProp");
   info (response.matches.join("|"));
   is(response.matches.length, 0, "Bailed out with too many properties");
 
   nextTest();
 }
 
-function* doAutocompleteLarge2() {
+async function doAutocompleteLarge2() {
   // Check that completion requests with pretty large objects will
   // have MAX_AUTOCOMPLETIONS suggestions
   info("test autocomplete for 'window.largeObject2.'");
-  let response = yield autocompletePromise("window.largeObject2.", 20);
+  let response = await autocompletePromise("window.largeObject2.", 20);
   ok(!response.matchProp, "matchProp");
   is(response.matches.length, MAX_AUTOCOMPLETIONS, "matches.length is MAX_AUTOCOMPLETIONS");
 
   nextTest();
 }
 
 function testEnd()
 {

--- a/devtools/shared/worker/tests/browser/browser_worker-01.js
+++ b/devtools/shared/worker/tests/browser/browser_worker-01.js
@@ -22,26 +22,26 @@ const DURATION = 1000;
 
 add_task(async function () {
   // Test both CJS and JSM versions
 
   await testWorker("JSM", () => ChromeUtils.import("resource://devtools/shared/worker/worker.js", {}));
   await testWorker("CommonJS", () => require("devtools/shared/worker/worker"));
 });
 
-function* testWorker(context, workerFactory) {
+async function testWorker(context, workerFactory) {
   let { DevToolsWorker, workerify } = workerFactory();
   let worker = new DevToolsWorker(WORKER_URL);
-  let results = yield worker.performTask("plotTimestampsGraph", {
+  let results = await worker.performTask("plotTimestampsGraph", {
     timestamps: WORKER_DATA,
     interval: INTERVAL,
     duration: DURATION
   });
 
   ok(results.plottedData.length,
     `worker should have returned an object with array properties in ${context}`);
 
   let fn = workerify(x => x * x);
-  is((yield fn(5)), 25, `workerify works in ${context}`);
+  is((await fn(5)), 25, `workerify works in ${context}`);
   fn.destroy();
 
   worker.destroy();
 }