diff: update the way rewrite diff handles incomplete lines

The diff_symbol based output framework uses one DIFF_SYMBOL_* enum
value per the kind of output lines of "git diff", which corresponds
to one output line from the xdiff machinery used internally.  Most
notably, DIFF_SYMBOL_PLUS and DIFF_SYMBOL_MINUS that correspond to
"+" and "-" lines are designed to always take a complete line, even
if the output from xdiff machinery may produce "\ No newline at the
end of file" immediately after them.

But this is not true in the rewrite-diff codepath, which completely
bypasses the xdiff machinery.  Since the code path feeds the bytes
directly from the payload to the output routines, the output layer
has to deal with an incomplete line with DIFF_SYMBOL_PLUS and
DIFF_SYMBOL_MINUS, which never would see an incomplete line in the
normal code paths.  This lack of final newline is compensated by an
ugly hack for a fabricated DIFF_SYMBOL_NO_LF_EOF token to inject an
extra newline to the output to simulate output coming from the xdiff
machinery.

Revamp the way the complete-rewrite code path feeds the lines to the
output layer by treating the last line of the pre/post image when it
is an incomplete line specially.

This lets us remove the DIFF_SYMBOL_NO_LF_EOF hack and use the usual
DIFF_SYMBOL_CONTEXT_INCOMPLETE code path, which will later learn how
to handle whitespace errors.

Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/diff.c b/diff.c
index 347cd9c6e90df6dba4b07c79321314adfdf426e8..99298720f48c6d69c480b9111fa5c98a856ae7ed 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -797,7 +797,6 @@ enum diff_symbol {
        DIFF_SYMBOL_CONTEXT_INCOMPLETE,
        DIFF_SYMBOL_PLUS,
        DIFF_SYMBOL_MINUS,
-       DIFF_SYMBOL_NO_LF_EOF,
        DIFF_SYMBOL_CONTEXT_FRAGINFO,
        DIFF_SYMBOL_CONTEXT_MARKER,
        DIFF_SYMBOL_SEPARATOR
@@ -1352,7 +1351,6 @@ static void emit_line_ws_markup(struct diff_options *o,
 static void emit_diff_symbol_from_struct(struct diff_options *o,
                                         struct emitted_diff_symbol *eds)
 {
-       static const char *nneof = " No newline at end of file\n";
        const char *context, *reset, *set, *set_sign, *meta, *fraginfo;
 
        enum diff_symbol s = eds->s;
@@ -1361,13 +1359,6 @@ static void emit_diff_symbol_from_struct(struct diff_options *o,
        unsigned flags = eds->flags;
 
        switch (s) {
-       case DIFF_SYMBOL_NO_LF_EOF:
-               context = diff_get_color_opt(o, DIFF_CONTEXT);
-               reset = diff_get_color_opt(o, DIFF_RESET);
-               putc('\n', o->file);
-               emit_line_0(o, context, NULL, 0, reset, '\\',
-                           nneof, strlen(nneof));
-               break;
        case DIFF_SYMBOL_SUBMODULE_HEADER:
        case DIFF_SYMBOL_SUBMODULE_ERROR:
        case DIFF_SYMBOL_SUBMODULE_PIPETHROUGH:
@@ -1786,22 +1777,36 @@ static void emit_rewrite_lines(struct emit_callback *ecbdata,
        const char *endp = NULL;
 
        while (0 < size) {
-               int len;
+               int len, plen;
+               char *pdata = NULL;
 
                endp = memchr(data, '\n', size);
                len = endp ? (endp - data + 1) : size;
+               plen = len;
+
+               if (!endp) {
+                       plen = len + 1;
+                       pdata = xmalloc(plen + 2);
+                       memcpy(pdata, data, len);
+                       pdata[len] = '\n';
+                       pdata[len + 1] = '\0';
+               }
                if (prefix != '+') {
                        ecbdata->lno_in_preimage++;
-                       emit_del_line(ecbdata, data, len);
+                       emit_del_line(ecbdata, pdata ? pdata : data, plen);
                } else {
                        ecbdata->lno_in_postimage++;
-                       emit_add_line(ecbdata, data, len);
+                       emit_add_line(ecbdata, pdata ? pdata : data, plen);
                }
+               free(pdata);
                size -= len;
                data += len;
        }
-       if (!endp)
-               emit_diff_symbol(ecbdata->opt, DIFF_SYMBOL_NO_LF_EOF, NULL, 0, 0);
+       if (!endp) {
+               static const char nneof[] = "\\ No newline at end of file\n";
+               ecbdata->last_line_kind = prefix;
+               emit_incomplete_line(ecbdata, nneof, sizeof(nneof) - 1);
+       }
 }
 
 static void emit_rewrite_diff(const char *name_a,