Restyle codebase with clang-format

src/ast.cpp

@@ -350,7 +350,7 @@ struct source_range_visitor_t {
     // Whether any node was found to be unsourced.
     bool any_unsourced{false};
 };
-}
+}  // namespace
 
 maybe_t<source_range_t> node_t::try_source_range() const {
     source_range_visitor_t v;

src/builtin.cpp

@@ -180,8 +180,7 @@ void builtin_missing_argument(parser_t &parser, io_streams_t &streams, const wch
         opt += std::wcslen(opt) - 1;
         // now prepend - to output -c
         streams.err.append_format(BUILTIN_ERR_MISSING, cmd, wcstring(L"-").append(opt).c_str());
-    }
+    } else
-    else
         streams.err.append_format(BUILTIN_ERR_MISSING, cmd, opt);
 
     if (print_hints) {

src/builtin.h

@@ -32,7 +32,7 @@ struct builtin_data_t {
 #define BUILTIN_ERR_MISSING _(L"%ls: %ls: option requires an argument\n")
 
 /// Error message on missing man page.
-#define BUILTIN_ERR_MISSING_HELP                                                                  \
+#define BUILTIN_ERR_MISSING_HELP                                                            \
     _(L"fish: %ls: missing man page\nDocumentation may not be installed.\n`help %ls` will " \
       L"show an online version\n")
 
@@ -44,8 +44,7 @@ struct builtin_data_t {
 #define BUILTIN_ERR_COMBO2_EXCLUSIVE _(L"%ls: %ls %ls: options cannot be used together\n")
 
 /// Error message on multiple scope levels for variables.
-#define BUILTIN_ERR_GLOCAL \
+#define BUILTIN_ERR_GLOCAL _(L"%ls: scope can be only one of: universal function global local\n")
-    _(L"%ls: scope can be only one of: universal function global local\n")
 
 /// Error message for specifying both export and unexport to set/read.
 #define BUILTIN_ERR_EXPUNEXP _(L"%ls: cannot both export and unexport\n")

src/builtin_argparse.cpp

@@ -411,11 +411,13 @@ static int parse_cmd_opts(argparse_cmd_opts_t &opts, int *optind,  //!OCLINT(hig
                 break;
             }
             case ':': {
-                builtin_missing_argument(parser, streams, cmd, argv[w.woptind - 1], /* print_hints */false);
+                builtin_missing_argument(parser, streams, cmd, argv[w.woptind - 1],
+                                         /* print_hints */ false);
                 return STATUS_INVALID_ARGS;
             }
             case '?': {
-                builtin_unknown_option(parser, streams, cmd, argv[w.woptind - 1], /* print_hints */false);
+                builtin_unknown_option(parser, streams, cmd, argv[w.woptind - 1],
+                                       /* print_hints */ false);
                 return STATUS_INVALID_ARGS;
             }
             default: {

src/builtin_function.cpp

@@ -206,9 +206,8 @@ static int validate_function_name(int argc, const wchar_t *const *argv, wcstring
     }
 
     if (parser_keywords_is_reserved(function_name)) {
-        streams.err.append_format(
+        streams.err.append_format(_(L"%ls: %ls: cannot use reserved keyword as function name"), cmd,
-            _(L"%ls: %ls: cannot use reserved keyword as function name"), cmd,
+                                  function_name.c_str());
-            function_name.c_str());
         return STATUS_INVALID_ARGS;
     }
 

src/builtin_history.cpp

@@ -21,15 +21,23 @@
 #include "wgetopt.h"
 #include "wutil.h"  // IWYU pragma: keep
 
-enum hist_cmd_t { HIST_SEARCH = 1, HIST_DELETE, HIST_CLEAR, HIST_MERGE, HIST_SAVE, HIST_UNDEF,
+enum hist_cmd_t {
-    HIST_CLEAR_SESSION };
+    HIST_SEARCH = 1,
+    HIST_DELETE,
+    HIST_CLEAR,
+    HIST_MERGE,
+    HIST_SAVE,
+    HIST_UNDEF,
+    HIST_CLEAR_SESSION
+};
 
 // Must be sorted by string, not enum or random.
 static const enum_map<hist_cmd_t> hist_enum_map[] = {
-    {HIST_CLEAR, L"clear"}, {HIST_CLEAR_SESSION, L"clear-session"},
+    {HIST_CLEAR, L"clear"},   {HIST_CLEAR_SESSION, L"clear-session"},
     {HIST_DELETE, L"delete"}, {HIST_MERGE, L"merge"},
-    {HIST_SAVE, L"save"}, {HIST_SEARCH, L"search"},
+    {HIST_SAVE, L"save"},     {HIST_SEARCH, L"search"},
-    {HIST_UNDEF, nullptr}, };
+    {HIST_UNDEF, nullptr},
+};
 
 struct history_cmd_opts_t {
     hist_cmd_t hist_cmd = HIST_UNDEF;
@@ -82,8 +90,7 @@ static bool check_for_unexpected_hist_args(const history_cmd_opts_t &opts, const
                                            const wcstring_list_t &args, io_streams_t &streams) {
     if (opts.history_search_type_defined || opts.show_time_format || opts.null_terminate) {
         const wchar_t *subcmd_str = enum_to_str(opts.hist_cmd, hist_enum_map);
-        streams.err.append_format(_(L"%ls: %ls: subcommand takes no options\n"), cmd,
+        streams.err.append_format(_(L"%ls: %ls: subcommand takes no options\n"), cmd, subcmd_str);
-                                  subcmd_str);
         return true;
     }
     if (!args.empty()) {

src/builtin_read.cpp

@@ -3,8 +3,8 @@
 
 #include "builtin_read.h"
 
-#include <unistd.h>
 #include <termios.h>
+#include <unistd.h>
 
 #include <algorithm>
 #include <cerrno>
@@ -392,8 +392,8 @@ static int validate_read_args(const wchar_t *cmd, read_cmd_opts_t &opts, int arg
         return STATUS_INVALID_ARGS;
     }
 
-    if ((opts.place & ENV_LOCAL ? 1 : 0) + (opts.place & ENV_FUNCTION ? 1 : 0) + (opts.place & ENV_GLOBAL ? 1 : 0) +
+    if ((opts.place & ENV_LOCAL ? 1 : 0) + (opts.place & ENV_FUNCTION ? 1 : 0) +
-            (opts.place & ENV_UNIVERSAL ? 1 : 0) >
+            (opts.place & ENV_GLOBAL ? 1 : 0) + (opts.place & ENV_UNIVERSAL ? 1 : 0) >
         1) {
         streams.err.append_format(BUILTIN_ERR_GLOCAL, cmd);
         builtin_print_error_trailer(parser, streams.err, cmd);

src/builtin_set.cpp

@@ -1,6 +1,8 @@
 // Functions used for implementing the set builtin.
 #include "config.h"  // IWYU pragma: keep
 
+#include "builtin_set.h"
+
 #include <sys/stat.h>
 #include <unistd.h>
 
@@ -17,7 +19,6 @@
 #include <vector>
 
 #include "builtin.h"
-#include "builtin_set.h"
 #include "common.h"
 #include "env.h"
 #include "expand.h"
@@ -60,16 +61,23 @@ enum {
 // (REQUIRE_ORDER) option for flag parsing. This is not typical of most fish commands. It means
 // we stop scanning for flags when the first non-flag argument is seen.
 static const wchar_t *const short_options = L"+:LSUaefghlnpqux";
-static const struct woption long_options[] = {
+static const struct woption long_options[] = {{L"export", no_argument, nullptr, 'x'},
-    {L"export", no_argument, nullptr, 'x'},    {L"global", no_argument, nullptr, 'g'},
+                                              {L"global", no_argument, nullptr, 'g'},
-    {L"function", no_argument, nullptr, 'f'},
+                                              {L"function", no_argument, nullptr, 'f'},
-    {L"local", no_argument, nullptr, 'l'},     {L"erase", no_argument, nullptr, 'e'},
+                                              {L"local", no_argument, nullptr, 'l'},
-    {L"names", no_argument, nullptr, 'n'},     {L"unexport", no_argument, nullptr, 'u'},
+                                              {L"erase", no_argument, nullptr, 'e'},
-    {L"universal", no_argument, nullptr, 'U'}, {L"long", no_argument, nullptr, 'L'},
+                                              {L"names", no_argument, nullptr, 'n'},
-    {L"query", no_argument, nullptr, 'q'},     {L"show", no_argument, nullptr, 'S'},
+                                              {L"unexport", no_argument, nullptr, 'u'},
-    {L"append", no_argument, nullptr, 'a'},    {L"prepend", no_argument, nullptr, 'p'},
+                                              {L"universal", no_argument, nullptr, 'U'},
-    {L"path", no_argument, nullptr, opt_path}, {L"unpath", no_argument, nullptr, opt_unpath},
+                                              {L"long", no_argument, nullptr, 'L'},
-    {L"help", no_argument, nullptr, 'h'},      {nullptr, 0, nullptr, 0}};
+                                              {L"query", no_argument, nullptr, 'q'},
+                                              {L"show", no_argument, nullptr, 'S'},
+                                              {L"append", no_argument, nullptr, 'a'},
+                                              {L"prepend", no_argument, nullptr, 'p'},
+                                              {L"path", no_argument, nullptr, opt_path},
+                                              {L"unpath", no_argument, nullptr, opt_unpath},
+                                              {L"help", no_argument, nullptr, 'h'},
+                                              {nullptr, 0, nullptr, 0}};
 
 // Hint for invalid path operation with a colon.
 #define BUILTIN_SET_MISMATCHED_ARGS _(L"%ls: You provided %d indexes but %d values\n")
@@ -218,8 +226,8 @@ static int validate_cmd_opts(const wchar_t *cmd,
     }
 
     // The --show flag cannot be combined with any other flag.
-    if (opts.show &&
+    if (opts.show && (opts.local || opts.function || opts.global || opts.erase || opts.list ||
-        (opts.local || opts.function || opts.global || opts.erase || opts.list || opts.exportv || opts.universal)) {
+                      opts.exportv || opts.universal)) {
         streams.err.append_format(BUILTIN_ERR_COMBO, cmd);
         builtin_print_error_trailer(parser, streams.err, cmd);
         return STATUS_INVALID_ARGS;
@@ -315,7 +323,8 @@ struct split_var_t {
 ///   a split var on success, none() on error, in which case an error will have been printed.
 ///   If no index is found, this leaves indexes empty.
 static maybe_t<split_var_t> split_var_and_indexes(const wchar_t *arg, env_mode_flags_t mode,
-                                           const environment_t &vars, io_streams_t &streams) {
+                                                  const environment_t &vars,
+                                                  io_streams_t &streams) {
     split_var_t res{};
     const wchar_t *open_bracket = std::wcschr(arg, L'[');
     size_t varname_len = open_bracket ? open_bracket - arg : wcslen(arg);
@@ -754,7 +763,8 @@ static int builtin_set_set(const wchar_t *cmd, set_cmd_opts_t &opts, int argc, c
         new_values = new_var_values_by_index(*split, argc, argv);
     }
 
-    bool have_shadowing_global = check_global_scope_exists(cmd, opts, split->varname, streams, parser);
+    bool have_shadowing_global =
+        check_global_scope_exists(cmd, opts, split->varname, streams, parser);
     // Set the value back in the variable stack and fire any events.
     int retval = env_set_reporting_errors(cmd, split->varname, scope, std::move(new_values),
                                           streams, parser);

src/builtin_string.h

@@ -5,8 +5,8 @@
 #include <cstring>
 #include <cwchar>
 
-#include "maybe.h"
 #include "io.h"
+#include "maybe.h"
 
 class parser_t;
 

src/common.cpp

@@ -1974,4 +1974,3 @@ bool is_console_session() {
     }();
     return console_session;
 }
-

src/common.h

@@ -216,7 +216,7 @@ extern const wcstring g_empty_string;
 #define DIE_ON_FAILURE(e)                                  \
     do {                                                   \
         int status = e;                                    \
-        if (unlikely(status != 0)) {                                 \
+        if (unlikely(status != 0)) {                       \
             __fish_assert(#e, __FILE__, __LINE__, status); \
         }                                                  \
     } while (0)
@@ -702,8 +702,7 @@ const T *get_by_sorted_name(const wcstring &name, const T (&vals)[N]) {
 /// As established in 1ab81ab90d1a408702e11f081fdaaafa30636c31, iswdigit() is very slow under glibc,
 /// and does nothing more than establish whether or not the single specified character is in the
 /// range ('0','9').
-__attribute__((always_inline))
+__attribute__((always_inline)) bool inline iswdigit(const wchar_t c) {
-bool inline iswdigit(const wchar_t c) {
     return c >= L'0' && c <= L'9';
 }
 

src/env.cpp

@@ -1046,9 +1046,8 @@ void env_stack_impl_t::set_in_node(const env_node_ref_t &node, const wcstring &k
         val = colon_split(val);
     }
 
-    var = var.setting_vals(std::move(val))
+    var =
-              .setting_exports(res_exports)
+        var.setting_vals(std::move(val)).setting_exports(res_exports).setting_pathvar(res_pathvar);
-              .setting_pathvar(res_pathvar);
 
     // Perhaps mark that this node contains an exported variable, or shadows an exported variable.
     // If so regenerate the export list.

src/env.h

@@ -81,7 +81,8 @@ struct statuses_t {
 };
 
 /// Initialize environment variable data.
-void env_init(const struct config_paths_t *paths = nullptr, bool do_uvars = true, bool default_paths = false);
+void env_init(const struct config_paths_t *paths = nullptr, bool do_uvars = true,
+              bool default_paths = false);
 
 /// Various things we need to initialize at run-time that don't really fit any of the other init
 /// routines.

src/env_dispatch.cpp

@@ -61,11 +61,23 @@
 
 /// List of all locale environment variable names that might trigger (re)initializing the locale
 /// subsystem.
-static const wcstring locale_variables[] = {
+static const wcstring locale_variables[] = {L"LANG",
-    L"LANG",     L"LANGUAGE",          L"LC_ALL",         L"LC_ADDRESS",   L"LC_COLLATE",
+                                            L"LANGUAGE",
-    L"LC_CTYPE", L"LC_IDENTIFICATION", L"LC_MEASUREMENT", L"LC_MESSAGES",  L"LC_MONETARY",
+                                            L"LC_ALL",
-    L"LC_NAME",  L"LC_NUMERIC",        L"LC_PAPER",       L"LC_TELEPHONE", L"LC_TIME",
+                                            L"LC_ADDRESS",
-    L"fish_allow_singlebyte_locale", L"LOCPATH"};
+                                            L"LC_COLLATE",
+                                            L"LC_CTYPE",
+                                            L"LC_IDENTIFICATION",
+                                            L"LC_MEASUREMENT",
+                                            L"LC_MESSAGES",
+                                            L"LC_MONETARY",
+                                            L"LC_NAME",
+                                            L"LC_NUMERIC",
+                                            L"LC_PAPER",
+                                            L"LC_TELEPHONE",
+                                            L"LC_TIME",
+                                            L"fish_allow_singlebyte_locale",
+                                            L"LOCPATH"};
 
 /// List of all curses environment variable names that might trigger (re)initializing the curses
 /// subsystem.
@@ -154,7 +166,7 @@ static void handle_timezone(const wchar_t *env_var_name, const environment_t &va
 static void guess_emoji_width(const environment_t &vars) {
     if (auto width_str = vars.get(L"fish_emoji_width")) {
         int new_width = fish_wcstol(width_str->as_string().c_str());
-        g_fish_emoji_width = std::min(2,std::max(1, new_width));
+        g_fish_emoji_width = std::min(2, std::max(1, new_width));
         FLOGF(term_support, "'fish_emoji_width' preference: %d, overwriting default",
               g_fish_emoji_width);
         return;
@@ -183,7 +195,7 @@ static void guess_emoji_width(const environment_t &vars) {
         // Default to whatever system wcwidth says to U+1F603,
         // but only if it's at least 1 and at most 2.
         int w = wcwidth(L'😃');
-        g_fish_emoji_width = std::min(2,std::max(1, w));
+        g_fish_emoji_width = std::min(2, std::max(1, w));
         FLOGF(term_support, "default emoji width: %d", g_fish_emoji_width);
     }
 }
@@ -495,9 +507,8 @@ static bool initialize_curses_using_fallback(const char *term) {
 /// One situation in which this breaks down is with screen, since screen supports setting the
 /// terminal title if the underlying terminal does so, but will print garbage on terminals that
 /// don't. Since we can't see the underlying terminal below screen there is no way to fix this.
-static const wchar_t *const title_terms[] = {L"xterm",  L"screen", L"tmux",
+static const wchar_t *const title_terms[] = {L"xterm", L"screen",    L"tmux",   L"nxterm",
-                                             L"nxterm", L"rxvt",   L"alacritty",
+                                             L"rxvt",  L"alacritty", L"wezterm"};
-                                             L"wezterm"};
 static bool does_term_support_setting_title(const environment_t &vars) {
     const auto term_var = vars.get(L"TERM");
     if (term_var.missing_or_empty()) return false;
@@ -567,12 +578,7 @@ static void init_curses(const environment_t &vars) {
 }
 
 static constexpr const char *utf8_locales[] = {
-    "C.UTF-8",
+    "C.UTF-8", "en_US.UTF-8", "en_GB.UTF-8", "de_DE.UTF-8", "C.utf8", "UTF-8",
-    "en_US.UTF-8",
-    "en_GB.UTF-8",
-    "de_DE.UTF-8",
-    "C.utf8",
-    "UTF-8",
 };
 
 /// Initialize the locale subsystem.

src/env_universal_common.cpp

@@ -395,7 +395,6 @@ bool env_universal_t::load_from_path(const wcstring &path, callback_data_list_t
 }
 
 bool env_universal_t::load_from_path(const std::string &path, callback_data_list_t &callbacks) {
-
     // Check to see if the file is unchanged. We do this again in load_from_fd, but this avoids
     // opening the file unnecessarily.
     if (last_read_file != kInvalidFileID && file_id_for_path(path) == last_read_file) {

src/expand.cpp

@@ -183,8 +183,8 @@ enum class parse_slice_error_t {
 /// Parse an array slicing specification Returns 0 on success. If a parse error occurs, returns the
 /// index of the bad token. Note that 0 can never be a bad index because the string always starts
 /// with [.
-static size_t parse_slice(const wchar_t * const in, wchar_t ** const end_ptr,
+static size_t parse_slice(const wchar_t *const in, wchar_t **const end_ptr, std::vector<long> &idx,
-        std::vector<long> &idx, size_t array_size, parse_slice_error_t * const error) {
+                          size_t array_size, parse_slice_error_t *const error) {
     const long size = static_cast<long>(array_size);
     size_t pos = 1;  // skip past the opening square brace
 
@@ -213,9 +213,9 @@ static size_t parse_slice(const wchar_t * const in, wchar_t ** const end_ptr,
                 *error = parse_slice_error_t::invalid_index;
                 return pos;
             } else if (tmp == 0) {
-                // Explicitly refuse $foo[0] as valid syntax, regardless of whether or not we're going
+                // Explicitly refuse $foo[0] as valid syntax, regardless of whether or not we're
-                // to show an error if the index ultimately evaluates to zero. This will help newcomers
+                // going to show an error if the index ultimately evaluates to zero. This will help
-                // to fish avoid a common off-by-one error. See #4862.
+                // newcomers to fish avoid a common off-by-one error. See #4862.
                 *error = parse_slice_error_t::zero_index;
                 return pos;
             }
@@ -384,7 +384,8 @@ static expand_result_t expand_variables(wcstring instr, completion_receiver_t *o
             effective_val_count = history->size();
         }
         parse_slice_error_t parse_error;
-        size_t bad_pos = parse_slice(in + slice_start, &slice_end, var_idx_list, effective_val_count, &parse_error);
+        size_t bad_pos = parse_slice(in + slice_start, &slice_end, var_idx_list,
+                                     effective_val_count, &parse_error);
         if (bad_pos != 0) {
             switch (parse_error) {
                 case parse_slice_error_t::none:
@@ -684,7 +685,8 @@ static expand_result_t expand_cmdsubst(wcstring input, const operation_context_t
         const wchar_t *const slice_begin = in + tail_begin;
         wchar_t *slice_end = nullptr;
         parse_slice_error_t parse_error;
-        size_t bad_pos = parse_slice(slice_begin, &slice_end, slice_idx, sub_res.size(), &parse_error);
+        size_t bad_pos =
+            parse_slice(slice_begin, &slice_end, slice_idx, sub_res.size(), &parse_error);
         if (bad_pos != 0) {
             switch (parse_error) {
                 case parse_slice_error_t::none:

src/fallback.h

@@ -167,4 +167,4 @@ double wcstod_l(const wchar_t *enptr, wchar_t **endptr, locale_t loc);
 #define wcstod_l(x, y, z) fish_compat::wcstod_l(x, y, z)
 #endif
 
-#endif // FISH_FALLBACK_H
+#endif  // FISH_FALLBACK_H

src/fds.cpp

@@ -17,7 +17,6 @@
 #include <sys/eventfd.h>
 #endif
 
-
 // The first fd in the "high range." fds below this are allowed to be used directly by users in
 // redirections, e.g. >&3
 const int k_first_high_fd = 10;

src/fish.cpp

@@ -50,8 +50,8 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 #include "history.h"
 #include "intern.h"
 #include "io.h"
-#include "parser.h"
 #include "parse_util.h"
+#include "parser.h"
 #include "path.h"
 #include "proc.h"
 #include "reader.h"
@@ -266,7 +266,8 @@ static int run_command_list(parser_t &parser, std::vector<std::string> *cmds,
         if (!errored) {
             // Construct a parsed source ref.
             // Be careful to transfer ownership, this could be a very large string.
-            parsed_source_ref_t ps = std::make_shared<parsed_source_t>(std::move(cmd_wcs), std::move(ast));
+            parsed_source_ref_t ps =
+                std::make_shared<parsed_source_t>(std::move(cmd_wcs), std::move(ast));
             parser.eval(ps, io);
         } else {
             wcstring sb;

src/fish_test_helper.cpp

@@ -135,8 +135,8 @@ static void print_ignored_signals() {
 
 static void print_stop_cont() {
     signal(SIGTSTP, [](int) {
-        // C++ compilers are awful and this is the dance we need to do to silence the "Unused result" warning.
+        // C++ compilers are awful and this is the dance we need to do to silence the "Unused
-        // No, casting to (void) does *not* work. Please leave this.
+        // result" warning. No, casting to (void) does *not* work. Please leave this.
         auto __attribute__((unused)) _ = write(STDOUT_FILENO, "SIGTSTP\n", strlen("SIGTSTP\n"));
         kill(getpid(), SIGSTOP);
     });

src/fish_tests.cpp

@@ -5507,7 +5507,6 @@ static void test_highlighting() {
         {L"# comment", highlight_role_t::comment},
     });
 
-
     highlight_tests.push_back({
         {L"echo", highlight_role_t::command},
         {L"--", highlight_role_t::option},
@@ -5580,13 +5579,15 @@ static void test_highlighting() {
                 auto e_col = expected_colors.at(i);
                 auto a_col = colors.at(i);
                 auto j = i + 1;
-                while (j < colors.size() && expected_colors.at(j) == e_col && colors.at(j) == a_col) j++;
+                while (j < colors.size() && expected_colors.at(j) == e_col && colors.at(j) == a_col)
+                    j++;
                 if (j == colors.size() - 1) j++;
                 const wcstring spaces(i, L' ');
                 const wcstring carets(j - i, L'^');
                 err(L"Wrong color in test at index %lu-%lu in text (expected %#x, actual "
                     L"%#x):\n%ls\n%ls%ls",
-                    i, j - 1, expected_colors.at(i), colors.at(i), text.c_str(), spaces.c_str(), carets.c_str());
+                    i, j - 1, expected_colors.at(i), colors.at(i), text.c_str(), spaces.c_str(),
+                    carets.c_str());
                 i = j;
             }
         }

src/highlight.cpp

@@ -523,9 +523,8 @@ static size_t color_variable(const wchar_t *in, size_t in_len,
 static void color_string_internal(const wcstring &buffstr, highlight_spec_t base_color,
                                   std::vector<highlight_spec_t>::iterator colors) {
     // Clarify what we expect.
-    assert((base_color == highlight_role_t::param
+    assert((base_color == highlight_role_t::param || base_color == highlight_role_t::option ||
-            || base_color == highlight_role_t::option
+            base_color == highlight_role_t::command) &&
-            || base_color == highlight_role_t::command) &&
            "Unexpected base color");
     const size_t buff_len = buffstr.size();
     std::fill(colors, colors + buff_len, base_color);
@@ -853,7 +852,7 @@ void highlighter_t::color_command(const ast::string_t &node) {
 }
 
 // node does not necessarily have type symbol_argument here.
-    void highlighter_t::color_as_argument(const ast::node_t &node, bool options_allowed) {
+void highlighter_t::color_as_argument(const ast::node_t &node, bool options_allowed) {
     auto source_range = node.source_range();
     const wcstring arg_str = get_source(source_range);
 

src/history.cpp

@@ -122,7 +122,6 @@ maybe_t<wcstring> history_filename(const wcstring &session_id, const wcstring &s
     return result;
 }
 
-
 }  // anonymous namespace
 
 class history_lru_cache_t : public lru_cache_t<history_item_t> {
@@ -1091,7 +1090,7 @@ void history_impl_t::clear() {
 
 void history_impl_t::clear_session() {
     for (const auto &item : new_items) {
-        deleted_items.insert(std::pair<wcstring,bool>(item.str(), true));
+        deleted_items.insert(std::pair<wcstring, bool>(item.str(), true));
     }
 
     new_items.clear();

src/lru.h

@@ -89,7 +89,6 @@ class lru_cache_t {
         evict_node(static_cast<lru_node_t *>(mouth.prev));
     }
 
-
     // Implementation of merge step for mergesort.
     // Given two singly linked lists left and right, and a binary func F implementing less-than,
     // return the list in sorted order.

src/parse_execution.cpp

@@ -454,8 +454,7 @@ end_execution_reason_t parse_execution_context_t::run_for_statement(
     auto var = parser->vars().get(for_var_name, ENV_DEFAULT);
     if (env_var_t::flags_for(for_var_name.c_str()) & env_var_t::flag_read_only) {
         return report_error(STATUS_INVALID_ARGS, header.var_name,
-                            L"for: %ls: cannot overwrite read-only variable",
+                            L"for: %ls: cannot overwrite read-only variable", for_var_name.c_str());
-                            for_var_name.c_str());
     }
 
     auto &vars = parser->vars();

src/postfork.cpp

@@ -78,7 +78,8 @@ void report_setpgid_error(int err, bool is_parent, pid_t desired_pgid, const job
             break;
         }
         case EPERM: {
-            FLOGF_SAFE(error, "setpgid: Process %s is a session leader or pgid %s does not match", pid_buff, getpgid_buff);
+            FLOGF_SAFE(error, "setpgid: Process %s is a session leader or pgid %s does not match",
+                       pid_buff, getpgid_buff);
             break;
         }
         case ESRCH: {
@@ -412,11 +413,10 @@ void safe_report_exec_error(int err, const char *actual_cmd, const char *const *
         }
 
         case ENOEXEC: {
-            FLOGF_SAFE(
+            FLOGF_SAFE(exec,
-                exec,
+                       "The file '%s' is marked as an executable but could not be run by the "
-                "The file '%s' is marked as an executable but could not be run by the "
+                       "operating system.",
-                "operating system.",
+                       actual_cmd);
-                actual_cmd);
             break;
         }
 
@@ -457,15 +457,20 @@ void safe_report_exec_error(int err, const char *actual_cmd, const char *const *
             break;
         }
         case EACCES: {
-            FLOGF_SAFE(exec, "Failed to execute process '%s': The file could not be accessed.", actual_cmd);
+            FLOGF_SAFE(exec, "Failed to execute process '%s': The file could not be accessed.",
+                       actual_cmd);
             break;
         }
         case ETXTBSY: {
-            FLOGF_SAFE(exec, "Failed to execute process '%s': File is currently open for writing.", actual_cmd);
+            FLOGF_SAFE(exec, "Failed to execute process '%s': File is currently open for writing.",
+                       actual_cmd);
             break;
         }
         case ELOOP: {
-            FLOGF_SAFE(exec, "Failed to execute process '%s': Too many layers of symbolic links. Maybe a loop?", actual_cmd);
+            FLOGF_SAFE(
+                exec,
+                "Failed to execute process '%s': Too many layers of symbolic links. Maybe a loop?",
+                actual_cmd);
             break;
         }
         case EINVAL: {
@@ -477,16 +482,19 @@ void safe_report_exec_error(int err, const char *actual_cmd, const char *const *
             break;
         }
         case ENOTDIR: {
-            FLOGF_SAFE(exec, "Failed to execute process '%s': A path component is not a directory.", actual_cmd);
+            FLOGF_SAFE(exec, "Failed to execute process '%s': A path component is not a directory.",
+                       actual_cmd);
             break;
         }
-        
+
         case EMFILE: {
-            FLOGF_SAFE(exec, "Failed to execute process '%s': Too many open files in this process.", actual_cmd);
+            FLOGF_SAFE(exec, "Failed to execute process '%s': Too many open files in this process.",
+                       actual_cmd);
             break;
         }
         case ENFILE: {
-            FLOGF_SAFE(exec, "Failed to execute process '%s': Too many open files on the system.", actual_cmd);
+            FLOGF_SAFE(exec, "Failed to execute process '%s': Too many open files on the system.",
+                       actual_cmd);
             break;
         }
         case ENAMETOOLONG: {
@@ -494,13 +502,17 @@ void safe_report_exec_error(int err, const char *actual_cmd, const char *const *
             break;
         }
         case EPERM: {
-            FLOGF_SAFE(exec, "Failed to execute process '%s': No permission. Either suid/sgid is forbidden or you lack capabilities.", actual_cmd);
+            FLOGF_SAFE(exec,
+                       "Failed to execute process '%s': No permission. Either suid/sgid is "
+                       "forbidden or you lack capabilities.",
+                       actual_cmd);
             break;
         }
         default: {
             char errnum_buff[64];
             format_long_safe(errnum_buff, err);
-            FLOGF_SAFE(exec, "Failed to execute process '%s', unknown error number %s", actual_cmd, errnum_buff);
+            FLOGF_SAFE(exec, "Failed to execute process '%s', unknown error number %s", actual_cmd,
+                       errnum_buff);
             break;
         }
     }

src/reader.cpp

@@ -2630,7 +2630,7 @@ static std::shared_ptr<reader_data_t> reader_push_ret(parser_t &parser,
                                                       const wcstring &history_name,
                                                       reader_config_t &&conf) {
     std::shared_ptr<history_t> hist = history_t::with_name(history_name);
-    hist->resolve_pending(); // see #6892
+    hist->resolve_pending();  // see #6892
     auto data = std::make_shared<reader_data_t>(parser.shared(), hist, std::move(conf));
     reader_data_stack.push_back(data);
     data->command_line_changed(&data->command_line);
@@ -4161,7 +4161,6 @@ bool reader_data_t::jump(jump_direction_t dir, jump_precision_t precision, edita
 
 maybe_t<wcstring> reader_readline(int nchars) { return current_data()->readline(nchars); }
 
-
 int reader_reading_interrupted() {
     int res = reader_test_and_clear_interrupted();
     reader_data_t *data = current_data_or_null();

src/screen.cpp

@@ -131,7 +131,7 @@ static bool is_screen_name_escape_seq(const wchar_t *code, size_t *resulting_len
                 const wchar_t *i = screen_name_end;
                 while (i > code && *(i - 1) == L'\x1B' && --i) esc_count++;
                 if (esc_count % 2 == 1) {
-                    offset=screen_name_end - code + 1;
+                    offset = screen_name_end - code + 1;
                     continue;
                 }
             }
@@ -355,7 +355,7 @@ static size_t measure_run_from(const wchar_t *input, size_t start, size_t *out_e
             auto w = fish_wcwidth_visible(input[idx]);
             // A backspace at the start of the line does nothing.
             if (w != -1 || width > 0) {
-               width += w;
+                width += w;
             }
         }
     }

src/screen.h

@@ -316,6 +316,7 @@ class layout_cache_t : noncopyable_t {
     static layout_cache_t shared;
 
     layout_cache_t() = default;
+
    private:
     // Add a cache entry.
     void add_prompt_layout(prompt_cache_entry_t entry);

src/signal.h

@@ -2,8 +2,8 @@
 #ifndef FISH_SIGNALH
 #define FISH_SIGNALH
 
-#include <cstdint>
 #include <csignal>
+#include <cstdint>
 
 /// Get the integer signal value representing the specified signal, or -1 of no signal was found.
 int wcs2sig(const wchar_t *str);

src/trace.cpp

@@ -8,9 +8,7 @@
 
 static bool do_trace = false;
 
-void trace_set_enabled(bool do_enable) {
+void trace_set_enabled(bool do_enable) { do_trace = do_enable; }
-    do_trace = do_enable;
-}
 
 bool trace_enabled(const parser_t &parser) {
     const auto &ld = parser.libdata();

src/wcstringutil.h

@@ -297,8 +297,10 @@ class line_iterator_t {
 /// Like fish_wcwidth, but returns 0 for characters with no real width instead of -1.
 int fish_wcwidth_visible(wchar_t widechar);
 
-/// The same, but for all chars. Note that this only makes sense if the string has an arbitrary long prefix - backslashes can move the cursor *before* the string.
+/// The same, but for all chars. Note that this only makes sense if the string has an arbitrary long
+/// prefix - backslashes can move the cursor *before* the string.
 ///
-/// In typical usage, you probably want to wrap wcwidth_visible to accumulate the width, but never go below 0.
+/// In typical usage, you probably want to wrap wcwidth_visible to accumulate the width, but never
+/// go below 0.
 int fish_wcswidth_visible(const wcstring &str);
 #endif

src/wutil.cpp

@@ -541,9 +541,7 @@ locale_t fish_c_locale() {
 
 static bool fish_numeric_locale_is_valid = false;
 
-void fish_invalidate_numeric_locale() {
+void fish_invalidate_numeric_locale() { fish_numeric_locale_is_valid = false; }
-    fish_numeric_locale_is_valid = false;
-}
 
 locale_t fish_numeric_locale() {
     // The current locale, except LC_NUMERIC isn't forced to C.
@@ -747,9 +745,7 @@ file_id_t file_id_for_fd(int fd) {
     return result;
 }
 
-file_id_t file_id_for_fd(const autoclose_fd_t &fd) {
+file_id_t file_id_for_fd(const autoclose_fd_t &fd) { return file_id_for_fd(fd.fd()); }
-    return file_id_for_fd(fd.fd());
-}
 
 file_id_t file_id_for_path(const wcstring &path) {
     file_id_t result = kInvalidFileID;
@@ -773,7 +769,6 @@ bool file_id_t::operator==(const file_id_t &rhs) const { return this->compare_fi
 
 bool file_id_t::operator!=(const file_id_t &rhs) const { return !(*this == rhs); }
 
-
 wcstring file_id_t::dump() const {
     using llong = long long;
     wcstring result;