combine-diff.c: remove implicit dependency on the_index
[gitweb.git] / diff.c
diff --git a/diff.c b/diff.c
index 04d044bbb67b77a9992a499d4f7728bb85cfe94f..e5d6d30a676aacf7a8ee1888d208582765630183 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -70,6 +70,12 @@ static char diff_colors[][COLOR_MAXLEN] = {
        GIT_COLOR_BOLD_YELLOW,  /* NEW_MOVED ALTERNATIVE */
        GIT_COLOR_FAINT,        /* NEW_MOVED_DIM */
        GIT_COLOR_FAINT_ITALIC, /* NEW_MOVED_ALTERNATIVE_DIM */
+       GIT_COLOR_FAINT,        /* CONTEXT_DIM */
+       GIT_COLOR_FAINT_RED,    /* OLD_DIM */
+       GIT_COLOR_FAINT_GREEN,  /* NEW_DIM */
+       GIT_COLOR_BOLD,         /* CONTEXT_BOLD */
+       GIT_COLOR_BOLD_RED,     /* OLD_BOLD */
+       GIT_COLOR_BOLD_GREEN,   /* NEW_BOLD */
 };
 
 static const char *color_diff_slots[] = {
@@ -89,6 +95,12 @@ static const char *color_diff_slots[] = {
        [DIFF_FILE_NEW_MOVED_ALT]     = "newMovedAlternative",
        [DIFF_FILE_NEW_MOVED_DIM]     = "newMovedDimmed",
        [DIFF_FILE_NEW_MOVED_ALT_DIM] = "newMovedAlternativeDimmed",
+       [DIFF_CONTEXT_DIM]            = "contextDimmed",
+       [DIFF_FILE_OLD_DIM]           = "oldDimmed",
+       [DIFF_FILE_NEW_DIM]           = "newDimmed",
+       [DIFF_CONTEXT_BOLD]           = "contextBold",
+       [DIFF_FILE_OLD_BOLD]          = "oldBold",
+       [DIFF_FILE_NEW_BOLD]          = "newBold",
 };
 
 static NORETURN void die_want_option(const char *option_name)
@@ -271,10 +283,12 @@ static int parse_color_moved(const char *arg)
                return COLOR_MOVED_ZEBRA;
        else if (!strcmp(arg, "default"))
                return COLOR_MOVED_DEFAULT;
+       else if (!strcmp(arg, "dimmed-zebra"))
+               return COLOR_MOVED_ZEBRA_DIM;
        else if (!strcmp(arg, "dimmed_zebra"))
                return COLOR_MOVED_ZEBRA_DIM;
        else
-               return error(_("color moved setting must be one of 'no', 'default', 'blocks', 'zebra', 'dimmed_zebra', 'plain'"));
+               return error(_("color moved setting must be one of 'no', 'default', 'blocks', 'zebra', 'dimmed-zebra', 'plain'"));
 }
 
 static int parse_color_moved_ws(const char *arg)
@@ -540,14 +554,15 @@ static int count_lines(const char *data, int size)
        return count;
 }
 
-static int fill_mmfile(mmfile_t *mf, struct diff_filespec *one)
+static int fill_mmfile(struct repository *r, mmfile_t *mf,
+                      struct diff_filespec *one)
 {
        if (!DIFF_FILE_VALID(one)) {
                mf->ptr = (char *)""; /* does not matter */
                mf->size = 0;
                return 0;
        }
-       else if (diff_populate_filespec(one, 0))
+       else if (diff_populate_filespec(r, one, 0))
                return -1;
 
        mf->ptr = one->data;
@@ -556,11 +571,12 @@ static int fill_mmfile(mmfile_t *mf, struct diff_filespec *one)
 }
 
 /* like fill_mmfile, but only for size, so we can avoid retrieving blob */
-static unsigned long diff_filespec_size(struct diff_filespec *one)
+static unsigned long diff_filespec_size(struct repository *r,
+                                       struct diff_filespec *one)
 {
        if (!DIFF_FILE_VALID(one))
                return 0;
-       diff_populate_filespec(one, CHECK_SIZE_ONLY);
+       diff_populate_filespec(r, one, CHECK_SIZE_ONLY);
        return one->size;
 }
 
@@ -609,14 +625,18 @@ static void check_blank_at_eof(mmfile_t *mf1, mmfile_t *mf2,
        ecbdata->blank_at_eof_in_postimage = (at - l2) + 1;
 }
 
-static void emit_line_0(struct diff_options *o, const char *set, const char *reset,
+static void emit_line_0(struct diff_options *o,
+                       const char *set, unsigned reverse, const char *reset,
                        int first, const char *line, int len)
 {
        int has_trailing_newline, has_trailing_carriage_return;
        int nofirst;
        FILE *file = o->file;
 
-       fputs(diff_line_prefix(o), file);
+       if (first)
+               fputs(diff_line_prefix(o), file);
+       else if (!len)
+               return;
 
        if (len == 0) {
                has_trailing_newline = (first == '\n');
@@ -634,8 +654,10 @@ static void emit_line_0(struct diff_options *o, const char *set, const char *res
        }
 
        if (len || !nofirst) {
+               if (reverse && want_color(o->use_color))
+                       fputs(GIT_COLOR_REVERSE, file);
                fputs(set, file);
-               if (!nofirst)
+               if (first && !nofirst)
                        fputc(first, file);
                fwrite(line, len, 1, file);
                fputs(reset, file);
@@ -649,7 +671,7 @@ static void emit_line_0(struct diff_options *o, const char *set, const char *res
 static void emit_line(struct diff_options *o, const char *set, const char *reset,
                      const char *line, int len)
 {
-       emit_line_0(o, set, reset, line[0], line+1, len-1);
+       emit_line_0(o, set, 0, reset, line[0], line+1, len-1);
 }
 
 enum diff_symbol {
@@ -1168,7 +1190,8 @@ static void dim_moved_lines(struct diff_options *o)
 
 static void emit_line_ws_markup(struct diff_options *o,
                                const char *set, const char *reset,
-                               const char *line, int len, char sign,
+                               const char *line, int len,
+                               const char *set_sign, char sign,
                                unsigned ws_rule, int blank_at_eof)
 {
        const char *ws = NULL;
@@ -1179,14 +1202,20 @@ static void emit_line_ws_markup(struct diff_options *o,
                        ws = NULL;
        }
 
-       if (!ws)
-               emit_line_0(o, set, reset, sign, line, len);
-       else if (blank_at_eof)
+       if (!ws && !set_sign)
+               emit_line_0(o, set, 0, reset, sign, line, len);
+       else if (!ws) {
+               /* Emit just the prefix, then the rest. */
+               emit_line_0(o, set_sign ? set_sign : set, !!set_sign, reset,
+                           sign, "", 0);
+               emit_line_0(o, set, 0, reset, 0, line, len);
+       } else if (blank_at_eof)
                /* Blank line at EOF - paint '+' as well */
-               emit_line_0(o, ws, reset, sign, line, len);
+               emit_line_0(o, ws, 0, reset, sign, line, len);
        else {
                /* Emit just the prefix, then the rest. */
-               emit_line_0(o, set, reset, sign, "", 0);
+               emit_line_0(o, set_sign ? set_sign : set, !!set_sign, reset,
+                           sign, "", 0);
                ws_check_emit(line, len, ws_rule,
                              o->file, set, reset, ws);
        }
@@ -1196,7 +1225,7 @@ 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, *meta, *fraginfo;
+       const char *context, *reset, *set, *set_sign, *meta, *fraginfo;
        struct strbuf sb = STRBUF_INIT;
 
        enum diff_symbol s = eds->s;
@@ -1209,7 +1238,7 @@ static void emit_diff_symbol_from_struct(struct diff_options *o,
                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, reset, '\\',
+               emit_line_0(o, context, 0, reset, '\\',
                            nneof, strlen(nneof));
                break;
        case DIFF_SYMBOL_SUBMODULE_HEADER:
@@ -1236,7 +1265,18 @@ static void emit_diff_symbol_from_struct(struct diff_options *o,
        case DIFF_SYMBOL_CONTEXT:
                set = diff_get_color_opt(o, DIFF_CONTEXT);
                reset = diff_get_color_opt(o, DIFF_RESET);
-               emit_line_ws_markup(o, set, reset, line, len, ' ',
+               set_sign = NULL;
+               if (o->flags.dual_color_diffed_diffs) {
+                       char c = !len ? 0 : line[0];
+
+                       if (c == '+')
+                               set = diff_get_color_opt(o, DIFF_FILE_NEW);
+                       else if (c == '@')
+                               set = diff_get_color_opt(o, DIFF_FRAGINFO);
+                       else if (c == '-')
+                               set = diff_get_color_opt(o, DIFF_FILE_OLD);
+               }
+               emit_line_ws_markup(o, set, reset, line, len, set_sign, ' ',
                                    flags & (DIFF_SYMBOL_CONTENT_WS_MASK), 0);
                break;
        case DIFF_SYMBOL_PLUS:
@@ -1263,7 +1303,23 @@ static void emit_diff_symbol_from_struct(struct diff_options *o,
                        set = diff_get_color_opt(o, DIFF_FILE_NEW);
                }
                reset = diff_get_color_opt(o, DIFF_RESET);
-               emit_line_ws_markup(o, set, reset, line, len, '+',
+               if (!o->flags.dual_color_diffed_diffs)
+                       set_sign = NULL;
+               else {
+                       char c = !len ? 0 : line[0];
+
+                       set_sign = set;
+                       if (c == '-')
+                               set = diff_get_color_opt(o, DIFF_FILE_OLD_BOLD);
+                       else if (c == '@')
+                               set = diff_get_color_opt(o, DIFF_FRAGINFO);
+                       else if (c == '+')
+                               set = diff_get_color_opt(o, DIFF_FILE_NEW_BOLD);
+                       else
+                               set = diff_get_color_opt(o, DIFF_CONTEXT_BOLD);
+                       flags &= ~DIFF_SYMBOL_CONTENT_WS_MASK;
+               }
+               emit_line_ws_markup(o, set, reset, line, len, set_sign, '+',
                                    flags & DIFF_SYMBOL_CONTENT_WS_MASK,
                                    flags & DIFF_SYMBOL_CONTENT_BLANK_LINE_EOF);
                break;
@@ -1291,7 +1347,22 @@ static void emit_diff_symbol_from_struct(struct diff_options *o,
                        set = diff_get_color_opt(o, DIFF_FILE_OLD);
                }
                reset = diff_get_color_opt(o, DIFF_RESET);
-               emit_line_ws_markup(o, set, reset, line, len, '-',
+               if (!o->flags.dual_color_diffed_diffs)
+                       set_sign = NULL;
+               else {
+                       char c = !len ? 0 : line[0];
+
+                       set_sign = set;
+                       if (c == '+')
+                               set = diff_get_color_opt(o, DIFF_FILE_NEW_DIM);
+                       else if (c == '@')
+                               set = diff_get_color_opt(o, DIFF_FRAGINFO);
+                       else if (c == '-')
+                               set = diff_get_color_opt(o, DIFF_FILE_OLD_DIM);
+                       else
+                               set = diff_get_color_opt(o, DIFF_CONTEXT_DIM);
+               }
+               emit_line_ws_markup(o, set, reset, line, len, set_sign, '-',
                                    flags & DIFF_SYMBOL_CONTENT_WS_MASK, 0);
                break;
        case DIFF_SYMBOL_WORDS_PORCELAIN:
@@ -1482,6 +1553,7 @@ static void emit_hunk_header(struct emit_callback *ecbdata,
        const char *frag = diff_get_color(ecbdata->color_diff, DIFF_FRAGINFO);
        const char *func = diff_get_color(ecbdata->color_diff, DIFF_FUNCINFO);
        const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);
+       const char *reverse = ecbdata->color_diff ? GIT_COLOR_REVERSE : "";
        static const char atat[2] = { '@', '@' };
        const char *cp, *ep;
        struct strbuf msgbuf = STRBUF_INIT;
@@ -1502,6 +1574,8 @@ static void emit_hunk_header(struct emit_callback *ecbdata,
        ep += 2; /* skip over @@ */
 
        /* The hunk header in fraginfo color */
+       if (ecbdata->opt->flags.dual_color_diffed_diffs)
+               strbuf_addstr(&msgbuf, reverse);
        strbuf_addstr(&msgbuf, frag);
        strbuf_add(&msgbuf, line, ep - line);
        strbuf_addstr(&msgbuf, reset);
@@ -2069,8 +2143,8 @@ static void init_diff_words_data(struct emit_callback *ecbdata,
                if (regcomp(ecbdata->diff_words->word_regex,
                            o->word_regex,
                            REG_EXTENDED | REG_NEWLINE))
-                       die ("Invalid regular expression: %s",
-                            o->word_regex);
+                       die("invalid regular expression: %s",
+                           o->word_regex);
        }
        for (i = 0; i < ARRAY_SIZE(diff_words_styles); i++) {
                if (o->word_diff == diff_words_styles[i].type) {
@@ -2893,18 +2967,19 @@ static void show_dirstat(struct diff_options *options)
                }
 
                if (DIFF_FILE_VALID(p->one) && DIFF_FILE_VALID(p->two)) {
-                       diff_populate_filespec(p->one, 0);
-                       diff_populate_filespec(p->two, 0);
-                       diffcore_count_changes(p->one, p->two, NULL, NULL,
+                       diff_populate_filespec(options->repo, p->one, 0);
+                       diff_populate_filespec(options->repo, p->two, 0);
+                       diffcore_count_changes(options->repo,
+                                              p->one, p->two, NULL, NULL,
                                               &copied, &added);
                        diff_free_filespec_data(p->one);
                        diff_free_filespec_data(p->two);
                } else if (DIFF_FILE_VALID(p->one)) {
-                       diff_populate_filespec(p->one, CHECK_SIZE_ONLY);
+                       diff_populate_filespec(options->repo, p->one, CHECK_SIZE_ONLY);
                        copied = added = 0;
                        diff_free_filespec_data(p->one);
                } else if (DIFF_FILE_VALID(p->two)) {
-                       diff_populate_filespec(p->two, CHECK_SIZE_ONLY);
+                       diff_populate_filespec(options->repo, p->two, CHECK_SIZE_ONLY);
                        copied = 0;
                        added = p->two->size;
                        diff_free_filespec_data(p->two);
@@ -3178,7 +3253,8 @@ static void emit_binary_diff(struct diff_options *o,
        emit_binary_diff_body(o, two, one);
 }
 
-int diff_filespec_is_binary(struct diff_filespec *one)
+int diff_filespec_is_binary(struct repository *r,
+                           struct diff_filespec *one)
 {
        if (one->is_binary == -1) {
                diff_filespec_load_driver(one);
@@ -3186,7 +3262,7 @@ int diff_filespec_is_binary(struct diff_filespec *one)
                        one->is_binary = one->driver->binary;
                else {
                        if (!one->data && DIFF_FILE_VALID(one))
-                               diff_populate_filespec(one, CHECK_BINARY);
+                               diff_populate_filespec(r, one, CHECK_BINARY);
                        if (one->is_binary == -1 && one->data)
                                one->is_binary = buffer_is_binary(one->data,
                                                one->size);
@@ -3308,13 +3384,13 @@ static void builtin_diff(const char *name_a,
                if ((one->mode ^ two->mode) & S_IFMT)
                        goto free_ab_and_return;
                if (complete_rewrite &&
-                   (textconv_one || !diff_filespec_is_binary(one)) &&
-                   (textconv_two || !diff_filespec_is_binary(two))) {
+                   (textconv_one || !diff_filespec_is_binary(o->repo, one)) &&
+                   (textconv_two || !diff_filespec_is_binary(o->repo, two))) {
                        emit_diff_symbol(o, DIFF_SYMBOL_HEADER,
                                         header.buf, header.len, 0);
                        strbuf_reset(&header);
                        emit_rewrite_diff(name_a, name_b, one, two,
-                                               textconv_one, textconv_two, o);
+                                         textconv_one, textconv_two, o);
                        o->found_changes = 1;
                        goto free_ab_and_return;
                }
@@ -3326,8 +3402,8 @@ static void builtin_diff(const char *name_a,
                strbuf_reset(&header);
                goto free_ab_and_return;
        } else if (!o->flags.text &&
-           ( (!textconv_one && diff_filespec_is_binary(one)) ||
-             (!textconv_two && diff_filespec_is_binary(two)) )) {
+                  ( (!textconv_one && diff_filespec_is_binary(o->repo, one)) ||
+                    (!textconv_two && diff_filespec_is_binary(o->repo, two)) )) {
                struct strbuf sb = STRBUF_INIT;
                if (!one->data && !two->data &&
                    S_ISREG(one->mode) && S_ISREG(two->mode) &&
@@ -3348,7 +3424,8 @@ static void builtin_diff(const char *name_a,
                        strbuf_release(&sb);
                        goto free_ab_and_return;
                }
-               if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
+               if (fill_mmfile(o->repo, &mf1, one) < 0 ||
+                   fill_mmfile(o->repo, &mf2, two) < 0)
                        die("unable to read files to diff");
                /* Quite common confusing case */
                if (mf1.size == mf2.size &&
@@ -3395,13 +3472,16 @@ static void builtin_diff(const char *name_a,
                memset(&xpp, 0, sizeof(xpp));
                memset(&xecfg, 0, sizeof(xecfg));
                memset(&ecbdata, 0, sizeof(ecbdata));
+               if (o->flags.suppress_diff_headers)
+                       lbl[0] = NULL;
                ecbdata.label_path = lbl;
                ecbdata.color_diff = want_color(o->use_color);
                ecbdata.ws_rule = whitespace_rule(name_b);
                if (ecbdata.ws_rule & WS_BLANK_AT_EOF)
                        check_blank_at_eof(&mf1, &mf2, &ecbdata);
                ecbdata.opt = o;
-               ecbdata.header = header.len ? &header : NULL;
+               if (header.len && !o->flags.suppress_diff_headers)
+                       ecbdata.header = &header;
                xpp.flags = o->xdl_opts;
                xpp.anchors = o->anchors;
                xpp.anchors_nr = o->anchors_nr;
@@ -3496,20 +3576,21 @@ static void builtin_diffstat(const char *name_a, const char *name_b,
 
        same_contents = !oidcmp(&one->oid, &two->oid);
 
-       if (diff_filespec_is_binary(one) || diff_filespec_is_binary(two)) {
+       if (diff_filespec_is_binary(o->repo, one) ||
+           diff_filespec_is_binary(o->repo, two)) {
                data->is_binary = 1;
                if (same_contents) {
                        data->added = 0;
                        data->deleted = 0;
                } else {
-                       data->added = diff_filespec_size(two);
-                       data->deleted = diff_filespec_size(one);
+                       data->added = diff_filespec_size(o->repo, two);
+                       data->deleted = diff_filespec_size(o->repo, one);
                }
        }
 
        else if (complete_rewrite) {
-               diff_populate_filespec(one, 0);
-               diff_populate_filespec(two, 0);
+               diff_populate_filespec(o->repo, one, 0);
+               diff_populate_filespec(o->repo, two, 0);
                data->deleted = count_lines(one->data, one->size);
                data->added = count_lines(two->data, two->size);
        }
@@ -3519,7 +3600,8 @@ static void builtin_diffstat(const char *name_a, const char *name_b,
                xpparam_t xpp;
                xdemitconf_t xecfg;
 
-               if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
+               if (fill_mmfile(o->repo, &mf1, one) < 0 ||
+                   fill_mmfile(o->repo, &mf2, two) < 0)
                        die("unable to read files to diff");
 
                memset(&xpp, 0, sizeof(xpp));
@@ -3557,7 +3639,8 @@ static void builtin_checkdiff(const char *name_a, const char *name_b,
        data.ws_rule = whitespace_rule(attr_path);
        data.conflict_marker_size = ll_merge_marker_size(attr_path);
 
-       if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
+       if (fill_mmfile(o->repo, &mf1, one) < 0 ||
+           fill_mmfile(o->repo, &mf2, two) < 0)
                die("unable to read files to diff");
 
        /*
@@ -3566,7 +3649,7 @@ static void builtin_checkdiff(const char *name_a, const char *name_b,
         * introduced changes, and as long as the "new" side is text, we
         * can and should check what it introduces.
         */
-       if (diff_filespec_is_binary(two))
+       if (diff_filespec_is_binary(o->repo, two))
                goto free_and_return;
        else {
                /* Crazy xdl interfaces.. */
@@ -3639,7 +3722,10 @@ void fill_filespec(struct diff_filespec *spec, const struct object_id *oid,
  * the work tree has that object contents, return true, so that
  * prepare_temp_file() does not have to inflate and extract.
  */
-static int reuse_worktree_file(const char *name, const struct object_id *oid, int want_file)
+static int reuse_worktree_file(struct index_state *istate,
+                              const char *name,
+                              const struct object_id *oid,
+                              int want_file)
 {
        const struct cache_entry *ce;
        struct stat st;
@@ -3658,7 +3744,7 @@ static int reuse_worktree_file(const char *name, const struct object_id *oid, in
         * by diff-cache --cached, which does read the cache before
         * calling us.
         */
-       if (!active_cache)
+       if (!istate->cache)
                return 0;
 
        /* We want to avoid the working directory if our caller
@@ -3677,14 +3763,14 @@ static int reuse_worktree_file(const char *name, const struct object_id *oid, in
         * Similarly, if we'd have to convert the file contents anyway, that
         * makes the optimization not worthwhile.
         */
-       if (!want_file && would_convert_to_git(&the_index, name))
+       if (!want_file && would_convert_to_git(istate, name))
                return 0;
 
        len = strlen(name);
-       pos = cache_name_pos(name, len);
+       pos = index_name_pos(istate, name, len);
        if (pos < 0)
                return 0;
-       ce = active_cache[pos];
+       ce = istate->cache[pos];
 
        /*
         * This is not the sha1 we are looking for, or
@@ -3704,7 +3790,7 @@ static int reuse_worktree_file(const char *name, const struct object_id *oid, in
         * If ce matches the file in the work tree, we can reuse it.
         */
        if (ce_uptodate(ce) ||
-           (!lstat(name, &st) && !ce_match_stat(ce, &st, 0)))
+           (!lstat(name, &st) && !ie_match_stat(istate, ce, &st, 0)))
                return 1;
 
        return 0;
@@ -3737,7 +3823,9 @@ static int diff_populate_gitlink(struct diff_filespec *s, int size_only)
  * grab the data for the blob (or file) for our own in-core comparison.
  * diff_filespec has data and size fields for this purpose.
  */
-int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
+int diff_populate_filespec(struct repository *r,
+                          struct diff_filespec *s,
+                          unsigned int flags)
 {
        int size_only = flags & CHECK_SIZE_ONLY;
        int err = 0;
@@ -3764,7 +3852,7 @@ int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
                return diff_populate_gitlink(s, size_only);
 
        if (!s->oid_valid ||
-           reuse_worktree_file(s->path, &s->oid, 0)) {
+           reuse_worktree_file(r->index, s->path, &s->oid, 0)) {
                struct strbuf buf = STRBUF_INIT;
                struct stat st;
                int fd;
@@ -3797,7 +3885,7 @@ int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
                 * point if the path requires us to run the content
                 * conversion.
                 */
-               if (size_only && !would_convert_to_git(&the_index, s->path))
+               if (size_only && !would_convert_to_git(r->index, s->path))
                        return 0;
 
                /*
@@ -3824,7 +3912,7 @@ int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
                /*
                 * Convert from working tree format to canonical git format
                 */
-               if (convert_to_git(&the_index, s->path, s->data, s->size, &buf, conv_flags)) {
+               if (convert_to_git(r->index, s->path, s->data, s->size, &buf, conv_flags)) {
                        size_t size = 0;
                        munmap(s->data, s->size);
                        s->should_munmap = 0;
@@ -3836,8 +3924,7 @@ int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
        else {
                enum object_type type;
                if (size_only || (flags & CHECK_BINARY)) {
-                       type = oid_object_info(the_repository, &s->oid,
-                                              &s->size);
+                       type = oid_object_info(r, &s->oid, &s->size);
                        if (type < 0)
                                die("unable to read %s",
                                    oid_to_hex(&s->oid));
@@ -3875,7 +3962,8 @@ void diff_free_filespec_data(struct diff_filespec *s)
        FREE_AND_NULL(s->cnt_data);
 }
 
-static void prep_temp_blob(const char *path, struct diff_tempfile *temp,
+static void prep_temp_blob(struct index_state *istate,
+                          const char *path, struct diff_tempfile *temp,
                           void *blob,
                           unsigned long size,
                           const struct object_id *oid,
@@ -3893,7 +3981,7 @@ static void prep_temp_blob(const char *path, struct diff_tempfile *temp,
        temp->tempfile = mks_tempfile_ts(tempfile.buf, strlen(base) + 1);
        if (!temp->tempfile)
                die_errno("unable to create temp-file");
-       if (convert_to_working_tree(path,
+       if (convert_to_working_tree(istate, path,
                        (const char *)blob, (size_t)size, &buf)) {
                blob = buf.buf;
                size = buf.len;
@@ -3909,8 +3997,9 @@ static void prep_temp_blob(const char *path, struct diff_tempfile *temp,
        free(path_dup);
 }
 
-static struct diff_tempfile *prepare_temp_file(const char *name,
-               struct diff_filespec *one)
+static struct diff_tempfile *prepare_temp_file(struct repository *r,
+                                              const char *name,
+                                              struct diff_filespec *one)
 {
        struct diff_tempfile *temp = claim_diff_tempfile();
 
@@ -3927,7 +4016,7 @@ static struct diff_tempfile *prepare_temp_file(const char *name,
 
        if (!S_ISGITLINK(one->mode) &&
            (!one->oid_valid ||
-            reuse_worktree_file(name, &one->oid, 1))) {
+            reuse_worktree_file(r->index, name, &one->oid, 1))) {
                struct stat st;
                if (lstat(name, &st) < 0) {
                        if (errno == ENOENT)
@@ -3938,7 +4027,7 @@ static struct diff_tempfile *prepare_temp_file(const char *name,
                        struct strbuf sb = STRBUF_INIT;
                        if (strbuf_readlink(&sb, name, st.st_size) < 0)
                                die_errno("readlink(%s)", name);
-                       prep_temp_blob(name, temp, sb.buf, sb.len,
+                       prep_temp_blob(r->index, name, temp, sb.buf, sb.len,
                                       (one->oid_valid ?
                                        &one->oid : &null_oid),
                                       (one->oid_valid ?
@@ -3963,19 +4052,21 @@ static struct diff_tempfile *prepare_temp_file(const char *name,
                return temp;
        }
        else {
-               if (diff_populate_filespec(one, 0))
+               if (diff_populate_filespec(r, one, 0))
                        die("cannot read data blob for %s", one->path);
-               prep_temp_blob(name, temp, one->data, one->size,
+               prep_temp_blob(r->index, name, temp,
+                              one->data, one->size,
                               &one->oid, one->mode);
        }
        return temp;
 }
 
-static void add_external_diff_name(struct argv_array *argv,
+static void add_external_diff_name(struct repository *r,
+                                  struct argv_array *argv,
                                   const char *name,
                                   struct diff_filespec *df)
 {
-       struct diff_tempfile *temp = prepare_temp_file(name, df);
+       struct diff_tempfile *temp = prepare_temp_file(r, name, df);
        argv_array_push(argv, temp->name);
        argv_array_push(argv, temp->hex);
        argv_array_push(argv, temp->mode);
@@ -4004,11 +4095,11 @@ static void run_external_diff(const char *pgm,
        argv_array_push(&argv, name);
 
        if (one && two) {
-               add_external_diff_name(&argv, name, one);
+               add_external_diff_name(o->repo, &argv, name, one);
                if (!other)
-                       add_external_diff_name(&argv, name, two);
+                       add_external_diff_name(o->repo, &argv, name, two);
                else {
-                       add_external_diff_name(&argv, other, two);
+                       add_external_diff_name(o->repo, &argv, other, two);
                        argv_array_push(&argv, other);
                        argv_array_push(&argv, xfrm_msg);
                }
@@ -4101,8 +4192,10 @@ static void fill_metainfo(struct strbuf *msg,
 
                if (o->flags.binary) {
                        mmfile_t mf;
-                       if ((!fill_mmfile(&mf, one) && diff_filespec_is_binary(one)) ||
-                           (!fill_mmfile(&mf, two) && diff_filespec_is_binary(two)))
+                       if ((!fill_mmfile(o->repo, &mf, one) &&
+                            diff_filespec_is_binary(o->repo, one)) ||
+                           (!fill_mmfile(o->repo, &mf, two) &&
+                            diff_filespec_is_binary(o->repo, two)))
                                abbrev = hexsz;
                }
                strbuf_addf(msg, "%s%sindex %s..%s", line_prefix, set,
@@ -4230,7 +4323,8 @@ static void run_diff(struct diff_filepair *p, struct diff_options *o)
                 */
                struct diff_filespec *null = alloc_filespec(two->path);
                run_diff_cmd(NULL, name, other, attr_path,
-                            one, null, &msg, o, p);
+                            one, null, &msg,
+                            o, p);
                free(null);
                strbuf_release(&msg);
 
@@ -4254,7 +4348,8 @@ static void run_diffstat(struct diff_filepair *p, struct diff_options *o,
 
        if (DIFF_PAIR_UNMERGED(p)) {
                /* unmerged */
-               builtin_diffstat(p->one->path, NULL, NULL, NULL, diffstat, o, p);
+               builtin_diffstat(p->one->path, NULL, NULL, NULL,
+                                diffstat, o, p);
                return;
        }
 
@@ -4267,7 +4362,8 @@ static void run_diffstat(struct diff_filepair *p, struct diff_options *o,
        diff_fill_oid_info(p->one);
        diff_fill_oid_info(p->two);
 
-       builtin_diffstat(name, other, p->one, p->two, diffstat, o, p);
+       builtin_diffstat(name, other, p->one, p->two,
+                        diffstat, o, p);
 }
 
 static void run_checkdiff(struct diff_filepair *p, struct diff_options *o)
@@ -4299,6 +4395,7 @@ void diff_setup(struct diff_options *options)
        memcpy(options, &default_diff_options, sizeof(*options));
 
        options->file = stdout;
+       options->repo->index = &the_index;
 
        options->abbrev = DEFAULT_ABBREV;
        options->line_termination = '\n';
@@ -4414,16 +4511,6 @@ void diff_setup_done(struct diff_options *options)
 
        if (options->detect_rename && options->rename_limit < 0)
                options->rename_limit = diff_rename_limit_default;
-       if (options->setup & DIFF_SETUP_USE_CACHE) {
-               if (!active_cache)
-                       /* read-cache does not die even when it fails
-                        * so it is safe for us to do this here.  Also
-                        * it does not smudge active_cache or active_nr
-                        * when it fails, so we do not have to worry about
-                        * cleaning it up ourselves either.
-                        */
-                       read_cache();
-       }
        if (hexsz < options->abbrev)
                options->abbrev = hexsz; /* full */
 
@@ -5631,12 +5718,12 @@ static int diff_get_patch_id(struct diff_options *options, struct object_id *oid
                if (diff_header_only)
                        continue;
 
-               if (fill_mmfile(&mf1, p->one) < 0 ||
-                   fill_mmfile(&mf2, p->two) < 0)
+               if (fill_mmfile(options->repo, &mf1, p->one) < 0 ||
+                   fill_mmfile(options->repo, &mf2, p->two) < 0)
                        return error("unable to read files to diff");
 
-               if (diff_filespec_is_binary(p->one) ||
-                   diff_filespec_is_binary(p->two)) {
+               if (diff_filespec_is_binary(options->repo, p->one) ||
+                   diff_filespec_is_binary(options->repo, p->two)) {
                        git_SHA1_Update(&ctx, oid_to_hex(&p->one->oid),
                                        GIT_SHA1_HEXSZ);
                        git_SHA1_Update(&ctx, oid_to_hex(&p->two->oid),
@@ -5939,19 +6026,21 @@ static void diffcore_apply_filter(struct diff_options *options)
 }
 
 /* Check whether two filespecs with the same mode and size are identical */
-static int diff_filespec_is_identical(struct diff_filespec *one,
+static int diff_filespec_is_identical(struct repository *r,
+                                     struct diff_filespec *one,
                                      struct diff_filespec *two)
 {
        if (S_ISGITLINK(one->mode))
                return 0;
-       if (diff_populate_filespec(one, 0))
+       if (diff_populate_filespec(r, one, 0))
                return 0;
-       if (diff_populate_filespec(two, 0))
+       if (diff_populate_filespec(r, two, 0))
                return 0;
        return !memcmp(one->data, two->data, one->size);
 }
 
-static int diff_filespec_check_stat_unmatch(struct diff_filepair *p)
+static int diff_filespec_check_stat_unmatch(struct repository *r,
+                                           struct diff_filepair *p)
 {
        if (p->done_skip_stat_unmatch)
                return p->skip_stat_unmatch_result;
@@ -5975,10 +6064,10 @@ static int diff_filespec_check_stat_unmatch(struct diff_filepair *p)
            !DIFF_FILE_VALID(p->two) ||
            (p->one->oid_valid && p->two->oid_valid) ||
            (p->one->mode != p->two->mode) ||
-           diff_populate_filespec(p->one, CHECK_SIZE_ONLY) ||
-           diff_populate_filespec(p->two, CHECK_SIZE_ONLY) ||
+           diff_populate_filespec(r, p->one, CHECK_SIZE_ONLY) ||
+           diff_populate_filespec(r, p->two, CHECK_SIZE_ONLY) ||
            (p->one->size != p->two->size) ||
-           !diff_filespec_is_identical(p->one, p->two)) /* (2) */
+           !diff_filespec_is_identical(r, p->one, p->two)) /* (2) */
                p->skip_stat_unmatch_result = 1;
        return p->skip_stat_unmatch_result;
 }
@@ -5993,7 +6082,7 @@ static void diffcore_skip_stat_unmatch(struct diff_options *diffopt)
        for (i = 0; i < q->nr; i++) {
                struct diff_filepair *p = q->queue[i];
 
-               if (diff_filespec_check_stat_unmatch(p))
+               if (diff_filespec_check_stat_unmatch(diffopt->repo, p))
                        diff_q(&outq, p);
                else {
                        /*
@@ -6035,7 +6124,8 @@ void diffcore_std(struct diff_options *options)
        if (!options->found_follow) {
                /* See try_to_follow_renames() in tree-diff.c */
                if (options->break_opt != -1)
-                       diffcore_break(options->break_opt);
+                       diffcore_break(options->repo,
+                                      options->break_opt);
                if (options->detect_rename)
                        diffcore_rename(options);
                if (options->break_opt != -1)
@@ -6186,7 +6276,7 @@ void diff_change(struct diff_options *options,
                return;
 
        if (options->flags.quick && options->skip_stat_unmatch &&
-           !diff_filespec_check_stat_unmatch(p))
+           !diff_filespec_check_stat_unmatch(options->repo, p))
                return;
 
        options->flags.has_changes = 1;
@@ -6208,8 +6298,10 @@ struct diff_filepair *diff_unmerge(struct diff_options *options, const char *pat
        return pair;
 }
 
-static char *run_textconv(const char *pgm, struct diff_filespec *spec,
-               size_t *outsize)
+static char *run_textconv(struct repository *r,
+                         const char *pgm,
+                         struct diff_filespec *spec,
+                         size_t *outsize)
 {
        struct diff_tempfile *temp;
        const char *argv[3];
@@ -6218,7 +6310,7 @@ static char *run_textconv(const char *pgm, struct diff_filespec *spec,
        struct strbuf buf = STRBUF_INIT;
        int err = 0;
 
-       temp = prepare_temp_file(spec->path, spec);
+       temp = prepare_temp_file(r, spec->path, spec);
        *arg++ = pgm;
        *arg++ = temp->name;
        *arg = NULL;
@@ -6249,6 +6341,7 @@ size_t fill_textconv(struct userdiff_driver *driver,
                     struct diff_filespec *df,
                     char **outbuf)
 {
+       struct repository *r = the_repository;
        size_t size;
 
        if (!driver) {
@@ -6256,7 +6349,7 @@ size_t fill_textconv(struct userdiff_driver *driver,
                        *outbuf = "";
                        return 0;
                }
-               if (diff_populate_filespec(df, 0))
+               if (diff_populate_filespec(r, df, 0))
                        die("unable to read files to diff");
                *outbuf = df->data;
                return df->size;
@@ -6273,7 +6366,7 @@ size_t fill_textconv(struct userdiff_driver *driver,
                        return size;
        }
 
-       *outbuf = run_textconv(driver->textconv, df, &size);
+       *outbuf = run_textconv(r, driver->textconv, df, &size);
        if (!*outbuf)
                die("unable to read files to diff");