Create git_diff_line and extend git_diff_hunk

Instead of having functions with so very many parameters to pass
hunk and line data, this takes the existing git_diff_hunk struct
and extends it with more hunk data, plus adds a git_diff_line.
Those structs are used to pass back hunk and line data instead of
the old APIs that took tons of parameters.

Some work that was previously only being done for git_diff_patch
creation (scanning the diff content for exact line counts) is now
done for all callbacks, but the performance difference should not
be noticable.

7 files changed, 164 insertions, 215 deletions

diff --git a/tests-clar/diff/blob.c b/tests-clar/diff/blob.c
index 898c037b5..b51bc0f38 100644
--- a/tests-clar/diff/blob.c
+++ b/tests-clar/diff/blob.c
@@ -319,8 +319,8 @@ void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
 	git_blob *e = NULL;
 	git_patch *p;
 	const git_diff_delta *delta;
-	int line;
-	char origin;
+	const git_diff_line *line;
+	int l, max_l;
 
 	cl_git_pass(git_patch_from_blobs(&p, d, NULL, e, NULL, &opts));
 
@@ -337,10 +337,10 @@ void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
 	cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
 	cl_assert_equal_i(14, git_patch_num_lines_in_hunk(p, 0));
 
-	for (line = 0; line < git_patch_num_lines_in_hunk(p, 0); ++line) {
-		cl_git_pass(git_patch_get_line_in_hunk(
-			&origin, NULL, NULL, NULL, NULL, p, 0, line));
-		cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)origin);
+	max_l = git_patch_num_lines_in_hunk(p, 0);
+	for (l = 0; l < max_l; ++l) {
+		cl_git_pass(git_patch_get_line_in_hunk(&line, p, 0, l));
+		cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)line->origin);
 	}
 
 	git_patch_free(p);
@@ -362,10 +362,10 @@ void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
 	cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
 	cl_assert_equal_i(14, git_patch_num_lines_in_hunk(p, 0));
 
-	for (line = 0; line < git_patch_num_lines_in_hunk(p, 0); ++line) {
-		cl_git_pass(git_patch_get_line_in_hunk(
-			&origin, NULL, NULL, NULL, NULL, p, 0, line));
-		cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)origin);
+	max_l = git_patch_num_lines_in_hunk(p, 0);
+	for (l = 0; l < max_l; ++l) {
+		cl_git_pass(git_patch_get_line_in_hunk(&line, p, 0, l));
+		cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)line->origin);
 	}
 
 	git_patch_free(p);
diff --git a/tests-clar/diff/diff_helpers.c b/tests-clar/diff/diff_helpers.c
index cf768865e..466d0ef54 100644
--- a/tests-clar/diff/diff_helpers.c
+++ b/tests-clar/diff/diff_helpers.c
@@ -95,41 +95,37 @@ int diff_print_file_cb(
 
 int diff_hunk_cb(
 	const git_diff_delta *delta,
-	const git_diff_hunk *range,
-	const char *header,
-	size_t header_len,
+	const git_diff_hunk *hunk,
 	void *payload)
 {
 	diff_expects *e = payload;
+	const char *scan = hunk->header, *scan_end = scan + hunk->header_len;
 
 	GIT_UNUSED(delta);
 
 	/* confirm no NUL bytes in header text */
-	while (header_len--) cl_assert('\0' != *header++);
+	while (scan < scan_end)
+		cl_assert('\0' != *scan++);
 
 	e->hunks++;
-	e->hunk_old_lines += range->old_lines;
-	e->hunk_new_lines += range->new_lines;
+	e->hunk_old_lines += hunk->old_lines;
+	e->hunk_new_lines += hunk->new_lines;
 	return 0;
 }
 
 int diff_line_cb(
 	const git_diff_delta *delta,
-	const git_diff_hunk *range,
-	char line_origin,
-	const char *content,
-	size_t content_len,
+	const git_diff_hunk *hunk,
+	const git_diff_line *line,
 	void *payload)
 {
 	diff_expects *e = payload;
 
 	GIT_UNUSED(delta);
-	GIT_UNUSED(range);
-	GIT_UNUSED(content);
-	GIT_UNUSED(content_len);
+	GIT_UNUSED(hunk);
 
 	e->lines++;
-	switch (line_origin) {
+	switch (line->origin) {
 	case GIT_DIFF_LINE_CONTEXT:
 	case GIT_DIFF_LINE_CONTEXT_EOFNL: /* techically not a line */
 		e->line_ctxt++;
@@ -186,30 +182,23 @@ int diff_foreach_via_iterator(
 		num_h = git_patch_num_hunks(patch);
 
 		for (h = 0; h < num_h; h++) {
-			const git_diff_hunk *range;
-			const char *hdr;
-			size_t hdr_len, l, num_l;
+			const git_diff_hunk *hunk;
+			size_t l, num_l;
 
-			cl_git_pass(git_patch_get_hunk(
-				&range, &hdr, &hdr_len, &num_l, patch, h));
+			cl_git_pass(git_patch_get_hunk(&hunk, &num_l, patch, h));
 
-			if (hunk_cb && hunk_cb(delta, range, hdr, hdr_len, data) != 0) {
+			if (hunk_cb && hunk_cb(delta, hunk, data) != 0) {
 				git_patch_free(patch);
 				goto abort;
 			}
 
 			for (l = 0; l < num_l; ++l) {
-				char origin;
-				const char *line;
-				size_t line_len;
-				int old_lineno, new_lineno;
+				const git_diff_line *line;
 
-				cl_git_pass(git_patch_get_line_in_hunk(
-					&origin, &line, &line_len, &old_lineno, &new_lineno,
-					patch, h, l));
+				cl_git_pass(git_patch_get_line_in_hunk(&line, patch, h, l));
 
 				if (line_cb &&
-					line_cb(delta, range, origin, line, line_len, data) != 0) {
+					line_cb(delta, hunk, line, data) != 0) {
 					git_patch_free(patch);
 					goto abort;
 				}
@@ -228,18 +217,15 @@ abort:
 
 static int diff_print_cb(
 	const git_diff_delta *delta,
-	const git_diff_hunk *range,
-	char line_origin, /**< GIT_DIFF_LINE_... value from above */
-	const char *content,
-	size_t content_len,
+	const git_diff_hunk *hunk,
+	const git_diff_line *line,
 	void *payload)
 {
 	GIT_UNUSED(payload);
 	GIT_UNUSED(delta);
-	GIT_UNUSED(range);
-	GIT_UNUSED(line_origin);
-	GIT_UNUSED(content_len);
-	fputs(content, (FILE *)payload);
+	GIT_UNUSED(hunk);
+	fprintf((FILE *)payload, "%c%.*s",
+		line->origin, (int)line->content_len, line->content);
 	return 0;
 }
 
diff --git a/tests-clar/diff/diff_helpers.h b/tests-clar/diff/diff_helpers.h
index e3ad61f29..bf21f4b1f 100644
--- a/tests-clar/diff/diff_helpers.h
+++ b/tests-clar/diff/diff_helpers.h
@@ -44,17 +44,13 @@ extern int diff_print_file_cb(
 
 extern int diff_hunk_cb(
 	const git_diff_delta *delta,
-	const git_diff_hunk *range,
-	const char *header,
-	size_t header_len,
+	const git_diff_hunk *hunk,
 	void *cb_data);
 
 extern int diff_line_cb(
 	const git_diff_delta *delta,
-	const git_diff_hunk *range,
-	char line_origin,
-	const char *content,
-	size_t content_len,
+	const git_diff_hunk *hunk,
+	const git_diff_line *line,
 	void *cb_data);
 
 extern int diff_foreach_via_iterator(
diff --git a/tests-clar/diff/diffiter.c b/tests-clar/diff/diffiter.c
index 1a1e5dfc3..f886e1baa 100644
--- a/tests-clar/diff/diffiter.c
+++ b/tests-clar/diff/diffiter.c
@@ -101,15 +101,10 @@ void test_diff_diffiter__iterate_files_and_hunks(void)
 		num_h = git_patch_num_hunks(patch);
 
 		for (h = 0; h < num_h; h++) {
-			const git_diff_hunk *range;
-			const char *header;
-			size_t header_len, num_l;
-
-			cl_git_pass(git_patch_get_hunk(
-				&range, &header, &header_len, &num_l, patch, h));
+			const git_diff_hunk *hunk;
 
-			cl_assert(range);
-			cl_assert(header);
+			cl_git_pass(git_patch_get_hunk(&hunk, NULL, patch, h));
+			cl_assert(hunk);
 
 			hunk_count++;
 		}
@@ -229,22 +224,17 @@ void test_diff_diffiter__iterate_all(void)
 		num_h = git_patch_num_hunks(patch);
 		for (h = 0; h < num_h; h++) {
 			const git_diff_hunk *range;
-			const char *header;
-			size_t header_len, l, num_l;
+			size_t l, num_l;
 
-			cl_git_pass(git_patch_get_hunk(
-				&range, &header, &header_len, &num_l, patch, h));
-			cl_assert(range && header);
+			cl_git_pass(git_patch_get_hunk(&range, &num_l, patch, h));
+			cl_assert(range);
 			exp.hunks++;
 
 			for (l = 0; l < num_l; ++l) {
-				char origin;
-				const char *content;
-				size_t content_len;
+				const git_diff_line *line;
 
-				cl_git_pass(git_patch_get_line_in_hunk(
-					&origin, &content, &content_len, NULL, NULL, patch, h, l));
-				cl_assert(content);
+				cl_git_pass(git_patch_get_line_in_hunk(&line, patch, h, l));
+				cl_assert(line && line->content);
 				exp.lines++;
 			}
 		}
diff --git a/tests-clar/diff/patch.c b/tests-clar/diff/patch.c
index 9c01c3b4e..366e5da58 100644
--- a/tests-clar/diff/patch.c
+++ b/tests-clar/diff/patch.c
@@ -26,40 +26,37 @@ void test_diff_patch__cleanup(void)
 
 static int check_removal_cb(
 	const git_diff_delta *delta,
-	const git_diff_hunk *range,
-	char line_origin,
-	const char *formatted_output,
-	size_t output_len,
+	const git_diff_hunk *hunk,
+	const git_diff_line *line,
 	void *payload)
 {
 	GIT_UNUSED(payload);
-	GIT_UNUSED(output_len);
 
-	switch (line_origin) {
+	switch (line->origin) {
 	case GIT_DIFF_LINE_FILE_HDR:
-		cl_assert_equal_s(EXPECTED_HEADER, formatted_output);
-		cl_assert(range == NULL);
+		cl_assert_equal_s(EXPECTED_HEADER, line->content);
+		cl_assert(hunk == NULL);
 		goto check_delta;
 
 	case GIT_DIFF_LINE_HUNK_HDR:
-		cl_assert_equal_s(EXPECTED_HUNK, formatted_output);
+		cl_assert_equal_s(EXPECTED_HUNK, line->content);
 		/* Fall through */
 
 	case GIT_DIFF_LINE_CONTEXT:
 	case GIT_DIFF_LINE_DELETION:
-		goto check_range;
+		goto check_hunk;
 
 	default:
 		/* unexpected code path */
 		return -1;
 	}
 
-check_range:
-	cl_assert(range != NULL);
-	cl_assert_equal_i(1, range->old_start);
-	cl_assert_equal_i(2, range->old_lines);
-	cl_assert_equal_i(0, range->new_start);
-	cl_assert_equal_i(0, range->new_lines);
+check_hunk:
+	cl_assert(hunk != NULL);
+	cl_assert_equal_i(1, hunk->old_start);
+	cl_assert_equal_i(2, hunk->old_lines);
+	cl_assert_equal_i(0, hunk->new_start);
+	cl_assert_equal_i(0, hunk->new_lines);
 
 check_delta:
 	cl_assert_equal_s("subdir.txt", delta->old_file.path);
@@ -227,11 +224,9 @@ void test_diff_patch__hunks_have_correct_line_numbers(void)
 	git_diff *diff;
 	git_patch *patch;
 	const git_diff_delta *delta;
-	const git_diff_hunk *range;
-	const char *hdr, *text;
-	size_t hdrlen, hunklen, textlen;
-	char origin;
-	int oldno, newno;
+	const git_diff_hunk *hunk;
+	const git_diff_line *line;
+	size_t hunklen;
 	git_buf old_content = GIT_BUF_INIT, actual = GIT_BUF_INIT;
 	const char *new_content = "The Song of Seven Cities\n------------------------\n\nI WAS Lord of Cities very sumptuously builded.\nSeven roaring Cities paid me tribute from afar.\nIvory their outposts were--the guardrooms of them gilded,\nAnd garrisoned with Amazons invincible in war.\n\nThis is some new text;\nNot as good as the old text;\nBut here it is.\n\nSo they warred and trafficked only yesterday, my Cities.\nTo-day there is no mark or mound of where my Cities stood.\nFor the River rose at midnight and it washed away my Cities.\nThey are evened with Atlantis and the towns before the Flood.\n\nRain on rain-gorged channels raised the water-levels round them,\nFreshet backed on freshet swelled and swept their world from sight,\nTill the emboldened floods linked arms and, flashing forward, drowned them--\nDrowned my Seven Cities and their peoples in one night!\n\nLow among the alders lie their derelict foundations,\nThe beams wherein they trusted and the plinths whereon they built--\nMy rulers and their treasure and their unborn populations,\nDead, destroyed, aborted, and defiled with mud and silt!\n\nAnother replacement;\nBreaking up the poem;\nGenerating some hunks.\n\nTo the sound of trumpets shall their seed restore my Cities\nWealthy and well-weaponed, that once more may I behold\nAll the world go softly when it walks before my Cities,\nAnd the horses and the chariots fleeing from them as of old!\n\n  -- Rudyard Kipling\n";
 
@@ -263,78 +258,71 @@ void test_diff_patch__hunks_have_correct_line_numbers(void)
 	/* check hunk 0 */
 
 	cl_git_pass(
-		git_patch_get_hunk(&range, &hdr, &hdrlen, &hunklen, patch, 0));
+		git_patch_get_hunk(&hunk, &hunklen, patch, 0));
 
 	cl_assert_equal_i(18, (int)hunklen);
 
-	cl_assert_equal_i(6, (int)range->old_start);
-	cl_assert_equal_i(15, (int)range->old_lines);
-	cl_assert_equal_i(6, (int)range->new_start);
-	cl_assert_equal_i(9, (int)range->new_lines);
+	cl_assert_equal_i(6, (int)hunk->old_start);
+	cl_assert_equal_i(15, (int)hunk->old_lines);
+	cl_assert_equal_i(6, (int)hunk->new_start);
+	cl_assert_equal_i(9, (int)hunk->new_lines);
 
 	cl_assert_equal_i(18, (int)git_patch_num_lines_in_hunk(patch, 0));
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 0, 0));
-	cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 0, 0));
+	cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("Ivory their outposts were--the guardrooms of them gilded,\n", actual.ptr);
-	cl_assert_equal_i(6, oldno);
-	cl_assert_equal_i(6, newno);
+	cl_assert_equal_i(6, line->old_lineno);
+	cl_assert_equal_i(6, line->new_lineno);
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 0, 3));
-	cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 0, 3));
+	cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("All the world went softly when it walked before my Cities--\n", actual.ptr);
-	cl_assert_equal_i(9, oldno);
-	cl_assert_equal_i(-1, newno);
+	cl_assert_equal_i(9, line->old_lineno);
+	cl_assert_equal_i(-1, line->new_lineno);
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 0, 12));
-	cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 0, 12));
+	cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("This is some new text;\n", actual.ptr);
-	cl_assert_equal_i(-1, oldno);
-	cl_assert_equal_i(9, newno);
+	cl_assert_equal_i(-1, line->old_lineno);
+	cl_assert_equal_i(9, line->new_lineno);
 
 	/* check hunk 1 */
 
-	cl_git_pass(
-		git_patch_get_hunk(&range, &hdr, &hdrlen, &hunklen, patch, 1));
+	cl_git_pass(git_patch_get_hunk(&hunk, &hunklen, patch, 1));
 
 	cl_assert_equal_i(18, (int)hunklen);
 
-	cl_assert_equal_i(31, (int)range->old_start);
-	cl_assert_equal_i(15, (int)range->old_lines);
-	cl_assert_equal_i(25, (int)range->new_start);
-	cl_assert_equal_i(9, (int)range->new_lines);
+	cl_assert_equal_i(31, (int)hunk->old_start);
+	cl_assert_equal_i(15, (int)hunk->old_lines);
+	cl_assert_equal_i(25, (int)hunk->new_start);
+	cl_assert_equal_i(9, (int)hunk->new_lines);
 
 	cl_assert_equal_i(18, (int)git_patch_num_lines_in_hunk(patch, 1));
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 1, 0));
-	cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 1, 0));
+	cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("My rulers and their treasure and their unborn populations,\n", actual.ptr);
-	cl_assert_equal_i(31, oldno);
-	cl_assert_equal_i(25, newno);
+	cl_assert_equal_i(31, line->old_lineno);
+	cl_assert_equal_i(25, line->new_lineno);
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 1, 3));
-	cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 1, 3));
+	cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("The Daughters of the Palace whom they cherished in my Cities,\n", actual.ptr);
-	cl_assert_equal_i(34, oldno);
-	cl_assert_equal_i(-1, newno);
+	cl_assert_equal_i(34, line->old_lineno);
+	cl_assert_equal_i(-1, line->new_lineno);
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 1, 12));
-	cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 1, 12));
+	cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("Another replacement;\n", actual.ptr);
-	cl_assert_equal_i(-1, oldno);
-	cl_assert_equal_i(28, newno);
+	cl_assert_equal_i(-1, line->old_lineno);
+	cl_assert_equal_i(28, line->new_lineno);
 
 	git_patch_free(patch);
 	git_diff_free(diff);
@@ -356,57 +344,51 @@ void test_diff_patch__hunks_have_correct_line_numbers(void)
 
 	/* check hunk 0 */
 
-	cl_git_pass(
-		git_patch_get_hunk(&range, &hdr, &hdrlen, &hunklen, patch, 0));
+	cl_git_pass(git_patch_get_hunk(&hunk, &hunklen, patch, 0));
 
 	cl_assert_equal_i(6, (int)hunklen);
 
-	cl_assert_equal_i(46, (int)range->old_start);
-	cl_assert_equal_i(4, (int)range->old_lines);
-	cl_assert_equal_i(46, (int)range->new_start);
-	cl_assert_equal_i(4, (int)range->new_lines);
+	cl_assert_equal_i(46, (int)hunk->old_start);
+	cl_assert_equal_i(4, (int)hunk->old_lines);
+	cl_assert_equal_i(46, (int)hunk->new_start);
+	cl_assert_equal_i(4, (int)hunk->new_lines);
 
 	cl_assert_equal_i(6, (int)git_patch_num_lines_in_hunk(patch, 0));
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 0, 1));
-	cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 0, 1));
+	cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("And the horses and the chariots fleeing from them as of old!\n", actual.ptr);
-	cl_assert_equal_i(47, oldno);
-	cl_assert_equal_i(47, newno);
+	cl_assert_equal_i(47, line->old_lineno);
+	cl_assert_equal_i(47, line->new_lineno);
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 0, 2));
-	cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 0, 2));
+	cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("\n", actual.ptr);
-	cl_assert_equal_i(48, oldno);
-	cl_assert_equal_i(48, newno);
+	cl_assert_equal_i(48, line->old_lineno);
+	cl_assert_equal_i(48, line->new_lineno);
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 0, 3));
-	cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 0, 3));
+	cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("  -- Rudyard Kipling\n", actual.ptr);
-	cl_assert_equal_i(49, oldno);
-	cl_assert_equal_i(-1, newno);
+	cl_assert_equal_i(49, line->old_lineno);
+	cl_assert_equal_i(-1, line->new_lineno);
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 0, 4));
-	cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 0, 4));
+	cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("  -- Rudyard Kipling", actual.ptr);
-	cl_assert_equal_i(-1, oldno);
-	cl_assert_equal_i(49, newno);
+	cl_assert_equal_i(-1, line->old_lineno);
+	cl_assert_equal_i(49, line->new_lineno);
 
-	cl_git_pass(git_patch_get_line_in_hunk(
-		&origin, &text, &textlen, &oldno, &newno, patch, 0, 5));
-	cl_assert_equal_i(GIT_DIFF_LINE_DEL_EOFNL, (int)origin);
-	cl_git_pass(git_buf_set(&actual, text, textlen));
+	cl_git_pass(git_patch_get_line_in_hunk(&line, patch, 0, 5));
+	cl_assert_equal_i(GIT_DIFF_LINE_DEL_EOFNL, (int)line->origin);
+	cl_git_pass(git_buf_set(&actual, line->content, line->content_len));
 	cl_assert_equal_s("\n\\ No newline at end of file\n", actual.ptr);
-	cl_assert_equal_i(-1, oldno);
-	cl_assert_equal_i(49, newno);
+	cl_assert_equal_i(-1, line->old_lineno);
+	cl_assert_equal_i(49, line->new_lineno);
 
 	git_patch_free(patch);
 	git_diff_free(diff);
@@ -465,31 +447,34 @@ static void check_single_patch_stats(
 	/* walk lines in hunk with basic sanity checks */
 	for (; hunks > 0; --hunks) {
 		size_t i, max_i;
-		int lastoldno = -1, oldno, lastnewno = -1, newno;
-		char origin;
+		const git_diff_line *line;
+		int last_new_lineno = -1, last_old_lineno = -1;
 
 		max_i = git_patch_num_lines_in_hunk(patch, hunks - 1);
 
 		for (i = 0; i < max_i; ++i) {
 			int expected = 1;
 
-			cl_git_pass(git_patch_get_line_in_hunk(
-				&origin, NULL, NULL, &oldno, &newno, patch, hunks - 1, i));
+			cl_git_pass(
+				git_patch_get_line_in_hunk(&line, patch, hunks - 1, i));
 
-			if (origin == GIT_DIFF_LINE_ADD_EOFNL ||
-				origin == GIT_DIFF_LINE_DEL_EOFNL ||
-				origin == GIT_DIFF_LINE_CONTEXT_EOFNL)
+			if (line->origin == GIT_DIFF_LINE_ADD_EOFNL ||
+				line->origin == GIT_DIFF_LINE_DEL_EOFNL ||
+				line->origin == GIT_DIFF_LINE_CONTEXT_EOFNL)
 				expected = 0;
 
-			if (oldno >= 0) {
-				if (lastoldno >= 0)
-					cl_assert_equal_i(expected, oldno - lastoldno);
-				lastoldno = oldno;
+			if (line->old_lineno >= 0) {
+				if (last_old_lineno >= 0)
+					cl_assert_equal_i(
+						expected, line->old_lineno - last_old_lineno);
+				last_old_lineno = line->old_lineno;
 			}
-			if (newno >= 0) {
-				if (lastnewno >= 0)
-					cl_assert_equal_i(expected, newno - lastnewno);
-				lastnewno = newno;
+
+			if (line->new_lineno >= 0) {
+				if (last_new_lineno >= 0)
+					cl_assert_equal_i(
+						expected, line->new_lineno - last_new_lineno);
+				last_new_lineno = line->new_lineno;
 			}
 		}
 	}
diff --git a/tests-clar/diff/tree.c b/tests-clar/diff/tree.c
index 8231d3632..ca2daf5fb 100644
--- a/tests-clar/diff/tree.c
+++ b/tests-clar/diff/tree.c
@@ -257,11 +257,10 @@ void test_diff_tree__larger_hunks(void)
 {
 	const char *a_commit = "d70d245ed97ed2aa596dd1af6536e4bfdb047b69";
 	const char *b_commit = "7a9e0b02e63179929fed24f0a3e0f19168114d10";
-	size_t d, num_d, h, num_h, l, num_l, header_len, line_len;
+	size_t d, num_d, h, num_h, l, num_l;
 	git_patch *patch;
-	const git_diff_hunk *range;
-	const char *header, *line;
-	char origin;
+	const git_diff_hunk *hunk;
+	const git_diff_line *line;
 
 	g_repo = cl_git_sandbox_init("diff");
 
@@ -280,21 +279,17 @@ void test_diff_tree__larger_hunks(void)
 
 		num_h = git_patch_num_hunks(patch);
 		for (h = 0; h < num_h; h++) {
-			cl_git_pass(git_patch_get_hunk(
-				&range, &header, &header_len, &num_l, patch, h));
+			cl_git_pass(git_patch_get_hunk(&hunk, &num_l, patch, h));
 
 			for (l = 0; l < num_l; ++l) {
-				cl_git_pass(git_patch_get_line_in_hunk(
-					&origin, &line, &line_len, NULL, NULL, patch, h, l));
+				cl_git_pass(git_patch_get_line_in_hunk(&line, patch, h, l));
 				cl_assert(line);
 			}
 
-			cl_git_fail(git_patch_get_line_in_hunk(
-				&origin, &line, &line_len, NULL, NULL, patch, h, num_l));
+			cl_git_fail(git_patch_get_line_in_hunk(&line, patch, h, num_l));
 		}
 
-		cl_git_fail(git_patch_get_hunk(
-			&range, &header, &header_len, &num_l, patch, num_h));
+		cl_git_fail(git_patch_get_hunk(&hunk, &num_l, patch, num_h));
 
 		git_patch_free(patch);
 	}
diff --git a/tests-clar/diff/workdir.c b/tests-clar/diff/workdir.c
index ee63a700d..474891c16 100644
--- a/tests-clar/diff/workdir.c
+++ b/tests-clar/diff/workdir.c
@@ -673,7 +673,7 @@ void test_diff_workdir__larger_hunks(void)
 	const char *b_commit = "7a9e0b02e63179929fed24f0a3e0f19168114d10";
 	git_tree *a, *b;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
-	size_t i, d, num_d, h, num_h, l, num_l, header_len, line_len;
+	size_t i, d, num_d, h, num_h, l, num_l;
 
 	g_repo = cl_git_sandbox_init("diff");
 
@@ -686,9 +686,8 @@ void test_diff_workdir__larger_hunks(void)
 	for (i = 0; i <= 2; ++i) {
 		git_diff *diff = NULL;
 		git_patch *patch;
-		const git_diff_hunk *range;
-		const char *header, *line;
-		char origin;
+		const git_diff_hunk *hunk;
+		const git_diff_line *line;
 
 		/* okay, this is a bit silly, but oh well */
 		switch (i) {
@@ -712,23 +711,21 @@ void test_diff_workdir__larger_hunks(void)
 
 			num_h = git_patch_num_hunks(patch);
 			for (h = 0; h < num_h; h++) {
-				cl_git_pass(git_patch_get_hunk(
-					&range, &header, &header_len, &num_l, patch, h));
+				cl_git_pass(git_patch_get_hunk(&hunk, &num_l, patch, h));
 
 				for (l = 0; l < num_l; ++l) {
-					cl_git_pass(git_patch_get_line_in_hunk(
-						&origin, &line, &line_len, NULL, NULL, patch, h, l));
+					cl_git_pass(
+						git_patch_get_line_in_hunk(&line, patch, h, l));
 					cl_assert(line);
 				}
 
 				/* confirm fail after the last item */
-				cl_git_fail(git_patch_get_line_in_hunk(
-					&origin, &line, &line_len, NULL, NULL, patch, h, num_l));
+				cl_git_fail(
+					git_patch_get_line_in_hunk(&line, patch, h, num_l));
 			}
 
 			/* confirm fail after the last item */
-			cl_git_fail(git_patch_get_hunk(
-				&range, &header, &header_len, &num_l, patch, num_h));
+			cl_git_fail(git_patch_get_hunk(&hunk, &num_l, patch, num_h));
 
 			git_patch_free(patch);
 		}