Merge pull request #3403 from mstoeckl/ipcleanup

Remove 'input' field of IPC command return json

129 files changed, 473 insertions, 567 deletions

diff --git a/sway/commands/assign.c b/sway/commands/assign.c
index 716d70cf..3bd1f65d 100644
--- a/sway/commands/assign.c
+++ b/sway/commands/assign.c
@@ -17,7 +17,7 @@ struct cmd_results *cmd_assign(int argc, char **argv) {
 	char *err_str = NULL;
 	struct criteria *criteria = criteria_parse(argv[0], &err_str);
 	if (!criteria) {
-		error = cmd_results_new(CMD_INVALID, "assign", err_str);
+		error = cmd_results_new(CMD_INVALID, err_str);
 		free(err_str);
 		return error;
 	}
@@ -27,7 +27,7 @@ struct cmd_results *cmd_assign(int argc, char **argv) {
 	if (strncmp(*argv, "→", strlen("→")) == 0) {
 		if (argc < 2) {
 			free(criteria);
-			return cmd_results_new(CMD_INVALID, "assign", "Missing workspace");
+			return cmd_results_new(CMD_INVALID, "Missing workspace");
 		}
 		--argc;
 		++argv;
@@ -44,7 +44,7 @@ struct cmd_results *cmd_assign(int argc, char **argv) {
 			--argc; ++argv;
 			if (argv[0][0] < '0' || argv[0][0] > '9') {
 				free(criteria);
-				return cmd_results_new(CMD_INVALID, "assign",
+				return cmd_results_new(CMD_INVALID,
 						"Invalid workspace number '%s'", argv[0]);
 			}
 			criteria->type = CT_ASSIGN_WORKSPACE_NUMBER;
@@ -59,5 +59,5 @@ struct cmd_results *cmd_assign(int argc, char **argv) {
 	wlr_log(WLR_DEBUG, "assign: '%s' -> '%s' added", criteria->raw,
 			criteria->target);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar.c b/sway/commands/bar.c
index 2a82d508..b19d9574 100644
--- a/sway/commands/bar.c
+++ b/sway/commands/bar.c
@@ -69,7 +69,7 @@ struct cmd_results *cmd_bar(int argc, char **argv) {
 			wlr_log(WLR_DEBUG, "Creating bar: %s", argv[0]);
 			bar = default_bar_config();
 			if (!bar) {
-				return cmd_results_new(CMD_FAILURE, "bar",
+				return cmd_results_new(CMD_FAILURE,
 						"Unable to allocate bar state");
 			}
 
@@ -83,7 +83,7 @@ struct cmd_results *cmd_bar(int argc, char **argv) {
 		// Create new bar with default values
 		struct bar_config *bar = default_bar_config();
 		if (!bar) {
-			return cmd_results_new(CMD_FAILURE, "bar",
+			return cmd_results_new(CMD_FAILURE,
 					"Unable to allocate bar state");
 		}
 
@@ -93,8 +93,7 @@ struct cmd_results *cmd_bar(int argc, char **argv) {
 		if (bar->id) {
 			snprintf(bar->id, len, "bar-%d", config->bars->length - 1);
 		} else {
-			return cmd_results_new(CMD_FAILURE,
-					"bar", "Unable to allocate bar ID");
+			return cmd_results_new(CMD_FAILURE, "Unable to allocate bar ID");
 		}
 
 		// Set current bar
@@ -117,7 +116,7 @@ struct cmd_results *cmd_bar(int argc, char **argv) {
 				}
 			}
 		}
-		return cmd_results_new(CMD_INVALID, "bar",
+		return cmd_results_new(CMD_INVALID,
 				"Can only be used in the config file.");
 	}
 
diff --git a/sway/commands/bar/bind.c b/sway/commands/bar/bind.c
index a4c65ec4..71adced8 100644
--- a/sway/commands/bar/bind.c
+++ b/sway/commands/bar/bind.c
@@ -16,13 +16,12 @@ static struct cmd_results *bar_cmd_bind(int argc, char **argv, bool code) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, command, "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 
 	struct bar_binding *binding = calloc(1, sizeof(struct bar_binding));
 	if (!binding) {
-		return cmd_results_new(CMD_FAILURE, command,
-				"Unable to allocate bar binding");
+		return cmd_results_new(CMD_FAILURE, "Unable to allocate bar binding");
 	}
 
 	binding->release = false;
@@ -40,13 +39,12 @@ static struct cmd_results *bar_cmd_bind(int argc, char **argv, bool code) {
 	}
 	if (message) {
 		free_bar_binding(binding);
-		error = cmd_results_new(CMD_INVALID, command, message);
+		error = cmd_results_new(CMD_INVALID, message);
 		free(message);
 		return error;
 	} else if (!binding->button) {
 		free_bar_binding(binding);
-		return cmd_results_new(CMD_INVALID, command,
-				"Unknown button %s", argv[0]);
+		return cmd_results_new(CMD_INVALID, "Unknown button %s", argv[0]);
 	}
 
 	const char *name = libevdev_event_code_get_name(EV_KEY, binding->button);
@@ -94,7 +92,7 @@ static struct cmd_results *bar_cmd_bind(int argc, char **argv, bool code) {
 				binding->release ? " - release" : "");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *bar_cmd_bindcode(int argc, char **argv) {
diff --git a/sway/commands/bar/binding_mode_indicator.c b/sway/commands/bar/binding_mode_indicator.c
index b048b7b9..15acc309 100644
--- a/sway/commands/bar/binding_mode_indicator.c
+++ b/sway/commands/bar/binding_mode_indicator.c
@@ -11,8 +11,7 @@ struct cmd_results *bar_cmd_binding_mode_indicator(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE,
-				"binding_mode_indicator", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	config->current_bar->binding_mode_indicator = 
 		parse_boolean(argv[0], config->current_bar->binding_mode_indicator);
@@ -23,5 +22,5 @@ struct cmd_results *bar_cmd_binding_mode_indicator(int argc, char **argv) {
 		wlr_log(WLR_DEBUG, "Disabling binding mode indicator on bar: %s",
 				config->current_bar->id);
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/colors.c b/sway/commands/bar/colors.c
index ebf1e3e1..7921db0d 100644
--- a/sway/commands/bar/colors.c
+++ b/sway/commands/bar/colors.c
@@ -25,11 +25,11 @@ static struct cmd_results *parse_single_color(char **color,
 	if (!*color && !(*color = malloc(10))) {
 		return NULL;
 	}
-	error = add_color(cmd_name, *color, argv[0]);
+	error = add_color(*color, argv[0]);
 	if (error) {
 		return error;
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 static struct cmd_results *parse_three_colors(char ***colors,
@@ -37,18 +37,18 @@ static struct cmd_results *parse_three_colors(char ***colors,
 	struct cmd_results *error = NULL;
 	if (argc != 3) {
 		return cmd_results_new(CMD_INVALID,
-				cmd_name, "Requires exactly three color values");
+				"Command '%s' requires exactly three color values", cmd_name);
 	}
 	for (size_t i = 0; i < 3; i++) {
 		if (!*colors[i] && !(*(colors[i]) = malloc(10))) {
 			return NULL;
 		}
-		error = add_color(cmd_name, *(colors[i]), argv[i]);
+		error = add_color(*(colors[i]), argv[i]);
 		if (error) {
 			return error;
 		}
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *bar_cmd_colors(int argc, char **argv) {
diff --git a/sway/commands/bar/font.c b/sway/commands/bar/font.c
index 2aa4e895..c6147e3d 100644
--- a/sway/commands/bar/font.c
+++ b/sway/commands/bar/font.c
@@ -10,12 +10,12 @@ struct cmd_results *bar_cmd_font(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "font", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	char *font = join_args(argv, argc);
 	free(config->current_bar->font);
 	config->current_bar->font = font;
 	wlr_log(WLR_DEBUG, "Settings font '%s' for bar: %s",
 			config->current_bar->font, config->current_bar->id);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/gaps.c b/sway/commands/bar/gaps.c
index f78f3742..fabe12fc 100644
--- a/sway/commands/bar/gaps.c
+++ b/sway/commands/bar/gaps.c
@@ -14,7 +14,7 @@ struct cmd_results *bar_cmd_gaps(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "bar gaps", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 
 	int top = 0, right = 0, bottom = 0, left = 0;
@@ -23,7 +23,7 @@ struct cmd_results *bar_cmd_gaps(int argc, char **argv) {
 		char *end;
 		int amount = strtol(argv[i], &end, 10);
 		if (strlen(end) && strcasecmp(end, "px") != 0) {
-			return cmd_results_new(CMD_INVALID, "bar gaps",
+			return cmd_results_new(CMD_INVALID,
 					"Expected 'bar [<bar-id>] gaps <all> | <horizonal> "
 					"<vertical> | <top> <right> <bottom> <left>'");
 		}
@@ -56,5 +56,5 @@ struct cmd_results *bar_cmd_gaps(int argc, char **argv) {
 		ipc_event_barconfig_update(config->current_bar);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/height.c b/sway/commands/bar/height.c
index 18258526..a2e72533 100644
--- a/sway/commands/bar/height.c
+++ b/sway/commands/bar/height.c
@@ -10,11 +10,11 @@ struct cmd_results *bar_cmd_height(int argc, char **argv) {
 	}
 	int height = atoi(argv[0]);
 	if (height < 0) {
-		return cmd_results_new(CMD_INVALID, "height",
+		return cmd_results_new(CMD_INVALID,
 				"Invalid height value: %s", argv[0]);
 	}
 	config->current_bar->height = height;
 	wlr_log(WLR_DEBUG, "Setting bar height to %d on bar: %s",
 			height, config->current_bar->id);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/hidden_state.c b/sway/commands/bar/hidden_state.c
index 79eaf01c..3364ce70 100644
--- a/sway/commands/bar/hidden_state.c
+++ b/sway/commands/bar/hidden_state.c
@@ -20,8 +20,7 @@ static struct cmd_results *bar_set_hidden_state(struct bar_config *bar,
 	} else if (strcasecmp("show", hidden_state) == 0) {
 		bar->hidden_state = strdup("show");
 	} else {
-		return cmd_results_new(CMD_INVALID, "hidden_state",
-				"Invalid value %s", hidden_state);
+		return cmd_results_new(CMD_INVALID, "Invalid value %s",	hidden_state);
 	}
 	if (strcmp(old_state, bar->hidden_state) != 0) {
 		if (!config->reading) {
@@ -44,7 +43,7 @@ struct cmd_results *bar_cmd_hidden_state(int argc, char **argv) {
 		return error;
 	}
 	if (config->reading && argc > 1) {
-		return cmd_results_new(CMD_INVALID, "hidden_state",
+		return cmd_results_new(CMD_INVALID,
 				"Unexpected value %s in config mode", argv[1]);
 	}
 
@@ -65,5 +64,5 @@ struct cmd_results *bar_cmd_hidden_state(int argc, char **argv) {
 			}
 		}
 	}
-	return error ? error : cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return error ? error : cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/icon_theme.c b/sway/commands/bar/icon_theme.c
index 9d3b6040..2d16f748 100644
--- a/sway/commands/bar/icon_theme.c
+++ b/sway/commands/bar/icon_theme.c
@@ -13,16 +13,16 @@ struct cmd_results *bar_cmd_icon_theme(int argc, char **argv) {
 	}
 
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "tray_padding", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 
 	wlr_log(WLR_DEBUG, "[Bar %s] Setting icon theme to %s",
 			config->current_bar->id, argv[0]);
 	free(config->current_bar->icon_theme);
 	config->current_bar->icon_theme = strdup(argv[0]);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 #else
-	return cmd_results_new(CMD_INVALID, "icon_theme",
+	return cmd_results_new(CMD_INVALID,
 			"Sway has been compiled without tray support");
 #endif
 }
diff --git a/sway/commands/bar/id.c b/sway/commands/bar/id.c
index 35509459..bef3023b 100644
--- a/sway/commands/bar/id.c
+++ b/sway/commands/bar/id.c
@@ -12,15 +12,15 @@ struct cmd_results *bar_cmd_id(int argc, char **argv) {
 	const char *name = argv[0];
 	const char *oldname = config->current_bar->id;
 	if (strcmp(name, oldname) == 0) {
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);  // NOP
+		return cmd_results_new(CMD_SUCCESS, NULL);  // NOP
 	} else if (strcmp(name, "id") == 0) {
-		return cmd_results_new(CMD_INVALID, "id", "id cannot be 'id'");
+		return cmd_results_new(CMD_INVALID, "id cannot be 'id'");
 	}
 	// check if id is used by a previously defined bar
 	for (int i = 0; i < config->bars->length; ++i) {
 		struct bar_config *find = config->bars->items[i];
 		if (strcmp(name, find->id) == 0 && config->current_bar != find) {
-			return cmd_results_new(CMD_FAILURE, "id",
+			return cmd_results_new(CMD_FAILURE,
 					"Id '%s' already defined for another bar. Id unchanged (%s).",
 					name, oldname);
 		}
@@ -31,5 +31,5 @@ struct cmd_results *bar_cmd_id(int argc, char **argv) {
 	// free old bar id
 	free(config->current_bar->id);
 	config->current_bar->id = strdup(name);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/mode.c b/sway/commands/bar/mode.c
index dcaf6da9..1698db8d 100644
--- a/sway/commands/bar/mode.c
+++ b/sway/commands/bar/mode.c
@@ -21,7 +21,7 @@ static struct cmd_results *bar_set_mode(struct bar_config *bar, const char *mode
 	} else if (strcasecmp("invisible", mode) == 0) {
 		bar->mode = strdup("invisible");
 	} else {
-		return cmd_results_new(CMD_INVALID, "mode", "Invalid value %s", mode);
+		return cmd_results_new(CMD_INVALID, "Invalid value %s", mode);
 	}
 
 	if (strcmp(old_mode, bar->mode) != 0) {
@@ -46,7 +46,7 @@ struct cmd_results *bar_cmd_mode(int argc, char **argv) {
 	}
 	if (config->reading && argc > 1) {
 		return cmd_results_new(CMD_INVALID,
-				"mode", "Unexpected value %s in config mode", argv[1]);
+				"Unexpected value %s in config mode", argv[1]);
 	}
 
 	const char *mode = argv[0];
@@ -66,5 +66,5 @@ struct cmd_results *bar_cmd_mode(int argc, char **argv) {
 			}
 		}
 	}
-	return error ? error : cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return error ? error : cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/modifier.c b/sway/commands/bar/modifier.c
index b5a16f45..0d28d6a2 100644
--- a/sway/commands/bar/modifier.c
+++ b/sway/commands/bar/modifier.c
@@ -11,7 +11,7 @@ struct cmd_results *bar_cmd_modifier(int argc, char **argv) {
 	}
 
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "modifier", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 
 	uint32_t mod = 0;
@@ -21,8 +21,8 @@ struct cmd_results *bar_cmd_modifier(int argc, char **argv) {
 		if ((tmp_mod = get_modifier_mask_by_name(split->items[i])) > 0) {
 			mod |= tmp_mod;
 		} else {
-			error = cmd_results_new(CMD_INVALID, "modifier",
-				"Unknown modifier '%s'", split->items[i]);
+			error = cmd_results_new(CMD_INVALID,
+				"Unknown modifier '%s'", (char *)split->items[i]);
 			list_free_items_and_destroy(split);
 			return error;
 		}
@@ -31,5 +31,5 @@ struct cmd_results *bar_cmd_modifier(int argc, char **argv) {
 	config->current_bar->modifier = mod;
 	wlr_log(WLR_DEBUG,
 			"Show/Hide the bar when pressing '%s' in hide mode.", argv[0]);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/output.c b/sway/commands/bar/output.c
index 930d779d..9ad10678 100644
--- a/sway/commands/bar/output.c
+++ b/sway/commands/bar/output.c
@@ -11,7 +11,7 @@ struct cmd_results *bar_cmd_output(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "output", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 
 	const char *output = argv[0];
@@ -45,5 +45,5 @@ struct cmd_results *bar_cmd_output(int argc, char **argv) {
 		wlr_log(WLR_DEBUG, "Adding bar: '%s' to output '%s'",
 				config->current_bar->id, output);
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/pango_markup.c b/sway/commands/bar/pango_markup.c
index d57cc45c..0ffa41d9 100644
--- a/sway/commands/bar/pango_markup.c
+++ b/sway/commands/bar/pango_markup.c
@@ -10,7 +10,7 @@ struct cmd_results *bar_cmd_pango_markup(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "pango_markup", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	config->current_bar->pango_markup 
 		= parse_boolean(argv[0], config->current_bar->pango_markup);
@@ -21,5 +21,5 @@ struct cmd_results *bar_cmd_pango_markup(int argc, char **argv) {
 		wlr_log(WLR_DEBUG, "Disabling pango markup for bar: %s",
 				config->current_bar->id);
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/position.c b/sway/commands/bar/position.c
index 2870f60f..2e3f79b4 100644
--- a/sway/commands/bar/position.c
+++ b/sway/commands/bar/position.c
@@ -10,7 +10,7 @@ struct cmd_results *bar_cmd_position(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "position", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	char *valid[] = { "top", "bottom" };
 	for (size_t i = 0; i < sizeof(valid) / sizeof(valid[0]); ++i) {
@@ -19,9 +19,8 @@ struct cmd_results *bar_cmd_position(int argc, char **argv) {
 					argv[0], config->current_bar->id);
 			free(config->current_bar->position);
 			config->current_bar->position = strdup(argv[0]);
-			return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+			return cmd_results_new(CMD_SUCCESS, NULL);
 		}
 	}
-	return cmd_results_new(CMD_INVALID,
-			"position", "Invalid value %s", argv[0]);
+	return cmd_results_new(CMD_INVALID, "Invalid value %s", argv[0]);
 }
diff --git a/sway/commands/bar/separator_symbol.c b/sway/commands/bar/separator_symbol.c
index 060b8f52..145cdea5 100644
--- a/sway/commands/bar/separator_symbol.c
+++ b/sway/commands/bar/separator_symbol.c
@@ -9,12 +9,11 @@ struct cmd_results *bar_cmd_separator_symbol(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE,
-				"separator_symbol", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	free(config->current_bar->separator_symbol);
 	config->current_bar->separator_symbol = strdup(argv[0]);
 	wlr_log(WLR_DEBUG, "Settings separator_symbol '%s' for bar: %s",
 			config->current_bar->separator_symbol, config->current_bar->id);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/status_command.c b/sway/commands/bar/status_command.c
index 490393f1..c379cc72 100644
--- a/sway/commands/bar/status_command.c
+++ b/sway/commands/bar/status_command.c
@@ -9,8 +9,7 @@ struct cmd_results *bar_cmd_status_command(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE,
-				"status_command", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	free(config->current_bar->status_command);
 	config->current_bar->status_command = NULL;
@@ -28,5 +27,5 @@ struct cmd_results *bar_cmd_status_command(int argc, char **argv) {
 		load_swaybar(config->current_bar);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/status_edge_padding.c b/sway/commands/bar/status_edge_padding.c
index f3b10631..565ab9a9 100644
--- a/sway/commands/bar/status_edge_padding.c
+++ b/sway/commands/bar/status_edge_padding.c
@@ -11,11 +11,11 @@ struct cmd_results *bar_cmd_status_edge_padding(int argc, char **argv) {
 	char *end;
 	int padding = strtol(argv[0], &end, 10);
 	if (strlen(end) || padding < 0) {
-		return cmd_results_new(CMD_INVALID, "status_edge_padding",
+		return cmd_results_new(CMD_INVALID,
 				"Padding must be a positive integer");
 	}
 	config->current_bar->status_edge_padding = padding;
 	wlr_log(WLR_DEBUG, "Status edge padding on bar %s: %d",
 			config->current_bar->id, config->current_bar->status_edge_padding);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/status_padding.c b/sway/commands/bar/status_padding.c
index 13b8eb6b..7a69a25d 100644
--- a/sway/commands/bar/status_padding.c
+++ b/sway/commands/bar/status_padding.c
@@ -11,11 +11,11 @@ struct cmd_results *bar_cmd_status_padding(int argc, char **argv) {
 	char *end;
 	int padding = strtol(argv[0], &end, 10);
 	if (strlen(end) || padding < 0) {
-		return cmd_results_new(CMD_INVALID, "status_padding",
+		return cmd_results_new(CMD_INVALID,
 				"Padding must be a positive integer");
 	}
 	config->current_bar->status_padding = padding;
 	wlr_log(WLR_DEBUG, "Status padding on bar %s: %d",
 			config->current_bar->id, config->current_bar->status_padding);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/strip_workspace_name.c b/sway/commands/bar/strip_workspace_name.c
index 79692f6e..b74afd6e 100644
--- a/sway/commands/bar/strip_workspace_name.c
+++ b/sway/commands/bar/strip_workspace_name.c
@@ -11,8 +11,7 @@ struct cmd_results *bar_cmd_strip_workspace_name(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE,
-				"strip_workspace_name", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 
 	config->current_bar->strip_workspace_name =
@@ -28,5 +27,5 @@ struct cmd_results *bar_cmd_strip_workspace_name(int argc, char **argv) {
 				config->current_bar->id);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/strip_workspace_numbers.c b/sway/commands/bar/strip_workspace_numbers.c
index b33d01e5..9c6ec228 100644
--- a/sway/commands/bar/strip_workspace_numbers.c
+++ b/sway/commands/bar/strip_workspace_numbers.c
@@ -11,8 +11,7 @@ struct cmd_results *bar_cmd_strip_workspace_numbers(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE,
-				"strip_workspace_numbers", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	
 	config->current_bar->strip_workspace_numbers =
@@ -28,5 +27,5 @@ struct cmd_results *bar_cmd_strip_workspace_numbers(int argc, char **argv) {
 				config->current_bar->id);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/swaybar_command.c b/sway/commands/bar/swaybar_command.c
index 04e78e77..6253e2b1 100644
--- a/sway/commands/bar/swaybar_command.c
+++ b/sway/commands/bar/swaybar_command.c
@@ -9,12 +9,11 @@ struct cmd_results *bar_cmd_swaybar_command(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE,
-				"swaybar_command", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	free(config->current_bar->swaybar_command);
 	config->current_bar->swaybar_command = join_args(argv, argc);
 	wlr_log(WLR_DEBUG, "Using custom swaybar command: %s",
 			config->current_bar->swaybar_command);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/tray_bindsym.c b/sway/commands/bar/tray_bindsym.c
index ad413446..4e57e35e 100644
--- a/sway/commands/bar/tray_bindsym.c
+++ b/sway/commands/bar/tray_bindsym.c
@@ -12,7 +12,7 @@ struct cmd_results *bar_cmd_tray_bindsym(int argc, char **argv) {
 	}
 
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "tray_bindsym", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 
 	int button = 0;
@@ -21,7 +21,7 @@ struct cmd_results *bar_cmd_tray_bindsym(int argc, char **argv) {
 		button = argv[0][strlen("button")] - '0';
 	}
 	if (button < 1 || button > 9) {
-		return cmd_results_new(CMD_FAILURE, "tray_bindsym",
+		return cmd_results_new(CMD_FAILURE,
 				"[Bar %s] Only buttons 1 to 9 are supported",
 				config->current_bar->id);
 	}
@@ -42,14 +42,14 @@ struct cmd_results *bar_cmd_tray_bindsym(int argc, char **argv) {
 			wlr_log(WLR_DEBUG, "[Bar %s] Binding button %d to %s",
 					config->current_bar->id, button, commands[i]);
 			config->current_bar->tray_bindings[button] = commands[i];
-			return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+			return cmd_results_new(CMD_SUCCESS, NULL);
 		}
 	}
 
-	return cmd_results_new(CMD_INVALID, "tray_bindsym",
+	return cmd_results_new(CMD_INVALID,
 			"[Bar %s] Invalid command %s", config->current_bar->id, argv[1]);
 #else
-	return cmd_results_new(CMD_INVALID, "tray_bindsym",
+	return cmd_results_new(CMD_INVALID,
 			"Sway has been compiled without tray support");
 #endif
 }
diff --git a/sway/commands/bar/tray_output.c b/sway/commands/bar/tray_output.c
index a1169c20..d45c09c6 100644
--- a/sway/commands/bar/tray_output.c
+++ b/sway/commands/bar/tray_output.c
@@ -14,7 +14,7 @@ struct cmd_results *bar_cmd_tray_output(int argc, char **argv) {
 	}
 
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "tray_output", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 
 	list_t *outputs = config->current_bar->tray_outputs;
@@ -34,9 +34,9 @@ struct cmd_results *bar_cmd_tray_output(int argc, char **argv) {
 	}
 	list_add(outputs, strdup(argv[0]));
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 #else
-	return cmd_results_new(CMD_INVALID, "tray_output",
+	return cmd_results_new(CMD_INVALID,
 			"Sway has been compiled without tray support");
 #endif
 }
diff --git a/sway/commands/bar/tray_padding.c b/sway/commands/bar/tray_padding.c
index eb795b00..1e8b294b 100644
--- a/sway/commands/bar/tray_padding.c
+++ b/sway/commands/bar/tray_padding.c
@@ -16,27 +16,27 @@ struct cmd_results *bar_cmd_tray_padding(int argc, char **argv) {
 	}
 
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "tray_padding", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	struct bar_config *bar = config->current_bar;
 
 	char *end;
 	int padding = strtol(argv[0], &end, 10);
 	if (padding < 0 || (*end != '\0' && strcasecmp(end, "px") != 0)) {
-		return cmd_results_new(CMD_INVALID, "tray_padding",
+		return cmd_results_new(CMD_INVALID,
 				"[Bar %s] Invalid tray padding value: %s", bar->id, argv[0]);
 	}
 
 	if (argc == 2 && strcasecmp(argv[1], "px") != 0) {
-		return cmd_results_new(CMD_INVALID, "tray_padding",
+		return cmd_results_new(CMD_INVALID,
 				"Expected 'tray_padding <px> [px]'");
 	}
 
 	wlr_log(WLR_DEBUG, "[Bar %s] Setting tray padding to %d", bar->id, padding);
 	config->current_bar->tray_padding = padding;
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 #else
-	return cmd_results_new(CMD_INVALID, "tray_padding",
+	return cmd_results_new(CMD_INVALID,
 			"Sway has been compiled without tray support");
 #endif
 }
diff --git a/sway/commands/bar/workspace_buttons.c b/sway/commands/bar/workspace_buttons.c
index cd001e20..773e6357 100644
--- a/sway/commands/bar/workspace_buttons.c
+++ b/sway/commands/bar/workspace_buttons.c
@@ -10,8 +10,7 @@ struct cmd_results *bar_cmd_workspace_buttons(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE,
-				"workspace_buttons", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	config->current_bar->workspace_buttons = 
 		parse_boolean(argv[0], config->current_bar->workspace_buttons);
@@ -22,5 +21,5 @@ struct cmd_results *bar_cmd_workspace_buttons(int argc, char **argv) {
 		wlr_log(WLR_DEBUG, "Disabling workspace buttons on bar: %s",
 				config->current_bar->id);
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bar/wrap_scroll.c b/sway/commands/bar/wrap_scroll.c
index 04a4e6b8..2f7bb090 100644
--- a/sway/commands/bar/wrap_scroll.c
+++ b/sway/commands/bar/wrap_scroll.c
@@ -10,7 +10,7 @@ struct cmd_results *bar_cmd_wrap_scroll(int argc, char **argv) {
 		return error;
 	}
 	if (!config->current_bar) {
-		return cmd_results_new(CMD_FAILURE, "wrap_scroll", "No bar defined.");
+		return cmd_results_new(CMD_FAILURE, "No bar defined.");
 	}
 	config->current_bar->wrap_scroll = 
 			parse_boolean(argv[0], config->current_bar->wrap_scroll);
@@ -21,5 +21,5 @@ struct cmd_results *bar_cmd_wrap_scroll(int argc, char **argv) {
 		wlr_log(WLR_DEBUG, "Disabling wrap scroll on bar: %s",
 				config->current_bar->id);
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/bind.c b/sway/commands/bind.c
index be47d412..b0493f7e 100644
--- a/sway/commands/bind.c
+++ b/sway/commands/bind.c
@@ -92,11 +92,11 @@ static struct cmd_results *identify_key(const char* name, bool first_key,
 		if (!button) {
 			if (message) {
 				struct cmd_results *error =
-					cmd_results_new(CMD_INVALID, "bindcode", message);
+					cmd_results_new(CMD_INVALID, message);
 				free(message);
 				return error;
 			} else {
-				return cmd_results_new(CMD_INVALID, "bindcode",
+				return cmd_results_new(CMD_INVALID,
 						"Unknown button code %s", name);
 			}
 		}
@@ -108,12 +108,11 @@ static struct cmd_results *identify_key(const char* name, bool first_key,
 		if (!button) {
 			if (message) {
 				struct cmd_results *error =
-					cmd_results_new(CMD_INVALID, "bindsym", message);
+					cmd_results_new(CMD_INVALID, message);
 				free(message);
 				return error;
 			} else if (!button) {
-				return cmd_results_new(CMD_INVALID, "bindsym",
-						"Unknown button %s", name);
+				return cmd_results_new(CMD_INVALID, "Unknown button %s", name);
 			}
 		}
 		*key_val = button;
@@ -133,10 +132,10 @@ static struct cmd_results *identify_key(const char* name, bool first_key,
 		xkb_keycode_t keycode = strtol(name, NULL, 10);
 		if (!xkb_keycode_is_legal_ext(keycode)) {
 			if (first_key) {
-				return cmd_results_new(CMD_INVALID, "bindcode",
+				return cmd_results_new(CMD_INVALID,
 						"Invalid keycode or button code '%s'", name);
 			} else {
-				return cmd_results_new(CMD_INVALID, "bindcode",
+				return cmd_results_new(CMD_INVALID,
 						"Invalid keycode '%s'", name);
 			}
 		}
@@ -148,7 +147,7 @@ static struct cmd_results *identify_key(const char* name, bool first_key,
 			uint32_t button = get_mouse_bindsym(name, &message);
 			if (message) {
 				struct cmd_results *error =
-					cmd_results_new(CMD_INVALID, "bindsym", message);
+					cmd_results_new(CMD_INVALID, message);
 				free(message);
 				return error;
 			} else if (button) {
@@ -162,11 +161,10 @@ static struct cmd_results *identify_key(const char* name, bool first_key,
 				XKB_KEYSYM_CASE_INSENSITIVE);
 		if (!keysym) {
 			if (first_key) {
-				return cmd_results_new(CMD_INVALID, "bindsym",
+				return cmd_results_new(CMD_INVALID,
 						"Unknown key or button '%s'", name);
 			} else {
-				return cmd_results_new(CMD_INVALID, "bindsym",
-					"Unknown key '%s'", name);
+				return cmd_results_new(CMD_INVALID, "Unknown key '%s'", name);
 			}
 		}
 		*key_val = keysym;
@@ -185,8 +183,7 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv,
 
 	struct sway_binding *binding = calloc(1, sizeof(struct sway_binding));
 	if (!binding) {
-		return cmd_results_new(CMD_FAILURE, bindtype,
-				"Unable to allocate binding");
+		return cmd_results_new(CMD_FAILURE, "Unable to allocate binding");
 	}
 	binding->input = strdup("*");
 	binding->keys = create_list();
@@ -229,7 +226,7 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv,
 
 	if (argc < 2) {
 		free_sway_binding(binding);
-		return cmd_results_new(CMD_FAILURE, bindtype,
+		return cmd_results_new(CMD_FAILURE,
 			"Invalid %s command "
 			"(expected at least 2 non-option arguments, got %d)", bindtype, argc);
 	}
@@ -259,7 +256,7 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv,
 		if (!key) {
 			free_sway_binding(binding);
 			list_free_items_and_destroy(split);
-			return cmd_results_new(CMD_FAILURE, bindtype,
+			return cmd_results_new(CMD_FAILURE,
 					"Unable to allocate binding key");
 		}
 		*key = key_val;
@@ -315,7 +312,7 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv,
 
 	wlr_log(WLR_DEBUG, "%s - Bound %s to command `%s` for device '%s'",
 		bindtype, argv[0], binding->command, binding->input);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *cmd_bindsym(int argc, char **argv) {
diff --git a/sway/commands/border.c b/sway/commands/border.c
index d51741d2..6be5b794 100644
--- a/sway/commands/border.c
+++ b/sway/commands/border.c
@@ -64,8 +64,7 @@ struct cmd_results *cmd_border(int argc, char **argv) {
 
 	struct sway_container *container = config->handler_context.container;
 	if (!container || !container->view) {
-		return cmd_results_new(CMD_INVALID, "border",
-				"Only views can have borders");
+		return cmd_results_new(CMD_INVALID, "Only views can have borders");
 	}
 	struct sway_view *view = container->view;
 
@@ -77,14 +76,14 @@ struct cmd_results *cmd_border(int argc, char **argv) {
 		set_border(container, B_PIXEL);
 	} else if (strcmp(argv[0], "csd") == 0) {
 		if (!view || !view->xdg_decoration) {
-			return cmd_results_new(CMD_INVALID, "border",
+			return cmd_results_new(CMD_INVALID,
 					"This window doesn't support client side decorations");
 		}
 		set_border(container, B_CSD);
 	} else if (strcmp(argv[0], "toggle") == 0) {
 		border_toggle(container);
 	} else {
-		return cmd_results_new(CMD_INVALID, "border",
+		return cmd_results_new(CMD_INVALID,
 				"Expected 'border <none|normal|pixel|csd|toggle>' "
 				"or 'border pixel <px>'");
 	}
@@ -98,5 +97,5 @@ struct cmd_results *cmd_border(int argc, char **argv) {
 
 	arrange_container(container);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/client.c b/sway/commands/client.c
index 746e8713..10bfa519 100644
--- a/sway/commands/client.c
+++ b/sway/commands/client.c
@@ -61,27 +61,27 @@ static struct cmd_results *handle_command(int argc, char **argv,
 	}
 
 	if (!parse_color_float(argv[0], class->border)) {
-		return cmd_results_new(CMD_INVALID, cmd_name,
+		return cmd_results_new(CMD_INVALID,
 				"Unable to parse border color '%s'", argv[0]);
 	}
 
 	if (!parse_color_float(argv[1], class->background)) {
-		return cmd_results_new(CMD_INVALID, cmd_name,
+		return cmd_results_new(CMD_INVALID,
 				"Unable to parse background color '%s'", argv[1]);
 	}
 
 	if (!parse_color_float(argv[2], class->text)) {
-		return cmd_results_new(CMD_INVALID, cmd_name,
+		return cmd_results_new(CMD_INVALID,
 				"Unable to parse text color '%s'", argv[2]);
 	}
 
 	if (!parse_color_float(argv[3], class->indicator)) {
-		return cmd_results_new(CMD_INVALID, cmd_name,
+		return cmd_results_new(CMD_INVALID,
 				"Unable to parse indicator color '%s'", argv[3]);
 	}
 
 	if (!parse_color_float(argv[4], class->child_border)) {
-		return cmd_results_new(CMD_INVALID, cmd_name,
+		return cmd_results_new(CMD_INVALID,
 				"Unable to parse child border color '%s'", argv[4]);
 	}
 
@@ -94,7 +94,7 @@ static struct cmd_results *handle_command(int argc, char **argv,
 		}
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *cmd_client_focused(int argc, char **argv) {
@@ -115,5 +115,5 @@ struct cmd_results *cmd_client_urgent(int argc, char **argv) {
 
 struct cmd_results *cmd_client_noop(int argc, char **argv) {
 	wlr_log(WLR_INFO, "Warning: %s is ignored by sway", argv[-1]);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/create_output.c b/sway/commands/create_output.c
index 3f870acb..9961c8fb 100644
--- a/sway/commands/create_output.c
+++ b/sway/commands/create_output.c
@@ -37,9 +37,9 @@ struct cmd_results *cmd_create_output(int argc, char **argv) {
 	wlr_multi_for_each_backend(server.backend, create_output, &done);
 
 	if (!done) {
-		return cmd_results_new(CMD_INVALID, "create_output",
+		return cmd_results_new(CMD_INVALID,
 				"Can only create outputs for Wayland or X11 backends");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/default_border.c b/sway/commands/default_border.c
index 2e356d3d..5c0fee3f 100644
--- a/sway/commands/default_border.c
+++ b/sway/commands/default_border.c
@@ -16,12 +16,12 @@ struct cmd_results *cmd_default_border(int argc, char **argv) {
 	} else if (strcmp(argv[0], "pixel") == 0) {
 		config->border = B_PIXEL;
 	} else {
-		return cmd_results_new(CMD_INVALID, "default_border",
+		return cmd_results_new(CMD_INVALID,
 				"Expected 'default_border <none|normal|pixel>' or 'default_border <normal|pixel> <px>'");
 	}
 	if (argc == 2) {
 		config->border_thickness = atoi(argv[1]);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/default_floating_border.c b/sway/commands/default_floating_border.c
index 1bfc24af..7e4edc36 100644
--- a/sway/commands/default_floating_border.c
+++ b/sway/commands/default_floating_border.c
@@ -17,7 +17,7 @@ struct cmd_results *cmd_default_floating_border(int argc, char **argv) {
 	} else if (strcmp(argv[0], "pixel") == 0) {
 		config->floating_border = B_PIXEL;
 	} else {
-		return cmd_results_new(CMD_INVALID, "default_floating_border",
+		return cmd_results_new(CMD_INVALID,
 				"Expected 'default_floating_border <none|normal|pixel>' "
 				"or 'default_floating_border <normal|pixel> <px>'");
 	}
@@ -25,5 +25,5 @@ struct cmd_results *cmd_default_floating_border(int argc, char **argv) {
 		config->floating_border_thickness = atoi(argv[1]);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/default_orientation.c b/sway/commands/default_orientation.c
index a5347ce2..fd42c167 100644
--- a/sway/commands/default_orientation.c
+++ b/sway/commands/default_orientation.c
@@ -14,8 +14,8 @@ struct cmd_results *cmd_default_orientation(int argc, char **argv) {
 	} else if (strcasecmp(argv[0], "auto") == 0) {
 		// Do nothing
 	} else {
-		return cmd_results_new(CMD_INVALID, "default_orientation",
+		return cmd_results_new(CMD_INVALID,
 				"Expected 'orientation <horizontal|vertical|auto>'");
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/exec.c b/sway/commands/exec.c
index 7fc54123..dc8d8aac 100644
--- a/sway/commands/exec.c
+++ b/sway/commands/exec.c
@@ -5,12 +5,12 @@
 #include "stringop.h"
 
 struct cmd_results *cmd_exec(int argc, char **argv) {
-	if (!config->active) return cmd_results_new(CMD_DEFER, "exec", NULL);
+	if (!config->active) return cmd_results_new(CMD_DEFER, NULL);
 	if (config->reloading) {
 		char *args = join_args(argv, argc);
 		wlr_log(WLR_DEBUG, "Ignoring 'exec %s' due to reload", args);
 		free(args);
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	}
 	return cmd_exec_always(argc, argv);
 }
diff --git a/sway/commands/exec_always.c b/sway/commands/exec_always.c
index 9ec28d81..1ed6c7e6 100644
--- a/sway/commands/exec_always.c
+++ b/sway/commands/exec_always.c
@@ -15,7 +15,9 @@
 
 struct cmd_results *cmd_exec_always(int argc, char **argv) {
 	struct cmd_results *error = NULL;
-	if (!config->active || config->validating) return cmd_results_new(CMD_DEFER, NULL, NULL);
+	if (!config->active || config->validating) {
+		return cmd_results_new(CMD_DEFER, NULL);
+	}
 	if ((error = checkarg(argc, argv[-1], EXPECTED_AT_LEAST, 1))) {
 		return error;
 	}
@@ -71,7 +73,7 @@ struct cmd_results *cmd_exec_always(int argc, char **argv) {
 	} else if (pid < 0) {
 		close(fd[0]);
 		close(fd[1]);
-		return cmd_results_new(CMD_FAILURE, argv[-1], "fork() failed");
+		return cmd_results_new(CMD_FAILURE, "fork() failed");
 	}
 	close(fd[1]); // close write
 	ssize_t s = 0;
@@ -85,9 +87,8 @@ struct cmd_results *cmd_exec_always(int argc, char **argv) {
 		wlr_log(WLR_DEBUG, "Child process created with pid %d", child);
 		root_record_workspace_pid(child);
 	} else {
-		return cmd_results_new(CMD_FAILURE, argv[-1],
-			"Second fork() failed");
+		return cmd_results_new(CMD_FAILURE, "Second fork() failed");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/exit.c b/sway/commands/exit.c
index d5353c20..10cde640 100644
--- a/sway/commands/exit.c
+++ b/sway/commands/exit.c
@@ -10,5 +10,5 @@ struct cmd_results *cmd_exit(int argc, char **argv) {
 		return error;
 	}
 	sway_terminate(0);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/floating.c b/sway/commands/floating.c
index 4b82921c..e95f3185 100644
--- a/sway/commands/floating.c
+++ b/sway/commands/floating.c
@@ -17,14 +17,13 @@ struct cmd_results *cmd_floating(int argc, char **argv) {
 		return error;
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "floating",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 	struct sway_container *container = config->handler_context.container;
 	struct sway_workspace *workspace = config->handler_context.workspace;
 	if (!container && workspace->tiling->length == 0) {
-		return cmd_results_new(CMD_INVALID, "floating",
-				"Can't float an empty workspace");
+		return cmd_results_new(CMD_INVALID, "Can't float an empty workspace");
 	}
 	if (!container) {
 		// Wrap the workspace's children in a container so we can float it
@@ -48,5 +47,5 @@ struct cmd_results *cmd_floating(int argc, char **argv) {
 
 	arrange_workspace(container->workspace);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/floating_minmax_size.c b/sway/commands/floating_minmax_size.c
index 0af78908..31c1e999 100644
--- a/sway/commands/floating_minmax_size.c
+++ b/sway/commands/floating_minmax_size.c
@@ -8,10 +8,10 @@
 #include "sway/commands.h"
 #include "log.h"
 
-static const char* min_usage =
+static const char min_usage[] =
 	"Expected 'floating_minimum_size <width> x <height>'";
 
-static const char* max_usage =
+static const char max_usage[] =
 	"Expected 'floating_maximum_size <width> x <height>'";
 
 static struct cmd_results *handle_command(int argc, char **argv, char *cmd_name,
@@ -39,7 +39,7 @@ static struct cmd_results *handle_command(int argc, char **argv, char *cmd_name,
 	*config_width = width;
 	*config_height = height;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *cmd_floating_minimum_size(int argc, char **argv) {
diff --git a/sway/commands/floating_modifier.c b/sway/commands/floating_modifier.c
index f5d2b3fe..3674971a 100644
--- a/sway/commands/floating_modifier.c
+++ b/sway/commands/floating_modifier.c
@@ -11,8 +11,7 @@ struct cmd_results *cmd_floating_modifier(int argc, char **argv) {
 
 	uint32_t mod = get_modifier_mask_by_name(argv[0]);
 	if (!mod) {
-		return cmd_results_new(CMD_INVALID, "floating_modifier",
-				"Invalid modifier");
+		return cmd_results_new(CMD_INVALID, "Invalid modifier");
 	}
 
 	if (argc == 1 || strcasecmp(argv[1], "normal") == 0) {
@@ -20,11 +19,11 @@ struct cmd_results *cmd_floating_modifier(int argc, char **argv) {
 	} else if (strcasecmp(argv[1], "inverse") == 0) {
 		config->floating_mod_inverse = true;
 	} else {
-		return cmd_results_new(CMD_INVALID, "floating_modifier",
+		return cmd_results_new(CMD_INVALID,
 				"Usage: floating_modifier <mod> [inverse|normal]");
 	}
 
 	config->floating_mod = mod;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/focus.c b/sway/commands/focus.c
index 97ffe91c..8564f3ff 100644
--- a/sway/commands/focus.c
+++ b/sway/commands/focus.c
@@ -179,17 +179,17 @@ static struct cmd_results *focus_mode(struct sway_workspace *ws,
 		seat_set_focus_container(seat, new_focus);
 		seat_consider_warp_to_focus(seat);
 	} else {
-		return cmd_results_new(CMD_FAILURE, "focus",
+		return cmd_results_new(CMD_FAILURE,
 				"Failed to find a %s container in workspace",
 				floating ? "floating" : "tiling");
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 static struct cmd_results *focus_output(struct sway_seat *seat,
 		int argc, char **argv) {
 	if (!argc) {
-		return cmd_results_new(CMD_INVALID, "focus",
+		return cmd_results_new(CMD_INVALID,
 			"Expected 'focus output <direction|name>'");
 	}
 	char *identifier = join_args(argv, argc);
@@ -199,7 +199,7 @@ static struct cmd_results *focus_output(struct sway_seat *seat,
 		enum wlr_direction direction;
 		if (!parse_direction(identifier, &direction)) {
 			free(identifier);
-			return cmd_results_new(CMD_INVALID, "focus",
+			return cmd_results_new(CMD_INVALID,
 				"There is no output with that name");
 		}
 		struct sway_workspace *ws = seat_get_focused_workspace(seat);
@@ -223,21 +223,21 @@ static struct cmd_results *focus_output(struct sway_seat *seat,
 		seat_consider_warp_to_focus(seat);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 static struct cmd_results *focus_parent(void) {
 	struct sway_seat *seat = config->handler_context.seat;
 	struct sway_container *con = config->handler_context.container;
 	if (!con || con->is_fullscreen) {
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	}
 	struct sway_node *parent = node_get_parent(&con->node);
 	if (parent) {
 		seat_set_focus(seat, parent);
 		seat_consider_warp_to_focus(seat);
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 static struct cmd_results *focus_child(void) {
@@ -248,15 +248,15 @@ static struct cmd_results *focus_child(void) {
 		seat_set_focus(seat, focus);
 		seat_consider_warp_to_focus(seat);
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *cmd_focus(int argc, char **argv) {
 	if (config->reading || !config->active) {
-		return cmd_results_new(CMD_DEFER, NULL, NULL);
+		return cmd_results_new(CMD_DEFER, NULL);
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "focus",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 	struct sway_node *node = config->handler_context.node;
@@ -264,7 +264,7 @@ struct cmd_results *cmd_focus(int argc, char **argv) {
 	struct sway_workspace *workspace = config->handler_context.workspace;
 	struct sway_seat *seat = config->handler_context.seat;
 	if (node->type < N_WORKSPACE) {
-		return cmd_results_new(CMD_FAILURE, "focus",
+		return cmd_results_new(CMD_FAILURE,
 			"Command 'focus' cannot be used above the workspace level");
 	}
 
@@ -274,7 +274,7 @@ struct cmd_results *cmd_focus(int argc, char **argv) {
 		}
 		seat_set_focus_container(seat, container);
 		seat_consider_warp_to_focus(seat);
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	}
 
 	if (strcmp(argv[0], "floating") == 0) {
@@ -300,7 +300,7 @@ struct cmd_results *cmd_focus(int argc, char **argv) {
 
 	enum wlr_direction direction = 0;
 	if (!parse_direction(argv[0], &direction)) {
-		return cmd_results_new(CMD_INVALID, "focus",
+		return cmd_results_new(CMD_INVALID,
 			"Expected 'focus <direction|parent|child|mode_toggle|floating|tiling>' "
 			"or 'focus output <direction|name>'");
 	}
@@ -310,14 +310,14 @@ struct cmd_results *cmd_focus(int argc, char **argv) {
 		struct sway_output *new_output =
 			output_get_in_direction(workspace->output, direction);
 		if (!new_output) {
-			return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+			return cmd_results_new(CMD_SUCCESS, NULL);
 		}
 
 		struct sway_node *node =
 			get_node_in_output_direction(new_output, direction);
 		seat_set_focus(seat, node);
 		seat_consider_warp_to_focus(seat);
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	}
 
 	struct sway_node *next_focus =
@@ -327,5 +327,5 @@ struct cmd_results *cmd_focus(int argc, char **argv) {
 		seat_consider_warp_to_focus(seat);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/focus_follows_mouse.c b/sway/commands/focus_follows_mouse.c
index d0d2cb8a..7afb5f62 100644
--- a/sway/commands/focus_follows_mouse.c
+++ b/sway/commands/focus_follows_mouse.c
@@ -14,8 +14,8 @@ struct cmd_results *cmd_focus_follows_mouse(int argc, char **argv) {
 	} else if(strcmp(argv[0], "always") == 0) {
 		config->focus_follows_mouse = FOLLOWS_ALWAYS;
 	} else {
-		return cmd_results_new(CMD_FAILURE, "focus_follows_mouse",
+		return cmd_results_new(CMD_FAILURE,
 				"Expected 'focus_follows_mouse no|yes|always'");
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/focus_on_window_activation.c b/sway/commands/focus_on_window_activation.c
index 1fb07918..2163fc59 100644
--- a/sway/commands/focus_on_window_activation.c
+++ b/sway/commands/focus_on_window_activation.c
@@ -16,10 +16,10 @@ struct cmd_results *cmd_focus_on_window_activation(int argc, char **argv) {
 	} else if (strcmp(argv[0], "none") == 0) {
 		config->focus_on_window_activation = FOWA_NONE;
 	} else {
-		return cmd_results_new(CMD_INVALID, "focus_on_window_activation",
+		return cmd_results_new(CMD_INVALID,
 				"Expected "
 				"'focus_on_window_activation smart|urgent|focus|none'");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/focus_wrapping.c b/sway/commands/focus_wrapping.c
index 562ee4f9..3a74a3ea 100644
--- a/sway/commands/focus_wrapping.c
+++ b/sway/commands/focus_wrapping.c
@@ -17,5 +17,5 @@ struct cmd_results *cmd_focus_wrapping(int argc, char **argv) {
 		config->focus_wrapping = WRAP_NO;
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/font.c b/sway/commands/font.c
index 3071ccd8..c54365b5 100644
--- a/sway/commands/font.c
+++ b/sway/commands/font.c
@@ -23,5 +23,5 @@ struct cmd_results *cmd_font(int argc, char **argv) {
 
 	free(font);
 	config_update_font_height(true);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/for_window.c b/sway/commands/for_window.c
index 7c0f7d7f..f151575e 100644
--- a/sway/commands/for_window.c
+++ b/sway/commands/for_window.c
@@ -14,7 +14,7 @@ struct cmd_results *cmd_for_window(int argc, char **argv) {
 	char *err_str = NULL;
 	struct criteria *criteria = criteria_parse(argv[0], &err_str);
 	if (!criteria) {
-		error = cmd_results_new(CMD_INVALID, "for_window", err_str);
+		error = cmd_results_new(CMD_INVALID, err_str);
 		free(err_str);
 		return error;
 	}
@@ -25,5 +25,5 @@ struct cmd_results *cmd_for_window(int argc, char **argv) {
 	list_add(config->criteria, criteria);
 	wlr_log(WLR_DEBUG, "for_window: '%s' -> '%s' added", criteria->raw, criteria->cmdlist);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/force_display_urgency_hint.c b/sway/commands/force_display_urgency_hint.c
index 5e5e2d55..3202fc43 100644
--- a/sway/commands/force_display_urgency_hint.c
+++ b/sway/commands/force_display_urgency_hint.c
@@ -12,12 +12,12 @@ struct cmd_results *cmd_force_display_urgency_hint(int argc, char **argv) {
 	int timeout = (int)strtol(argv[0], &err, 10);
 	if (*err) {
 		if (strcmp(err, "ms") != 0) {
-			return cmd_results_new(CMD_INVALID, "force_display_urgency_hint",
+			return cmd_results_new(CMD_INVALID,
 					"Expected 'force_display_urgency_hint <timeout> ms'");
 		}
 	}
 
 	config->urgent_timeout = timeout > 0 ? timeout : 0;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/force_focus_wrapping.c b/sway/commands/force_focus_wrapping.c
index 0892d9e9..e646ae9b 100644
--- a/sway/commands/force_focus_wrapping.c
+++ b/sway/commands/force_focus_wrapping.c
@@ -16,5 +16,5 @@ struct cmd_results *cmd_force_focus_wrapping(int argc, char **argv) {
 		config->focus_wrapping = WRAP_YES;
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/fullscreen.c b/sway/commands/fullscreen.c
index b78187d9..920b9bd0 100644
--- a/sway/commands/fullscreen.c
+++ b/sway/commands/fullscreen.c
@@ -13,14 +13,14 @@ struct cmd_results *cmd_fullscreen(int argc, char **argv) {
 		return error;
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_FAILURE, "fullscreen",
+		return cmd_results_new(CMD_FAILURE,
 				"Can't run this command while there's no outputs connected.");
 	}
 	struct sway_node *node = config->handler_context.node;
 	struct sway_container *container = config->handler_context.container;
 	struct sway_workspace *workspace = config->handler_context.workspace;
 	if (node->type == N_WORKSPACE && workspace->tiling->length == 0) {
-		return cmd_results_new(CMD_FAILURE, "fullscreen",
+		return cmd_results_new(CMD_FAILURE,
 				"Can't fullscreen an empty workspace");
 	}
 	if (node->type == N_WORKSPACE) {
@@ -38,5 +38,5 @@ struct cmd_results *cmd_fullscreen(int argc, char **argv) {
 	container_set_fullscreen(container, enable);
 	arrange_workspace(workspace);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/gaps.c b/sway/commands/gaps.c
index faaeab37..021df843 100644
--- a/sway/commands/gaps.c
+++ b/sway/commands/gaps.c
@@ -43,7 +43,7 @@ static void prevent_invalid_outer_gaps(void) {
 }
 
 // gaps inner|outer|horizontal|vertical|top|right|bottom|left <px>
-static const char *expected_defaults =
+static const char expected_defaults[] =
 	"'gaps inner|outer|horizontal|vertical|top|right|bottom|left <px>'";
 static struct cmd_results *gaps_set_defaults(int argc, char **argv) {
 	struct cmd_results *error = checkarg(argc, "gaps", EXPECTED_EQUAL_TO, 2);
@@ -54,8 +54,7 @@ static struct cmd_results *gaps_set_defaults(int argc, char **argv) {
 	char *end;
 	int amount = strtol(argv[1], &end, 10);
 	if (strlen(end) && strcasecmp(end, "px") != 0) {
-		return cmd_results_new(CMD_INVALID, "gaps",
-				"Expected %s", expected_defaults);
+		return cmd_results_new(CMD_INVALID, "Expected %s", expected_defaults);
 	}
 
 	bool valid = false;
@@ -85,12 +84,11 @@ static struct cmd_results *gaps_set_defaults(int argc, char **argv) {
 		}
 	}
 	if (!valid) {
-		return cmd_results_new(CMD_INVALID, "gaps",
-				"Expected %s", expected_defaults);
+		return cmd_results_new(CMD_INVALID, "Expected %s", expected_defaults);
 	}
 
 	prevent_invalid_outer_gaps();
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 static void apply_gaps_op(int *prop, enum gaps_op op, int amount) {
@@ -136,7 +134,7 @@ static void configure_gaps(struct sway_workspace *ws, void *_data) {
 
 // gaps inner|outer|horizontal|vertical|top|right|bottom|left current|all
 // set|plus|minus <px>
-static const char *expected_runtime = "'gaps inner|outer|horizontal|vertical|"
+static const char expected_runtime[] = "'gaps inner|outer|horizontal|vertical|"
 	"top|right|bottom|left current|all set|plus|minus <px>'";
 static struct cmd_results *gaps_set_runtime(int argc, char **argv) {
 	struct cmd_results *error = checkarg(argc, "gaps", EXPECTED_EQUAL_TO, 4);
@@ -144,7 +142,7 @@ static struct cmd_results *gaps_set_runtime(int argc, char **argv) {
 		return error;
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "gaps",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 
@@ -164,8 +162,7 @@ static struct cmd_results *gaps_set_runtime(int argc, char **argv) {
 	}
 	if (!data.inner && !data.outer.top && !data.outer.right &&
 			!data.outer.bottom && !data.outer.left) {
-		return cmd_results_new(CMD_INVALID, "gaps",
-				"Expected %s", expected_runtime);
+		return cmd_results_new(CMD_INVALID, "Expected %s", expected_runtime);
 	}
 
 	bool all;
@@ -174,8 +171,7 @@ static struct cmd_results *gaps_set_runtime(int argc, char **argv) {
 	} else if (strcasecmp(argv[1], "all") == 0) {
 		all = true;
 	} else {
-		return cmd_results_new(CMD_INVALID, "gaps",
-				"Expected %s", expected_runtime);
+		return cmd_results_new(CMD_INVALID, "Expected %s", expected_runtime);
 	}
 
 	if (strcasecmp(argv[2], "set") == 0) {
@@ -185,15 +181,13 @@ static struct cmd_results *gaps_set_runtime(int argc, char **argv) {
 	} else if (strcasecmp(argv[2], "minus") == 0) {
 		data.operation = GAPS_OP_SUBTRACT;
 	} else {
-		return cmd_results_new(CMD_INVALID, "gaps",
-				"Expected %s", expected_runtime);
+		return cmd_results_new(CMD_INVALID, "Expected %s", expected_runtime);
 	}
 
 	char *end;
 	data.amount = strtol(argv[3], &end, 10);
 	if (strlen(end) && strcasecmp(end, "px") != 0) {
-		return cmd_results_new(CMD_INVALID, "gaps",
-				"Expected %s", expected_runtime);
+		return cmd_results_new(CMD_INVALID, "Expected %s", expected_runtime);
 	}
 
 	if (all) {
@@ -202,7 +196,7 @@ static struct cmd_results *gaps_set_runtime(int argc, char **argv) {
 		configure_gaps(config->handler_context.workspace, &data);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 // gaps inner|outer|<dir>|<side> <px> - sets defaults for workspaces
@@ -224,9 +218,8 @@ struct cmd_results *cmd_gaps(int argc, char **argv) {
 		return gaps_set_runtime(argc, argv);
 	}
 	if (config_loading) {
-		return cmd_results_new(CMD_INVALID, "gaps",
-				"Expected %s", expected_defaults);
+		return cmd_results_new(CMD_INVALID, "Expected %s", expected_defaults);
 	}
-	return cmd_results_new(CMD_INVALID, "gaps",
-			"Expected %s or %s", expected_runtime, expected_defaults);
+	return cmd_results_new(CMD_INVALID, "Expected %s or %s",
+			expected_runtime, expected_defaults);
 }
diff --git a/sway/commands/hide_edge_borders.c b/sway/commands/hide_edge_borders.c
index ea261fb1..84a217b8 100644
--- a/sway/commands/hide_edge_borders.c
+++ b/sway/commands/hide_edge_borders.c
@@ -22,13 +22,12 @@ struct cmd_results *cmd_hide_edge_borders(int argc, char **argv) {
 	} else if (strcmp(argv[0], "smart_no_gaps") == 0) {
 		config->hide_edge_borders = E_SMART_NO_GAPS;
 	} else {
-		return cmd_results_new(CMD_INVALID, "hide_edge_borders",
-				"Expected 'hide_edge_borders "
+		return cmd_results_new(CMD_INVALID, "Expected 'hide_edge_borders "
 				"<none|vertical|horizontal|both|smart|smart_no_gaps>'");
 	}
 	config->saved_edge_borders = config->hide_edge_borders;
 
 	arrange_root();
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/include.c b/sway/commands/include.c
index 61f383bb..d1809856 100644
--- a/sway/commands/include.c
+++ b/sway/commands/include.c
@@ -9,9 +9,9 @@ struct cmd_results *cmd_include(int argc, char **argv) {
 
 	if (!load_include_configs(argv[0], config,
 				&config->swaynag_config_errors)) {
-		return cmd_results_new(CMD_INVALID, "include",
+		return cmd_results_new(CMD_INVALID,
 				"Failed to include sub configuration file: %s", argv[0]);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input.c b/sway/commands/input.c
index b5765c38..1f77507a 100644
--- a/sway/commands/input.c
+++ b/sway/commands/input.c
@@ -49,7 +49,7 @@ struct cmd_results *cmd_input(int argc, char **argv) {
 
 	config->handler_context.input_config = new_input_config(argv[0]);
 	if (!config->handler_context.input_config) {
-		return cmd_results_new(CMD_FAILURE, NULL, "Couldn't allocate config");
+		return cmd_results_new(CMD_FAILURE, "Couldn't allocate config");
 	}
 
 	struct cmd_results *res;
@@ -60,7 +60,7 @@ struct cmd_results *cmd_input(int argc, char **argv) {
 			res = config_subcommand(argv + 1, argc - 1,
 				input_config_handlers, sizeof(input_config_handlers));
 		} else {
-			res = cmd_results_new(CMD_FAILURE, "input",
+			res = cmd_results_new(CMD_FAILURE,
 				"Can only be used in config file.");
 		}
 	} else {
diff --git a/sway/commands/input/accel_profile.c b/sway/commands/input/accel_profile.c
index f7016790..08f324cc 100644
--- a/sway/commands/input/accel_profile.c
+++ b/sway/commands/input/accel_profile.c
@@ -11,8 +11,7 @@ struct cmd_results *input_cmd_accel_profile(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "accel_profile",
-				"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (strcasecmp(argv[0], "adaptive") == 0) {
@@ -20,9 +19,9 @@ struct cmd_results *input_cmd_accel_profile(int argc, char **argv) {
 	} else if (strcasecmp(argv[0], "flat") == 0) {
 		ic->accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT;
 	} else {
-		return cmd_results_new(CMD_INVALID, "accel_profile",
+		return cmd_results_new(CMD_INVALID,
 				"Expected 'accel_profile <adaptive|flat>'");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/click_method.c b/sway/commands/input/click_method.c
index 24777475..03fcb458 100644
--- a/sway/commands/input/click_method.c
+++ b/sway/commands/input/click_method.c
@@ -12,8 +12,7 @@ struct cmd_results *input_cmd_click_method(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "click_method",
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (strcasecmp(argv[0], "none") == 0) {
@@ -23,9 +22,9 @@ struct cmd_results *input_cmd_click_method(int argc, char **argv) {
 	} else if (strcasecmp(argv[0], "clickfinger") == 0) {
 		ic->click_method = LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER;
 	} else {
-		return cmd_results_new(CMD_INVALID, "click_method",
+		return cmd_results_new(CMD_INVALID,
 			"Expected 'click_method <none|button_areas|clickfinger'>");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/drag.c b/sway/commands/input/drag.c
index e325df29..062357d4 100644
--- a/sway/commands/input/drag.c
+++ b/sway/commands/input/drag.c
@@ -12,8 +12,7 @@ struct cmd_results *input_cmd_drag(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE,
-			"drag", "No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (parse_boolean(argv[0], true)) {
@@ -22,5 +21,5 @@ struct cmd_results *input_cmd_drag(int argc, char **argv) {
 		ic->drag = LIBINPUT_CONFIG_DRAG_DISABLED;
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/drag_lock.c b/sway/commands/input/drag_lock.c
index db5d5afa..24c548e2 100644
--- a/sway/commands/input/drag_lock.c
+++ b/sway/commands/input/drag_lock.c
@@ -12,8 +12,7 @@ struct cmd_results *input_cmd_drag_lock(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE,
-			"drag_lock", "No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (parse_boolean(argv[0], true)) {
@@ -22,5 +21,5 @@ struct cmd_results *input_cmd_drag_lock(int argc, char **argv) {
 		ic->drag_lock = LIBINPUT_CONFIG_DRAG_LOCK_DISABLED;
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/dwt.c b/sway/commands/input/dwt.c
index 0c3881dd..a7a4e494 100644
--- a/sway/commands/input/dwt.c
+++ b/sway/commands/input/dwt.c
@@ -12,7 +12,7 @@ struct cmd_results *input_cmd_dwt(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "dwt", "No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (parse_boolean(argv[0], true)) {
@@ -21,5 +21,5 @@ struct cmd_results *input_cmd_dwt(int argc, char **argv) {
 		ic->dwt = LIBINPUT_CONFIG_DWT_DISABLED;
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/events.c b/sway/commands/input/events.c
index 69f46269..2c6505d8 100644
--- a/sway/commands/input/events.c
+++ b/sway/commands/input/events.c
@@ -71,8 +71,7 @@ struct cmd_results *input_cmd_events(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "events",
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (strcasecmp(argv[0], "enabled") == 0) {
@@ -83,7 +82,7 @@ struct cmd_results *input_cmd_events(int argc, char **argv) {
 		ic->send_events =
 			LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE;
 	} else if (config->reading) {
-		return cmd_results_new(CMD_INVALID, "events",
+		return cmd_results_new(CMD_INVALID,
 			"Expected 'events <enabled|disabled|disabled_on_external_mouse>'");
 	} else if (strcasecmp(argv[0], "toggle") == 0) {
 		if (strcmp(ic->identifier, "*") == 0) {
@@ -97,10 +96,10 @@ struct cmd_results *input_cmd_events(int argc, char **argv) {
 			toggle_send_events(ic);
 		}
 	} else {
-		return cmd_results_new(CMD_INVALID, "events",
+		return cmd_results_new(CMD_INVALID,
 			"Expected 'events <enabled|disabled|disabled_on_external_mouse|"
 			"toggle>'");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/left_handed.c b/sway/commands/input/left_handed.c
index 2e0f757b..93d8d56d 100644
--- a/sway/commands/input/left_handed.c
+++ b/sway/commands/input/left_handed.c
@@ -12,11 +12,10 @@ struct cmd_results *input_cmd_left_handed(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "left_handed",
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->left_handed = parse_boolean(argv[0], true);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/map_from_region.c b/sway/commands/input/map_from_region.c
index 53608a67..de00b714 100644
--- a/sway/commands/input/map_from_region.c
+++ b/sway/commands/input/map_from_region.c
@@ -40,8 +40,7 @@ struct cmd_results *input_cmd_map_from_region(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "map_from_region",
-			"No input device defined");
+		return cmd_results_new(CMD_FAILURE, "No input device defined");
 	}
 
 	ic->mapped_from_region =
@@ -52,30 +51,27 @@ struct cmd_results *input_cmd_map_from_region(int argc, char **argv) {
 			&ic->mapped_from_region->y1, &mm1)) {
 		free(ic->mapped_from_region);
 		ic->mapped_from_region = NULL;
-		return cmd_results_new(CMD_FAILURE, "map_from_region",
-			"Invalid top-left coordinates");
+		return cmd_results_new(CMD_FAILURE, "Invalid top-left coordinates");
 	}
 	if (!parse_coords(argv[1], &ic->mapped_from_region->x2,
 			&ic->mapped_from_region->y2, &mm2)) {
 		free(ic->mapped_from_region);
 		ic->mapped_from_region = NULL;
-		return cmd_results_new(CMD_FAILURE, "map_from_region",
-			"Invalid bottom-right coordinates");
+		return cmd_results_new(CMD_FAILURE, "Invalid bottom-right coordinates");
 	}
 	if (ic->mapped_from_region->x1 > ic->mapped_from_region->x2 ||
 			ic->mapped_from_region->y1 > ic->mapped_from_region->y2) {
 		free(ic->mapped_from_region);
 		ic->mapped_from_region = NULL;
-		return cmd_results_new(CMD_FAILURE, "map_from_region",
-			"Invalid rectangle");
+		return cmd_results_new(CMD_FAILURE, "Invalid rectangle");
 	}
 	if (mm1 != mm2) {
 		free(ic->mapped_from_region);
 		ic->mapped_from_region = NULL;
-		return cmd_results_new(CMD_FAILURE, "map_from_region",
+		return cmd_results_new(CMD_FAILURE,
 			"Both coordinates must be in the same unit");
 	}
 	ic->mapped_from_region->mm = mm1;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/map_to_output.c b/sway/commands/input/map_to_output.c
index 8b16c557..6d623186 100644
--- a/sway/commands/input/map_to_output.c
+++ b/sway/commands/input/map_to_output.c
@@ -13,11 +13,10 @@ struct cmd_results *input_cmd_map_to_output(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "map_to_output",
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->mapped_to_output = strdup(argv[0]);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/middle_emulation.c b/sway/commands/input/middle_emulation.c
index 80d26838..9f32692e 100644
--- a/sway/commands/input/middle_emulation.c
+++ b/sway/commands/input/middle_emulation.c
@@ -12,8 +12,7 @@ struct cmd_results *input_cmd_middle_emulation(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "middle_emulation",
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (parse_boolean(argv[0], true)) {
@@ -22,5 +21,5 @@ struct cmd_results *input_cmd_middle_emulation(int argc, char **argv) {
 		ic->middle_emulation = LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED;
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/natural_scroll.c b/sway/commands/input/natural_scroll.c
index e2a93500..dec32a5b 100644
--- a/sway/commands/input/natural_scroll.c
+++ b/sway/commands/input/natural_scroll.c
@@ -12,11 +12,10 @@ struct cmd_results *input_cmd_natural_scroll(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "natural_scoll",
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->natural_scroll = parse_boolean(argv[0], true);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/pointer_accel.c b/sway/commands/input/pointer_accel.c
index efd81ee6..e214b32f 100644
--- a/sway/commands/input/pointer_accel.c
+++ b/sway/commands/input/pointer_accel.c
@@ -13,19 +13,17 @@ struct cmd_results *input_cmd_pointer_accel(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE,
-			"pointer_accel", "No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	float pointer_accel = parse_float(argv[0]);
 	if (isnan(pointer_accel)) {
-		return cmd_results_new(CMD_INVALID, "pointer_accel",
+		return cmd_results_new(CMD_INVALID,
 			"Invalid pointer accel; expected float.");
 	} if (pointer_accel < -1 || pointer_accel > 1) {
-		return cmd_results_new(CMD_INVALID, "pointer_accel",
-			"Input out of range [-1, 1]");
+		return cmd_results_new(CMD_INVALID, "Input out of range [-1, 1]");
 	}
 	ic->pointer_accel = pointer_accel;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/repeat_delay.c b/sway/commands/input/repeat_delay.c
index d94b3e4d..5b787fe6 100644
--- a/sway/commands/input/repeat_delay.c
+++ b/sway/commands/input/repeat_delay.c
@@ -11,16 +11,14 @@ struct cmd_results *input_cmd_repeat_delay(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE,
-			"repeat_delay", "No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	int repeat_delay = atoi(argv[0]);
 	if (repeat_delay < 0) {
-		return cmd_results_new(CMD_INVALID, "repeat_delay",
-			"Repeat delay cannot be negative");
+		return cmd_results_new(CMD_INVALID, "Repeat delay cannot be negative");
 	}
 	ic->repeat_delay = repeat_delay;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/repeat_rate.c b/sway/commands/input/repeat_rate.c
index ebec4cdb..79c5efe2 100644
--- a/sway/commands/input/repeat_rate.c
+++ b/sway/commands/input/repeat_rate.c
@@ -11,16 +11,14 @@ struct cmd_results *input_cmd_repeat_rate(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE,
-			"repeat_rate", "No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	int repeat_rate = atoi(argv[0]);
 	if (repeat_rate < 0) {
-		return cmd_results_new(CMD_INVALID, "repeat_rate",
-			"Repeat rate cannot be negative");
+		return cmd_results_new(CMD_INVALID, "Repeat rate cannot be negative");
 	}
 	ic->repeat_rate = repeat_rate;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/scroll_button.c b/sway/commands/input/scroll_button.c
index d82a1fe1..6b331419 100644
--- a/sway/commands/input/scroll_button.c
+++ b/sway/commands/input/scroll_button.c
@@ -10,30 +10,28 @@ struct cmd_results *input_cmd_scroll_button(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "scroll_button",
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (strcmp(*argv, "disable") == 0) {
 		ic->scroll_button = 0;
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	}
 
 	char *message = NULL;
 	uint32_t button = get_mouse_button(*argv, &message);
 	if (message) {
-		error = cmd_results_new(CMD_INVALID, "scroll_button", message);
+		error = cmd_results_new(CMD_INVALID, message);
 		free(message);
 		return error;
 	} else if (button == SWAY_SCROLL_UP || button == SWAY_SCROLL_DOWN
 			|| button == SWAY_SCROLL_LEFT || button == SWAY_SCROLL_RIGHT) {
-		return cmd_results_new(CMD_INVALID, "scroll_button",
+		return cmd_results_new(CMD_INVALID,
 				"X11 axis buttons are not supported for scroll_button");
 	} else if (!button) {
-		return cmd_results_new(CMD_INVALID, "scroll_button",
-				"Unknown button %s", *argv);
+		return cmd_results_new(CMD_INVALID, "Unknown button %s", *argv);
 	}
 	ic->scroll_button = button;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/scroll_factor.c b/sway/commands/input/scroll_factor.c
index 52d943b0..4b72b6fa 100644
--- a/sway/commands/input/scroll_factor.c
+++ b/sway/commands/input/scroll_factor.c
@@ -14,19 +14,18 @@ struct cmd_results *input_cmd_scroll_factor(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE,
-			"scroll_factor", "No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	float scroll_factor = parse_float(argv[0]);
 	if (isnan(scroll_factor)) {
-		return cmd_results_new(CMD_INVALID, "scroll_factor",
+		return cmd_results_new(CMD_INVALID,
 			"Invalid scroll factor; expected float.");
 	} else if (scroll_factor < 0) {
-		return cmd_results_new(CMD_INVALID, "scroll_factor",
+		return cmd_results_new(CMD_INVALID,
 			"Scroll factor cannot be negative.");
 	}
 	ic->scroll_factor = scroll_factor;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/scroll_method.c b/sway/commands/input/scroll_method.c
index c116b052..cd8b5f7a 100644
--- a/sway/commands/input/scroll_method.c
+++ b/sway/commands/input/scroll_method.c
@@ -11,8 +11,7 @@ struct cmd_results *input_cmd_scroll_method(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "scroll_method",
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (strcasecmp(argv[0], "none") == 0) {
@@ -24,9 +23,9 @@ struct cmd_results *input_cmd_scroll_method(int argc, char **argv) {
 	} else if (strcasecmp(argv[0], "on_button_down") == 0) {
 		ic->scroll_method = LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
 	} else {
-		return cmd_results_new(CMD_INVALID, "scroll_method",
+		return cmd_results_new(CMD_INVALID,
 			"Expected 'scroll_method <none|two_finger|edge|on_button_down>'");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/tap.c b/sway/commands/input/tap.c
index c455b696..443fd49d 100644
--- a/sway/commands/input/tap.c
+++ b/sway/commands/input/tap.c
@@ -13,7 +13,7 @@ struct cmd_results *input_cmd_tap(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "tap", "No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (parse_boolean(argv[0], true)) {
@@ -22,5 +22,5 @@ struct cmd_results *input_cmd_tap(int argc, char **argv) {
 		ic->tap = LIBINPUT_CONFIG_TAP_DISABLED;
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/tap_button_map.c b/sway/commands/input/tap_button_map.c
index dff2985b..77ac6de7 100644
--- a/sway/commands/input/tap_button_map.c
+++ b/sway/commands/input/tap_button_map.c
@@ -11,8 +11,7 @@ struct cmd_results *input_cmd_tap_button_map(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "tap_button_map",
-				"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	if (strcasecmp(argv[0], "lrm") == 0) {
@@ -20,9 +19,9 @@ struct cmd_results *input_cmd_tap_button_map(int argc, char **argv) {
 	} else if (strcasecmp(argv[0], "lmr") == 0) {
 		ic->tap_button_map = LIBINPUT_CONFIG_TAP_MAP_LMR;
 	} else {
-		return cmd_results_new(CMD_INVALID, "tap_button_map",
+		return cmd_results_new(CMD_INVALID,
 			"Expected 'tap_button_map <lrm|lmr>'");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/xkb_capslock.c b/sway/commands/input/xkb_capslock.c
index a939c72f..7ce98ebb 100644
--- a/sway/commands/input/xkb_capslock.c
+++ b/sway/commands/input/xkb_capslock.c
@@ -12,11 +12,10 @@ struct cmd_results *input_cmd_xkb_capslock(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "xkb_capslock", 
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->xkb_capslock = parse_boolean(argv[0], false);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/xkb_layout.c b/sway/commands/input/xkb_layout.c
index 43166401..c9200aa2 100644
--- a/sway/commands/input/xkb_layout.c
+++ b/sway/commands/input/xkb_layout.c
@@ -11,13 +11,12 @@ struct cmd_results *input_cmd_xkb_layout(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "xkb_layout",
-				"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->xkb_layout = strdup(argv[0]);
 
 	wlr_log(WLR_DEBUG, "set-xkb_layout for config: %s layout: %s",
 			ic->identifier, ic->xkb_layout);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/xkb_model.c b/sway/commands/input/xkb_model.c
index 066f632b..763ae80e 100644
--- a/sway/commands/input/xkb_model.c
+++ b/sway/commands/input/xkb_model.c
@@ -11,13 +11,12 @@ struct cmd_results *input_cmd_xkb_model(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "xkb_model",
-				"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->xkb_model = strdup(argv[0]);
 
 	wlr_log(WLR_DEBUG, "set-xkb_model for config: %s model: %s",
 			ic->identifier, ic->xkb_model);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/xkb_numlock.c b/sway/commands/input/xkb_numlock.c
index 2e962c5b..d5b75672 100644
--- a/sway/commands/input/xkb_numlock.c
+++ b/sway/commands/input/xkb_numlock.c
@@ -12,11 +12,10 @@ struct cmd_results *input_cmd_xkb_numlock(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "xkb_numlock", 
-			"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->xkb_numlock = parse_boolean(argv[0], false);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/xkb_options.c b/sway/commands/input/xkb_options.c
index 09dc4a5c..1ff6e680 100644
--- a/sway/commands/input/xkb_options.c
+++ b/sway/commands/input/xkb_options.c
@@ -11,13 +11,12 @@ struct cmd_results *input_cmd_xkb_options(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "xkb_options",
-				"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->xkb_options = strdup(argv[0]);
 
 	wlr_log(WLR_DEBUG, "set-xkb_options for config: %s options: %s",
 			ic->identifier, ic->xkb_options);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/xkb_rules.c b/sway/commands/input/xkb_rules.c
index d3e576e6..29172b24 100644
--- a/sway/commands/input/xkb_rules.c
+++ b/sway/commands/input/xkb_rules.c
@@ -11,13 +11,12 @@ struct cmd_results *input_cmd_xkb_rules(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "xkb_rules",
-				"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->xkb_rules = strdup(argv[0]);
 
 	wlr_log(WLR_DEBUG, "set-xkb_rules for config: %s rules: %s",
 			ic->identifier, ic->xkb_rules);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/xkb_variant.c b/sway/commands/input/xkb_variant.c
index 2d7581d1..9f3baed6 100644
--- a/sway/commands/input/xkb_variant.c
+++ b/sway/commands/input/xkb_variant.c
@@ -11,13 +11,12 @@ struct cmd_results *input_cmd_xkb_variant(int argc, char **argv) {
 	}
 	struct input_config *ic = config->handler_context.input_config;
 	if (!ic) {
-		return cmd_results_new(CMD_FAILURE, "xkb_variant",
-				"No input device defined.");
+		return cmd_results_new(CMD_FAILURE, "No input device defined.");
 	}
 
 	ic->xkb_variant = strdup(argv[0]);
 
 	wlr_log(WLR_DEBUG, "set-xkb_variant for config: %s variant: %s",
 			ic->identifier, ic->xkb_variant);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/kill.c b/sway/commands/kill.c
index f1d75b9a..41daeb4e 100644
--- a/sway/commands/kill.c
+++ b/sway/commands/kill.c
@@ -15,7 +15,7 @@ static void close_container_iterator(struct sway_container *con, void *data) {
 
 struct cmd_results *cmd_kill(int argc, char **argv) {
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "kill",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 	struct sway_container *con = config->handler_context.container;
@@ -28,5 +28,5 @@ struct cmd_results *cmd_kill(int argc, char **argv) {
 		workspace_for_each_container(ws, close_container_iterator, NULL);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/layout.c b/sway/commands/layout.c
index 8fde1776..2aca31dc 100644
--- a/sway/commands/layout.c
+++ b/sway/commands/layout.c
@@ -20,7 +20,7 @@ static enum sway_container_layout parse_layout_string(char *s) {
 	return L_NONE;
 }
 
-static const char* expected_syntax =
+static const char expected_syntax[] =
 	"Expected 'layout default|tabbed|stacking|splitv|splith' or "
 	"'layout toggle [split|all]' or "
 	"'layout toggle [split|tabbed|stacking|splitv|splith] [split|tabbed|stacking|splitv|splith]...'";
@@ -100,14 +100,14 @@ struct cmd_results *cmd_layout(int argc, char **argv) {
 		return error;
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "layout",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 	struct sway_container *container = config->handler_context.container;
 	struct sway_workspace *workspace = config->handler_context.workspace;
 
 	if (container && container_is_floating(container)) {
-		return cmd_results_new(CMD_FAILURE, "layout",
+		return cmd_results_new(CMD_FAILURE,
 				"Unable to change layout of floating windows");
 	}
 
@@ -133,7 +133,7 @@ struct cmd_results *cmd_layout(int argc, char **argv) {
 				workspace->layout, workspace->prev_split_layout);
 	}
 	if (new_layout == L_NONE) {
-		return cmd_results_new(CMD_INVALID, "layout", expected_syntax);
+		return cmd_results_new(CMD_INVALID, expected_syntax);
 	}
 	if (new_layout != old_layout) {
 		if (container) {
@@ -152,5 +152,5 @@ struct cmd_results *cmd_layout(int argc, char **argv) {
 		arrange_workspace(workspace);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/mark.c b/sway/commands/mark.c
index c76e1d63..aa5f185c 100644
--- a/sway/commands/mark.c
+++ b/sway/commands/mark.c
@@ -20,8 +20,7 @@ struct cmd_results *cmd_mark(int argc, char **argv) {
 	}
 	struct sway_container *container = config->handler_context.container;
 	if (!container) {
-		return cmd_results_new(CMD_INVALID, "mark",
-				"Only containers can have marks");
+		return cmd_results_new(CMD_INVALID, "Only containers can have marks");
 	}
 
 	bool add = false, toggle = false;
@@ -33,7 +32,7 @@ struct cmd_results *cmd_mark(int argc, char **argv) {
 		} else if (strcmp(*argv, "--toggle") == 0) {
 			toggle = true;
 		} else {
-			return cmd_results_new(CMD_INVALID, "mark",
+			return cmd_results_new(CMD_INVALID,
 					"Unrecognized argument '%s'", *argv);
 		}
 		++argv;
@@ -41,7 +40,7 @@ struct cmd_results *cmd_mark(int argc, char **argv) {
 	}
 
 	if (!argc) {
-		return cmd_results_new(CMD_INVALID, "mark",
+		return cmd_results_new(CMD_INVALID,
 				"Expected '[--add|--replace] [--toggle] <identifier>'");
 	}
 
@@ -65,5 +64,5 @@ struct cmd_results *cmd_mark(int argc, char **argv) {
 		view_execute_criteria(container->view);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/mode.c b/sway/commands/mode.c
index 189e3c1a..828d77e1 100644
--- a/sway/commands/mode.c
+++ b/sway/commands/mode.c
@@ -22,16 +22,14 @@ struct cmd_results *cmd_mode(int argc, char **argv) {
 	}
 
 	if (argc > 1 && !config->reading) {
-		return cmd_results_new(CMD_FAILURE,
-				"mode", "Can only be used in config file.");
+		return cmd_results_new(CMD_FAILURE, "Can only be used in config file");
 	}
 
 	bool pango = strcmp(*argv, "--pango_markup") == 0;
 	if (pango) {
 		argc--; argv++;
 		if (argc == 0) {
-			return cmd_results_new(CMD_FAILURE, "mode",
-					"Mode name is missing");
+			return cmd_results_new(CMD_FAILURE, "Mode name is missing");
 		}
 	}
 
@@ -50,8 +48,7 @@ struct cmd_results *cmd_mode(int argc, char **argv) {
 	if (!mode && argc > 1) {
 		mode = calloc(1, sizeof(struct sway_mode));
 		if (!mode) {
-			return cmd_results_new(CMD_FAILURE,
-					"mode", "Unable to allocate mode");
+			return cmd_results_new(CMD_FAILURE, "Unable to allocate mode");
 		}
 		mode->name = strdup(mode_name);
 		mode->keysym_bindings = create_list();
@@ -61,8 +58,7 @@ struct cmd_results *cmd_mode(int argc, char **argv) {
 		list_add(config->modes, mode);
 	}
 	if (!mode) {
-		error = cmd_results_new(CMD_INVALID,
-				"mode", "Unknown mode `%s'", mode_name);
+		error = cmd_results_new(CMD_INVALID, "Unknown mode `%s'", mode_name);
 		return error;
 	}
 	if ((config->reading && argc > 1) || (!config->reading && argc == 1)) {
@@ -75,7 +71,7 @@ struct cmd_results *cmd_mode(int argc, char **argv) {
 		// trigger IPC mode event
 		ipc_event_mode(config->current_mode->name,
 				config->current_mode->pango);
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	}
 
 	// Create binding
diff --git a/sway/commands/mouse_warping.c b/sway/commands/mouse_warping.c
index d067bc65..8b643f62 100644
--- a/sway/commands/mouse_warping.c
+++ b/sway/commands/mouse_warping.c
@@ -13,9 +13,9 @@ struct cmd_results *cmd_mouse_warping(int argc, char **argv) {
 	} else if (strcasecmp(argv[0], "none") == 0) {
 		config->mouse_warping = WARP_NO;
 	} else {
-		return cmd_results_new(CMD_FAILURE, "mouse_warping",
+		return cmd_results_new(CMD_FAILURE,
 				"Expected 'mouse_warping output|container|none'");
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
diff --git a/sway/commands/move.c b/sway/commands/move.c
index 72e177e8..d4fe2f01 100644
--- a/sway/commands/move.c
+++ b/sway/commands/move.c
@@ -21,7 +21,7 @@
 #include "log.h"
 #include "util.h"
 
-static const char *expected_syntax =
+static const char expected_syntax[] =
 	"Expected 'move <left|right|up|down> <[px] px>' or "
 	"'move [--no-auto-back-and-forth] <container|window> [to] workspace <name>' or "
 	"'move <container|window|workspace> [to] output <name|direction>' or "
@@ -378,7 +378,7 @@ static struct cmd_results *cmd_move_container(int argc, char **argv) {
 	struct sway_container *container = config->handler_context.container;
 	if (node->type == N_WORKSPACE) {
 		if (workspace->tiling->length == 0) {
-			return cmd_results_new(CMD_FAILURE, "move",
+			return cmd_results_new(CMD_FAILURE,
 					"Can't move an empty workspace");
 		}
 		container = workspace_wrap_children(workspace);
@@ -388,21 +388,21 @@ static struct cmd_results *cmd_move_container(int argc, char **argv) {
 	while (strcasecmp(argv[0], "--no-auto-back-and-forth") == 0) {
 		no_auto_back_and_forth = true;
 		if (--argc < 3) {
-			return cmd_results_new(CMD_INVALID, "move", expected_syntax);
+			return cmd_results_new(CMD_INVALID, expected_syntax);
 		}
 		++argv;
 	}
 	while (strcasecmp(argv[1], "--no-auto-back-and-forth") == 0) {
 		no_auto_back_and_forth = true;
 		if (--argc < 3) {
-			return cmd_results_new(CMD_INVALID, "move", expected_syntax);
+			return cmd_results_new(CMD_INVALID, expected_syntax);
 		}
 		argv++;
 	}
 
 	while (strcasecmp(argv[1], "to") == 0) {
 		if (--argc < 3) {
-			return cmd_results_new(CMD_INVALID, "move", expected_syntax);
+			return cmd_results_new(CMD_INVALID, expected_syntax);
 		}
 		argv++;
 	}
@@ -429,7 +429,7 @@ static struct cmd_results *cmd_move_container(int argc, char **argv) {
 				if (seat->prev_workspace_name) {
 					ws_name = strdup(seat->prev_workspace_name);
 				} else {
-					return cmd_results_new(CMD_FAILURE, "move",
+					return cmd_results_new(CMD_FAILURE,
 							"No workspace was previously active.");
 				}
 			}
@@ -437,11 +437,10 @@ static struct cmd_results *cmd_move_container(int argc, char **argv) {
 			if (strcasecmp(argv[2], "number") == 0) {
 				// move "container to workspace number x"
 				if (argc < 4) {
-					return cmd_results_new(CMD_INVALID, "move",
-							expected_syntax);
+					return cmd_results_new(CMD_INVALID, expected_syntax);
 				}
 				if (!isdigit(argv[3][0])) {
-					return cmd_results_new(CMD_INVALID, "move",
+					return cmd_results_new(CMD_INVALID,
 							"Invalid workspace number '%s'", argv[3]);
 				}
 				ws_name = join_args(argv + 3, argc - 3);
@@ -472,7 +471,7 @@ static struct cmd_results *cmd_move_container(int argc, char **argv) {
 					workspace_get_initial_output(ws_name);
 				if (old_output == new_output) {
 					free(ws_name);
-					return cmd_results_new(CMD_FAILURE, "move",
+					return cmd_results_new(CMD_FAILURE,
 							"Can't move sticky container to another workspace "
 							"on the same output");
 				}
@@ -486,24 +485,24 @@ static struct cmd_results *cmd_move_container(int argc, char **argv) {
 		struct sway_output *new_output = output_in_direction(argv[2],
 				old_output, container->x, container->y);
 		if (!new_output) {
-			return cmd_results_new(CMD_FAILURE, "move workspace",
+			return cmd_results_new(CMD_FAILURE,
 				"Can't find output with name/direction '%s'", argv[2]);
 		}
 		destination = seat_get_focus_inactive(seat, &new_output->node);
 	} else if (strcasecmp(argv[1], "mark") == 0) {
 		struct sway_container *dest_con = container_find_mark(argv[2]);
 		if (dest_con == NULL) {
-			return cmd_results_new(CMD_FAILURE, "move",
+			return cmd_results_new(CMD_FAILURE,
 					"Mark '%s' not found", argv[2]);
 		}
 		destination = &dest_con->node;
 	} else {
-		return cmd_results_new(CMD_INVALID, "move", expected_syntax);
+		return cmd_results_new(CMD_INVALID, expected_syntax);
 	}
 
 	if (container->is_sticky && old_output &&
 			node_has_ancestor(destination, &old_output->node)) {
-		return cmd_results_new(CMD_FAILURE, "move", "Can't move sticky "
+		return cmd_results_new(CMD_FAILURE, "Can't move sticky "
 				"container to another workspace on the same output");
 	}
 
@@ -569,7 +568,7 @@ static struct cmd_results *cmd_move_container(int argc, char **argv) {
 	}
 	arrange_node(node_get_parent(destination));
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 static void workspace_move_to_output(struct sway_workspace *workspace,
@@ -611,13 +610,13 @@ static struct cmd_results *cmd_move_workspace(int argc, char **argv) {
 
 	while (strcasecmp(argv[1], "to") == 0) {
 		if (--argc < 3) {
-			return cmd_results_new(CMD_INVALID, "move", expected_syntax);
+			return cmd_results_new(CMD_INVALID, expected_syntax);
 		}
 		++argv;
 	}
 
 	if (strcasecmp(argv[1], "output") != 0) {
-		return cmd_results_new(CMD_INVALID, "move", expected_syntax);
+		return cmd_results_new(CMD_INVALID, expected_syntax);
 	}
 
 	struct sway_workspace *workspace = config->handler_context.workspace;
@@ -627,7 +626,7 @@ static struct cmd_results *cmd_move_workspace(int argc, char **argv) {
 	struct sway_output *new_output = output_in_direction(argv[2],
 			old_output, center_x, center_y);
 	if (!new_output) {
-		return cmd_results_new(CMD_FAILURE, "move workspace",
+		return cmd_results_new(CMD_FAILURE,
 			"Can't find output with name/direction '%s'", argv[2]);
 	}
 	workspace_move_to_output(workspace, new_output);
@@ -635,7 +634,7 @@ static struct cmd_results *cmd_move_workspace(int argc, char **argv) {
 	arrange_output(old_output);
 	arrange_output(new_output);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 static struct cmd_results *cmd_move_in_direction(
@@ -645,19 +644,18 @@ static struct cmd_results *cmd_move_in_direction(
 		char *inv;
 		move_amt = (int)strtol(argv[1], &inv, 10);
 		if (*inv != '\0' && strcasecmp(inv, "px") != 0) {
-			return cmd_results_new(CMD_FAILURE, "move",
-					"Invalid distance specified");
+			return cmd_results_new(CMD_FAILURE, "Invalid distance specified");
 		}
 	}
 
 	struct sway_container *container = config->handler_context.container;
 	if (!container) {
-		return cmd_results_new(CMD_FAILURE, "move",
+		return cmd_results_new(CMD_FAILURE,
 				"Cannot move workspaces in a direction");
 	}
 	if (container_is_floating(container)) {
 		if (container->is_fullscreen) {
-			return cmd_results_new(CMD_FAILURE, "move",
+			return cmd_results_new(CMD_FAILURE,
 					"Cannot move fullscreen floating container");
 		}
 		double lx = container->x;
@@ -677,13 +675,13 @@ static struct cmd_results *cmd_move_in_direction(
 			break;
 		}
 		container_floating_move_to(container, lx, ly);
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	}
 	struct sway_workspace *old_ws = container->workspace;
 
 	if (!container_move_in_direction(container, direction)) {
 		// Container didn't move
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	}
 
 	struct sway_workspace *new_ws = container->workspace;
@@ -708,10 +706,10 @@ static struct cmd_results *cmd_move_in_direction(
 	}
 	container_end_mouse_operation(container);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
-static const char *expected_position_syntax =
+static const char expected_position_syntax[] =
 	"Expected 'move [absolute] position <x> [px] <y> [px]' or "
 	"'move [absolute] position center' or "
 	"'move position cursor|mouse|pointer'";
@@ -719,12 +717,11 @@ static const char *expected_position_syntax =
 static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
 	struct sway_container *container = config->handler_context.container;
 	if (!container || !container_is_floating(container)) {
-		return cmd_results_new(CMD_FAILURE, "move",
-				"Only floating containers "
+		return cmd_results_new(CMD_FAILURE, "Only floating containers "
 				"can be moved to an absolute position");
 	}
 	if (!argc) {
-		return cmd_results_new(CMD_FAILURE, "move", expected_position_syntax);
+		return cmd_results_new(CMD_FAILURE, expected_position_syntax);
 	}
 
 	bool absolute = false;
@@ -734,25 +731,25 @@ static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
 		++argv;
 	}
 	if (!argc) {
-		return cmd_results_new(CMD_FAILURE, "move", expected_position_syntax);
+		return cmd_results_new(CMD_FAILURE, expected_position_syntax);
 	}
 	if (strcmp(argv[0], "position") == 0) {
 		--argc;
 		++argv;
 	}
 	if (!argc) {
-		return cmd_results_new(CMD_FAILURE, "move", expected_position_syntax);
+		return cmd_results_new(CMD_FAILURE, expected_position_syntax);
 	}
 	if (strcmp(argv[0], "cursor") == 0 || strcmp(argv[0], "mouse") == 0 ||
 			strcmp(argv[0], "pointer") == 0) {
 		struct sway_seat *seat = config->handler_context.seat;
 		if (!seat->cursor) {
-			return cmd_results_new(CMD_FAILURE, "move", "No cursor device");
+			return cmd_results_new(CMD_FAILURE, "No cursor device");
 		}
 		double lx = seat->cursor->cursor->x - container->width / 2;
 		double ly = seat->cursor->cursor->y - container->height / 2;
 		container_floating_move_to(container, lx, ly);
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	} else if (strcmp(argv[0], "center") == 0) {
 		double lx, ly;
 		if (absolute) {
@@ -764,19 +761,18 @@ static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
 			ly = ws->y + (ws->height - container->height) / 2;
 		}
 		container_floating_move_to(container, lx, ly);
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	}
 
 	if (argc < 2) {
-		return cmd_results_new(CMD_FAILURE, "move", expected_position_syntax);
+		return cmd_results_new(CMD_FAILURE, expected_position_syntax);
 	}
 
 	double lx, ly;
 	char *inv;
 	lx = (double)strtol(argv[0], &inv, 10);
 	if (*inv != '\0' && strcasecmp(inv, "px") != 0) {
-		return cmd_results_new(CMD_FAILURE, "move",
-				"Invalid position specified");
+		return cmd_results_new(CMD_FAILURE, "Invalid position specified");
 	}
 	if (strcmp(argv[1], "px") == 0) {
 		--argc;
@@ -784,14 +780,13 @@ static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
 	}
 
 	if (argc > 3) {
-		return cmd_results_new(CMD_FAILURE, "move", expected_position_syntax);
+		return cmd_results_new(CMD_FAILURE, expected_position_syntax);
 	}
 
 	ly = (double)strtol(argv[1], &inv, 10);
 	if ((*inv != '\0' && strcasecmp(inv, "px") != 0) ||
 			(argc == 3 && strcmp(argv[2], "px") != 0)) {
-		return cmd_results_new(CMD_FAILURE, "move",
-				"Invalid position specified");
+		return cmd_results_new(CMD_FAILURE, "Invalid position specified");
 	}
 
 	if (!absolute) {
@@ -799,7 +794,7 @@ static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
 		ly += container->workspace->y;
 	}
 	container_floating_move_to(container, lx, ly);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 static struct cmd_results *cmd_move_to_scratchpad(void) {
@@ -807,7 +802,7 @@ static struct cmd_results *cmd_move_to_scratchpad(void) {
 	struct sway_container *con = config->handler_context.container;
 	struct sway_workspace *ws = config->handler_context.workspace;
 	if (node->type == N_WORKSPACE && ws->tiling->length == 0) {
-		return cmd_results_new(CMD_INVALID, "move",
+		return cmd_results_new(CMD_INVALID,
 				"Can't move an empty workspace to the scratchpad");
 	}
 	if (node->type == N_WORKSPACE) {
@@ -825,11 +820,11 @@ static struct cmd_results *cmd_move_to_scratchpad(void) {
 	}
 
 	if (con->scratchpad) {
-		return cmd_results_new(CMD_INVALID, "move",
+		return cmd_results_new(CMD_INVALID,
 				"Container is already in the scratchpad");
 	}
 	root_scratchpad_add_container(con);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *cmd_move(int argc, char **argv) {
@@ -838,7 +833,7 @@ struct cmd_results *cmd_move(int argc, char **argv) {
 		return error;
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "move",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 
@@ -867,7 +862,7 @@ struct cmd_results *cmd_move(int argc, char **argv) {
 	} else if (strcasecmp(argv[0], "absolute") == 0) {
 		return cmd_move_to_position(argc, argv);
 	} else {
-		return cmd_results_new(CMD_INVALID, "move", expected_syntax);
+		return cmd_results_new(CMD_INVALID, expected_syntax);
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/no_focus.c b/sway/commands/no_focus.c
index cb81a445..07e824a1 100644
--- a/sway/commands/no_focus.c
+++ b/sway/commands/no_focus.c
@@ -13,7 +13,7 @@ struct cmd_results *cmd_no_focus(int argc, char **argv) {
 	char *err_str = NULL;
 	struct criteria *criteria = criteria_parse(argv[0], &err_str);
 	if (!criteria) {
-		error = cmd_results_new(CMD_INVALID, "no_focus", err_str);
+		error = cmd_results_new(CMD_INVALID, err_str);
 		free(err_str);
 		return error;
 	}
@@ -21,5 +21,5 @@ struct cmd_results *cmd_no_focus(int argc, char **argv) {
 	criteria->type = CT_NO_FOCUS;
 	list_add(config->criteria, criteria);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/nop.c b/sway/commands/nop.c
index c12fe15a..973ade0e 100644
--- a/sway/commands/nop.c
+++ b/sway/commands/nop.c
@@ -1,5 +1,5 @@
 #include "sway/commands.h"
 
 struct cmd_results *cmd_nop(int argc, char **argv) {
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/opacity.c b/sway/commands/opacity.c
index 8c45b528..14a07051 100644
--- a/sway/commands/opacity.c
+++ b/sway/commands/opacity.c
@@ -22,18 +22,18 @@ struct cmd_results *cmd_opacity(int argc, char **argv) {
 	struct sway_container *con = config->handler_context.container;
 
 	if (con == NULL) {
-		return cmd_results_new(CMD_FAILURE, "opacity", "No current container");
+		return cmd_results_new(CMD_FAILURE, "No current container");
 	}
 
 	float opacity = 0.0f;
 
 	if (!parse_opacity(argv[0], &opacity)) {
-		return cmd_results_new(CMD_INVALID, "opacity <value>",
+		return cmd_results_new(CMD_INVALID,
 				"Invalid value (expected 0..1): %s", argv[0]);
 	}
 
 	con->alpha = opacity;
 	container_damage_whole(con);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/output.c b/sway/commands/output.c
index 00910843..73dbb723 100644
--- a/sway/commands/output.c
+++ b/sway/commands/output.c
@@ -43,7 +43,7 @@ struct cmd_results *cmd_output(int argc, char **argv) {
 			error = config_subcommand(argv, argc, output_handlers,
 					sizeof(output_handlers));
 		} else {
-			error = cmd_results_new(CMD_INVALID, "output",
+			error = cmd_results_new(CMD_INVALID,
 				"Invalid output subcommand: %s.", *argv);
 		}
 
@@ -68,7 +68,7 @@ struct cmd_results *cmd_output(int argc, char **argv) {
 		apply_output_config_to_outputs(output);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 
 fail:
 	config->handler_context.output_config = NULL;
diff --git a/sway/commands/output/background.c b/sway/commands/output/background.c
index 2cd1b76a..ae2f0640 100644
--- a/sway/commands/output/background.c
+++ b/sway/commands/output/background.c
@@ -20,14 +20,14 @@ static const char *bg_options[] = {
 
 struct cmd_results *output_cmd_background(int argc, char **argv) {
 	if (!config->handler_context.output_config) {
-		return cmd_results_new(CMD_FAILURE, "output", "Missing output config");
+		return cmd_results_new(CMD_FAILURE, "Missing output config");
 	}
 	if (!argc) {
-		return cmd_results_new(CMD_INVALID, "output",
+		return cmd_results_new(CMD_INVALID,
 			"Missing background file or color specification.");
 	}
 	if (argc < 2) {
-		return cmd_results_new(CMD_INVALID, "output",
+		return cmd_results_new(CMD_INVALID,
 			"Missing background scaling mode or `solid_color`.");
 	}
 
@@ -57,7 +57,7 @@ struct cmd_results *output_cmd_background(int argc, char **argv) {
 			}
 		}
 		if (!valid) {
-			return cmd_results_new(CMD_INVALID, "output",
+			return cmd_results_new(CMD_INVALID,
 				"Missing background scaling mode.");
 		}
 
@@ -70,7 +70,7 @@ struct cmd_results *output_cmd_background(int argc, char **argv) {
 			*ptr = '\\';
 		}
 		if (wordexp(src, &p, 0) != 0 || p.we_wordv[0] == NULL) {
-			struct cmd_results *cmd_res = cmd_results_new(CMD_INVALID, "output",
+			struct cmd_results *cmd_res = cmd_results_new(CMD_INVALID,
 				"Invalid syntax (%s)", src);
 			free(src);
 			wordfree(&p);
@@ -81,8 +81,7 @@ struct cmd_results *output_cmd_background(int argc, char **argv) {
 		wordfree(&p);
 		if (!src) {
 			wlr_log(WLR_ERROR, "Failed to duplicate string");
-			return cmd_results_new(CMD_FAILURE, "output",
-				"Unable to allocate resource");
+			return cmd_results_new(CMD_FAILURE, "Unable to allocate resource");
 		}
 
 		if (config->reading && *src != '/') {
@@ -92,7 +91,7 @@ struct cmd_results *output_cmd_background(int argc, char **argv) {
 			if (!conf) {
 				wlr_log(WLR_ERROR, "Failed to duplicate string");
 				free(src);
-				return cmd_results_new(CMD_FAILURE, "output",
+				return cmd_results_new(CMD_FAILURE,
 						"Unable to allocate resources");
 			}
 
@@ -103,7 +102,7 @@ struct cmd_results *output_cmd_background(int argc, char **argv) {
 				free(rel_path);
 				free(conf);
 				wlr_log(WLR_ERROR, "Unable to allocate memory");
-				return cmd_results_new(CMD_FAILURE, "output",
+				return cmd_results_new(CMD_FAILURE,
 						"Unable to allocate resources");
 			}
 
diff --git a/sway/commands/output/disable.c b/sway/commands/output/disable.c
index 65517c49..624f4056 100644
--- a/sway/commands/output/disable.c
+++ b/sway/commands/output/disable.c
@@ -3,7 +3,7 @@
 
 struct cmd_results *output_cmd_disable(int argc, char **argv) {
 	if (!config->handler_context.output_config) {
-		return cmd_results_new(CMD_FAILURE, "output", "Missing output config");
+		return cmd_results_new(CMD_FAILURE, "Missing output config");
 	}
 	config->handler_context.output_config->enabled = 0;
 
diff --git a/sway/commands/output/dpms.c b/sway/commands/output/dpms.c
index 3492061e..9d75a80e 100644
--- a/sway/commands/output/dpms.c
+++ b/sway/commands/output/dpms.c
@@ -4,10 +4,10 @@
 
 struct cmd_results *output_cmd_dpms(int argc, char **argv) {
 	if (!config->handler_context.output_config) {
-		return cmd_results_new(CMD_FAILURE, "output", "Missing output config");
+		return cmd_results_new(CMD_FAILURE, "Missing output config");
 	}
 	if (!argc) {
-		return cmd_results_new(CMD_INVALID, "output", "Missing dpms argument.");
+		return cmd_results_new(CMD_INVALID, "Missing dpms argument.");
 	}
 
 	if (parse_boolean(argv[0], true)) {
diff --git a/sway/commands/output/enable.c b/sway/commands/output/enable.c
index 8e3314f8..71a7d75a 100644
--- a/sway/commands/output/enable.c
+++ b/sway/commands/output/enable.c
@@ -3,7 +3,7 @@
 
 struct cmd_results *output_cmd_enable(int argc, char **argv) {
 	if (!config->handler_context.output_config) {
-		return cmd_results_new(CMD_FAILURE, "output", "Missing output config");
+		return cmd_results_new(CMD_FAILURE, "Missing output config");
 	}
 	config->handler_context.output_config->enabled = 1;
 
diff --git a/sway/commands/output/mode.c b/sway/commands/output/mode.c
index ef56ae9e..bcfce372 100644
--- a/sway/commands/output/mode.c
+++ b/sway/commands/output/mode.c
@@ -4,10 +4,10 @@
 
 struct cmd_results *output_cmd_mode(int argc, char **argv) {
 	if (!config->handler_context.output_config) {
-		return cmd_results_new(CMD_FAILURE, "output", "Missing output config");
+		return cmd_results_new(CMD_FAILURE, "Missing output config");
 	}
 	if (!argc) {
-		return cmd_results_new(CMD_INVALID, "output", "Missing mode argument.");
+		return cmd_results_new(CMD_INVALID, "Missing mode argument.");
 	}
 
 	struct output_config *output = config->handler_context.output_config;
@@ -17,20 +17,18 @@ struct cmd_results *output_cmd_mode(int argc, char **argv) {
 	if (*end) {
 		// Format is 1234x4321
 		if (*end != 'x') {
-			return cmd_results_new(CMD_INVALID, "output",
-				"Invalid mode width.");
+			return cmd_results_new(CMD_INVALID, "Invalid mode width.");
 		}
 		++end;
 		output->height = strtol(end, &end, 10);
 		if (*end) {
 			if (*end != '@') {
-				return cmd_results_new(CMD_INVALID, "output",
-					"Invalid mode height.");
+				return cmd_results_new(CMD_INVALID, "Invalid mode height.");
 			}
 			++end;
 			output->refresh_rate = strtof(end, &end);
 			if (strcasecmp("Hz", end) != 0) {
-				return cmd_results_new(CMD_INVALID, "output",
+				return cmd_results_new(CMD_INVALID,
 					"Invalid mode refresh rate.");
 			}
 		}
@@ -38,13 +36,12 @@ struct cmd_results *output_cmd_mode(int argc, char **argv) {
 		// Format is 1234 4321
 		argc--; argv++;
 		if (!argc) {
-			return cmd_results_new(CMD_INVALID, "output",
+			return cmd_results_new(CMD_INVALID,
 				"Missing mode argument (height).");
 		}
 		output->height = strtol(*argv, &end, 10);
 		if (*end) {
-			return cmd_results_new(CMD_INVALID, "output",
-				"Invalid mode height.");
+			return cmd_results_new(CMD_INVALID, "Invalid mode height.");
 		}
 	}
 
diff --git a/sway/commands/output/position.c b/sway/commands/output/position.c
index 449767b1..689462cb 100644
--- a/sway/commands/output/position.c
+++ b/sway/commands/output/position.c
@@ -4,11 +4,10 @@
 
 struct cmd_results *output_cmd_position(int argc, char **argv) {
 	if (!config->handler_context.output_config) {
-		return cmd_results_new(CMD_FAILURE, "output", "Missing output config");
+		return cmd_results_new(CMD_FAILURE, "Missing output config");
 	}
 	if (!argc) {
-		return cmd_results_new(CMD_INVALID, "output",
-			"Missing position argument.");
+		return cmd_results_new(CMD_INVALID, "Missing position argument.");
 	}
 
 	char *end;
@@ -16,26 +15,22 @@ struct cmd_results *output_cmd_position(int argc, char **argv) {
 	if (*end) {
 		// Format is 1234,4321
 		if (*end != ',') {
-			return cmd_results_new(CMD_INVALID, "output",
-				"Invalid position x.");
+			return cmd_results_new(CMD_INVALID, "Invalid position x.");
 		}
 		++end;
 		config->handler_context.output_config->y = strtol(end, &end, 10);
 		if (*end) {
-			return cmd_results_new(CMD_INVALID, "output",
-				"Invalid position y.");
+			return cmd_results_new(CMD_INVALID, "Invalid position y.");
 		}
 	} else {
 		// Format is 1234 4321 (legacy)
 		argc--; argv++;
 		if (!argc) {
-			return cmd_results_new(CMD_INVALID, "output",
-				"Missing position argument (y).");
+			return cmd_results_new(CMD_INVALID, "Missing position argument (y).");
 		}
 		config->handler_context.output_config->y = strtol(*argv, &end, 10);
 		if (*end) {
-			return cmd_results_new(CMD_INVALID, "output",
-				"Invalid position y.");
+			return cmd_results_new(CMD_INVALID, "Invalid position y.");
 		}
 	}
 
diff --git a/sway/commands/output/scale.c b/sway/commands/output/scale.c
index 0b4cc131..9398e06a 100644
--- a/sway/commands/output/scale.c
+++ b/sway/commands/output/scale.c
@@ -4,17 +4,16 @@
 
 struct cmd_results *output_cmd_scale(int argc, char **argv) {
 	if (!config->handler_context.output_config) {
-		return cmd_results_new(CMD_FAILURE, "output", "Missing output config");
+		return cmd_results_new(CMD_FAILURE, "Missing output config");
 	}
 	if (!argc) {
-		return cmd_results_new(CMD_INVALID, "output",
-			"Missing scale argument.");
+		return cmd_results_new(CMD_INVALID, "Missing scale argument.");
 	}
 
 	char *end;
 	config->handler_context.output_config->scale = strtof(*argv, &end);
 	if (*end) {
-		return cmd_results_new(CMD_INVALID, "output", "Invalid scale.");
+		return cmd_results_new(CMD_INVALID, "Invalid scale.");
 	}
 
 	config->handler_context.leftovers.argc = argc - 1;
diff --git a/sway/commands/output/transform.c b/sway/commands/output/transform.c
index ca6f73a4..8613a8e7 100644
--- a/sway/commands/output/transform.c
+++ b/sway/commands/output/transform.c
@@ -6,11 +6,10 @@
 
 struct cmd_results *output_cmd_transform(int argc, char **argv) {
 	if (!config->handler_context.output_config) {
-		return cmd_results_new(CMD_FAILURE, "output", "Missing output config");
+		return cmd_results_new(CMD_FAILURE, "Missing output config");
 	}
 	if (!argc) {
-		return cmd_results_new(CMD_INVALID, "output",
-			"Missing transform argument.");
+		return cmd_results_new(CMD_INVALID, "Missing transform argument.");
 	}
 	enum wl_output_transform transform;
 	if (strcmp(*argv, "normal") == 0) {
@@ -30,8 +29,7 @@ struct cmd_results *output_cmd_transform(int argc, char **argv) {
 	} else if (strcmp(*argv, "flipped-270") == 0) {
 		transform = WL_OUTPUT_TRANSFORM_FLIPPED_270;
 	} else {
-		return cmd_results_new(CMD_INVALID, "output",
-			"Invalid output transform.");
+		return cmd_results_new(CMD_INVALID, "Invalid output transform.");
 	}
 	struct output_config *output = config->handler_context.output_config;
 	config->handler_context.leftovers.argc = argc - 1;
@@ -42,12 +40,12 @@ struct cmd_results *output_cmd_transform(int argc, char **argv) {
 			return NULL;
 		}
 		if (strcmp(output->name, "*") == 0) {
-			return cmd_results_new(CMD_INVALID, "output",
+			return cmd_results_new(CMD_INVALID,
 				"Cannot apply relative transform to all outputs.");
 		}
 		struct sway_output *s_output = output_by_name_or_id(output->name);
 		if (s_output == NULL) {
-			return cmd_results_new(CMD_INVALID, "output",
+			return cmd_results_new(CMD_INVALID,
 				"Cannot apply relative transform to unknown output %s", output->name);
 		}
 		if (strcmp(argv[1], "anticlockwise") == 0) {
diff --git a/sway/commands/popup_during_fullscreen.c b/sway/commands/popup_during_fullscreen.c
index da1904b6..e8156262 100644
--- a/sway/commands/popup_during_fullscreen.c
+++ b/sway/commands/popup_during_fullscreen.c
@@ -16,10 +16,9 @@ struct cmd_results *cmd_popup_during_fullscreen(int argc, char **argv) {
 	} else if (strcasecmp(argv[0], "leave_fullscreen") == 0) {
 		config->popup_during_fullscreen = POPUP_LEAVE;
 	} else {
-		return cmd_results_new(CMD_INVALID, "popup_during_fullscreen",
-				"Expected "
+		return cmd_results_new(CMD_INVALID, "Expected "
 				"'popup_during_fullscreen smart|ignore|leave_fullscreen'");
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/reload.c b/sway/commands/reload.c
index 3ccbbf34..6e7772e9 100644
--- a/sway/commands/reload.c
+++ b/sway/commands/reload.c
@@ -56,13 +56,12 @@ struct cmd_results *cmd_reload(int argc, char **argv) {
 	}
 
 	if (!load_main_config(config->current_config_path, true, true)) {
-		return cmd_results_new(CMD_FAILURE, "reload",
-				"Error(s) reloading config.");
+		return cmd_results_new(CMD_FAILURE, "Error(s) reloading config.");
 	}
 
 	// The reload command frees a lot of stuff, so to avoid use-after-frees
 	// we schedule the reload to happen using an idle event.
 	wl_event_loop_add_idle(server.wl_event_loop, do_reload, NULL);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/rename.c b/sway/commands/rename.c
index 491dbab0..a68302c4 100644
--- a/sway/commands/rename.c
+++ b/sway/commands/rename.c
@@ -10,7 +10,7 @@
 #include "sway/tree/container.h"
 #include "sway/tree/workspace.h"
 
-static const char* expected_syntax =
+static const char expected_syntax[] =
 	"Expected 'rename workspace <old_name> to <new_name>' or "
 	"'rename workspace to <new_name>'";
 
@@ -20,11 +20,11 @@ struct cmd_results *cmd_rename(int argc, char **argv) {
 		return error;
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "rename",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 	if (strcasecmp(argv[0], "workspace") != 0) {
-		return cmd_results_new(CMD_INVALID, "rename", expected_syntax);
+		return cmd_results_new(CMD_INVALID, expected_syntax);
 	}
 
 	int argn = 1;
@@ -36,7 +36,7 @@ struct cmd_results *cmd_rename(int argc, char **argv) {
 	} else if (strcasecmp(argv[1], "number") == 0) {
 		// 'rename workspace number x to new_name'
 		if (!isdigit(argv[2][0])) {
-			return cmd_results_new(CMD_INVALID, "rename",
+			return cmd_results_new(CMD_INVALID,
 					"Invalid workspace number '%s'", argv[2]);
 		}
 		workspace = workspace_by_number(argv[2]);
@@ -56,14 +56,14 @@ struct cmd_results *cmd_rename(int argc, char **argv) {
 	}
 
 	if (!workspace) {
-		return cmd_results_new(CMD_INVALID, "rename",
+		return cmd_results_new(CMD_INVALID,
 				"There is no workspace with that name");
 	}
 
 	++argn; // move past "to"
 
 	if (argn >= argc) {
-		return cmd_results_new(CMD_INVALID, "rename", expected_syntax);
+		return cmd_results_new(CMD_INVALID, expected_syntax);
 	}
 
 	char *new_name = join_args(argv + argn, argc - argn);
@@ -75,17 +75,16 @@ struct cmd_results *cmd_rename(int argc, char **argv) {
 			strcasecmp(new_name, "current") == 0 ||
 			strcasecmp(new_name, "number") == 0) {
 		free(new_name);
-		return cmd_results_new(CMD_INVALID, "rename",
+		return cmd_results_new(CMD_INVALID,
 				"Cannot use special workspace name '%s'", argv[argn]);
 	}
 	struct sway_workspace *tmp_workspace = workspace_by_name(new_name);
 	if (tmp_workspace) {
 		free(new_name);
 		if (tmp_workspace == workspace) {
-			return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+			return cmd_results_new(CMD_SUCCESS, NULL);
 		} else {
-			return cmd_results_new(CMD_INVALID, "rename",
-					"Workspace already exists");
+			return cmd_results_new(CMD_INVALID, "Workspace already exists");
 		}
 	}
 
@@ -96,5 +95,5 @@ struct cmd_results *cmd_rename(int argc, char **argv) {
 	output_sort_workspaces(workspace->output);
 	ipc_event_workspace(NULL, workspace, "rename");
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/resize.c b/sway/commands/resize.c
index 0e849afc..fad1ecb1 100644
--- a/sway/commands/resize.c
+++ b/sway/commands/resize.c
@@ -340,8 +340,7 @@ static struct cmd_results *resize_adjust_floating(uint32_t axis,
 		grow_x = -grow_width;
 	}
 	if (grow_x == 0 && grow_y == 0) {
-		return cmd_results_new(CMD_INVALID, "resize",
-				"Cannot resize any further");
+		return cmd_results_new(CMD_INVALID, "Cannot resize any further");
 	}
 	con->x += grow_x;
 	con->y += grow_y;
@@ -355,7 +354,7 @@ static struct cmd_results *resize_adjust_floating(uint32_t axis,
 
 	arrange_container(con);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 /**
@@ -382,10 +381,9 @@ static struct cmd_results *resize_adjust_tiled(uint32_t axis,
 	double old_height = current->height;
 	resize_tiled(current, amount->amount, axis);
 	if (current->width == old_width && current->height == old_height) {
-		return cmd_results_new(CMD_INVALID, "resize",
-				"Cannot resize any further");
+		return cmd_results_new(CMD_INVALID, "Cannot resize any further");
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 /**
@@ -433,7 +431,7 @@ static struct cmd_results *resize_set_tiled(struct sway_container *con,
 		}
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 /**
@@ -491,7 +489,7 @@ static struct cmd_results *resize_set_floating(struct sway_container *con,
 
 	arrange_container(con);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 /**
@@ -506,7 +504,7 @@ static struct cmd_results *cmd_resize_set(int argc, char **argv) {
 	if ((error = checkarg(argc, "resize", EXPECTED_AT_LEAST, 1))) {
 		return error;
 	}
-	const char *usage = "Expected 'resize set [width] <width> [px|ppt]' or "
+	const char usage[] = "Expected 'resize set [width] <width> [px|ppt]' or "
 		"'resize set height <height> [px|ppt]' or "
 		"'resize set [width] <width> [px|ppt] [height] <height> [px|ppt]'";
 
@@ -520,7 +518,7 @@ static struct cmd_results *cmd_resize_set(int argc, char **argv) {
 		argc -= num_consumed_args;
 		argv += num_consumed_args;
 		if (width.unit == RESIZE_UNIT_INVALID) {
-			return cmd_results_new(CMD_INVALID, "resize set", usage);
+			return cmd_results_new(CMD_INVALID, usage);
 		}
 	}
 
@@ -534,7 +532,7 @@ static struct cmd_results *cmd_resize_set(int argc, char **argv) {
 		argc -= num_consumed_args;
 		argv += num_consumed_args;
 		if (width.unit == RESIZE_UNIT_INVALID) {
-			return cmd_results_new(CMD_INVALID, "resize set", usage);
+			return cmd_results_new(CMD_INVALID, usage);
 		}
 	}
 
@@ -562,11 +560,11 @@ static struct cmd_results *cmd_resize_set(int argc, char **argv) {
  */
 static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
 		int multiplier) {
-	const char *usage = "Expected 'resize grow|shrink <direction> "
+	const char usage[] = "Expected 'resize grow|shrink <direction> "
 		"[<amount> px|ppt [or <amount> px|ppt]]'";
 	uint32_t axis = parse_resize_axis(*argv);
 	if (axis == WLR_EDGE_NONE) {
-		return cmd_results_new(CMD_INVALID, "resize", usage);
+		return cmd_results_new(CMD_INVALID, usage);
 	}
 	--argc; ++argv;
 
@@ -577,7 +575,7 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
 		argc -= num_consumed_args;
 		argv += num_consumed_args;
 		if (first_amount.unit == RESIZE_UNIT_INVALID) {
-			return cmd_results_new(CMD_INVALID, "resize", usage);
+			return cmd_results_new(CMD_INVALID, usage);
 		}
 	} else {
 		first_amount.amount = 10;
@@ -587,7 +585,7 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
 	// "or"
 	if (argc) {
 		if (strcmp(*argv, "or") != 0) {
-			return cmd_results_new(CMD_INVALID, "resize", usage);
+			return cmd_results_new(CMD_INVALID, usage);
 		}
 		--argc; ++argv;
 	}
@@ -599,7 +597,7 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
 		argc -= num_consumed_args;
 		argv += num_consumed_args;
 		if (second_amount.unit == RESIZE_UNIT_INVALID) {
-			return cmd_results_new(CMD_INVALID, "resize", usage);
+			return cmd_results_new(CMD_INVALID, usage);
 		}
 	} else {
 		second_amount.unit = RESIZE_UNIT_INVALID;
@@ -621,7 +619,7 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
 		} else if (second_amount.unit == RESIZE_UNIT_DEFAULT) {
 			return resize_adjust_floating(axis, &second_amount);
 		} else {
-			return cmd_results_new(CMD_INVALID, "resize",
+			return cmd_results_new(CMD_INVALID,
 					"Floating containers cannot use ppt measurements");
 		}
 	}
@@ -642,12 +640,12 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
 
 struct cmd_results *cmd_resize(int argc, char **argv) {
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "resize",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 	struct sway_container *current = config->handler_context.container;
 	if (!current) {
-		return cmd_results_new(CMD_INVALID, "resize", "Cannot resize nothing");
+		return cmd_results_new(CMD_INVALID, "Cannot resize nothing");
 	}
 
 	struct cmd_results *error;
@@ -665,8 +663,8 @@ struct cmd_results *cmd_resize(int argc, char **argv) {
 		return cmd_resize_adjust(argc - 1, &argv[1], -1);
 	}
 
-	const char *usage = "Expected 'resize <shrink|grow> "
+	const char usage[] = "Expected 'resize <shrink|grow> "
 		"<width|height|up|down|left|right> [<amount>] [px|ppt]'";
 
-	return cmd_results_new(CMD_INVALID, "resize", usage);
+	return cmd_results_new(CMD_INVALID, usage);
 }
diff --git a/sway/commands/scratchpad.c b/sway/commands/scratchpad.c
index 6eab456d..1162d51f 100644
--- a/sway/commands/scratchpad.c
+++ b/sway/commands/scratchpad.c
@@ -84,16 +84,14 @@ struct cmd_results *cmd_scratchpad(int argc, char **argv) {
 		return error;
 	}
 	if (strcmp(argv[0], "show") != 0) {
-		return cmd_results_new(CMD_INVALID, "scratchpad",
-				"Expected 'scratchpad show'");
+		return cmd_results_new(CMD_INVALID, "Expected 'scratchpad show'");
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "scratchpad",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 	if (!root->scratchpad->length) {
-		return cmd_results_new(CMD_INVALID, "scratchpad",
-				"Scratchpad is empty");
+		return cmd_results_new(CMD_INVALID, "Scratchpad is empty");
 	}
 
 	if (config->handler_context.using_criteria) {
@@ -111,12 +109,12 @@ struct cmd_results *cmd_scratchpad(int argc, char **argv) {
 		// matches the criteria. If this container isn't in the scratchpad,
 		// we'll just silently return a success.
 		if (!con->scratchpad) {
-			return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+			return cmd_results_new(CMD_SUCCESS, NULL);
 		}
 		scratchpad_toggle_container(con);
 	} else {
 		scratchpad_toggle_auto();
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/seat.c b/sway/commands/seat.c
index b8db862b..69000b57 100644
--- a/sway/commands/seat.c
+++ b/sway/commands/seat.c
@@ -21,8 +21,7 @@ struct cmd_results *cmd_seat(int argc, char **argv) {
 
 	config->handler_context.seat_config = new_seat_config(argv[0]);
 	if (!config->handler_context.seat_config) {
-		return cmd_results_new(CMD_FAILURE, NULL,
-				"Couldn't allocate config");
+		return cmd_results_new(CMD_FAILURE, "Couldn't allocate config");
 	}
 
 	struct cmd_results *res = config_subcommand(argv + 1, argc - 1,
@@ -40,5 +39,5 @@ struct cmd_results *cmd_seat(int argc, char **argv) {
 	}
 
 	config->handler_context.seat_config = NULL;
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/seat/attach.c b/sway/commands/seat/attach.c
index 0fb17f1d..1e509a58 100644
--- a/sway/commands/seat/attach.c
+++ b/sway/commands/seat/attach.c
@@ -10,16 +10,16 @@ struct cmd_results *seat_cmd_attach(int argc, char **argv) {
 		return error;
 	}
 	if (!config->handler_context.seat_config) {
-		return cmd_results_new(CMD_FAILURE, "attach", "No seat defined");
+		return cmd_results_new(CMD_FAILURE, "No seat defined");
 	}
 
 	struct seat_attachment_config *attachment = seat_attachment_config_new();
 	if (!attachment) {
-		return cmd_results_new(CMD_FAILURE, "attach",
+		return cmd_results_new(CMD_FAILURE,
 				"Failed to allocate seat attachment config");
 	}
 	attachment->identifier = strdup(argv[0]);
 	list_add(config->handler_context.seat_config->attachments, attachment);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/seat/cursor.c b/sway/commands/seat/cursor.c
index 8d9e426a..4f805b22 100644
--- a/sway/commands/seat/cursor.c
+++ b/sway/commands/seat/cursor.c
@@ -10,7 +10,7 @@
 static struct cmd_results *press_or_release(struct sway_cursor *cursor,
 		char *action, char *button_str);
 
-static const char *expected_syntax = "Expected 'cursor <move> <x> <y>' or "
+static const char expected_syntax[] = "Expected 'cursor <move> <x> <y>' or "
 					"'cursor <set> <x> <y>' or "
 					"'curor <press|release> <button[1-9]|event-name-or-code>'";
 
@@ -18,7 +18,7 @@ static struct cmd_results *handle_command(struct sway_cursor *cursor,
 		int argc, char **argv) {
 	if (strcasecmp(argv[0], "move") == 0) {
 		if (argc < 3) {
-			return cmd_results_new(CMD_INVALID, "cursor", expected_syntax);
+			return cmd_results_new(CMD_INVALID, expected_syntax);
 		}
 		int delta_x = strtol(argv[1], NULL, 10);
 		int delta_y = strtol(argv[2], NULL, 10);
@@ -26,7 +26,7 @@ static struct cmd_results *handle_command(struct sway_cursor *cursor,
 		cursor_rebase(cursor);
 	} else if (strcasecmp(argv[0], "set") == 0) {
 		if (argc < 3) {
-			return cmd_results_new(CMD_INVALID, "cursor", expected_syntax);
+			return cmd_results_new(CMD_INVALID, expected_syntax);
 		}
 		// map absolute coords (0..1,0..1) to root container coords
 		float x = strtof(argv[1], NULL) / root->width;
@@ -35,7 +35,7 @@ static struct cmd_results *handle_command(struct sway_cursor *cursor,
 		cursor_rebase(cursor);
 	} else {
 		if (argc < 2) {
-			return cmd_results_new(CMD_INVALID, "cursor", expected_syntax);
+			return cmd_results_new(CMD_INVALID, expected_syntax);
 		}
 		struct cmd_results *error = NULL;
 		if ((error = press_or_release(cursor, argv[0], argv[1]))) {
@@ -43,7 +43,7 @@ static struct cmd_results *handle_command(struct sway_cursor *cursor,
 		}
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *seat_cmd_cursor(int argc, char **argv) {
@@ -53,18 +53,17 @@ struct cmd_results *seat_cmd_cursor(int argc, char **argv) {
 	}
 	struct seat_config *sc = config->handler_context.seat_config;
 	if (!sc) {
-		return cmd_results_new(CMD_FAILURE, "cursor", "No seat defined");
+		return cmd_results_new(CMD_FAILURE, "No seat defined");
 	}
 
 	if (config->reading || !config->active) {
-		return cmd_results_new(CMD_DEFER, NULL, NULL);
+		return cmd_results_new(CMD_DEFER, NULL);
 	}
 
 	if (strcmp(sc->name, "*") != 0) {
 		struct sway_seat *seat = input_manager_get_seat(sc->name);
 		if (!seat) {
-			return cmd_results_new(CMD_FAILURE, "cursor",
-					"Failed to get seat");
+			return cmd_results_new(CMD_FAILURE, "Failed to get seat");
 		}
 		error = handle_command(seat->cursor, argc, argv);
 	} else {
@@ -77,7 +76,7 @@ struct cmd_results *seat_cmd_cursor(int argc, char **argv) {
 		}
 	}
 
-	return error ? error : cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return error ? error : cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 static struct cmd_results *press_or_release(struct sway_cursor *cursor,
@@ -89,14 +88,14 @@ static struct cmd_results *press_or_release(struct sway_cursor *cursor,
 	} else if (strcasecmp(action, "release") == 0) {
 		state = WLR_BUTTON_RELEASED;
 	} else {
-		return cmd_results_new(CMD_INVALID, "cursor", expected_syntax);
+		return cmd_results_new(CMD_INVALID, expected_syntax);
 	}
 
 	char *message = NULL;
 	button = get_mouse_button(button_str, &message);
 	if (message) {
 		struct cmd_results *error =
-			cmd_results_new(CMD_INVALID, "cursor", message);
+			cmd_results_new(CMD_INVALID, message);
 		free(message);
 		return error;
 	} else if (button == SWAY_SCROLL_UP || button == SWAY_SCROLL_DOWN
@@ -117,11 +116,10 @@ static struct cmd_results *press_or_release(struct sway_cursor *cursor,
 			.delta_discrete = delta
 		};
 		dispatch_cursor_axis(cursor, &event);
-		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+		return cmd_results_new(CMD_SUCCESS, NULL);
 	} else if (!button) {
-		return cmd_results_new(CMD_INVALID, "curor",
-				"Unknown button %s", button_str);
+		return cmd_results_new(CMD_INVALID, "Unknown button %s", button_str);
 	}
 	dispatch_cursor_button(cursor, NULL, 0, button, state);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/seat/fallback.c b/sway/commands/seat/fallback.c
index 8f1ab12c..0330c353 100644
--- a/sway/commands/seat/fallback.c
+++ b/sway/commands/seat/fallback.c
@@ -8,11 +8,11 @@ struct cmd_results *seat_cmd_fallback(int argc, char **argv) {
 		return error;
 	}
 	if (!config->handler_context.seat_config) {
-		return cmd_results_new(CMD_FAILURE, "fallback", "No seat defined");
+		return cmd_results_new(CMD_FAILURE, "No seat defined");
 	}
 
 	config->handler_context.seat_config->fallback =
 		parse_boolean(argv[0], false);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/seat/hide_cursor.c b/sway/commands/seat/hide_cursor.c
index 343573b5..3bfce697 100644
--- a/sway/commands/seat/hide_cursor.c
+++ b/sway/commands/seat/hide_cursor.c
@@ -11,19 +11,18 @@ struct cmd_results *seat_cmd_hide_cursor(int argc, char **argv) {
 		return error;
 	}
 	if (!config->handler_context.seat_config) {
-		return cmd_results_new(CMD_FAILURE, "hide_cursor", "No seat defined");
+		return cmd_results_new(CMD_FAILURE, "No seat defined");
 	}
 
 	char *end;
 	int timeout = strtol(argv[0], &end, 10);
 	if (*end) {
-		return cmd_results_new(CMD_INVALID, "hide_cursor",
-				"Expected an integer timeout");
+		return cmd_results_new(CMD_INVALID, "Expected an integer timeout");
 	}
 	if (timeout < 100 && timeout != 0) {
 		timeout = 100;
 	}
 	config->handler_context.seat_config->hide_cursor_timeout = timeout;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/set.c b/sway/commands/set.c
index d912e4fd..c539e9fc 100644
--- a/sway/commands/set.c
+++ b/sway/commands/set.c
@@ -31,7 +31,7 @@ struct cmd_results *cmd_set(int argc, char **argv) {
 	}
 
 	if (argv[0][0] != '$') {
-		return cmd_results_new(CMD_INVALID, "set", "variable '%s' must start with $", argv[0]);
+		return cmd_results_new(CMD_INVALID, "variable '%s' must start with $", argv[0]);
 	}
 
 	struct sway_variable *var = NULL;
@@ -49,12 +49,12 @@ struct cmd_results *cmd_set(int argc, char **argv) {
 	} else {
 		var = malloc(sizeof(struct sway_variable));
 		if (!var) {
-			return cmd_results_new(CMD_FAILURE, "set", "Unable to allocate variable");
+			return cmd_results_new(CMD_FAILURE, "Unable to allocate variable");
 		}
 		var->name = strdup(argv[0]);
 		list_add(config->symbols, var);
 		list_qsort(config->symbols, compare_set_qsort);
 	}
 	var->value = join_args(argv + 1, argc - 1);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/show_marks.c b/sway/commands/show_marks.c
index 0baf6852..0d373b80 100644
--- a/sway/commands/show_marks.c
+++ b/sway/commands/show_marks.c
@@ -31,5 +31,5 @@ struct cmd_results *cmd_show_marks(int argc, char **argv) {
 		output_damage_whole(output);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/smart_borders.c b/sway/commands/smart_borders.c
index fcb4040e..be346106 100644
--- a/sway/commands/smart_borders.c
+++ b/sway/commands/smart_borders.c
@@ -21,5 +21,5 @@ struct cmd_results *cmd_smart_borders(int argc, char **argv) {
 
 	arrange_root();
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/smart_gaps.c b/sway/commands/smart_gaps.c
index f14b6760..b27f9ccd 100644
--- a/sway/commands/smart_gaps.c
+++ b/sway/commands/smart_gaps.c
@@ -19,5 +19,5 @@ struct cmd_results *cmd_smart_gaps(int argc, char **argv) {
 
 	arrange_root();
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/split.c b/sway/commands/split.c
index 84385fa9..ed370d26 100644
--- a/sway/commands/split.c
+++ b/sway/commands/split.c
@@ -24,7 +24,7 @@ static struct cmd_results *do_split(int layout) {
 
 	arrange_workspace(ws);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *cmd_split(int argc, char **argv) {
@@ -33,7 +33,7 @@ struct cmd_results *cmd_split(int argc, char **argv) {
 		return error;
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "split",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 	if (strcasecmp(argv[0], "v") == 0 || strcasecmp(argv[0], "vertical") == 0) {
@@ -51,10 +51,10 @@ struct cmd_results *cmd_split(int argc, char **argv) {
 			return do_split(L_VERT);
 		}
 	} else {
-		return cmd_results_new(CMD_FAILURE, "split",
+		return cmd_results_new(CMD_FAILURE,
 			"Invalid split command (expected either horizontal or vertical).");
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
 
 struct cmd_results *cmd_splitv(int argc, char **argv) {
diff --git a/sway/commands/sticky.c b/sway/commands/sticky.c
index 7cd358a4..6cac8a45 100644
--- a/sway/commands/sticky.c
+++ b/sway/commands/sticky.c
@@ -19,11 +19,11 @@ struct cmd_results *cmd_sticky(int argc, char **argv) {
 	struct sway_container *container = config->handler_context.container;
 	
 	if (container == NULL) {
-		return cmd_results_new(CMD_FAILURE, "sticky", "No current container");
+		return cmd_results_new(CMD_FAILURE, "No current container");
 	};
 	
 	if (!container_is_floating(container)) {
-		return cmd_results_new(CMD_FAILURE, "sticky",
+		return cmd_results_new(CMD_FAILURE,
 			"Can't set sticky on a tiled container");
 	}
 
@@ -43,5 +43,5 @@ struct cmd_results *cmd_sticky(int argc, char **argv) {
 		}
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/swap.c b/sway/commands/swap.c
index 670d6bca..a8beb162 100644
--- a/sway/commands/swap.c
+++ b/sway/commands/swap.c
@@ -11,7 +11,7 @@
 #include "sway/tree/workspace.h"
 #include "stringop.h"
 
-static const char* EXPECTED_SYNTAX =
+static const char expected_syntax[] =
 	"Expected 'swap container with id|con_id|mark <arg>'";
 
 static void swap_places(struct sway_container *con1,
@@ -171,12 +171,12 @@ struct cmd_results *cmd_swap(int argc, char **argv) {
 		return error;
 	}
 	if (!root->outputs->length) {
-		return cmd_results_new(CMD_INVALID, "swap",
+		return cmd_results_new(CMD_INVALID,
 				"Can't run this command while there's no outputs connected.");
 	}
 
 	if (strcasecmp(argv[0], "container") || strcasecmp(argv[1], "with")) {
-		return cmd_results_new(CMD_INVALID, "swap", EXPECTED_SYNTAX);
+		return cmd_results_new(CMD_INVALID, expected_syntax);
 	}
 
 	struct sway_container *current = config->handler_context.container;
@@ -195,21 +195,21 @@ struct cmd_results *cmd_swap(int argc, char **argv) {
 		other = root_find_container(test_mark, value);
 	} else {
 		free(value);
-		return cmd_results_new(CMD_INVALID, "swap", EXPECTED_SYNTAX);
+		return cmd_results_new(CMD_INVALID, expected_syntax);
 	}
 
 	if (!other) {
-		error = cmd_results_new(CMD_FAILURE, "swap",
+		error = cmd_results_new(CMD_FAILURE,
 				"Failed to find %s '%s'", argv[2], value);
 	} else if (!current) {
-		error = cmd_results_new(CMD_FAILURE, "swap",
+		error = cmd_results_new(CMD_FAILURE,
 				"Can only swap with containers and views");
 	} else if (container_has_ancestor(current, other)
 			|| container_has_ancestor(other, current)) {
-		error = cmd_results_new(CMD_FAILURE, "swap",
+		error = cmd_results_new(CMD_FAILURE,
 				"Cannot swap ancestor and descendant");
 	} else if (container_is_floating(current) || container_is_floating(other)) {
-		error = cmd_results_new(CMD_FAILURE, "swap",
+		error = cmd_results_new(CMD_FAILURE,
 				"Swapping with floating containers is not supported");
 	}
 
@@ -226,5 +226,5 @@ struct cmd_results *cmd_swap(int argc, char **argv) {
 		arrange_node(node_get_parent(&other->node));
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/swaybg_command.c b/sway/commands/swaybg_command.c
index b184b193..91294bf4 100644
--- a/sway/commands/swaybg_command.c
+++ b/sway/commands/swaybg_command.c
@@ -21,5 +21,5 @@ struct cmd_results *cmd_swaybg_command(int argc, char **argv) {
 		free(new_command);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/swaynag_command.c b/sway/commands/swaynag_command.c
index 5e54504c..b420f311 100644
--- a/sway/commands/swaynag_command.c
+++ b/sway/commands/swaynag_command.c
@@ -21,5 +21,5 @@ struct cmd_results *cmd_swaynag_command(int argc, char **argv) {
 		free(new_command);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/tiling_drag.c b/sway/commands/tiling_drag.c
index 92fbde7c..e95526e8 100644
--- a/sway/commands/tiling_drag.c
+++ b/sway/commands/tiling_drag.c
@@ -9,5 +9,5 @@ struct cmd_results *cmd_tiling_drag(int argc, char **argv) {
 
 	config->tiling_drag = parse_boolean(argv[0], config->tiling_drag);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/tiling_drag_threshold.c b/sway/commands/tiling_drag_threshold.c
index 6b0531c3..f1191118 100644
--- a/sway/commands/tiling_drag_threshold.c
+++ b/sway/commands/tiling_drag_threshold.c
@@ -12,11 +12,10 @@ struct cmd_results *cmd_tiling_drag_threshold(int argc, char **argv) {
 	char *inv;
 	int value = strtol(argv[0], &inv, 10);
 	if (*inv != '\0' || value < 0) {
-		return cmd_results_new(CMD_INVALID, "tiling_drag_threshold",
-			"Invalid threshold specified");
+		return cmd_results_new(CMD_INVALID, "Invalid threshold specified");
 	}
 
 	config->tiling_drag_threshold = value;
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/title_align.c b/sway/commands/title_align.c
index 82578186..c30355de 100644
--- a/sway/commands/title_align.c
+++ b/sway/commands/title_align.c
@@ -17,7 +17,7 @@ struct cmd_results *cmd_title_align(int argc, char **argv) {
 	} else if (strcmp(argv[0], "right") == 0) {
 		config->title_align = ALIGN_RIGHT;
 	} else {
-		return cmd_results_new(CMD_INVALID, "title_align",
+		return cmd_results_new(CMD_INVALID,
 				"Expected 'title_align left|center|right'");
 	}
 
@@ -26,5 +26,5 @@ struct cmd_results *cmd_title_align(int argc, char **argv) {
 		output_damage_whole(output);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/title_format.c b/sway/commands/title_format.c
index ef1c8935..9d312470 100644
--- a/sway/commands/title_format.c
+++ b/sway/commands/title_format.c
@@ -13,7 +13,7 @@ struct cmd_results *cmd_title_format(int argc, char **argv) {
 	}
 	struct sway_container *container = config->handler_context.container;
 	if (!container || !container->view) {
-		return cmd_results_new(CMD_INVALID, "title_format",
+		return cmd_results_new(CMD_INVALID,
 				"Only views can have a title_format");
 	}
 	struct sway_view *view = container->view;
@@ -24,5 +24,5 @@ struct cmd_results *cmd_title_format(int argc, char **argv) {
 	view->title_format = format;
 	view_update_title(view, true);
 	config_update_font_height(true);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/titlebar_border_thickness.c b/sway/commands/titlebar_border_thickness.c
index c1e9bb52..3c5e9ba1 100644
--- a/sway/commands/titlebar_border_thickness.c
+++ b/sway/commands/titlebar_border_thickness.c
@@ -14,8 +14,7 @@ struct cmd_results *cmd_titlebar_border_thickness(int argc, char **argv) {
 	char *inv;
 	int value = strtol(argv[0], &inv, 10);
 	if (*inv != '\0' || value < 0 || value > config->titlebar_v_padding) {
-		return cmd_results_new(CMD_FAILURE, "titlebar_border_thickness",
-			"Invalid size specified");
+		return cmd_results_new(CMD_FAILURE, "Invalid size specified");
 	}
 
 	config->titlebar_border_thickness = value;
@@ -26,5 +25,5 @@ struct cmd_results *cmd_titlebar_border_thickness(int argc, char **argv) {
 		output_damage_whole(output);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/titlebar_padding.c b/sway/commands/titlebar_padding.c
index a642e945..29ce59ff 100644
--- a/sway/commands/titlebar_padding.c
+++ b/sway/commands/titlebar_padding.c
@@ -14,8 +14,7 @@ struct cmd_results *cmd_titlebar_padding(int argc, char **argv) {
 	char *inv;
 	int h_value = strtol(argv[0], &inv, 10);
 	if (*inv != '\0' || h_value < 0 || h_value < config->titlebar_border_thickness) {
-		return cmd_results_new(CMD_FAILURE, "titlebar_padding",
-			"Invalid size specified");
+		return cmd_results_new(CMD_FAILURE, "Invalid size specified");
 	}
 
 	int v_value;
@@ -24,8 +23,7 @@ struct cmd_results *cmd_titlebar_padding(int argc, char **argv) {
 	} else {
 		v_value = strtol(argv[1], &inv, 10);
 		if (*inv != '\0' || v_value < 0 || v_value < config->titlebar_border_thickness) {
-			return cmd_results_new(CMD_FAILURE, "titlebar_padding",
-				"Invalid size specified");
+			return cmd_results_new(CMD_FAILURE, "Invalid size specified");
 		}
 	}
 
@@ -38,5 +36,5 @@ struct cmd_results *cmd_titlebar_padding(int argc, char **argv) {
 		output_damage_whole(output);
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/unmark.c b/sway/commands/unmark.c
index 98ac6ff2..cedfcfb2 100644
--- a/sway/commands/unmark.c
+++ b/sway/commands/unmark.c
@@ -49,5 +49,5 @@ struct cmd_results *cmd_unmark(int argc, char **argv) {
 	}
 	free(mark);
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/urgent.c b/sway/commands/urgent.c
index 4f283c55..3a2b00ed 100644
--- a/sway/commands/urgent.c
+++ b/sway/commands/urgent.c
@@ -13,11 +13,10 @@ struct cmd_results *cmd_urgent(int argc, char **argv) {
 	}
 	struct sway_container *container = config->handler_context.container;
 	if (!container) {
-		return cmd_results_new(CMD_FAILURE, "urgent", "No current container");
+		return cmd_results_new(CMD_FAILURE, "No current container");
 	}
 	if (!container->view) {
-		return cmd_results_new(CMD_INVALID, "urgent",
-				"Only views can be urgent");
+		return cmd_results_new(CMD_INVALID, "Only views can be urgent");
 	}
 	struct sway_view *view = container->view;
 
@@ -29,5 +28,5 @@ struct cmd_results *cmd_urgent(int argc, char **argv) {
 		view_set_urgent(view, parse_boolean(argv[0], view_is_urgent(view)));
 	}
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/workspace.c b/sway/commands/workspace.c
index 211b344d..6bfca506 100644
--- a/sway/commands/workspace.c
+++ b/sway/commands/workspace.c
@@ -58,7 +58,7 @@ static void prevent_invalid_outer_gaps(struct workspace_config *wsc) {
 
 static struct cmd_results *cmd_workspace_gaps(int argc, char **argv,
 		int gaps_location) {
-	const char *expected = "Expected 'workspace <name> gaps "
+	const char expected[] = "Expected 'workspace <name> gaps "
 		"inner|outer|horizontal|vertical|top|right|bottom|left <px>'";
 	struct cmd_results *error = NULL;
 	if ((error = checkarg(argc, "workspace", EXPECTED_EQUAL_TO,
@@ -69,7 +69,7 @@ static struct cmd_results *cmd_workspace_gaps(int argc, char **argv,
 	struct workspace_config *wsc = workspace_config_find_or_create(ws_name);
 	free(ws_name);
 	if (!wsc) {
-		return cmd_results_new(CMD_FAILURE, "workspace gaps",
+		return cmd_results_new(CMD_FAILURE,
 				"Unable to allocate workspace output");
 	}
 
@@ -77,7 +77,7 @@ static struct cmd_results *cmd_workspace_gaps(int argc, char **argv,
 	int amount = strtol(argv[gaps_location + 2], &end, 10);
 	if (strlen(end)) {
 		free(end);
-		return cmd_results_new(CMD_FAILURE, "workspace gaps", expected);
+		return cmd_results_new(CMD_FAILURE, expected);
 	}
 
 	bool valid = false;
@@ -108,7 +108,7 @@ static struct cmd_results *cmd_workspace_gaps(int argc, char **argv,
 		}
 	}
 	if (!valid) {
-		return cmd_results_new(CMD_INVALID, "workspace gaps", expected);
+		return cmd_results_new(CMD_INVALID, expected);
 	}
 
 	// Prevent invalid gaps configurations.
@@ -150,7 +150,7 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
 		struct workspace_config *wsc = workspace_config_find_or_create(ws_name);
 		free(ws_name);
 		if (!wsc) {
-			return cmd_results_new(CMD_FAILURE, "workspace output",
+			return cmd_results_new(CMD_FAILURE,
 					"Unable to allocate workspace output");
 		}
 		for (int i = output_location + 1; i < argc; ++i) {
@@ -162,9 +162,9 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
 		}
 	} else {
 		if (config->reading || !config->active) {
-			return cmd_results_new(CMD_DEFER, "workspace", NULL);
+			return cmd_results_new(CMD_DEFER, NULL);
 		} else if (!root->outputs->length) {
-			return cmd_results_new(CMD_INVALID, "workspace",
+			return cmd_results_new(CMD_INVALID,
 					"Can't run this command while there's no outputs connected.");
 		}
 
@@ -181,11 +181,11 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
 		struct sway_workspace *ws = NULL;
 		if (strcasecmp(argv[0], "number") == 0) {
 			if (argc < 2) {
-				return cmd_results_new(CMD_INVALID, "workspace",
+				return cmd_results_new(CMD_INVALID,
 						"Expected workspace number");
 			}
 			if (!isdigit(argv[1][0])) {
-				return cmd_results_new(CMD_INVALID, "workspace",
+				return cmd_results_new(CMD_INVALID,
 						"Invalid workspace number '%s'", argv[1]);
 			}
 			if (!(ws = workspace_by_number(argv[1]))) {
@@ -202,7 +202,7 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
 		} else if (strcasecmp(argv[0], "back_and_forth") == 0) {
 			struct sway_seat *seat = config->handler_context.seat;
 			if (!seat->prev_workspace_name) {
-				return cmd_results_new(CMD_INVALID, "workspace",
+				return cmd_results_new(CMD_INVALID,
 						"There is no previous workspace");
 			}
 			if (!(ws = workspace_by_name(argv[0]))) {
@@ -218,5 +218,5 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
 		workspace_switch(ws, no_auto_back_and_forth);
 		seat_consider_warp_to_focus(config->handler_context.seat);
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/workspace_layout.c b/sway/commands/workspace_layout.c
index ed4c0ee0..4fed05ab 100644
--- a/sway/commands/workspace_layout.c
+++ b/sway/commands/workspace_layout.c
@@ -14,8 +14,8 @@ struct cmd_results *cmd_workspace_layout(int argc, char **argv) {
 	} else if (strcasecmp(argv[0], "tabbed") == 0) {
 		config->default_layout = L_TABBED;
 	} else {
-		return cmd_results_new(CMD_INVALID, "workspace_layout",
+		return cmd_results_new(CMD_INVALID,
 				"Expected 'workspace_layout <default|stacking|tabbed>'");
 	}
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/ws_auto_back_and_forth.c b/sway/commands/ws_auto_back_and_forth.c
index adb851c2..e4411c8e 100644
--- a/sway/commands/ws_auto_back_and_forth.c
+++ b/sway/commands/ws_auto_back_and_forth.c
@@ -10,5 +10,5 @@ struct cmd_results *cmd_ws_auto_back_and_forth(int argc, char **argv) {
 	}
 	config->auto_back_and_forth = 
 		parse_boolean(argv[0], config->auto_back_and_forth);
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/xwayland.c b/sway/commands/xwayland.c
index 03a0121b..c3f73f67 100644
--- a/sway/commands/xwayland.c
+++ b/sway/commands/xwayland.c
@@ -17,5 +17,5 @@ struct cmd_results *cmd_xwayland(int argc, char **argv) {
 		"sway hasn't been built with Xwayland support");
 #endif
 
-	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	return cmd_results_new(CMD_SUCCESS, NULL);
 }