libgit2 · jar-of-salt · Sep 3, 2025 · Sep 3, 2025 · Sep 3, 2025 · Sep 3, 2025
diff --git a/src/libgit2/merge.c b/src/libgit2/merge.c
@@ -1831,12 +1831,47 @@ int git_merge_diff_list__find_differences(
 	git_merge_diff_list *diff_list,
 	git_iterator *ancestor_iter,
 	git_iterator *our_iter,
-	git_iterator *their_iter)
+	git_iterator **their_iters,
+	size_t their_iters_len)
 {
-	git_iterator *iterators[3] = { ancestor_iter, our_iter, their_iter };
-	struct merge_diff_find_data find_data = { diff_list };
+	size_t i, j, iters_len = 1 + their_iters_len;
+	git_iterator** iterators;
+	git_iterator* curr_iterators[3];
+	struct merge_diff_find_data find_data;
+	int error = 0;
+
+	iterators = git__calloc(iters_len, sizeof(git_iterator*));
+	GIT_ERROR_CHECK_ALLOC(iterators);
+
+	iterators[0] = our_iter;
+
+	for(i = 0; i < their_iters_len; i++) {
+		iterators[i + 1] = their_iters[i];
+	}
+
+	for (i = 0; i < iters_len - 1; i++) {
+		for(j = i + 1; j < iters_len; j++) {
+			find_data = (struct merge_diff_find_data){ diff_list };
+
+			/* Reset the ancestor iterator, since it is always walked. */
+			git_iterator_reset(ancestor_iter);
+			/* Reset the "ours" iterator since it may have previously been walked. */
+			git_iterator_reset(iterators[i]);
+			/* "theirs" will get reset once it takes the "ours" spot on the next loop */
+
+			curr_iterators[0] = ancestor_iter;
+			curr_iterators[1] = iterators[i];
+			curr_iterators[2] = iterators[j];
+
+			if ((error = git_iterator_walk(curr_iterators, 3, queue_difference, &find_data)) < 0)
+				goto done;
+		}
+	}
 
-	return git_iterator_walk(iterators, 3, queue_difference, &find_data);
+done:
+	git__free(iterators);
+
+	return error;
 }
 
 git_merge_diff_list *git_merge_diff_list__alloc(git_repository *repo)
@@ -2101,19 +2136,21 @@ int git_merge__iterators(
 	git_repository *repo,
 	git_iterator *ancestor_iter,
 	git_iterator *our_iter,
-	git_iterator *theirs_iter,
+	git_iterator **theirs_iters,
+	size_t theirs_iters_len,
 	const git_merge_options *given_opts)
 {
 	git_iterator *empty_ancestor = NULL,
-		*empty_ours = NULL,
-		*empty_theirs = NULL;
+		*empty_ours = NULL;
+	git_iterator **empty_theirs_iters;
 	git_merge_diff_list *diff_list;
 	git_merge_options opts;
 	git_merge_file_options file_opts = GIT_MERGE_FILE_OPTIONS_INIT;
 	git_merge_diff *conflict;
 	git_vector changes;
 	size_t i;
 	int error = 0;
+	bool is_octopus = theirs_iters_len > 1;
 
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(repo);
@@ -2138,15 +2175,27 @@ int git_merge__iterators(
 		file_opts.marker_size = GIT_MERGE_CONFLICT_MARKER_SIZE + 2;
 	}
 
+	/* set fail on merge conflict for octopus merge */
+	if (is_octopus) {
+		opts.flags |= GIT_MERGE_FAIL_ON_CONFLICT;
+		file_opts.flags &= ~GIT_MERGE_FILE_ACCEPT_CONFLICTS;
+	}
+
 	diff_list = git_merge_diff_list__alloc(repo);
 	GIT_ERROR_CHECK_ALLOC(diff_list);
 
 	ancestor_iter = iterator_given_or_empty(&empty_ancestor, ancestor_iter);
 	our_iter = iterator_given_or_empty(&empty_ours, our_iter);
-	theirs_iter = iterator_given_or_empty(&empty_theirs, theirs_iter);
+
+	empty_theirs_iters = git__calloc(theirs_iters_len, sizeof(git_iterator*));
+	GIT_ERROR_CHECK_ALLOC(empty_theirs_iters);
+	for (i = 0; i < theirs_iters_len; i++) {
+		theirs_iters[i] = iterator_given_or_empty(&empty_theirs_iters[i], 
+				theirs_iters[i]);
+	}
 
 	if ((error = git_merge_diff_list__find_differences(
-			diff_list, ancestor_iter, our_iter, theirs_iter)) < 0 ||
+			diff_list, ancestor_iter, our_iter, theirs_iters, theirs_iters_len)) < 0 ||
 		(error = git_merge_diff_list__find_renames(repo, diff_list, &opts)) < 0)
 		goto done;
 
@@ -2160,9 +2209,13 @@ int git_merge__iterators(
 			&resolved, diff_list, conflict, &opts, &file_opts)) < 0)
 			goto done;
 
-		if (!resolved) {
+		if (!resolved) { 
 			if ((opts.flags & GIT_MERGE_FAIL_ON_CONFLICT)) {
-				git_error_set(GIT_ERROR_MERGE, "merge conflicts exist");
+				if (is_octopus)
+					git_error_set(GIT_ERROR_MERGE, "Automated merge did not work.\n"
+							"Should not be doing an octopus.");
+				else
+					git_error_set(GIT_ERROR_MERGE, "merge conflicts exist");
 				error = GIT_EMERGECONFLICT;
 				goto done;
 			}
@@ -2183,7 +2236,9 @@ int git_merge__iterators(
 	git_merge_diff_list__free(diff_list);
 	git_iterator_free(empty_ancestor);
 	git_iterator_free(empty_ours);
-	git_iterator_free(empty_theirs);
+	for (i = 0; i < theirs_iters_len; i++)
+		git_iterator_free(empty_theirs_iters[i]);
+	git__free(empty_theirs_iters);
 
 	return error;
 }
@@ -2233,7 +2288,7 @@ int git_merge_trees(
 		goto done;
 
 	error = git_merge__iterators(
-		out, repo, ancestor_iter, our_iter, their_iter, merge_opts);
+		out, repo, ancestor_iter, our_iter, &their_iter, 1, merge_opts);
 
 done:
 	git_iterator_free(ancestor_iter);
@@ -2248,7 +2303,8 @@ static int merge_annotated_commits(
 	git_annotated_commit **base_out,
 	git_repository *repo,
 	git_annotated_commit *our_commit,
-	git_annotated_commit *their_commit,
+	const git_annotated_commit **their_commits,
+	size_t their_commits_len,
 	size_t recursion_level,
 	const git_merge_options *opts);
 
@@ -2297,8 +2353,9 @@ static int create_virtual_base(
 	virtual_opts.flags &= ~GIT_MERGE_FAIL_ON_CONFLICT;
 	virtual_opts.flags |= GIT_MERGE_VIRTUAL_BASE;
 
-	if ((merge_annotated_commits(&index, NULL, repo, one, two,
-			recursion_level + 1, &virtual_opts)) < 0)
+	if ((merge_annotated_commits(&index, NULL, repo, one, 
+					(const git_annotated_commit **)&two, 1, 
+					recursion_level + 1, &virtual_opts)) < 0)
 		return -1;
 
 	result = git__calloc(1, sizeof(git_annotated_commit));
@@ -2389,6 +2446,55 @@ static int compute_base(
 	return error;
 }
 
+static int compute_base_octopus(
+	git_annotated_commit **out,
+	git_repository *repo,
+	const git_annotated_commit *one,
+	const git_annotated_commit **twos,
+	size_t twos_len,
+	const git_merge_options *given_opts)
+{
+	git_array_oid_t head_ids = GIT_ARRAY_INIT;
+	git_oid base_id;
+	git_annotated_commit *base = NULL;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
+	size_t i;
+	int error;
+
+	*out = NULL;
+
+	if (given_opts)
+		memcpy(&opts, given_opts, sizeof(git_merge_options));
+
+	/* With more than two commits, merge_bases_many finds the base of
+	 * the first commit and a hypothetical merge of the others. Since
+	 * "one" may itself be a virtual commit, which insert_head_ids
+	 * substitutes multiple ancestors for, it needs to be added
+	 * after "two" which is always a single real commit.
+	 */
+	for (i = 0; i < twos_len; i++) {
+		if ((error = insert_head_ids(&head_ids, twos[i])) < 0)
+			goto done;
+
+	}
+	if ((error = insert_head_ids(&head_ids, one)) < 0 ||
+		(error = git_merge_base_octopus(&base_id, repo,
+			head_ids.size, head_ids.ptr)) < 0)
+		goto done;
+
+	if ((error = git_annotated_commit_lookup(&base, repo, &base_id)) < 0)
+		goto done;
+
+done:
+	if (error == 0)
+		*out = base;
+	else
+		git_annotated_commit_free(base);
+
+	git_array_clear(head_ids);
+	return error;
+}
+
 static int iterator_for_annotated_commit(
 	git_iterator **out,
 	git_annotated_commit *commit)
@@ -2419,28 +2525,50 @@ static int merge_annotated_commits(
 	git_annotated_commit **base_out,
 	git_repository *repo,
 	git_annotated_commit *ours,
-	git_annotated_commit *theirs,
+	const git_annotated_commit **their_commits,
+	size_t their_commits_len,
 	size_t recursion_level,
 	const git_merge_options *opts)
 {
-	git_annotated_commit *base = NULL;
+	git_annotated_commit *base = NULL, *prev_base = ours;
 	git_iterator *base_iter = NULL, *our_iter = NULL, *their_iter = NULL;
 	int error;
+	size_t i;
+	git_iterator **their_iters;
+	bool is_octopus = their_commits_len > 1;
 
-	if ((error = compute_base(&base, repo, ours, theirs, opts,
-		recursion_level)) < 0) {
+	their_iters = git__calloc(their_commits_len, sizeof(git_iterator*));
 
+	/* TODO: write test confirming that the base is as expected*/
+	if (is_octopus) {
+		if ((error = compute_base_octopus(&base, repo, ours, their_commits, 
+						their_commits_len, opts)) < 0)
+			goto done;
+	} else if ((error = compute_base(&base, repo, prev_base, their_commits[0], 
+					opts, recursion_level)) < 0) {
 		if (error != GIT_ENOTFOUND)
 			goto done;
 
 		git_error_clear();
 	}
 
 	if ((error = iterator_for_annotated_commit(&base_iter, base)) < 0 ||
-		(error = iterator_for_annotated_commit(&our_iter, ours)) < 0 ||
-		(error = iterator_for_annotated_commit(&their_iter, theirs)) < 0 ||
-		(error = git_merge__iterators(index_out, repo, base_iter, our_iter,
-			their_iter, opts)) < 0)
+		(error = iterator_for_annotated_commit(&our_iter, ours)) < 0) 
+		goto done;
+
+	if (is_octopus) {
+	/* TODO: remove ancestor commits */
+	}
+
+	for (i = 0; i < their_commits_len; i++) {
+		if((error = iterator_for_annotated_commit(&their_iter, 
+						(git_annotated_commit *)their_commits[i])) < 0)
+			goto done;
+		their_iters[i] = their_iter;
+	}
+
+	if ((error = git_merge__iterators(index_out, repo, base_iter, our_iter,
+			their_iters, their_commits_len, opts)) < 0)
 		goto done;
 
 	if (base_out) {
@@ -2449,14 +2577,17 @@ static int merge_annotated_commits(
 	}
 
 done:
+	/* TODO: check for memory leaks */
 	git_annotated_commit_free(base);
 	git_iterator_free(base_iter);
 	git_iterator_free(our_iter);
-	git_iterator_free(their_iter);
+	for(i = 0; i < their_commits_len; i++) {
+		git_iterator_free(their_iters[i]);
+	}
+	git__free(their_iters);
 	return error;
 }
 
-
 int git_merge_commits(
 	git_index **out,
 	git_repository *repo,
@@ -2471,7 +2602,8 @@ int git_merge_commits(
 		(error = git_annotated_commit_from_commit(&theirs, (git_commit *)their_commit)) < 0)
 		goto done;
 
-	error = merge_annotated_commits(out, &base, repo, ours, theirs, 0, opts);
+	error = merge_annotated_commits(out, &base, repo, ours, 
+			(const git_annotated_commit **)&theirs, 1, 0, opts);
 
 done:
 	git_annotated_commit_free(ours);
@@ -3347,10 +3479,10 @@ int git_merge(
 	GIT_ASSERT_ARG(repo);
 	GIT_ASSERT_ARG(their_heads && their_heads_len > 0);
 
-	if (their_heads_len != 1) {
-		git_error_set(GIT_ERROR_MERGE, "can only merge a single branch");
-		return -1;
-	}
+	/* if (their_heads_len != 1) { */
+	/* 	git_error_set(GIT_ERROR_MERGE, "can only merge a single branch"); */
+	/* 	return -1; */
+	/* } */
 
 	if ((error = git_repository__ensure_not_bare(repo, "merge")) < 0)
 		goto done;
@@ -3363,7 +3495,7 @@ int git_merge(
 		goto done;
 
 	if ((error = git_repository_index(&repo_index, repo) < 0) ||
-	    (error = git_index_read(repo_index, 0) < 0))
+		(error = git_index_read(repo_index, 0) < 0))
 		goto done;
 
 	/* Write the merge setup files to the repository. */
@@ -3372,10 +3504,9 @@ int git_merge(
 			their_heads_len)) < 0)
 		goto done;
 
-	/* TODO: octopus */
-
+	/* Run octopus merge if there is more than one `their_heads` */
 	if ((error = merge_annotated_commits(&index, &base, repo, our_head,
-			(git_annotated_commit *)their_heads[0], 0, merge_opts)) < 0 ||
+					their_heads, their_heads_len, 0, merge_opts)) < 0 ||
 		(error = git_merge__check_result(repo, index)) < 0 ||
 		(error = git_merge__append_conflicts_to_merge_msg(repo, index)) < 0)
 		goto done;

diff --git a/src/libgit2/merge.h b/src/libgit2/merge.h
@@ -129,7 +129,8 @@ int git_merge_diff_list__find_differences(
 	git_merge_diff_list *merge_diff_list,
 	git_iterator *ancestor_iterator,
 	git_iterator *ours_iter,
-	git_iterator *theirs_iter);
+	git_iterator **theirs_iters,
+	size_t theirs_iters_len);
 
 int git_merge_diff_list__find_renames(git_repository *repo, git_merge_diff_list *merge_diff_list, const git_merge_options *opts);
 
@@ -148,7 +149,8 @@ int git_merge__iterators(
 	git_repository *repo,
 	git_iterator *ancestor_iter,
 	git_iterator *our_iter,
-	git_iterator *their_iter,
+	git_iterator **their_iters,
+	size_t their_iters_len,
 	const git_merge_options *given_opts);
 
 int git_merge__check_result(git_repository *repo, git_index *index_new);

diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c
@@ -885,7 +885,7 @@ static int merge_indexes(
 		(error = git_iterator_for_index(&theirs, repo, theirs_index, &iter_opts)) < 0)
 		goto done;
 
-	error = git_merge__iterators(out, repo, ancestor, ours, theirs, NULL);
+	error = git_merge__iterators(out, repo, ancestor, ours, &theirs, 1, NULL);
 
 done:
 	git_iterator_free(ancestor);
@@ -912,7 +912,7 @@ static int merge_index_and_tree(
 		(error = git_iterator_for_tree(&theirs, theirs_tree, &iter_opts)) < 0)
 		goto done;
 
-	error = git_merge__iterators(out, repo, ancestor, ours, theirs, NULL);
+	error = git_merge__iterators(out, repo, ancestor, ours, &theirs, 1, NULL);
 
 done:
 	git_iterator_free(ancestor);