the modifier '{0}' can't be applied to the body of a setter

######## Solution 1:
If you need to do something asynchronous inside the setter anyway, perhaps log 
something after doing the actual setting, you have a few options.
The simplest is to just call an async helper function:

set foo(Foo foo) { 
  _foo = foo;
  _logSettingFoo(foo);
}

static void _logSettingFoo(Foo foo) async {
  try {
    var logger = await _getLogger();
    await logger.log("set foo", foo);
    logger.release();  // or whatever.
  } catch (e) {
    // report e somehow.
  }
}

######## Solution 2:
This makes it very clear that you are calling an async function where nobody's
waiting for it to complete.
If you don't want to have a separate helper function, you can inline it:

set foo(Foo foo) { 
  _foo = foo;
  void _logSettingFoo() async {
    ...
  }
  _logSettingFoo();
}

########## OR 

set foo(Foo foo) { 
  _foo = foo;
  () async {
    ...foo...
  }();
}

############ Reason For above Solution:
The reason a setter cannot be async is that an async function returns a future,
and a setter does not return anything. That makes it highly dangerous to make a
setter async because any error in the setter will become an uncaught
asynchronous error (which may crash your program). Also, being async probably
means that the operation will take some time, but there is no way for the 
caller to wait for the operation to complete. That introduces a risk of race 
conditions. So, it's for your own protections.