reftable: mark unused parameters in virtual functions

peff · gitster · commit 4695c3f3a9a4 · 2024-08-17T09:46:12.000-07:00
The reftable code uses a lot of virtual function pointers, but many of
the concrete implementations do not need all of the parameters.

For the most part these are obviously fine to just mark as UNUSED (e.g.,
the empty_iterator functions unsurprisingly do not do anything). Here
are a few cases where I dug a little deeper (but still ended up just
marking them UNUSED):

  - the iterator exclude_patterns is best-effort and optional (though it
    would be nice to support in the long run as an optimization)

  - ignoring the ref_store in many transaction functions is unexpected,
    but works because the ref_transaction itself carries enough
    information to do what we need.

  - ignoring "err" for in some cases (e.g., transaction abort) is OK
    because we do not return any errors. It is a little odd for
    reftable_be_create_reflog(), though, since we do return errors
    there. We should perhaps be creating string error messages at this
    layer, but I've punted on that for now.

Signed-off-by: Jeff King &lt;peff@peff.net&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
@@ -614,7 +614,7 @@ static struct reftable_ref_iterator *ref_iterator_for_stack(struct reftable_ref_
 
 static struct ref_iterator *reftable_be_iterator_begin(struct ref_store *ref_store,
 						       const char *prefix,
-						       const char **exclude_patterns,
+						       const char **exclude_patterns UNUSED,
 						       unsigned int flags)
 {
 	struct reftable_ref_iterator *main_iter, *worktree_iter;
@@ -1123,9 +1123,9 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store,
 	return ret;
 }
 
-static int reftable_be_transaction_abort(struct ref_store *ref_store,
+static int reftable_be_transaction_abort(struct ref_store *ref_store UNUSED,
 					 struct ref_transaction *transaction,
-					 struct strbuf *err)
+					 struct strbuf *err UNUSED)
 {
 	struct reftable_transaction_data *tx_data = transaction->backend_data;
 	free_transaction_data(tx_data);
@@ -1315,7 +1315,7 @@ static int write_transaction_table(struct reftable_writer *writer, void *cb_data
 	return ret;
 }
 
-static int reftable_be_transaction_finish(struct ref_store *ref_store,
+static int reftable_be_transaction_finish(struct ref_store *ref_store UNUSED,
 					  struct ref_transaction *transaction,
 					  struct strbuf *err)
 {
@@ -1726,8 +1726,8 @@ static int reftable_reflog_iterator_advance(struct ref_iterator *ref_iterator)
 	return ITER_OK;
 }
 
-static int reftable_reflog_iterator_peel(struct ref_iterator *ref_iterator,
-						 struct object_id *peeled)
+static int reftable_reflog_iterator_peel(struct ref_iterator *ref_iterator UNUSED,
+					 struct object_id *peeled UNUSED)
 {
 	BUG("reftable reflog iterator cannot be peeled");
 	return -1;
@@ -1988,7 +1988,7 @@ static int write_reflog_existence_table(struct reftable_writer *writer,
 
 static int reftable_be_create_reflog(struct ref_store *ref_store,
 				     const char *refname,
-				     struct strbuf *errmsg)
+				     struct strbuf *errmsg UNUSED)
 {
 	struct reftable_ref_store *refs =
 		reftable_be_downcast(ref_store, REF_STORE_WRITE, "create_reflog");
diff --git a/reftable/blocksource.c b/reftable/blocksource.c
@@ -13,14 +13,14 @@ license that can be found in the LICENSE file or at
 #include "reftable-blocksource.h"
 #include "reftable-error.h"
 
-static void strbuf_return_block(void *b, struct reftable_block *dest)
+static void strbuf_return_block(void *b UNUSED, struct reftable_block *dest)
 {
 	if (dest->len)
 		memset(dest->data, 0xff, dest->len);
 	reftable_free(dest->data);
 }
 
-static void strbuf_close(void *b)
+static void strbuf_close(void *b UNUSED)
 {
 }
 
@@ -55,7 +55,7 @@ void block_source_from_strbuf(struct reftable_block_source *bs,
 	bs->arg = buf;
 }
 
-static void malloc_return_block(void *b, struct reftable_block *dest)
+static void malloc_return_block(void *b UNUSED, struct reftable_block *dest)
 {
 	if (dest->len)
 		memset(dest->data, 0xff, dest->len);
@@ -85,7 +85,7 @@ static uint64_t file_size(void *b)
 	return ((struct file_block_source *)b)->size;
 }
 
-static void file_return_block(void *b, struct reftable_block *dest)
+static void file_return_block(void *b UNUSED, struct reftable_block *dest UNUSED)
 {
 }
 
diff --git a/reftable/generic.c b/reftable/generic.c
@@ -201,17 +201,19 @@ int iterator_next(struct reftable_iterator *it, struct reftable_record *rec)
 	return it->ops->next(it->iter_arg, rec);
 }
 
-static int empty_iterator_seek(void *arg, struct reftable_record *want)
+static int empty_iterator_seek(void *arg UNUSED,
+			       struct reftable_record *want UNUSED)
 {
 	return 0;
 }
 
-static int empty_iterator_next(void *arg, struct reftable_record *rec)
+static int empty_iterator_next(void *arg UNUSED,
+			       struct reftable_record *rec UNUSED)
 {
 	return 1;
 }
 
-static void empty_iterator_close(void *arg)
+static void empty_iterator_close(void *arg UNUSED)
 {
 }
 
diff --git a/reftable/iter.c b/reftable/iter.c
@@ -127,7 +127,8 @@ static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)
 	return 0;
 }
 
-static int indexed_table_ref_iter_seek(void *p, struct reftable_record *want)
+static int indexed_table_ref_iter_seek(void *p UNUSED,
+				       struct reftable_record *want UNUSED)
 {
 	BUG("seeking indexed table is not supported");
 	return -1;
diff --git a/reftable/record.c b/reftable/record.c
@@ -516,7 +516,7 @@ static void reftable_obj_record_release(void *rec)
 	memset(obj, 0, sizeof(struct reftable_obj_record));
 }
 
-static void reftable_obj_record_print(const void *rec, int hash_size)
+static void reftable_obj_record_print(const void *rec, int hash_size UNUSED)
 {
 	const struct reftable_obj_record *obj = rec;
 	char hex[GIT_MAX_HEXSZ + 1] = { 0 };
@@ -532,7 +532,7 @@ static void reftable_obj_record_print(const void *rec, int hash_size)
 }
 
 static void reftable_obj_record_copy_from(void *rec, const void *src_rec,
-					  int hash_size)
+					  int hash_size UNUSED)
 {
 	struct reftable_obj_record *obj = rec;
 	const struct reftable_obj_record *src =
@@ -559,7 +559,7 @@ static uint8_t reftable_obj_record_val_type(const void *rec)
 }
 
 static int reftable_obj_record_encode(const void *rec, struct string_view s,
-				      int hash_size)
+				      int hash_size UNUSED)
 {
 	const struct reftable_obj_record *r = rec;
 	struct string_view start = s;
@@ -594,7 +594,8 @@ static int reftable_obj_record_encode(const void *rec, struct string_view s,
 
 static int reftable_obj_record_decode(void *rec, struct strbuf key,
 				      uint8_t val_type, struct string_view in,
-				      int hash_size, struct strbuf *scratch UNUSED)
+				      int hash_size UNUSED,
+				      struct strbuf *scratch UNUSED)
 {
 	struct string_view start = in;
 	struct reftable_obj_record *r = rec;
@@ -647,12 +648,13 @@ static int reftable_obj_record_decode(void *rec, struct strbuf key,
 	return start.len - in.len;
 }
 
-static int not_a_deletion(const void *p)
+static int not_a_deletion(const void *p UNUSED)
 {
 	return 0;
 }
 
-static int reftable_obj_record_equal_void(const void *a, const void *b, int hash_size)
+static int reftable_obj_record_equal_void(const void *a, const void *b,
+					  int hash_size UNUSED)
 {
 	struct reftable_obj_record *ra = (struct reftable_obj_record *) a;
 	struct reftable_obj_record *rb = (struct reftable_obj_record *) b;
@@ -1066,7 +1068,7 @@ static void reftable_index_record_key(const void *r, struct strbuf *dest)
 }
 
 static void reftable_index_record_copy_from(void *rec, const void *src_rec,
-					    int hash_size)
+					    int hash_size UNUSED)
 {
 	struct reftable_index_record *dst = rec;
 	const struct reftable_index_record *src = src_rec;
@@ -1082,13 +1084,13 @@ static void reftable_index_record_release(void *rec)
 	strbuf_release(&idx->last_key);
 }
 
-static uint8_t reftable_index_record_val_type(const void *rec)
+static uint8_t reftable_index_record_val_type(const void *rec UNUSED)
 {
 	return 0;
 }
 
 static int reftable_index_record_encode(const void *rec, struct string_view out,
-					int hash_size)
+					int hash_size UNUSED)
 {
 	const struct reftable_index_record *r =
 		(const struct reftable_index_record *)rec;
@@ -1104,8 +1106,10 @@ static int reftable_index_record_encode(const void *rec, struct string_view out,
 }
 
 static int reftable_index_record_decode(void *rec, struct strbuf key,
-					uint8_t val_type, struct string_view in,
-					int hash_size, struct strbuf *scratch UNUSED)
+					uint8_t val_type UNUSED,
+					struct string_view in,
+					int hash_size UNUSED,
+					struct strbuf *scratch UNUSED)
 {
 	struct string_view start = in;
 	struct reftable_index_record *r = rec;
@@ -1122,7 +1126,8 @@ static int reftable_index_record_decode(void *rec, struct strbuf key,
 	return start.len - in.len;
 }
 
-static int reftable_index_record_equal(const void *a, const void *b, int hash_size)
+static int reftable_index_record_equal(const void *a, const void *b,
+				       int hash_size UNUSED)
 {
 	struct reftable_index_record *ia = (struct reftable_index_record *) a;
 	struct reftable_index_record *ib = (struct reftable_index_record *) b;
@@ -1137,7 +1142,7 @@ static int reftable_index_record_cmp(const void *_a, const void *_b)
 	return strbuf_cmp(&a->last_key, &b->last_key);
 }
 
-static void reftable_index_record_print(const void *rec, int hash_size)
+static void reftable_index_record_print(const void *rec, int hash_size UNUSED)
 {
 	const struct reftable_index_record *idx = rec;
 	/* TODO: escape null chars? */
diff --git a/reftable/stack_test.c b/reftable/stack_test.c
@@ -399,7 +399,7 @@ static void test_reftable_stack_auto_compaction_fails_gracefully(void)
 	clear_dir(dir);
 }
 
-static int write_error(struct reftable_writer *wr, void *arg)
+static int write_error(struct reftable_writer *wr UNUSED, void *arg)
 {
 	return *((int *)arg);
 }
@@ -816,7 +816,7 @@ static void test_reflog_expire(void)
 	reftable_log_record_release(&log);
 }
 
-static int write_nothing(struct reftable_writer *wr, void *arg)
+static int write_nothing(struct reftable_writer *wr, void *arg UNUSED)
 {
 	reftable_writer_set_limits(wr, 1, 1);
 	return 0;
diff --git a/reftable/test_framework.c b/reftable/test_framework.c
@@ -21,7 +21,7 @@ ssize_t strbuf_add_void(void *b, const void *data, size_t sz)
 	return sz;
 }
 
-int noop_flush(void *arg)
+int noop_flush(void *arg UNUSED)
 {
 	return 0;
 }
diff --git a/reftable/writer.c b/reftable/writer.c
@@ -544,7 +544,7 @@ static void write_object_record(void *void_arg, void *key)
 done:;
 }
 
-static void object_record_free(void *void_arg, void *key)
+static void object_record_free(void *void_arg UNUSED, void *key)
 {
 	struct obj_index_tree_node *entry = key;
 
diff --git a/t/unit-tests/t-reftable-merged.c b/t/unit-tests/t-reftable-merged.c
@@ -22,7 +22,7 @@ static ssize_t strbuf_add_void(void *b, const void *data, const size_t sz)
 	return sz;
 }
 
-static int noop_flush(void *arg)
+static int noop_flush(void *arg UNUSED)
 {
 	return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -614,7 +614,7 @@ static struct reftable_ref_iterator *ref_iterator_for_stack(struct reftable_ref_`
`614`	`614`
`615`	`615`	`static struct ref_iterator reftable_be_iterator_begin(struct ref_store ref_store,`
`616`	`616`	`const char *prefix,`
`617`		`- const char **exclude_patterns,`
	`617`	`+ const char **exclude_patterns UNUSED,`
`618`	`618`	`unsigned int flags)`
`619`	`619`	`{`
`620`	`620`	`struct reftable_ref_iterator main_iter, worktree_iter;`
`@@ -1123,9 +1123,9 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store,`
`1123`	`1123`	`return ret;`
`1124`	`1124`	`}`
`1125`	`1125`
`1126`		`-static int reftable_be_transaction_abort(struct ref_store *ref_store,`
	`1126`	`+static int reftable_be_transaction_abort(struct ref_store *ref_store UNUSED,`
`1127`	`1127`	`struct ref_transaction *transaction,`
`1128`		`- struct strbuf *err)`
	`1128`	`+ struct strbuf *err UNUSED)`
`1129`	`1129`	`{`
`1130`	`1130`	`struct reftable_transaction_data *tx_data = transaction->backend_data;`
`1131`	`1131`	`free_transaction_data(tx_data);`
`@@ -1315,7 +1315,7 @@ static int write_transaction_table(struct reftable_writer writer, void cb_data`
`1315`	`1315`	`return ret;`
`1316`	`1316`	`}`
`1317`	`1317`
`1318`		`-static int reftable_be_transaction_finish(struct ref_store *ref_store,`
	`1318`	`+static int reftable_be_transaction_finish(struct ref_store *ref_store UNUSED,`
`1319`	`1319`	`struct ref_transaction *transaction,`
`1320`	`1320`	`struct strbuf *err)`
`1321`	`1321`	`{`
`@@ -1726,8 +1726,8 @@ static int reftable_reflog_iterator_advance(struct ref_iterator *ref_iterator)`
`1726`	`1726`	`return ITER_OK;`
`1727`	`1727`	`}`
`1728`	`1728`
`1729`		`-static int reftable_reflog_iterator_peel(struct ref_iterator *ref_iterator,`
`1730`		`- struct object_id *peeled)`
	`1729`	`+static int reftable_reflog_iterator_peel(struct ref_iterator *ref_iterator UNUSED,`
	`1730`	`+ struct object_id *peeled UNUSED)`
`1731`	`1731`	`{`
`1732`	`1732`	`BUG("reftable reflog iterator cannot be peeled");`
`1733`	`1733`	`return -1;`
`@@ -1988,7 +1988,7 @@ static int write_reflog_existence_table(struct reftable_writer *writer,`
`1988`	`1988`
`1989`	`1989`	`static int reftable_be_create_reflog(struct ref_store *ref_store,`
`1990`	`1990`	`const char *refname,`
`1991`		`- struct strbuf *errmsg)`
	`1991`	`+ struct strbuf *errmsg UNUSED)`
`1992`	`1992`	`{`
`1993`	`1993`	`struct reftable_ref_store *refs =`
`1994`	`1994`	`reftable_be_downcast(ref_store, REF_STORE_WRITE, "create_reflog");`
Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,14 @@ license that can be found in the LICENSE file or at`
`13`	`13`	`#include "reftable-blocksource.h"`
`14`	`14`	`#include "reftable-error.h"`
`15`	`15`
`16`		`-static void strbuf_return_block(void b, struct reftable_block dest)`
	`16`	`+static void strbuf_return_block(void b UNUSED, struct reftable_block dest)`
`17`	`17`	`{`
`18`	`18`	`if (dest->len)`
`19`	`19`	`memset(dest->data, 0xff, dest->len);`
`20`	`20`	`reftable_free(dest->data);`
`21`	`21`	`}`
`22`	`22`
`23`		`-static void strbuf_close(void *b)`
	`23`	`+static void strbuf_close(void *b UNUSED)`
`24`	`24`	`{`
`25`	`25`	`}`
`26`	`26`
`@@ -55,7 +55,7 @@ void block_source_from_strbuf(struct reftable_block_source *bs,`
`55`	`55`	`bs->arg = buf;`
`56`	`56`	`}`
`57`	`57`
`58`		`-static void malloc_return_block(void b, struct reftable_block dest)`
	`58`	`+static void malloc_return_block(void b UNUSED, struct reftable_block dest)`
`59`	`59`	`{`
`60`	`60`	`if (dest->len)`
`61`	`61`	`memset(dest->data, 0xff, dest->len);`
`@@ -85,7 +85,7 @@ static uint64_t file_size(void *b)`
`85`	`85`	`return ((struct file_block_source *)b)->size;`
`86`	`86`	`}`
`87`	`87`
`88`		`-static void file_return_block(void b, struct reftable_block dest)`
	`88`	`+static void file_return_block(void b UNUSED, struct reftable_block dest UNUSED)`
`89`	`89`	`{`
`90`	`90`	`}`
`91`	`91`
Original file line number	Diff line number	Diff line change
`@@ -201,17 +201,19 @@ int iterator_next(struct reftable_iterator it, struct reftable_record rec)`
`201`	`201`	`return it->ops->next(it->iter_arg, rec);`
`202`	`202`	`}`
`203`	`203`
`204`		`-static int empty_iterator_seek(void arg, struct reftable_record want)`
	`204`	`+static int empty_iterator_seek(void *arg UNUSED,`
	`205`	`+ struct reftable_record *want UNUSED)`
`205`	`206`	`{`
`206`	`207`	`return 0;`
`207`	`208`	`}`
`208`	`209`
`209`		`-static int empty_iterator_next(void arg, struct reftable_record rec)`
	`210`	`+static int empty_iterator_next(void *arg UNUSED,`
	`211`	`+ struct reftable_record *rec UNUSED)`
`210`	`212`	`{`
`211`	`213`	`return 1;`
`212`	`214`	`}`
`213`	`215`
`214`		`-static void empty_iterator_close(void *arg)`
	`216`	`+static void empty_iterator_close(void *arg UNUSED)`
`215`	`217`	`{`
`216`	`218`	`}`
`217`	`219`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,8 @@ static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)`
`127`	`127`	`return 0;`
`128`	`128`	`}`
`129`	`129`
`130`		`-static int indexed_table_ref_iter_seek(void p, struct reftable_record want)`
	`130`	`+static int indexed_table_ref_iter_seek(void *p UNUSED,`
	`131`	`+ struct reftable_record *want UNUSED)`
`131`	`132`	`{`
`132`	`133`	`BUG("seeking indexed table is not supported");`
`133`	`134`	`return -1;`
Original file line number	Diff line number	Diff line change
`@@ -516,7 +516,7 @@ static void reftable_obj_record_release(void *rec)`
`516`	`516`	`memset(obj, 0, sizeof(struct reftable_obj_record));`
`517`	`517`	`}`
`518`	`518`
`519`		`-static void reftable_obj_record_print(const void *rec, int hash_size)`
	`519`	`+static void reftable_obj_record_print(const void *rec, int hash_size UNUSED)`
`520`	`520`	`{`
`521`	`521`	`const struct reftable_obj_record *obj = rec;`
`522`	`522`	`char hex[GIT_MAX_HEXSZ + 1] = { 0 };`
`@@ -532,7 +532,7 @@ static void reftable_obj_record_print(const void *rec, int hash_size)`
`532`	`532`	`}`
`533`	`533`
`534`	`534`	`static void reftable_obj_record_copy_from(void rec, const void src_rec,`
`535`		`- int hash_size)`
	`535`	`+ int hash_size UNUSED)`
`536`	`536`	`{`
`537`	`537`	`struct reftable_obj_record *obj = rec;`
`538`	`538`	`const struct reftable_obj_record *src =`
`@@ -559,7 +559,7 @@ static uint8_t reftable_obj_record_val_type(const void *rec)`
`559`	`559`	`}`
`560`	`560`
`561`	`561`	`static int reftable_obj_record_encode(const void *rec, struct string_view s,`
`562`		`- int hash_size)`
	`562`	`+ int hash_size UNUSED)`
`563`	`563`	`{`
`564`	`564`	`const struct reftable_obj_record *r = rec;`
`565`	`565`	`struct string_view start = s;`
`@@ -594,7 +594,8 @@ static int reftable_obj_record_encode(const void *rec, struct string_view s,`
`594`	`594`
`595`	`595`	`static int reftable_obj_record_decode(void *rec, struct strbuf key,`
`596`	`596`	`uint8_t val_type, struct string_view in,`
`597`		`- int hash_size, struct strbuf *scratch UNUSED)`
	`597`	`+ int hash_size UNUSED,`
	`598`	`+ struct strbuf *scratch UNUSED)`
`598`	`599`	`{`
`599`	`600`	`struct string_view start = in;`
`600`	`601`	`struct reftable_obj_record *r = rec;`
`@@ -647,12 +648,13 @@ static int reftable_obj_record_decode(void *rec, struct strbuf key,`
`647`	`648`	`return start.len - in.len;`
`648`	`649`	`}`
`649`	`650`
`650`		`-static int not_a_deletion(const void *p)`
	`651`	`+static int not_a_deletion(const void *p UNUSED)`
`651`	`652`	`{`
`652`	`653`	`return 0;`
`653`	`654`	`}`
`654`	`655`
`655`		`-static int reftable_obj_record_equal_void(const void a, const void b, int hash_size)`
	`656`	`+static int reftable_obj_record_equal_void(const void a, const void b,`
	`657`	`+ int hash_size UNUSED)`
`656`	`658`	`{`
`657`	`659`	`struct reftable_obj_record ra = (struct reftable_obj_record ) a;`
`658`	`660`	`struct reftable_obj_record rb = (struct reftable_obj_record ) b;`
`@@ -1066,7 +1068,7 @@ static void reftable_index_record_key(const void r, struct strbuf dest)`
`1066`	`1068`	`}`
`1067`	`1069`
`1068`	`1070`	`static void reftable_index_record_copy_from(void rec, const void src_rec,`
`1069`		`- int hash_size)`
	`1071`	`+ int hash_size UNUSED)`
`1070`	`1072`	`{`
`1071`	`1073`	`struct reftable_index_record *dst = rec;`
`1072`	`1074`	`const struct reftable_index_record *src = src_rec;`
`@@ -1082,13 +1084,13 @@ static void reftable_index_record_release(void *rec)`
`1082`	`1084`	`strbuf_release(&idx->last_key);`
`1083`	`1085`	`}`
`1084`	`1086`
`1085`		`-static uint8_t reftable_index_record_val_type(const void *rec)`
	`1087`	`+static uint8_t reftable_index_record_val_type(const void *rec UNUSED)`
`1086`	`1088`	`{`
`1087`	`1089`	`return 0;`
`1088`	`1090`	`}`
`1089`	`1091`
`1090`	`1092`	`static int reftable_index_record_encode(const void *rec, struct string_view out,`
`1091`		`- int hash_size)`
	`1093`	`+ int hash_size UNUSED)`
`1092`	`1094`	`{`
`1093`	`1095`	`const struct reftable_index_record *r =`
`1094`	`1096`	`(const struct reftable_index_record *)rec;`
`@@ -1104,8 +1106,10 @@ static int reftable_index_record_encode(const void *rec, struct string_view out,`
`1104`	`1106`	`}`
`1105`	`1107`
`1106`	`1108`	`static int reftable_index_record_decode(void *rec, struct strbuf key,`
`1107`		`- uint8_t val_type, struct string_view in,`
`1108`		`- int hash_size, struct strbuf *scratch UNUSED)`
	`1109`	`+ uint8_t val_type UNUSED,`
	`1110`	`+ struct string_view in,`
	`1111`	`+ int hash_size UNUSED,`
	`1112`	`+ struct strbuf *scratch UNUSED)`
`1109`	`1113`	`{`
`1110`	`1114`	`struct string_view start = in;`
`1111`	`1115`	`struct reftable_index_record *r = rec;`
`@@ -1122,7 +1126,8 @@ static int reftable_index_record_decode(void *rec, struct strbuf key,`
`1122`	`1126`	`return start.len - in.len;`
`1123`	`1127`	`}`
`1124`	`1128`
`1125`		`-static int reftable_index_record_equal(const void a, const void b, int hash_size)`
	`1129`	`+static int reftable_index_record_equal(const void a, const void b,`
	`1130`	`+ int hash_size UNUSED)`
`1126`	`1131`	`{`
`1127`	`1132`	`struct reftable_index_record ia = (struct reftable_index_record ) a;`
`1128`	`1133`	`struct reftable_index_record ib = (struct reftable_index_record ) b;`
`@@ -1137,7 +1142,7 @@ static int reftable_index_record_cmp(const void _a, const void _b)`
`1137`	`1142`	`return strbuf_cmp(&a->last_key, &b->last_key);`
`1138`	`1143`	`}`
`1139`	`1144`
`1140`		`-static void reftable_index_record_print(const void *rec, int hash_size)`
	`1145`	`+static void reftable_index_record_print(const void *rec, int hash_size UNUSED)`
`1141`	`1146`	`{`
`1142`	`1147`	`const struct reftable_index_record *idx = rec;`
`1143`	`1148`	`/* TODO: escape null chars? */`
Original file line number	Diff line number	Diff line change
`@@ -399,7 +399,7 @@ static void test_reftable_stack_auto_compaction_fails_gracefully(void)`
`399`	`399`	`clear_dir(dir);`
`400`	`400`	`}`
`401`	`401`
`402`		`-static int write_error(struct reftable_writer wr, void arg)`
	`402`	`+static int write_error(struct reftable_writer wr UNUSED, void arg)`
`403`	`403`	`{`
`404`	`404`	`return ((int )arg);`
`405`	`405`	`}`
`@@ -816,7 +816,7 @@ static void test_reflog_expire(void)`
`816`	`816`	`reftable_log_record_release(&log);`
`817`	`817`	`}`
`818`	`818`
`819`		`-static int write_nothing(struct reftable_writer wr, void arg)`
	`819`	`+static int write_nothing(struct reftable_writer wr, void arg UNUSED)`
`820`	`820`	`{`
`821`	`821`	`reftable_writer_set_limits(wr, 1, 1);`
`822`	`822`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ ssize_t strbuf_add_void(void b, const void data, size_t sz)`
`21`	`21`	`return sz;`
`22`	`22`	`}`
`23`	`23`
`24`		`-int noop_flush(void *arg)`
	`24`	`+int noop_flush(void *arg UNUSED)`
`25`	`25`	`{`
`26`	`26`	`return 0;`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -544,7 +544,7 @@ static void write_object_record(void void_arg, void key)`
`544`	`544`	`done:;`
`545`	`545`	`}`
`546`	`546`
`547`		`-static void object_record_free(void void_arg, void key)`
	`547`	`+static void object_record_free(void void_arg UNUSED, void key)`
`548`	`548`	`{`
`549`	`549`	`struct obj_index_tree_node *entry = key;`
`550`	`550`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ static ssize_t strbuf_add_void(void b, const void data, const size_t sz)`
`22`	`22`	`return sz;`
`23`	`23`	`}`
`24`	`24`
`25`		`-static int noop_flush(void *arg)`
	`25`	`+static int noop_flush(void *arg UNUSED)`
`26`	`26`	`{`
`27`	`27`	`return 0;`
`28`	`28`	`}`