Каков (потенциальный) недостаток повсеместного использования асинхронных функций?

Функции async всегда возвращают Promises. Это означает, что каждый раз, когда вы не имеете дело с чем-то асинхронным, вам придется преобразовать возвращенное Promise в значение, прежде чем вы сможете его использовать. Например:

const return4 = async () => 4;
console.log(4 + return4());

Вместо этого вам придется использовать (излишне многословный):

const return4 = async () => 4;
(async () => {
  console.log(4 + await return4());
})();

(или вызовите .then в вызове return4 перед его использованием)

С другой стороны, если бы return4 не было async, то, конечно, только console.log(4 + return4()); работало бы нормально.

Еще одна проблема с функциями async заключается в том, что для их преобразования в код ES5 (что обеспечивает совместимость с устаревшими браузерами, такими как IE) требуется regenerator-runtime, который очень тяжеловесен. Например, транспиляция следующей строки с помощью Babel:

const foo = async () => console.log('async!');

Когда вы подключаете его к repl, вы получаете:

"use strict";

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }
  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}

function _asyncToGenerator(fn) {
  return function() {
    var self = this,
      args = arguments;
    return new Promise(function(resolve, reject) {
      var gen = fn.apply(self, args);
      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }
      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }
      _next(undefined);
    });
  };
}

var foo =
  /*#__PURE__*/
  (function() {
    var _ref = _asyncToGenerator(
      /*#__PURE__*/
      regeneratorRuntime.mark(function _callee() {
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch ((_context.prev = _context.next)) {
              case 0:
                return _context.abrupt("return", console.log("async!"));

              case 1:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      })
    );

    return function foo() {
      return _ref.apply(this, arguments);
    };
  })();

что также зависит от того, что regeneratorRuntime уже включено в скрипт, а это 700 с чем-то строк кода, которые вы можете увидеть здесь.

На менее мощных системах это может привести к значительному снижению производительности. Вот почему некоторые (например, в руководстве по стилю AirBNB) предпочитают никогда не использовать функции async, даже если они делают асинхронный поток управления скриптом более понятным.