Basically, I think we have two options here, metaphorically. Have a traceur option that basically means `--wrap-async-functions`, or have a library that means `var wrap = require('wrap-async-functions');`. I believe the library is a more flexible solution.

For example, if I want to:
* only wrap certain functions, either for performance or interop.
* wrap a new module that follows the node conventions.
* wrap a module that doesn't follow the `func`, `funcSync` convention.
* wrap a function that doesn't follow the `callback(err, ...args)`   convention. Case in point, `fs.exists`.

With a library, I can (theoretically) access the wrapping functionality and do just that.

----

There are a few more lines of code to preserve the original module, but you save a lot more lines of code since you no longer have check for the callback.

----

Putting it into a module is not as transparent as magic, but that can be a good thing too. Here is some code that does not use `await`, but would have a use for your library.

```
# This isn't ES5 code, but it could be trivially converted.
cat > promises-readfiles.js <<"END"
// pretend promises-module:
//   var M = require('pretend-promises-module');
//   var async = M.async;
//   var join = M.join;
var async = (fn) => (...args) => {
  var deferred = new Deferred;
  fn(...args, (err, value) => {
    if (err !== null)
      deferred.errback(err);
    else
      deferred.callback(value);
  });
  return deferred.createPromise();
};

// Pretend this is part of a larger library that handles CommonJS Promises.
// The specifics of this rough implementation are not really the point,
// but with that in mind, feel free to critique.
var join = dfs => {
  var len = dfs.length, rs = Array(len), es = Array(len);
  var done = 0;
  var df = new Deferred;
  function checkDone() {
    if (++done >= len) {
      if (es.every((x) => !x)) {
        df.callback(rs);
      } else {
        df.errback(es);
      }
    }
  }
  for (var i = 0; i < len; i++) {
    ((i) =>
      dfs[i].then(d => {
        rs[i] = d;
        checkDone();
      }, e => {
        es[i] = e;
        checkDone();
      })
    )(i);
  }
  return df.createPromise();
};
// end module code

var fs = require('fs');
var readFileAsync = async(fs.readFile);

var fileNames = process.argv.slice(2);
console.log(fileNames);
join(fileNames.map((file) => readFileAsync(file, 'utf8'))).then((data) => {
  console.log(`${fileNames} has total ${
    data.reduce((l, d) => l + d.split('\n').length, 0)
  } lines`);
}, (ex) => {
  console.error(ex);
});
console.log(`Loading ${fileNames}...`);
END
./traceur promises-readfiles.js *.js
```

----

Note: I still think this is a good patch; I'd just like to give the user (possibly me) more direct control over the wrapping functionality.