rugged 1.7.2 → 1.9.0

data/vendor/libgit2/src/libgit2/config_snapshot.c

@@ -8,12 +8,12 @@
 #include "config_backend.h"
 
 #include "config.h"
-#include "config_entries.h"
+#include "config_list.h"
 
 typedef struct {
 	git_config_backend parent;
 	git_mutex values_mutex;
-	git_config_entries *entries;
+	git_config_list *config_list;
 	git_config_backend *source;
 } config_snapshot_backend;
 
@@ -28,31 +28,27 @@ static int config_snapshot_iterator(
 	struct git_config_backend *backend)
 {
 	config_snapshot_backend *b = GIT_CONTAINER_OF(backend, config_snapshot_backend, parent);
-	git_config_entries *entries = NULL;
+	git_config_list *config_list = NULL;
 	int error;
 
-	if ((error = git_config_entries_dup(&entries, b->entries)) < 0 ||
-	    (error = git_config_entries_iterator_new(iter, entries)) < 0)
+	if ((error = git_config_list_dup(&config_list, b->config_list)) < 0 ||
+	    (error = git_config_list_iterator_new(iter, config_list)) < 0)
 		goto out;
 
 out:
-	/* Let iterator delete duplicated entries when it's done */
-	git_config_entries_free(entries);
+	/* Let iterator delete duplicated config_list when it's done */
+	git_config_list_free(config_list);
 	return error;
 }
 
-/* release the map containing the entry as an equivalent to freeing it */
-static void config_snapshot_entry_free(git_config_entry *entry)
-{
-	git_config_entries *entries = (git_config_entries *) entry->payload;
-	git_config_entries_free(entries);
-}
-
-static int config_snapshot_get(git_config_backend *cfg, const char *key, git_config_entry **out)
+static int config_snapshot_get(
+	git_config_backend *cfg,
+	const char *key,
+	git_config_backend_entry **out)
 {
 	config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent);
-	git_config_entries *entries = NULL;
-	git_config_entry *entry;
+	git_config_list *config_list = NULL;
+	git_config_list_entry *entry;
 	int error = 0;
 
 	if (git_mutex_lock(&b->values_mutex) < 0) {
@@ -60,19 +56,16 @@ static int config_snapshot_get(git_config_backend *cfg, const char *key, git_con
 	    return -1;
 	}
 
-	entries = b->entries;
-	git_config_entries_incref(entries);
+	config_list = b->config_list;
+	git_config_list_incref(config_list);
 	git_mutex_unlock(&b->values_mutex);
 
-	if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
-		git_config_entries_free(entries);
+	if ((error = (git_config_list_get(&entry, config_list, key))) < 0) {
+		git_config_list_free(config_list);
 		return error;
 	}
 
-	entry->free = config_snapshot_entry_free;
-	entry->payload = entries;
-	*out = entry;
-
+	*out = &entry->base;
 	return 0;
 }
 
@@ -135,7 +128,7 @@ static void config_snapshot_free(git_config_backend *_backend)
 	if (backend == NULL)
 		return;
 
-	git_config_entries_free(backend->entries);
+	git_config_list_free(backend->config_list);
 	git_mutex_free(&backend->values_mutex);
 	git__free(backend);
 }
@@ -143,7 +136,7 @@ static void config_snapshot_free(git_config_backend *_backend)
 static int config_snapshot_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
 {
 	config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent);
-	git_config_entries *entries = NULL;
+	git_config_list *config_list = NULL;
 	git_config_iterator *it = NULL;
 	git_config_entry *entry;
 	int error;
@@ -152,12 +145,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve
 	GIT_UNUSED(level);
 	GIT_UNUSED(repo);
 
-	if ((error = git_config_entries_new(&entries)) < 0 ||
+	if ((error = git_config_list_new(&config_list)) < 0 ||
 	    (error = b->source->iterator(&it, b->source)) < 0)
 		goto out;
 
 	while ((error = git_config_next(&entry, it)) == 0)
-		if ((error = git_config_entries_dup_entry(entries, entry)) < 0)
+		if ((error = git_config_list_dup_entry(config_list, entry)) < 0)
 			goto out;
 
 	if (error < 0) {
@@ -166,12 +159,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve
 		error = 0;
 	}
 
-	b->entries = entries;
+	b->config_list = config_list;
 
 out:
 	git_config_iterator_free(it);
 	if (error)
-		git_config_entries_free(entries);
+		git_config_list_free(config_list);
 	return error;
 }
 

data/vendor/libgit2/src/libgit2/describe.c

@@ -14,7 +14,6 @@
 #include "buf.h"
 #include "commit.h"
 #include "commit_list.h"
-#include "oidmap.h"
 #include "refs.h"
 #include "repository.h"
 #include "revwalk.h"
@@ -22,6 +21,7 @@
 #include "tag.h"
 #include "vector.h"
 #include "wildmatch.h"
+#include "hashmap_oid.h"
 
 /* Ported from https://github.com/git/git/blob/89dde7882f71f846ccd0359756d27bebc31108de/builtin/describe.c */
 
@@ -32,20 +32,22 @@ struct commit_name {
 	git_oid sha1;
 	char *path;
 
-	/* Khash workaround. They original key has to still be reachable */
+	/* The original key for the hashmap */
 	git_oid peeled;
 };
 
-static void *oidmap_value_bykey(git_oidmap *map, const git_oid *key)
-{
-	return git_oidmap_get(map, key);
-}
+GIT_HASHMAP_OID_SETUP(git_describe_oidmap, struct commit_name *);
 
 static struct commit_name *find_commit_name(
-	git_oidmap *names,
+	git_describe_oidmap *names,
 	const git_oid *peeled)
 {
-	return (struct commit_name *)(oidmap_value_bykey(names, peeled));
+	struct commit_name *result;
+
+	if (git_describe_oidmap_get(&result, names, peeled) == 0)
+		return result;
+
+	return NULL;
 }
 
 static int replace_name(
@@ -92,7 +94,7 @@ static int replace_name(
 
 static int add_to_known_names(
 	git_repository *repo,
-	git_oidmap *names,
+	git_describe_oidmap *names,
 	const char *path,
 	const git_oid *peeled,
 	unsigned int prio,
@@ -121,7 +123,7 @@ static int add_to_known_names(
 		e->path = git__strdup(path);
 		git_oid_cpy(&e->peeled, peeled);
 
-		if (!found && git_oidmap_set(names, &e->peeled, e) < 0)
+		if (!found && git_describe_oidmap_put(names, &e->peeled, e) < 0)
 			return -1;
 	}
 	else
@@ -174,7 +176,7 @@ struct get_name_data
 {
 	git_describe_options *opts;
 	git_repository *repo;
-	git_oidmap *names;
+	git_describe_oidmap names;
 	git_describe_result *result;
 };
 
@@ -240,7 +242,7 @@ static int get_name(const char *refname, void *payload)
 	else
 		prio = 0;
 
-	add_to_known_names(data->repo, data->names,
+	add_to_known_names(data->repo, &data->names,
 		all ? refname + strlen(GIT_REFS_DIR) : refname + strlen(GIT_REFS_TAGS_DIR),
 		&peeled, prio, &sha1);
 	return 0;
@@ -451,7 +453,7 @@ static int describe(
 
 	git_oid_cpy(&data->result->commit_id, git_commit_id(commit));
 
-	n = find_commit_name(data->names, git_commit_id(commit));
+	n = find_commit_name(&data->names, git_commit_id(commit));
 	if (n && (tags || all || n->prio == 2)) {
 		/*
 		 * Exact match to an existing ref.
@@ -492,7 +494,7 @@ static int describe(
 		git_commit_list_node *c = (git_commit_list_node *)git_pqueue_pop(&list);
 		seen_commits++;
 
-		n = find_commit_name(data->names, &c->oid);
+		n = find_commit_name(&data->names, &c->oid);
 
 		if (n) {
 			if (!tags && !all && n->prio < 2) {
@@ -627,7 +629,7 @@ cleanup:
 			git__free(match);
 		}
 	}
-	git_vector_free(&all_matches);
+	git_vector_dispose(&all_matches);
 	git_pqueue_free(&list);
 	git_revwalk_free(walk);
 	return error;
@@ -653,11 +655,12 @@ int git_describe_commit(
 	git_object *committish,
 	git_describe_options *opts)
 {
-	struct get_name_data data;
+	struct get_name_data data = {0};
 	struct commit_name *name;
 	git_commit *commit;
-	int error = -1;
 	git_describe_options normalized;
+	git_hashmap_iter_t iter = GIT_HASHMAP_INIT;
+	int error = -1;
 
 	GIT_ASSERT_ARG(result);
 	GIT_ASSERT_ARG(committish);
@@ -677,9 +680,6 @@ int git_describe_commit(
 		"git_describe_options");
 	data.opts = &normalized;
 
-	if ((error = git_oidmap_new(&data.names)) < 0)
-		return error;
-
 	/** TODO: contains to be implemented */
 
 	if ((error = git_object_peel((git_object **)(&commit), committish, GIT_OBJECT_COMMIT)) < 0)
@@ -690,7 +690,7 @@ int git_describe_commit(
 			get_name, &data)) < 0)
 				goto cleanup;
 
-	if (git_oidmap_size(data.names) == 0 && !normalized.show_commit_oid_as_fallback) {
+	if (git_describe_oidmap_size(&data.names) == 0 && !normalized.show_commit_oid_as_fallback) {
 		git_error_set(GIT_ERROR_DESCRIBE, "cannot describe - "
 			"no reference found, cannot describe anything.");
 		error = -1;
@@ -703,13 +703,13 @@ int git_describe_commit(
 cleanup:
 	git_commit_free(commit);
 
-	git_oidmap_foreach_value(data.names, name, {
+	while (git_describe_oidmap_iterate(&iter, NULL, &name, &data.names) == 0) {
 		git_tag_free(name->tag);
 		git__free(name->path);
 		git__free(name);
-	});
+	}
 
-	git_oidmap_free(data.names);
+	git_describe_oidmap_dispose(&data.names);
 
 	if (error < 0)
 		git_describe_result_free(data.result);

data/vendor/libgit2/src/libgit2/diff.c

@@ -16,7 +16,7 @@
 #include "diff_generate.h"
 
 #include "git2/version.h"
-#include "git2/email.h"
+#include "git2/sys/email.h"
 
 struct patch_id_args {
 	git_diff *diff;

data/vendor/libgit2/src/libgit2/diff_driver.c

@@ -11,11 +11,11 @@
 
 #include "common.h"
 #include "diff.h"
-#include "strmap.h"
 #include "map.h"
 #include "config.h"
 #include "regexp.h"
 #include "repository.h"
+#include "userdiff.h"
 
 typedef enum {
 	DIFF_DRIVER_AUTO = 0,
@@ -43,10 +43,10 @@ struct git_diff_driver {
 	char name[GIT_FLEX_ARRAY];
 };
 
-#include "userdiff.h"
+GIT_HASHMAP_STR_SETUP(git_diff_driver_map, git_diff_driver *);
 
 struct git_diff_driver_registry {
-	git_strmap *drivers;
+	git_diff_driver_map map;
 };
 
 #define FORCE_DIFFABLE (GIT_DIFF_FORCE_TEXT | GIT_DIFF_FORCE_BINARY)
@@ -57,28 +57,21 @@ static git_diff_driver diff_driver_text =   { DIFF_DRIVER_TEXT,   GIT_DIFF_FORCE
 
 git_diff_driver_registry *git_diff_driver_registry_new(void)
 {
-	git_diff_driver_registry *reg =
-		git__calloc(1, sizeof(git_diff_driver_registry));
-	if (!reg)
-		return NULL;
-
-	if (git_strmap_new(&reg->drivers) < 0) {
-		git_diff_driver_registry_free(reg);
-		return NULL;
-	}
-
-	return reg;
+	return git__calloc(1, sizeof(git_diff_driver_registry));
 }
 
 void git_diff_driver_registry_free(git_diff_driver_registry *reg)
 {
 	git_diff_driver *drv;
+	git_hashmap_iter_t iter = 0;
 
 	if (!reg)
 		return;
 
-	git_strmap_foreach_value(reg->drivers, drv, git_diff_driver_free(drv));
-	git_strmap_free(reg->drivers);
+	while (git_diff_driver_map_iterate(&iter, NULL, &drv, &reg->map) == 0)
+		git_diff_driver_free(drv);
+
+	git_diff_driver_map_dispose(&reg->map);
 	git__free(reg);
 }
 
@@ -215,7 +208,7 @@ static int git_diff_driver_builtin(
 	    (error = git_regexp_compile(&drv->word_pattern, ddef->words, ddef->flags)) < 0)
 		goto done;
 
-	if ((error = git_strmap_set(reg->drivers, drv->name, drv)) < 0)
+	if ((error = git_diff_driver_map_put(&reg->map, drv->name, drv)) < 0)
 		goto done;
 
 done:
@@ -242,7 +235,7 @@ static int git_diff_driver_load(
 	if ((reg = git_repository_driver_registry(repo)) == NULL)
 		return -1;
 
-	if ((drv = git_strmap_get(reg->drivers, driver_name)) != NULL) {
+	if (git_diff_driver_map_get(&drv, &reg->map, driver_name) == 0) {
 		*out = drv;
 		return 0;
 	}
@@ -331,7 +324,7 @@ static int git_diff_driver_load(
 		goto done;
 
 	/* store driver in registry */
-	if ((error = git_strmap_set(reg->drivers, drv->name, drv)) < 0)
+	if ((error = git_diff_driver_map_put(&reg->map, drv->name, drv)) < 0)
 		goto done;
 
 	*out = drv;

data/vendor/libgit2/src/libgit2/diff_driver.h

@@ -11,14 +11,14 @@
 
 #include "attr_file.h"
 #include "str.h"
+#include "hashmap.h"
 
+typedef struct git_diff_driver git_diff_driver;
 typedef struct git_diff_driver_registry git_diff_driver_registry;
 
 git_diff_driver_registry *git_diff_driver_registry_new(void);
 void git_diff_driver_registry_free(git_diff_driver_registry *);
 
-typedef struct git_diff_driver git_diff_driver;
-
 int git_diff_driver_lookup(git_diff_driver **, git_repository *,
 	git_attr_session *attrsession, const char *);
 void git_diff_driver_free(git_diff_driver *);

data/vendor/libgit2/src/libgit2/diff_generate.c

@@ -429,7 +429,7 @@ static void diff_generated_free(git_diff *d)
 	git_diff_generated *diff = (git_diff_generated *)d;
 
 	git_attr_session__free(&diff->base.attrsession);
-	git_vector_free_deep(&diff->base.deltas);
+	git_vector_dispose_deep(&diff->base.deltas);
 
 	git_pathspec__vfree(&diff->pathspec);
 	git_pool_clear(&diff->base.pool);
@@ -729,7 +729,7 @@ typedef struct {
 	git_iterator *new_iter;
 	const git_index_entry *oitem;
 	const git_index_entry *nitem;
-	git_strmap *submodule_cache;
+	git_submodule_cache *submodule_cache;
 	bool submodule_cache_initialized;
 } diff_in_progress;
 
@@ -745,7 +745,7 @@ static int maybe_modified_submodule(
 	git_submodule *sub;
 	unsigned int sm_status = 0;
 	git_submodule_ignore_t ign = diff->base.opts.ignore_submodules;
-	git_strmap *submodule_cache = NULL;
+	git_submodule_cache *submodule_cache = NULL;
 
 	*status = GIT_DELTA_UNMODIFIED;
 

data/vendor/libgit2/src/libgit2/diff_parse.c

@@ -20,9 +20,9 @@ static void diff_parsed_free(git_diff *d)
 	git_vector_foreach(&diff->patches, i, patch)
 		git_patch_free(patch);
 
-	git_vector_free(&diff->patches);
+	git_vector_dispose(&diff->patches);
 
-	git_vector_free(&diff->base.deltas);
+	git_vector_dispose(&diff->base.deltas);
 	git_pool_clear(&diff->base.pool);
 
 	git__memzero(diff, sizeof(*diff));

data/vendor/libgit2/src/libgit2/diff_print.c

@@ -15,6 +15,7 @@
 #include "zstream.h"
 #include "blob.h"
 #include "delta.h"
+#include "repository.h"
 #include "git2/sys/diff.h"
 
 typedef struct {
@@ -29,6 +30,7 @@ typedef struct {
 	const char *new_prefix;
 	uint32_t flags;
 	int id_strlen;
+	unsigned int sent_file_header;
 	git_oid_t oid_type;
 
 	int (*strcomp)(const char *, const char *);
@@ -52,14 +54,10 @@ static int diff_print_info_init__common(
 	if (!pi->id_strlen) {
 		if (!repo)
 			pi->id_strlen = GIT_ABBREV_DEFAULT;
-		else if (git_repository__configmap_lookup(&pi->id_strlen, repo, GIT_CONFIGMAP_ABBREV) < 0)
+		else if (git_repository__abbrev_length(&pi->id_strlen, repo) < 0)
 			return -1;
 	}
 
-	if (pi->id_strlen > 0 &&
-	    (size_t)pi->id_strlen > git_oid_hexsize(pi->oid_type))
-		pi->id_strlen = (int)git_oid_hexsize(pi->oid_type);
-
 	memset(&pi->line, 0, sizeof(pi->line));
 	pi->line.old_lineno = -1;
 	pi->line.new_lineno = -1;
@@ -579,6 +577,30 @@ static int diff_print_patch_file_binary(
 	return error;
 }
 
+GIT_INLINE(int) should_force_header(const git_diff_delta *delta)
+{
+	if (delta->old_file.mode != delta->new_file.mode)
+		return 1;
+
+	if (delta->status == GIT_DELTA_RENAMED || delta->status == GIT_DELTA_COPIED)
+		return 1;
+
+	return 0;
+}
+
+GIT_INLINE(int) flush_file_header(const git_diff_delta *delta, diff_print_info *pi)
+{
+	if (pi->sent_file_header)
+		return 0;
+
+	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
+	pi->line.content     = git_str_cstr(pi->buf);
+	pi->line.content_len = git_str_len(pi->buf);
+	pi->sent_file_header = 1;
+
+	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
+}
+
 static int diff_print_patch_file(
 	const git_diff_delta *delta, float progress, void *data)
 {
@@ -609,15 +631,22 @@ static int diff_print_patch_file(
 		 (pi->flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) == 0))
 		return 0;
 
+	pi->sent_file_header = 0;
+
 	if ((error = git_diff_delta__format_file_header(pi->buf, delta, oldpfx, newpfx,
 							id_strlen, print_index)) < 0)
 		return error;
 
-	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
-	pi->line.content     = git_str_cstr(pi->buf);
-	pi->line.content_len = git_str_len(pi->buf);
+	/*
+	 * pi->buf now contains the file header data. Go ahead and send it
+	 * if there's useful data in there, like similarity. Otherwise, we
+	 * should queue it to send when we see the first hunk. This prevents
+	 * us from sending a header when all hunks were ignored.
+	 */
+	if (should_force_header(delta) && (error = flush_file_header(delta, pi)) < 0)
+		return error;
 
-	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
+	return 0;
 }
 
 static int diff_print_patch_binary(
@@ -632,6 +661,16 @@ static int diff_print_patch_binary(
 		pi->new_prefix ? pi->new_prefix : DIFF_NEW_PREFIX_DEFAULT;
 	int error;
 
+	if ((error = flush_file_header(delta, pi)) < 0)
+		return error;
+
+	/*
+	 * If the caller only wants the header, we just needed to make sure to
+	 * call flush_file_header
+	 */
+	if (pi->format == GIT_DIFF_FORMAT_PATCH_HEADER)
+		return 0;
+
 	git_str_clear(pi->buf);
 
 	if ((error = diff_print_patch_file_binary(
@@ -651,10 +690,21 @@ static int diff_print_patch_hunk(
 	void *data)
 {
 	diff_print_info *pi = data;
+	int error;
 
 	if (S_ISDIR(d->new_file.mode))
 		return 0;
 
+	if ((error = flush_file_header(d, pi)) < 0)
+		return error;
+
+	/*
+	 * If the caller only wants the header, we just needed to make sure to
+	 * call flush_file_header
+	 */
+	if (pi->format == GIT_DIFF_FORMAT_PATCH_HEADER)
+		return 0;
+
 	pi->line.origin      = GIT_DIFF_LINE_HUNK_HDR;
 	pi->line.content     = h->header;
 	pi->line.content_len = h->header_len;
@@ -669,10 +719,14 @@ static int diff_print_patch_line(
 	void *data)
 {
 	diff_print_info *pi = data;
+	int error;
 
 	if (S_ISDIR(delta->new_file.mode))
 		return 0;
 
+	if ((error = flush_file_header(delta, pi)) < 0)
+		return error;
+
 	return pi->print_cb(delta, hunk, line, pi->payload);
 }
 
@@ -705,6 +759,8 @@ int git_diff_print(
 		break;
 	case GIT_DIFF_FORMAT_PATCH_HEADER:
 		print_file = diff_print_patch_file;
+		print_binary = diff_print_patch_binary;
+		print_hunk = diff_print_patch_hunk;
 		break;
 	case GIT_DIFF_FORMAT_RAW:
 		print_file = diff_print_one_raw;

data/vendor/libgit2/src/libgit2/diff_tform.c

@@ -190,7 +190,7 @@ int git_diff__merge(
 			git_pool_strdup_safe(&onto->pool, onto->opts.new_prefix);
 	}
 
-	git_vector_free_deep(&onto_new);
+	git_vector_dispose_deep(&onto_new);
 	git_pool_clear(&onto_pool);
 
 	return error;
@@ -424,13 +424,13 @@ static int apply_splits_and_deletes(
 
 	/* swap new delta list into place */
 	git_vector_swap(&diff->deltas, &onto);
-	git_vector_free(&onto);
+	git_vector_dispose(&onto);
 	git_vector_sort(&diff->deltas);
 
 	return 0;
 
 on_error:
-	git_vector_free_deep(&onto);
+	git_vector_dispose_deep(&onto);
 
 	return -1;
 }
@@ -653,6 +653,23 @@ static int calc_self_similarity(
 	return 0;
 }
 
+static void handle_non_blob(
+	git_diff *diff,
+	const git_diff_find_options *opts,
+	size_t delta_idx)
+{
+	git_diff_delta *delta = GIT_VECTOR_GET(&diff->deltas, delta_idx);
+
+	/* skip things that are blobs */
+	if (GIT_MODE_ISBLOB(delta->old_file.mode))
+		return;
+
+	/* honor "remove unmodified" flag for non-blobs (eg submodules) */
+	if (delta->status == GIT_DELTA_UNMODIFIED &&
+	    FLAG_SET(opts, GIT_DIFF_FIND_REMOVE_UNMODIFIED))
+		delta->flags |= GIT_DIFF_FLAG__TO_DELETE;
+}
+
 static bool is_rename_target(
 	git_diff *diff,
 	const git_diff_find_options *opts,
@@ -810,7 +827,8 @@ int git_diff_find_similar(
 	git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
 	size_t num_deltas, num_srcs = 0, num_tgts = 0;
 	size_t tried_srcs = 0, tried_tgts = 0;
-	size_t num_rewrites = 0, num_updates = 0, num_bumped = 0;
+	size_t num_rewrites = 0, num_updates = 0, num_bumped = 0,
+	       num_to_delete = 0;
 	size_t sigcache_size;
 	void **sigcache = NULL; /* cache of similarity metric file signatures */
 	diff_find_match *tgt2src = NULL;
@@ -844,6 +862,8 @@ int git_diff_find_similar(
 	 * mark them for splitting if break-rewrites is enabled
 	 */
 	git_vector_foreach(&diff->deltas, t, tgt) {
+		handle_non_blob(diff, &opts, t);
+
 		if (is_rename_source(diff, &opts, t, sigcache))
 			++num_srcs;
 
@@ -852,11 +872,14 @@ int git_diff_find_similar(
 
 		if ((tgt->flags & GIT_DIFF_FLAG__TO_SPLIT) != 0)
 			num_rewrites++;
+
+		if ((tgt->flags & GIT_DIFF_FLAG__TO_DELETE) != 0)
+			num_to_delete++;
 	}
 
-	/* if there are no candidate srcs or tgts, we're done */
+	/* If there are no candidate srcs or tgts, no need to find matches */
 	if (!num_srcs || !num_tgts)
-		goto cleanup;
+		goto split_and_delete;
 
 	src2tgt = git__calloc(num_deltas, sizeof(diff_find_match));
 	GIT_ERROR_CHECK_ALLOC(src2tgt);
@@ -1093,15 +1116,20 @@ find_best_matches:
 		}
 	}
 
+split_and_delete:
 	/*
 	 * Actually split and delete entries as needed
 	 */
 
-	if (num_rewrites > 0 || num_updates > 0)
+	if (num_rewrites > 0 || num_updates > 0 || num_to_delete > 0) {
+		size_t apply_len = diff->deltas.length -
+		                   num_rewrites - num_to_delete;
+
 		error = apply_splits_and_deletes(
-			diff, diff->deltas.length - num_rewrites,
+			diff, apply_len,
 			FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES) &&
 			!FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY));
+	}
 
 cleanup:
 	git__free(tgt2src);