[v2,00/11] tree-wide: chip away at USE_THE_INDEX_COMPATIBILITY_MACROS

Message

Ævar Arnfjörð Bjarmason Nov. 19, 2022, 1:07 p.m. UTC

A re-roll that should address feedback on v1[1]. Change since v1:

* Since "vd/skip-cache-tree-update" has landed on "master" the
  "test-tool.h" can stop providing
  "USE_THE_INDEX_COMPATIBILITY_MACROS" to the test tools, which we're
  unlikely to have a semantic conflict for while this graduates.

  A change in 7/12 is due to rebasing on that topic, ditto applying
  the transformation in 8/12 to code it added.

* The 11/12 is now quite a bit larger, and now does the
  transformations that don't conflict with anything in-flight.
  I.e. (aside from needing to eject v1 of this topic) it'll merge
  cleanly with "seen"

  Hopfully that expanded scope isn't stepping too much outside the
  bounds here. But once "vd/skip-cache-tree-update" had landed just
  applying it to the rest that didn't conflict didn't seem too
  bad. It's a relatively large diffstat, but not that much on top of
  the v1, and it's almost entirely a change coccinelle is making".

1. https://lore.kernel.org/git/[e-mail]/

Branch & passing CI at:
https://github.com/avar/git/tree/avar/narrow-down-the-index-compatibilty-macros-2

Ævar Arnfjörð Bjarmason (11):
  cache.h: remove unused "the_index" compat macros
  builtin/{grep,log}.: don't define "USE_THE_INDEX_COMPATIBILITY_MACROS"
  cocci & cache.h: remove rarely used "the_index" compat macros
  read-cache API & users: make discard_index() return void
  cocci: add a index-compatibility.pending.cocci
  cocci & cache.h: apply a selection of "pending" index-compatibility
  cocci & cache.h: apply variable section of "pending"
    index-compatibility
  cocci: apply "pending" index-compatibility to "t/helper/*.c"
  {builtin/*,repository}.c: add & use "USE_THE_INDEX_VARIABLE"
  cache.h & test-tool.h: add & use "USE_THE_INDEX_VARIABLE"
  cocci: apply "pending" index-compatibility to some "builtin/*.c"

 add-interactive.c                             |   8 +-
 add-patch.c                                   |   3 +-
 builtin/add.c                                 |  21 +--
 builtin/am.c                                  |  25 ++--
 builtin/cat-file.c                            |   2 +-
 builtin/check-attr.c                          |   4 +-
 builtin/check-ignore.c                        |   4 +-
 builtin/checkout-index.c                      |  19 +--
 builtin/checkout.c                            |  67 ++++-----
 builtin/clean.c                               |   6 +-
 builtin/clone.c                               |   4 +-
 builtin/commit.c                              |  60 ++++----
 builtin/describe.c                            |   7 +-
 builtin/diff-files.c                          |   5 +-
 builtin/diff-index.c                          |   9 +-
 builtin/diff-tree.c                           |   4 +-
 builtin/diff.c                                |  25 ++--
 builtin/difftool.c                            |   2 +-
 builtin/fsck.c                                |  16 +--
 builtin/grep.c                                |   1 -
 builtin/log.c                                 |   1 -
 builtin/merge-index.c                         |  16 +--
 builtin/merge-ours.c                          |   3 +-
 builtin/merge-tree.c                          |   2 +-
 builtin/merge.c                               |  32 +++--
 builtin/mv.c                                  |  41 +++---
 builtin/pull.c                                |   6 +-
 builtin/read-tree.c                           |  12 +-
 builtin/rebase.c                              |   6 +-
 builtin/reset.c                               |  20 +--
 builtin/rev-parse.c                           |   4 +-
 builtin/rm.c                                  |  26 ++--
 builtin/stash.c                               |  43 +++---
 builtin/submodule--helper.c                   |  28 ++--
 builtin/update-index.c                        |  91 ++++++------
 cache.h                                       |  36 +----
 contrib/coccinelle/index-compatibility.cocci  | 135 ++++++++++++++++++
 .../index-compatibility.pending.cocci         |  24 ++++
 read-cache.c                                  |   4 +-
 repository.c                                  |   2 +-
 sequencer.c                                   |  15 +-
 t/helper/test-cache-tree.c                    |   3 +-
 t/helper/test-dump-cache-tree.c               |   5 +-
 t/helper/test-dump-split-index.c              |   1 +
 t/helper/test-dump-untracked-cache.c          |   4 +-
 t/helper/test-fast-rebase.c                   |   4 +-
 t/helper/test-lazy-init-name-hash.c           |  21 +--
 t/helper/test-read-cache.c                    |   5 +-
 t/helper/test-scrap-cache-tree.c              |   9 +-
 t/helper/test-tool.h                          |   1 -
 t/helper/test-write-cache.c                   |   6 +-
 51 files changed, 532 insertions(+), 366 deletions(-)
 create mode 100644 contrib/coccinelle/index-compatibility.cocci
 create mode 100644 contrib/coccinelle/index-compatibility.pending.cocci

Range-diff against v1:
 1:  760b4ddf06a =  1:  3ddae1f5886 cache.h: remove unused "the_index" compat macros
 2:  9789509a902 =  2:  3dd3af7b7bb builtin/{grep,log}.: don't define "USE_THE_INDEX_COMPATIBILITY_MACROS"
 3:  faa7757cb32 =  3:  5c2776a28f7 cocci & cache.h: remove rarely used "the_index" compat macros
 4:  362a14a0539 =  4:  b4d6685585a read-cache API & users: make discard_index() return void
 5:  14bf6e7188c =  5:  ec740a81d9f cocci: add a index-compatibility.pending.cocci
 6:  dbf14ed23e6 =  6:  6849233bf2b cocci & cache.h: apply a selection of "pending" index-compatibility
 7:  bf507c79d07 !  7:  fff2d0459a0 cocci & cache.h: apply variable section of "pending" index-compatibility
    @@ Commit message
         In doing so move more of "index-compatibility.pending.cocci" to
         "index-compatibility.cocci".
     
    -    In the case of "active_cache_tree" we'd have a textual conflict with
    -    "vd/skip-cache-tree-update" in "next"[1], and in the case of
    -    "active_nr" with "ab/various-leak-fixes" in "seen". Let's exclude
    -    those specific cases while moving the rule over from "pending".
    +    In the case of "active_nr" we'd have a textual conflict with
    +    "ab/various-leak-fixes" in "next"[1]. Let's exclude that specific case
    +    while moving the rule over from "pending".
     
    -    1. dc5d40f5bc4 (read-tree: use 'skip_cache_tree_update' option,
    -       2022-11-10)
    +    1. 407b94280f8 (commit: discard partial cache before (re-)reading it,
    +       2022-11-08)
     
         Signed-off-by: Ævar Arnfjörð Bjarmason <[e-mail]>
     
    @@ builtin/mv.c: int cmd_mv(int argc, const char **argv, const char *prefix)
      				/*
      				 * if src is clean, it will suffice to remove it
     
    + ## builtin/read-tree.c ##
    +@@ builtin/read-tree.c: int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
    + 	if (nr_trees == 1 && !opts.prefix)
    + 		opts.skip_cache_tree_update = 1;
    + 
    +-	cache_tree_free(&active_cache_tree);
    ++	cache_tree_free(&the_index.cache_tree);
    + 	for (i = 0; i < nr_trees; i++) {
    + 		struct tree *tree = trees[i];
    + 		parse_tree(tree);
    +
      ## builtin/reset.c ##
     @@ builtin/reset.c: static void update_index_from_diff(struct diff_queue_struct *q,
      		 * to properly construct the reset sparse directory.
    @@ cache.h: void prefetch_cache_entries(const struct index_state *istate,
     -#define active_cache (the_index.cache)
      #define active_nr (the_index.cache_nr)
     -#define active_cache_changed (the_index.cache_changed)
    - #define active_cache_tree (the_index.cache_tree)
    +-#define active_cache_tree (the_index.cache_tree)
      
      #define read_cache() repo_read_index(the_repository)
    + #define read_cache_from(path) read_index_from(&the_index, (path), (get_git_dir()))
     
      ## contrib/coccinelle/index-compatibility.cocci ##
     @@
    @@ contrib/coccinelle/index-compatibility.cocci
     +|
     +- active_cache_changed
     ++ the_index.cache_changed
    ++|
    ++- active_cache_tree
    +++ the_index.cache_tree
     +)
     +
     +@@
    @@ contrib/coccinelle/index-compatibility.cocci
     +- active_nr
     ++ the_index.cache_nr
     +  ...>}
    -+
    -+@@
    -+identifier f != cmd_read_tree;
    -+@@
    -+  f(...) {<...
    -+- active_cache_tree
    -++ the_index.cache_tree
    -+  ...>}
     +
      // "the_repository" simple cases
      @@
 8:  f3e265e6edb !  8:  6d57a383623 cocci: apply "pending" index-compatibility to "t/helper/*.c"
    @@ Commit message
     
         Signed-off-by: Ævar Arnfjörð Bjarmason <[e-mail]>
     
    + ## t/helper/test-cache-tree.c ##
    +@@ t/helper/test-cache-tree.c: int cmd__cache_tree(int argc, const char **argv)
    + 
    + 	argc = parse_options(argc, argv, NULL, options, test_cache_tree_usage, 0);
    + 
    +-	if (read_cache() < 0)
    ++	if (repo_read_index(the_repository) < 0)
    + 		die(_("unable to read index file"));
    + 
    + 	oidcpy(&oid, &the_index.cache_tree->oid);
    +
      ## t/helper/test-dump-cache-tree.c ##
     @@ t/helper/test-dump-cache-tree.c: int cmd__dump_cache_tree(int ac, const char **av)
      	int ret;
 9:  5b69cfa17ad !  9:  429eecc78ec {builtin/*,repository}.c: add & use "USE_THE_INDEX_VARIABLE"
    @@ Commit message
         built-ins we only need "the_index" variable, but not the compatibility
         wrapper for functions we're not using.
     
    +    Let's then have some users of "USE_THE_INDEX_COMPATIBILITY_MACROS" use
    +    this more narrow and descriptive define.
    +
    +    For context: The USE_THE_INDEX_COMPATIBILITY_MACROS macro was added to
    +    test-tool.h in f8adbec9fea (cache.h: flip
    +    NO_THE_INDEX_COMPATIBILITY_MACROS switch, 2019-01-24).
    +
         Signed-off-by: Ævar Arnfjörð Bjarmason <[e-mail]>
     
      ## builtin/cat-file.c ##
    @@ cache.h: typedef int (*must_prefetch_predicate)(const struct cache_entry *);
     +#ifndef USE_THE_INDEX_VARIABLE
     +#ifdef USE_THE_INDEX_COMPATIBILITY_MACROS
      #define active_nr (the_index.cache_nr)
    - #define active_cache_tree (the_index.cache_tree)
      
    + #define read_cache() repo_read_index(the_repository)
     @@ cache.h: extern struct index_state the_index;
      #define refresh_and_write_cache(refresh_flags, write_flags, gentle) repo_refresh_and_write_index(the_repository, (refresh_flags), (write_flags), (gentle), NULL, NULL, NULL)
      #define hold_locked_index(lock_file, flags) repo_hold_locked_index(the_repository, (lock_file), (flags))
10:  9eda7916e75 ! 10:  5456859b244 cache.h & test-tool.h: add & use "USE_THE_INDEX_VARIABLE"
    @@ Commit message
         cache.h & test-tool.h: add & use "USE_THE_INDEX_VARIABLE"
     
         In a preceding commit we fully applied the
    -    "index-compatibility.pending.cocci" rule to "t/helper/*". Let's now
    -    stop defining "USE_THE_INDEX_COMPATIBILITY_MACROS" in test-tool.h
    -    itself, and instead instead move the define to the individual test
    -    helpers that need it. This mirrors how we do the same thing in the
    -    "builtin/" directory.
    +    "index-compatibility.pending.cocci" rule to "t/helper/*".
     
    -    We could start using "USE_THE_INDEX_COMPATIBILITY_MACROS", but let's
    -    instead introduce a narrow version of it named
    -    "USE_THE_INDEX_VARIABLE". As the name suggests this doesn't give us
    -    any of the compatibility macros, but only "the_index" variable.
    -
    -    Eventually we'll move other outstanding users of
    -    "USE_THE_INDEX_COMPATIBILITY_MACROS" over to using this more narrow
    -    and descriptive define.
    -
    -    For context: The USE_THE_INDEX_COMPATIBILITY_MACROS macro was added to
    -    test-tool.h in f8adbec9fea (cache.h: flip
    -    NO_THE_INDEX_COMPATIBILITY_MACROS switch, 2019-01-24).
    +    Let's now stop defining "USE_THE_INDEX_COMPATIBILITY_MACROS" in
    +    test-tool.h itself, and instead instead define
    +    "USE_THE_INDEX_VARIABLE" in the individual test helpers that need
    +    it. This mirrors how we do the same thing in the "builtin/" directory.
     
         Signed-off-by: Ævar Arnfjörð Bjarmason <[e-mail]>
     
    + ## t/helper/test-cache-tree.c ##
    +@@
    ++#define USE_THE_INDEX_VARIABLE
    + #include "test-tool.h"
    + #include "cache.h"
    + #include "tree.h"
    +
      ## t/helper/test-dump-cache-tree.c ##
     @@
     +#define USE_THE_INDEX_VARIABLE
    @@ t/helper/test-scrap-cache-tree.c
      #include "cache.h"
      #include "lockfile.h"
     
    + ## t/helper/test-tool.h ##
    +@@
    + #ifndef TEST_TOOL_H
    + #define TEST_TOOL_H
    + 
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    + #include "git-compat-util.h"
    + 
    + int cmd__advise_if_enabled(int argc, const char **argv);
    +
      ## t/helper/test-write-cache.c ##
     @@
     +#define USE_THE_INDEX_VARIABLE
11:  3cb15ff40f6 ! 11:  b645cec189e cocci: apply "pending" index-compatibility to some "builtin/*.c"
    @@ Metadata
      ## Commit message ##
         cocci: apply "pending" index-compatibility to some "builtin/*.c"
     
    -    Apply "index-compatibility.pending.cocci" rule to those "builtin/*",
    -    and commit the ones that have 3 uses or less of the relevant
    -    macros.
    +    Apply "index-compatibility.pending.cocci" rule to "builtin/*", but
    +    exclude those where we conflict with in-flight changes.
    +
    +    As a result some of them end up using only "the_index", so let's have
    +    them use the more narrow "USE_THE_INDEX_VARIABLE" rather than
    +    "USE_THE_INDEX_COMPATIBILITY_MACROS".
    +
    +    Manual changes not made by coccinelle, that were squashed in:
    +
    +    * Whitespace-wrap argument lists for repo_hold_locked_index(),
    +      repo_read_index_preload() and repo_refresh_and_write_index(), in cases
    +      where the line became too long after the transformation.
    +    * Change "refresh_cache()" to "refresh_index()" in a comment in
    +      "builtin/update-index.c".
    +    * For those whose call was followed by perror("<macro-name>"), change
    +      it to perror("<function-name>"), referring to the new function.
     
         Signed-off-by: Ævar Arnfjörð Bjarmason <[e-mail]>
     
      ## builtin/add.c ##
    +@@
    +  *
    +  * Copyright (C) 2006 Linus Torvalds
    +  */
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "cache.h"
    + #include "config.h"
    + #include "builtin.h"
     @@ builtin/add.c: static int edit_patch(int argc, const char **argv, const char *prefix)
      
      	git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
    @@ builtin/add.c: int cmd_add(int argc, const char **argv, const char *prefix)
      
      	die_in_unpopulated_submodule(&the_index, prefix);
     
    + ## builtin/am.c ##
    +@@ builtin/am.c: static int run_apply(const struct am_state *state, const char *index_file)
    + 
    + 	if (index_file) {
    + 		/* Reload index as apply_all_patches() will have modified it. */
    +-		discard_cache();
    +-		read_cache_from(index_file);
    ++		discard_index(&the_index);
    ++		read_index_from(&the_index, index_file, get_git_dir());
    + 	}
    + 
    + 	return 0;
    +@@ builtin/am.c: static int fall_back_threeway(const struct am_state *state, const char *index_pa
    + 	if (build_fake_ancestor(state, index_path))
    + 		return error("could not build fake ancestor");
    + 
    +-	discard_cache();
    +-	read_cache_from(index_path);
    ++	discard_index(&the_index);
    ++	read_index_from(&the_index, index_path, get_git_dir());
    + 
    + 	if (write_index_as_tree(&orig_tree, &the_index, index_path, 0, NULL))
    + 		return error(_("Repository lacks necessary blobs to fall back on 3-way merge."));
    +@@ builtin/am.c: static int fall_back_threeway(const struct am_state *state, const char *index_pa
    + 
    + 	say(state, stdout, _("Falling back to patching base and 3-way merge..."));
    + 
    +-	discard_cache();
    +-	read_cache();
    ++	discard_index(&the_index);
    ++	repo_read_index(the_repository);
    + 
    + 	/*
    + 	 * This is not so wrong. Depending on which base we picked, orig_tree
    +@@ builtin/am.c: static void am_run(struct am_state *state, int resume)
    + 
    + 	unlink(am_path(state, "dirtyindex"));
    + 
    +-	if (refresh_and_write_cache(REFRESH_QUIET, 0, 0) < 0)
    ++	if (repo_refresh_and_write_index(the_repository, REFRESH_QUIET, 0, 0,
    ++					 NULL, NULL, NULL) < 0)
    + 		die(_("unable to write index file"));
    + 
    + 	if (repo_index_has_changes(the_repository, NULL, &sb)) {
    +@@ builtin/am.c: static int fast_forward_to(struct tree *head, struct tree *remote, int reset)
    + 	if (parse_tree(head) || parse_tree(remote))
    + 		return -1;
    + 
    +-	hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
    ++	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
    + 
    +-	refresh_cache(REFRESH_QUIET);
    ++	refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL);
    + 
    + 	memset(&opts, 0, sizeof(opts));
    + 	opts.head_idx = 1;
    +@@ builtin/am.c: static int merge_tree(struct tree *tree)
    + 	if (parse_tree(tree))
    + 		return -1;
    + 
    +-	hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
    ++	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
    + 
    + 	memset(&opts, 0, sizeof(opts));
    + 	opts.head_idx = 1;
    +
      ## builtin/check-attr.c ##
    +@@
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "cache.h"
    + #include "config.h"
     @@ builtin/check-attr.c: int cmd_check_attr(int argc, const char **argv, const char *prefix)
      	argc = parse_options(argc, argv, prefix, check_attr_options,
      			     check_attr_usage, PARSE_OPT_KEEP_DASHDASH);
    @@ builtin/check-attr.c: int cmd_check_attr(int argc, const char **argv, const char
      
     
      ## builtin/check-ignore.c ##
    +@@
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "cache.h"
    + #include "config.h"
     @@ builtin/check-ignore.c: int cmd_check_ignore(int argc, const char **argv, const char *prefix)
      		die(_("--non-matching is only valid with --verbose"));
      
    @@ builtin/check-ignore.c: int cmd_check_ignore(int argc, const char **argv, const
      	setup_standard_excludes(&dir);
     
      ## builtin/checkout-index.c ##
    +@@
    +  * Copyright (C) 2005 Linus Torvalds
    +  *
    +  */
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "config.h"
    + #include "dir.h"
     @@ builtin/checkout-index.c: static void write_tempfile_record(const char *name, const char *prefix)
      static int checkout_file(const char *name, const char *prefix)
      {
    @@ builtin/checkout-index.c: int cmd_checkout_index(int argc, const char **argv, co
      
      	get_parallel_checkout_configs(&pc_workers, &pc_threshold);
     
    + ## builtin/checkout.c ##
    +@@
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "advice.h"
    + #include "blob.h"
    +@@ builtin/checkout.c: static int update_some(const struct object_id *oid, struct strbuf *base,
    + 	 * entry in place. Whether it is UPTODATE or not, checkout_entry will
    + 	 * do the right thing.
    + 	 */
    +-	pos = cache_name_pos(ce->name, ce->ce_namelen);
    ++	pos = index_name_pos(&the_index, ce->name, ce->ce_namelen);
    + 	if (pos >= 0) {
    + 		struct cache_entry *old = the_index.cache[pos];
    + 		if (ce->ce_mode == old->ce_mode &&
    +@@ builtin/checkout.c: static int checkout_paths(const struct checkout_opts *opts,
    + 	}
    + 
    + 	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
    +-	if (read_cache_preload(&opts->pathspec) < 0)
    ++	if (repo_read_index_preload(the_repository, &opts->pathspec, 0) < 0)
    + 		return error(_("index file corrupt"));
    + 
    + 	if (opts->source_tree)
    +@@ builtin/checkout.c: static int merge_working_tree(const struct checkout_opts *opts,
    + 	struct lock_file lock_file = LOCK_INIT;
    + 	struct tree *new_tree;
    + 
    +-	hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
    +-	if (read_cache_preload(NULL) < 0)
    ++	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
    ++	if (repo_read_index_preload(the_repository, NULL, 0) < 0)
    + 		return error(_("index file corrupt"));
    + 
    + 	resolve_undo_clear_index(&the_index);
    +@@ builtin/checkout.c: static int merge_working_tree(const struct checkout_opts *opts,
    + 		struct unpack_trees_options topts;
    + 		const struct object_id *old_commit_oid;
    + 
    +-		refresh_cache(REFRESH_QUIET);
    ++		refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL);
    + 
    + 		if (unmerged_index(&the_index)) {
    + 			error(_("you need to resolve your current index first"));
    +
      ## builtin/clean.c ##
    +@@
    +  * Based on git-clean.sh by Pavel Roskin
    +  */
    + 
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "cache.h"
    + #include "config.h"
     @@ builtin/clean.c: int cmd_clean(int argc, const char **argv, const char *prefix)
      	prepare_repo_settings(the_repository);
      	the_repository->settings.command_requires_full_index = 0;
    @@ builtin/clean.c: int cmd_clean(int argc, const char **argv, const char *prefix)
      	pl = add_pattern_list(&dir, EXC_CMDL, "--exclude option");
     
      ## builtin/clone.c ##
    +@@
    +  * Clone a repository into a different directory that does not yet exist.
    +  */
    + 
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "config.h"
    + #include "lockfile.h"
     @@ builtin/clone.c: static int checkout(int submodule_progress, int filter_submodules)
      	/* We need to be in the new work tree for the checkout */
      	setup_work_tree();
    @@ builtin/clone.c: static int checkout(int submodule_progress, int filter_submodul
      	memset(&opts, 0, sizeof opts);
      	opts.update = 1;
     
    + ## builtin/commit.c ##
    +@@ builtin/commit.c: static void create_base_index(const struct commit *current_head)
    + 	struct tree_desc t;
    + 
    + 	if (!current_head) {
    +-		discard_cache();
    ++		discard_index(&the_index);
    + 		return;
    + 	}
    + 
    +@@ builtin/commit.c: static void refresh_cache_or_die(int refresh_flags)
    + 	 * refresh_flags contains REFRESH_QUIET, so the only errors
    + 	 * are for unmerged entries.
    + 	 */
    +-	if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
    ++	if (refresh_index(&the_index, refresh_flags | REFRESH_IN_PORCELAIN, NULL, NULL, NULL))
    + 		die_resolve_conflict("commit");
    + }
    + 
    +@@ builtin/commit.c: static const char *prepare_index(const char **argv, const char *prefix,
    + 	    (!amend || (fixup_message && strcmp(fixup_prefix, "amend"))))))
    + 		die(_("No paths with --include/--only does not make sense."));
    + 
    +-	if (read_cache_preload(&pathspec) < 0)
    ++	if (repo_read_index_preload(the_repository, &pathspec, 0) < 0)
    + 		die(_("index file corrupt"));
    + 
    + 	if (interactive) {
    + 		char *old_index_env = NULL, *old_repo_index_file;
    +-		hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
    ++		repo_hold_locked_index(the_repository, &index_lock,
    ++				       LOCK_DIE_ON_ERROR);
    + 
    + 		refresh_cache_or_die(refresh_flags);
    + 
    +@@ builtin/commit.c: static const char *prepare_index(const char **argv, const char *prefix,
    + 			unsetenv(INDEX_ENVIRONMENT);
    + 		FREE_AND_NULL(old_index_env);
    + 
    +-		discard_cache();
    +-		read_cache_from(get_lock_file_path(&index_lock));
    ++		discard_index(&the_index);
    ++		read_index_from(&the_index, get_lock_file_path(&index_lock),
    ++				get_git_dir());
    + 		if (update_main_cache_tree(WRITE_TREE_SILENT) == 0) {
    + 			if (reopen_lock_file(&index_lock) < 0)
    + 				die(_("unable to write index file"));
    +@@ builtin/commit.c: static const char *prepare_index(const char **argv, const char *prefix,
    + 	 * (B) on failure, rollback the real index.
    + 	 */
    + 	if (all || (also && pathspec.nr)) {
    +-		hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
    ++		repo_hold_locked_index(the_repository, &index_lock,
    ++				       LOCK_DIE_ON_ERROR);
    + 		add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
    + 		refresh_cache_or_die(refresh_flags);
    + 		update_main_cache_tree(WRITE_TREE_SILENT);
    +@@ builtin/commit.c: static const char *prepare_index(const char **argv, const char *prefix,
    + 	 * We still need to refresh the index here.
    + 	 */
    + 	if (!only && !pathspec.nr) {
    +-		hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
    ++		repo_hold_locked_index(the_repository, &index_lock,
    ++				       LOCK_DIE_ON_ERROR);
    + 		refresh_cache_or_die(refresh_flags);
    + 		if (the_index.cache_changed
    + 		    || !cache_tree_fully_valid(the_index.cache_tree))
    +@@ builtin/commit.c: static const char *prepare_index(const char **argv, const char *prefix,
    + 	if (list_paths(&partial, !current_head ? NULL : "HEAD", &pathspec))
    + 		exit(1);
    + 
    +-	discard_cache();
    +-	if (read_cache() < 0)
    ++	discard_index(&the_index);
    ++	if (repo_read_index(the_repository) < 0)
    + 		die(_("cannot read the index"));
    + 
    +-	hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
    ++	repo_hold_locked_index(the_repository, &index_lock, LOCK_DIE_ON_ERROR);
    + 	add_remove_files(&partial);
    +-	refresh_cache(REFRESH_QUIET);
    ++	refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL);
    + 	update_main_cache_tree(WRITE_TREE_SILENT);
    + 	if (write_locked_index(&the_index, &index_lock, 0))
    + 		die(_("unable to write new_index file"));
    +@@ builtin/commit.c: static const char *prepare_index(const char **argv, const char *prefix,
    + 
    + 	create_base_index(current_head);
    + 	add_remove_files(&partial);
    +-	refresh_cache(REFRESH_QUIET);
    ++	refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL);
    + 
    + 	if (write_locked_index(&the_index, &false_lock, 0))
    + 		die(_("unable to write temporary index file"));
    + 
    +-	discard_cache();
    ++	discard_index(&the_index);
    + 	ret = get_lock_file_path(&false_lock);
    +-	read_cache_from(ret);
    ++	read_index_from(&the_index, ret, get_git_dir());
    + out:
    + 	string_list_clear(&partial, 0);
    + 	clear_pathspec(&pathspec);
    +@@ builtin/commit.c: static int prepare_to_commit(const char *index_file, const char *prefix,
    + 		 * and could have updated it. We must do this before we invoke
    + 		 * the editor and after we invoke run_status above.
    + 		 */
    +-		discard_cache();
    ++		discard_index(&the_index);
    + 	}
    +-	read_cache_from(index_file);
    ++	read_index_from(&the_index, index_file, get_git_dir());
    + 
    + 	if (update_main_cache_tree(0)) {
    + 		error(_("Error building trees"));
    +@@ builtin/commit.c: int cmd_status(int argc, const char **argv, const char *prefix)
    + 		      &s.pathspec, NULL, NULL);
    + 
    + 	if (use_optional_locks())
    +-		fd = hold_locked_index(&index_lock, 0);
    ++		fd = repo_hold_locked_index(the_repository, &index_lock, 0);
    + 	else
    + 		fd = -1;
    + 
    +
      ## builtin/describe.c ##
    +@@
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "cache.h"
    + #include "config.h"
    + #include "lockfile.h"
     @@ builtin/describe.c: int cmd_describe(int argc, const char **argv, const char *prefix)
      			int fd, result;
      
    @@ builtin/describe.c: int cmd_describe(int argc, const char **argv, const char *pr
      
     
      ## builtin/diff-files.c ##
    +@@
    +  *
    +  * Copyright (C) Linus Torvalds, 2005
    +  */
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    + #include "cache.h"
    + #include "config.h"
    + #include "diff.h"
     @@ builtin/diff-files.c: int cmd_diff_files(int argc, const char **argv, const char *prefix)
      	    (rev.diffopt.output_format & DIFF_FORMAT_PATCH))
      		diff_merges_set_dense_combined_if_unset(&rev);
      
     -	if (read_cache_preload(&rev.diffopt.pathspec) < 0) {
    +-		perror("read_cache_preload");
     +	if (repo_read_index_preload(the_repository, &rev.diffopt.pathspec, 0) < 0) {
    - 		perror("read_cache_preload");
    ++		perror("repo_read_index_preload");
      		result = -1;
      		goto cleanup;
    + 	}
     
      ## builtin/diff-index.c ##
    +@@
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    + #include "cache.h"
    + #include "config.h"
    + #include "diff.h"
     @@ builtin/diff-index.c: int cmd_diff_index(int argc, const char **argv, const char *prefix)
      		usage(diff_cache_usage);
      	if (!(option & DIFF_INDEX_CACHED)) {
      		setup_work_tree();
     -		if (read_cache_preload(&rev.diffopt.pathspec) < 0) {
    +-			perror("read_cache_preload");
     +		if (repo_read_index_preload(the_repository, &rev.diffopt.pathspec, 0) < 0) {
    - 			perror("read_cache_preload");
    ++			perror("repo_read_index_preload");
      			return -1;
      		}
     -	} else if (read_cache() < 0) {
    +-		perror("read_cache");
     +	} else if (repo_read_index(the_repository) < 0) {
    - 		perror("read_cache");
    ++		perror("repo_read_index");
      		return -1;
      	}
    + 	result = run_diff_index(&rev, option);
     
      ## builtin/diff-tree.c ##
    +@@
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "cache.h"
    + #include "config.h"
    + #include "diff.h"
     @@ builtin/diff-tree.c: int cmd_diff_tree(int argc, const char **argv, const char *prefix)
      
      	git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
    @@ builtin/diff-tree.c: int cmd_diff_tree(int argc, const char **argv, const char *
      	opt->abbrev = 0;
      	opt->diff = 1;
     
    + ## builtin/diff.c ##
    +@@
    +  *
    +  * Copyright (c) 2006 Junio C Hamano
    +  */
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "cache.h"
    + #include "config.h"
    + #include "ewah/ewok.h"
    +@@ builtin/diff.c: static int builtin_diff_index(struct rev_info *revs,
    + 		usage(builtin_diff_usage);
    + 	if (!(option & DIFF_INDEX_CACHED)) {
    + 		setup_work_tree();
    +-		if (read_cache_preload(&revs->diffopt.pathspec) < 0) {
    +-			perror("read_cache_preload");
    ++		if (repo_read_index_preload(the_repository,
    ++					    &revs->diffopt.pathspec, 0) < 0) {
    ++			perror("repo_read_index_preload");
    + 			return -1;
    + 		}
    +-	} else if (read_cache() < 0) {
    +-		perror("read_cache");
    ++	} else if (repo_read_index(the_repository) < 0) {
    ++		perror("repo_read_cache");
    + 		return -1;
    + 	}
    + 	return run_diff_index(revs, option);
    +@@ builtin/diff.c: static void refresh_index_quietly(void)
    + 	struct lock_file lock_file = LOCK_INIT;
    + 	int fd;
    + 
    +-	fd = hold_locked_index(&lock_file, 0);
    ++	fd = repo_hold_locked_index(the_repository, &lock_file, 0);
    + 	if (fd < 0)
    + 		return;
    +-	discard_cache();
    +-	read_cache();
    +-	refresh_cache(REFRESH_QUIET|REFRESH_UNMERGED);
    ++	discard_index(&the_index);
    ++	repo_read_index(the_repository);
    ++	refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL,
    ++		      NULL);
    + 	repo_update_index_if_able(the_repository, &lock_file);
    + }
    + 
    +@@ builtin/diff.c: static int builtin_diff_files(struct rev_info *revs, int argc, const char **argv
    + 		diff_merges_set_dense_combined_if_unset(revs);
    + 
    + 	setup_work_tree();
    +-	if (read_cache_preload(&revs->diffopt.pathspec) < 0) {
    +-		perror("read_cache_preload");
    ++	if (repo_read_index_preload(the_repository, &revs->diffopt.pathspec,
    ++				    0) < 0) {
    ++		perror("repo_read_index_preload");
    + 		return -1;
    + 	}
    + 	return run_diff_files(revs, options);
    +
      ## builtin/fsck.c ##
    +@@
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "cache.h"
    + #include "repository.h"
     @@ builtin/fsck.c: int cmd_fsck(int argc, const char **argv, const char *prefix)
      	if (keep_cache_objects) {
      		verify_index_checksum = 1;
    @@ builtin/fsck.c: int cmd_fsck(int argc, const char **argv, const char *prefix)
      		for (i = 0; i < the_index.cache_nr; i++) {
     
      ## builtin/merge-index.c ##
    +@@
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "run-command.h"
    + 
     @@ builtin/merge-index.c: static int merge_entry(int pos, const char *path)
      
      static void merge_one_path(const char *path)
    @@ builtin/merge-index.c: int cmd_merge_index(int argc, const char **argv, const ch
      	ensure_full_index(&the_index);
     
      ## builtin/merge-ours.c ##
    +@@
    +  *
    +  * Pretend we resolved the heads, but declare our tree trumps everybody else.
    +  */
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    + #include "git-compat-util.h"
    + #include "builtin.h"
    + #include "diff.h"
     @@ builtin/merge-ours.c: int cmd_merge_ours(int argc, const char **argv, const char *prefix)
      	 * commit.  The index must match HEAD, or this merge cannot go
      	 * through.
    @@ builtin/merge-ours.c: int cmd_merge_ours(int argc, const char **argv, const char
      	if (index_differs_from(the_repository, "HEAD", NULL, 0))
      		return 2;
     
    + ## builtin/merge.c ##
    +@@ builtin/merge.c: static int save_state(struct object_id *stash)
    + 	int rc = -1;
    + 
    + 	fd = repo_hold_locked_index(the_repository, &lock_file, 0);
    +-	refresh_cache(REFRESH_QUIET);
    ++	refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL);
    + 	if (0 <= fd)
    + 		repo_update_index_if_able(the_repository, &lock_file);
    + 	rollback_lock_file(&lock_file);
    +@@ builtin/merge.c: static int try_merge_strategy(const char *strategy, struct commit_list *common,
    + {
    + 	const char *head_arg = "HEAD";
    + 
    +-	if (refresh_and_write_cache(REFRESH_QUIET, SKIP_IF_UNCHANGED, 0) < 0)
    ++	if (repo_refresh_and_write_index(the_repository, REFRESH_QUIET,
    ++					 SKIP_IF_UNCHANGED, 0, NULL, NULL,
    ++					 NULL) < 0)
    + 		return error(_("Unable to write index."));
    + 
    + 	if (!strcmp(strategy, "recursive") || !strcmp(strategy, "subtree") ||
    +@@ builtin/merge.c: static int try_merge_strategy(const char *strategy, struct commit_list *common,
    + 		for (j = common; j; j = j->next)
    + 			commit_list_insert(j->item, &reversed);
    + 
    +-		hold_locked_index(&lock, LOCK_DIE_ON_ERROR);
    ++		repo_hold_locked_index(the_repository, &lock,
    ++				       LOCK_DIE_ON_ERROR);
    + 		if (!strcmp(strategy, "ort"))
    + 			clean = merge_ort_recursive(&o, head, remoteheads->item,
    + 						    reversed, &result);
    +@@ builtin/merge.c: static void prepare_to_commit(struct commit_list *remoteheads)
    + 		 * the editor and after we invoke run_status above.
    + 		 */
    + 		if (invoked_hook)
    +-			discard_cache();
    ++			discard_index(&the_index);
    + 	}
    +-	read_cache_from(index_file);
    ++	read_index_from(&the_index, index_file, get_git_dir());
    + 	strbuf_addbuf(&msg, &merge_msg);
    + 	if (squash)
    + 		BUG("the control must not reach here under --squash");
    +@@ builtin/merge.c: static int merge_trivial(struct commit *head, struct commit_list *remoteheads)
    + 	struct object_id result_tree, result_commit;
    + 	struct commit_list *parents, **pptr = &parents;
    + 
    +-	if (refresh_and_write_cache(REFRESH_QUIET, SKIP_IF_UNCHANGED, 0) < 0)
    ++	if (repo_refresh_and_write_index(the_repository, REFRESH_QUIET,
    ++					 SKIP_IF_UNCHANGED, 0, NULL, NULL,
    ++					 NULL) < 0)
    + 		return error(_("Unable to write index."));
    + 
    + 	write_tree_trivial(&result_tree);
    +@@ builtin/merge.c: int cmd_merge(int argc, const char **argv, const char *prefix)
    + 		 * We are not doing octopus, not fast-forward, and have
    + 		 * only one common.
    + 		 */
    +-		refresh_cache(REFRESH_QUIET);
    ++		refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL);
    + 		if (allow_trivial && fast_forward != FF_ONLY) {
    + 			/*
    + 			 * Must first ensure that index matches HEAD before
    +
    + ## builtin/mv.c ##
    +@@ builtin/mv.c: static int index_range_of_same_dir(const char *src, int length,
    + 	const char *src_w_slash = add_slash(src);
    + 	int first, last, len_w_slash = length + 1;
    + 
    +-	first = cache_name_pos(src_w_slash, len_w_slash);
    ++	first = index_name_pos(&the_index, src_w_slash, len_w_slash);
    + 	if (first >= 0)
    + 		die(_("%.*s is in index"), len_w_slash, src_w_slash);
    + 
    +@@ builtin/mv.c: static int empty_dir_has_sparse_contents(const char *name)
    + 	const char *with_slash = add_slash(name);
    + 	int length = strlen(with_slash);
    + 
    +-	int pos = cache_name_pos(with_slash, length);
    ++	int pos = index_name_pos(&the_index, with_slash, length);
    + 	const struct cache_entry *ce;
    + 
    + 	if (pos < 0) {
    +@@ builtin/mv.c: int cmd_mv(int argc, const char **argv, const char *prefix)
    + 	if (--argc < 1)
    + 		usage_with_options(builtin_mv_usage, builtin_mv_options);
    + 
    +-	hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
    +-	if (read_cache() < 0)
    ++	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
    ++	if (repo_read_index(the_repository) < 0)
    + 		die(_("index file corrupt"));
    + 
    + 	source = internal_prefix_pathspec(prefix, argv, argc, 0);
    +@@ builtin/mv.c: int cmd_mv(int argc, const char **argv, const char *prefix)
    + 			int pos;
    + 			const struct cache_entry *ce;
    + 
    +-			pos = cache_name_pos(src, length);
    ++			pos = index_name_pos(&the_index, src, length);
    + 			if (pos < 0) {
    + 				const char *src_w_slash = add_slash(src);
    + 				if (!path_in_sparse_checkout(src_w_slash, &the_index) &&
    +@@ builtin/mv.c: int cmd_mv(int argc, const char **argv, const char *prefix)
    + 				goto act_on_entry;
    + 			}
    + 			/* Check if dst exists in index */
    +-			if (cache_name_pos(dst, strlen(dst)) < 0) {
    ++			if (index_name_pos(&the_index, dst, strlen(dst)) < 0) {
    + 				modes[i] |= SPARSE;
    + 				goto act_on_entry;
    + 			}
    +@@ builtin/mv.c: int cmd_mv(int argc, const char **argv, const char *prefix)
    + dir_check:
    + 		if (S_ISDIR(st.st_mode)) {
    + 			int j, dst_len, n;
    +-			int first = cache_name_pos(src, length), last;
    ++			int first = index_name_pos(&the_index, src, length), last;
    + 
    + 			if (first >= 0) {
    + 				prepare_move_submodule(src, first,
    +@@ builtin/mv.c: int cmd_mv(int argc, const char **argv, const char *prefix)
    + 		if (mode & (WORKING_DIRECTORY | SKIP_WORKTREE_DIR))
    + 			continue;
    + 
    +-		pos = cache_name_pos(src, strlen(src));
    ++		pos = index_name_pos(&the_index, src, strlen(src));
    + 		assert(pos >= 0);
    + 		if (!(mode & SPARSE) && !lstat(src, &st))
    + 			sparse_and_dirty = ie_modified(&the_index,
    +
    + ## builtin/read-tree.c ##
    +@@
    +  * Copyright (C) Linus Torvalds, 2005
    +  */
    + 
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "cache.h"
    + #include "config.h"
    + #include "lockfile.h"
    +@@ builtin/read-tree.c: int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
    + 	prepare_repo_settings(the_repository);
    + 	the_repository->settings.command_requires_full_index = 0;
    + 
    +-	hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
    ++	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
    + 
    + 	/*
    + 	 * NEEDSWORK
    +
      ## builtin/rebase.c ##
    +@@
    +  * Copyright (c) 2018 Pratik Karki
    +  */
    + 
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "run-command.h"
    + #include "exec-cmd.h"
     @@ builtin/rebase.c: static int do_interactive_rebase(struct rebase_options *opts, unsigned flags)
      	if (ret)
      		error(_("could not generate todo list"));
    @@ builtin/rebase.c: int cmd_rebase(int argc, const char **argv, const char *prefix
      		refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL,
     
      ## builtin/reset.c ##
    +@@
    +  *
    +  * Copyright (c) 2005, 2006 Linus Torvalds and Junio C Hamano
    +  */
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "config.h"
    + #include "lockfile.h"
     @@ builtin/reset.c: static void update_index_from_diff(struct diff_queue_struct *q,
      		 * if this entry is outside the sparse cone - this is necessary
      		 * to properly construct the reset sparse directory.
    @@ builtin/reset.c: int cmd_reset(int argc, const char **argv, const char *prefix)
      			if (read_from_tree(&pathspec, &oid, intent_to_add))
     
      ## builtin/rev-parse.c ##
    +@@
    +  *
    +  * Copyright (C) Linus Torvalds, 2005
    +  */
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "cache.h"
    + #include "config.h"
    + #include "commit.h"
     @@ builtin/rev-parse.c: int cmd_rev_parse(int argc, const char **argv, const char *prefix)
      				continue;
      			}
    @@ builtin/rev-parse.c: int cmd_rev_parse(int argc, const char **argv, const char *
      					die(_("Could not read the index"));
      				if (the_index.split_index) {
      					const struct object_id *oid = &the_index.split_index->base_oid;
    +
    + ## builtin/rm.c ##
    +@@ builtin/rm.c: static void submodules_absorb_gitdir_if_needed(void)
    + 		int pos;
    + 		const struct cache_entry *ce;
    + 
    +-		pos = cache_name_pos(name, strlen(name));
    ++		pos = index_name_pos(&the_index, name, strlen(name));
    + 		if (pos < 0) {
    + 			pos = get_ours_cache_pos(name, pos);
    + 			if (pos < 0)
    +@@ builtin/rm.c: static int check_local_mod(struct object_id *head, int index_only)
    + 		int local_changes = 0;
    + 		int staged_changes = 0;
    + 
    +-		pos = cache_name_pos(name, strlen(name));
    ++		pos = index_name_pos(&the_index, name, strlen(name));
    + 		if (pos < 0) {
    + 			/*
    + 			 * Skip unmerged entries except for populated submodules
    +@@ builtin/rm.c: int cmd_rm(int argc, const char **argv, const char *prefix)
    + 
    + 	prepare_repo_settings(the_repository);
    + 	the_repository->settings.command_requires_full_index = 0;
    +-	hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
    ++	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
    + 
    +-	if (read_cache() < 0)
    ++	if (repo_read_index(the_repository) < 0)
    + 		die(_("index file corrupt"));
    + 
    + 	refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &pathspec, NULL, NULL);
    +
    + ## builtin/stash.c ##
    +@@ builtin/stash.c: static int reset_tree(struct object_id *i_tree, int update, int reset)
    + 	struct tree *tree;
    + 	struct lock_file lock_file = LOCK_INIT;
    + 
    +-	read_cache_preload(NULL);
    +-	if (refresh_cache(REFRESH_QUIET))
    ++	repo_read_index_preload(the_repository, NULL, 0);
    ++	if (refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL))
    + 		return -1;
    + 
    +-	hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
    ++	repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
    + 
    + 	memset(&opts, 0, sizeof(opts));
    + 
    +@@ builtin/stash.c: static int do_apply_stash(const char *prefix, struct stash_info *info,
    + 	struct tree *head, *merge, *merge_base;
    + 	struct lock_file lock = LOCK_INIT;
    + 
    +-	read_cache_preload(NULL);
    +-	if (refresh_and_write_cache(REFRESH_QUIET, 0, 0))
    ++	repo_read_index_preload(the_repository, NULL, 0);
    ++	if (repo_refresh_and_write_index(the_repository, REFRESH_QUIET, 0, 0,
    ++					 NULL, NULL, NULL))
    + 		return -1;
    + 
    + 	if (write_cache_as_tree(&c_tree, 0, NULL))
    +@@ builtin/stash.c: static int do_apply_stash(const char *prefix, struct stash_info *info,
    + 				return error(_("conflicts in index. "
    + 					       "Try without --index."));
    + 
    +-			discard_cache();
    +-			read_cache();
    ++			discard_index(&the_index);
    ++			repo_read_index(the_repository);
    + 			if (write_cache_as_tree(&index_tree, 0, NULL))
    + 				return error(_("could not save index tree"));
    + 
    + 			reset_head();
    +-			discard_cache();
    +-			read_cache();
    ++			discard_index(&the_index);
    ++			repo_read_index(the_repository);
    + 		}
    + 	}
    + 
    +@@ builtin/stash.c: static int check_changes_tracked_files(const struct pathspec *ps)
    + 	if (get_oid("HEAD", &dummy))
    + 		return -1;
    + 
    +-	if (read_cache() < 0)
    ++	if (repo_read_index(the_repository) < 0)
    + 		return -1;
    + 
    + 	init_revisions(&rev, NULL);
    +@@ builtin/stash.c: static int stash_working_tree(struct stash_info *info, const struct pathspec *ps
    + 	rev.diffopt.format_callback = add_diff_to_buf;
    + 	rev.diffopt.format_callback_data = &diff_output;
    + 
    +-	if (read_cache_preload(&rev.diffopt.pathspec) < 0) {
    ++	if (repo_read_index_preload(the_repository, &rev.diffopt.pathspec, 0) < 0) {
    + 		ret = -1;
    + 		goto done;
    + 	}
    +@@ builtin/stash.c: static int do_create_stash(const struct pathspec *ps, struct strbuf *stash_msg_b
    + 
    + 	prepare_fallback_ident("git stash", "git@stash");
    + 
    +-	read_cache_preload(NULL);
    +-	if (refresh_and_write_cache(REFRESH_QUIET, 0, 0) < 0) {
    ++	repo_read_index_preload(the_repository, NULL, 0);
    ++	if (repo_refresh_and_write_index(the_repository, REFRESH_QUIET, 0, 0,
    ++					 NULL, NULL, NULL) < 0) {
    + 		ret = -1;
    + 		goto done;
    + 	}
    +@@ builtin/stash.c: static int do_push_stash(const struct pathspec *ps, const char *stash_msg, int q
    + 		goto done;
    + 	}
    + 
    +-	read_cache_preload(NULL);
    ++	repo_read_index_preload(the_repository, NULL, 0);
    + 	if (!include_untracked && ps->nr) {
    + 		int i;
    + 		char *ps_matched = xcalloc(ps->nr, 1);
    +@@ builtin/stash.c: static int do_push_stash(const struct pathspec *ps, const char *stash_msg, int q
    + 		free(ps_matched);
    + 	}
    + 
    +-	if (refresh_and_write_cache(REFRESH_QUIET, 0, 0)) {
    ++	if (repo_refresh_and_write_index(the_repository, REFRESH_QUIET, 0, 0,
    ++					 NULL, NULL, NULL)) {
    + 		ret = -1;
    + 		goto done;
    + 	}
    +@@ builtin/stash.c: static int do_push_stash(const struct pathspec *ps, const char *stash_msg, int q
    + 				goto done;
    + 			}
    + 		}
    +-		discard_cache();
    ++		discard_index(&the_index);
    + 		if (ps->nr) {
    + 			struct child_process cp_add = CHILD_PROCESS_INIT;
    + 			struct child_process cp_diff = CHILD_PROCESS_INIT;
    +
    + ## builtin/submodule--helper.c ##
    +@@
    +-#define USE_THE_INDEX_COMPATIBILITY_MACROS
    ++#define USE_THE_INDEX_VARIABLE
    + #include "builtin.h"
    + #include "repository.h"
    + #include "cache.h"
    +@@ builtin/submodule--helper.c: static int module_list_compute(const char **argv,
    + 	if (pathspec->nr)
    + 		ps_matched = xcalloc(pathspec->nr, 1);
    + 
    +-	if (read_cache() < 0)
    ++	if (repo_read_index(the_repository) < 0)
    + 		die(_("index file corrupt"));
    + 
    + 	for (i = 0; i < the_index.cache_nr; i++) {
    +@@ builtin/submodule--helper.c: static int compute_summary_module_list(struct object_id *head_oid,
    + 	if (!info->cached) {
    + 		if (diff_cmd == DIFF_INDEX)
    + 			setup_work_tree();
    +-		if (read_cache_preload(&rev.diffopt.pathspec) < 0) {
    +-			perror("read_cache_preload");
    ++		if (repo_read_index_preload(the_repository, &rev.diffopt.pathspec, 0) < 0) {
    ++			perror("repo_read_index_preload");
    + 			ret = -1;
    + 			goto cleanup;
    + 		}
    +-	} else if (read_cache() < 0) {
    +-		perror("read_cache");
    ++	} else if (repo_read_index(the_repository) < 0) {
    ++		perror("repo_read_cache");
    + 		ret = -1;
    + 		goto cleanup;
    + 	}
    +@@ builtin/submodule--helper.c: static void die_on_index_match(const char *path, int force)
    + 	const char *args[] = { path, NULL };
    + 	parse_pathspec(&ps, 0, PATHSPEC_PREFER_CWD, NULL, args);
    + 
    +-	if (read_cache_preload(NULL) < 0)
    ++	if (repo_read_index_preload(the_repository, NULL, 0) < 0)
    + 		die(_("index file corrupt"));
    + 
    + 	if (ps.nr) {
    +
    + ## builtin/update-index.c ##
    +@@ builtin/update-index.c: static int test_if_untracked_cache_is_supported(void)
    + static int mark_ce_flags(const char *path, int flag, int mark)
    + {
    + 	int namelen = strlen(path);
    +-	int pos = cache_name_pos(path, namelen);
    ++	int pos = index_name_pos(&the_index, path, namelen);
    + 	if (0 <= pos) {
    + 		mark_fsmonitor_invalid(&the_index, the_index.cache[pos]);
    + 		if (mark)
    +@@ builtin/update-index.c: static int add_one_path(const struct cache_entry *old, const char *path, int len
    + static int process_directory(const char *path, int len, struct stat *st)
    + {
    + 	struct object_id oid;
    +-	int pos = cache_name_pos(path, len);
    ++	int pos = index_name_pos(&the_index, path, len);
    + 
    + 	/* Exact match: file or existing gitlink */
    + 	if (pos >= 0) {
    +@@ builtin/update-index.c: static void chmod_path(char flip, const char *path)
    + 	int pos;
    + 	struct cache_entry *ce;
    + 
    +-	pos = cache_name_pos(path, strlen(path));
    ++	pos = index_name_pos(&the_index, path, strlen(path));
    + 	if (pos < 0)
    + 		goto fail;
    + 	ce = the_index.cache[pos];
    +@@ builtin/update-index.c: static int unresolve_one(const char *path)
    + 	struct cache_entry *ce_2 = NULL, *ce_3 = NULL;
    + 
    + 	/* See if there is such entry in the index. */
    +-	pos = cache_name_pos(path, namelen);
    ++	pos = index_name_pos(&the_index, path, namelen);
    + 	if (0 <= pos) {
    + 		/* already merged */
    + 		pos = unmerge_index_entry_at(&the_index, pos);
    +@@ builtin/update-index.c: struct refresh_params {
    + static int refresh(struct refresh_params *o, unsigned int flag)
    + {
    + 	setup_work_tree();
    +-	read_cache();
    +-	*o->has_errors |= refresh_cache(o->flags | flag);
    ++	repo_read_index(the_repository);
    ++	*o->has_errors |= refresh_index(&the_index, o->flags | flag, NULL,
    ++					NULL, NULL);
    + 	if (has_racy_timestamp(&the_index)) {
    + 		/*
    + 		 * Even if nothing else has changed, updating the file
    + 		 * increases the chance that racy timestamps become
    + 		 * non-racy, helping future run-time performance.
    + 		 * We do that even in case of "errors" returned by
    +-		 * refresh_cache() as these are no actual errors.
    ++		 * refresh_index() as these are no actual errors.
    + 		 * cmd_status() does the same.
    + 		 */
    + 		the_index.cache_changed |= SOMETHING_CHANGED;
    +@@ builtin/update-index.c: int cmd_update_index(int argc, const char **argv, const char *prefix)
    + 	the_repository->settings.command_requires_full_index = 0;
    + 
    + 	/* we will diagnose later if it turns out that we need to update it */
    +-	newfd = hold_locked_index(&lock_file, 0);
    ++	newfd = repo_hold_locked_index(the_repository, &lock_file, 0);
    + 	if (newfd < 0)
    + 		lock_error = errno;
    + 
    +-	entries = read_cache();
    ++	entries = repo_read_index(the_repository);
    + 	if (entries < 0)
    + 		die("cache corrupted");
    + 
    +
    + ## cache.h ##
    +@@ cache.h: extern struct index_state the_index;
    + #define active_nr (the_index.cache_nr)
    + 
    + #define read_cache() repo_read_index(the_repository)
    +-#define read_cache_from(path) read_index_from(&the_index, (path), (get_git_dir()))
    +-#define read_cache_preload(pathspec) repo_read_index_preload(the_repository, (pathspec), 0)
    + #define discard_cache() discard_index(&the_index)
    + #define cache_name_pos(name, namelen) index_name_pos(&the_index,(name),(namelen))
    +-#define refresh_cache(flags) refresh_index(&the_index, (flags), NULL, NULL, NULL)
    +-#define refresh_and_write_cache(refresh_flags, write_flags, gentle) repo_refresh_and_write_index(the_repository, (refresh_flags), (write_flags), (gentle), NULL, NULL, NULL)
    +-#define hold_locked_index(lock_file, flags) repo_hold_locked_index(the_repository, (lock_file), (flags))
    + #endif
    + #endif
    + #endif
    +
    + ## contrib/coccinelle/index-compatibility.cocci ##
    +@@ contrib/coccinelle/index-compatibility.cocci: identifier f != prepare_to_commit;
    + (
    + - read_cache_unmerged
    + + repo_read_index_unmerged
    ++|
    ++- hold_locked_index
    +++ repo_hold_locked_index
    + )
    +   (
    + + the_repository,
    +   ...)
    + 
    ++// "the_repository" special-cases
    ++@@
    ++@@
    ++(
    ++- read_cache_preload
    +++ repo_read_index_preload
    ++)
    ++  (
    +++ the_repository,
    ++  ...
    +++ , 0
    ++  )
    ++
    + // "the_index" simple cases
    + @@
    + @@
    +@@ contrib/coccinelle/index-compatibility.cocci: identifier f != prepare_to_commit;
    +   (
    + + &the_index,
    +   ...)
    ++
    ++@@
    ++@@
    ++(
    ++- refresh_and_write_cache
    +++ repo_refresh_and_write_index
    ++)
    ++  (
    +++ the_repository,
    ++  ...
    +++ , NULL, NULL, NULL
    ++  )
    ++
    ++// "the_index" special-cases
    ++@@
    ++@@
    ++(
    ++- read_cache_from
    +++ read_index_from
    ++)
    ++  (
    +++ &the_index,
    ++  ...
    +++ , get_git_dir()
    ++  )
    ++
    ++@@
    ++@@
    ++(
    ++- refresh_cache
    +++ refresh_index
    ++)
    ++  (
    +++ &the_index,
    ++  ...
    +++ , NULL, NULL, NULL
    ++  )
    +
    + ## contrib/coccinelle/index-compatibility.pending.cocci ##
    +@@
    + (
    + - read_cache
    + + repo_read_index
    +-|
    +-- hold_locked_index
    +-+ repo_hold_locked_index
    + )
    +   (
    + + the_repository,
    +@@
    +   (
    + + &the_index,
    +   ...)
    +-
    +-// "the_repository" special-cases
    +-@@
    +-@@
    +-(
    +-- read_cache_preload
    +-+ repo_read_index_preload
    +-)
    +-  (
    +-+ the_repository,
    +-  ...
    +-+ , 0
    +-  )
    +-
    +-@@
    +-@@
    +-(
    +-- refresh_and_write_cache
    +-+ repo_refresh_and_write_index
    +-)
    +-  (
    +-+ the_repository,
    +-  ...
    +-+ , NULL, NULL, NULL
    +-  )
    +-
    +-
    +-// "the_index" special-cases
    +-@@
    +-@@
    +-(
    +-- read_cache_from
    +-+ read_index_from
    +-)
    +-  (
    +-+ &the_index,
    +-  ...
    +-+ , get_git_dir()
    +-  )
    +-
    +-@@
    +-@@
    +-(
    +-- refresh_cache
    +-+ refresh_index
    +-)
    +-  (
    +-+ &the_index,
    +-  ...
    +-+ , NULL, NULL, NULL
    +-  )
12:  b69cf6d7600 <  -:  ----------- builtin/*: remove or amend "USE_THE_INDEX_COMPATIBILITY_MACROS"