anchor.diff:                                end, Loggers),
                           NewState = State#state{compilers=NewCompilers,
                                                  loggers=NewLoggers},
  -                        {noreply, NewState};
  +                        NewState2 = case dict:size(NewCompilers) =:= 0 of
  +                                        true ->
  +                                            [gen_server:reply(F, ok)
  +                                             || F <- NewState#state.compiler_sync_waiters],
  +                                            NewState#state{compiler_sync_waiters = []};
  +                                        false ->
  +                                            NewState
  +                                    end,
  +                        {noreply, NewState2};
                       _ ->
                           %% should not happen
                           ale:error(?ALE_LOGGER,
  
positive.code:          stop_logger/1,
           add_sink/2, add_sink/3,
           set_loglevel/2, get_loglevel/1,
           set_sink_loglevel/3, get_sink_loglevel/2]).
  
  
  %% gen_server callbacks
  
negative.code: 
      {ok, State2}.
  
  handle_call(sync_compilers, From, #state{compilers = Compilers, compiler_sync_waiters = Waiters} = State) ->
      case dict:size(Compilers) =:= 0 of
          true ->
              [] = Waiters,
              {reply, ok, State};
          false ->
              {noreply, State#state{compiler_sync_waiters = [From | Waiters]}}
      end;
  handle_call({start_sink, Name, Type, Module, Args}, _From, State) ->
      RV = do_start_sink(Name, Type, Module, Args, State),
      handle_result(RV, State);
  