Merge branch 'bc/object-id'
authorJunio C Hamano <gitster@pobox.com>
Mon, 9 Apr 2018 23:25:45 +0000 (08:25 +0900)
committerJunio C Hamano <gitster@pobox.com>
Mon, 9 Apr 2018 23:25:45 +0000 (08:25 +0900)
Conversion from uchar[20] to struct object_id continues.

* bc/object-id: (36 commits)
  convert: convert to struct object_id
  sha1_file: introduce a constant for max header length
  Convert lookup_replace_object to struct object_id
  sha1_file: convert read_sha1_file to struct object_id
  sha1_file: convert read_object_with_reference to object_id
  tree-walk: convert tree entry functions to object_id
  streaming: convert istream internals to struct object_id
  tree-walk: convert get_tree_entry_follow_symlinks internals to object_id
  builtin/notes: convert static functions to object_id
  builtin/fmt-merge-msg: convert remaining code to object_id
  sha1_file: convert sha1_object_info* to object_id
  Convert remaining callers of sha1_object_info_extended to object_id
  packfile: convert unpack_entry to struct object_id
  sha1_file: convert retry_bad_packed_offset to struct object_id
  sha1_file: convert assert_sha1_type to object_id
  builtin/mktree: convert to struct object_id
  streaming: convert open_istream to use struct object_id
  sha1_file: convert check_sha1_signature to struct object_id
  sha1_file: convert read_loose_object to use struct object_id
  builtin/index-pack: convert struct ref_delta_entry to object_id
  ...

26 files changed:
1  2 
apply.c
builtin/branch.c
builtin/checkout.c
builtin/fetch.c
builtin/grep.c
builtin/index-pack.c
builtin/merge.c
builtin/notes.c
builtin/pack-objects.c
builtin/reflog.c
builtin/replace.c
builtin/rev-list.c
builtin/rm.c
builtin/tag.c
builtin/unpack-objects.c
builtin/worktree.c
cache.h
diff.c
fast-import.c
merge-recursive.c
read-cache.c
rerere.c
sequencer.c
sha1_file.c
strbuf.c
strbuf.h

diff --cc apply.c
Simple merge
Simple merge
Simple merge
diff --cc builtin/fetch.c
Simple merge
diff --cc builtin/grep.c
Simple merge
Simple merge
diff --cc builtin/merge.c
Simple merge
diff --cc builtin/notes.c
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc builtin/rm.c
Simple merge
diff --cc builtin/tag.c
Simple merge
Simple merge
Simple merge
diff --cc cache.h
+++ b/cache.h
@@@ -1777,9 -1773,7 +1777,9 @@@ struct object_info 
  #define OBJECT_INFO_SKIP_CACHED 4
  /* Do not retry packed storage after checking packed and loose storage */
  #define OBJECT_INFO_QUICK 8
- extern int sha1_object_info_extended(const unsigned char *, struct object_info *, unsigned flags);
 +/* Do not check loose object */
 +#define OBJECT_INFO_IGNORE_LOOSE 16
+ extern int oid_object_info_extended(const struct object_id *, struct object_info *, unsigned flags);
  
  /*
   * Set this to 0 to prevent sha1_object_info_extended() from fetching missing
diff --cc diff.c
Simple merge
diff --cc fast-import.c
Simple merge
@@@ -427,21 -360,6 +427,21 @@@ static void get_files_dirs(struct merge
        read_tree_recursive(tree, "", 0, 0, &match_all, save_files_dirs, o);
  }
  
- static int get_tree_entry_if_blob(const unsigned char *tree,
++static int get_tree_entry_if_blob(struct tree *tree,
 +                                const char *path,
-                                 unsigned char *hashy,
++                                struct object_id *hashy,
 +                                unsigned int *mode_o)
 +{
 +      int ret;
 +
-       ret = get_tree_entry(tree, path, hashy, mode_o);
++      ret = get_tree_entry(&tree->object.oid, path, hashy, mode_o);
 +      if (S_ISDIR(*mode_o)) {
-               hashcpy(hashy, null_sha1);
++              oidcpy(hashy, &null_oid);
 +              *mode_o = 0;
 +      }
 +      return ret;
 +}
 +
  /*
   * Returns an index_entry instance which doesn't have to correspond to
   * a real cache entry in Git's index.
@@@ -452,12 -370,12 +452,12 @@@ static struct stage_data *insert_stage_
  {
        struct string_list_item *item;
        struct stage_data *e = xcalloc(1, sizeof(struct stage_data));
-       get_tree_entry_if_blob(o->object.oid.hash, path,
-                              e->stages[1].oid.hash, &e->stages[1].mode);
-       get_tree_entry_if_blob(a->object.oid.hash, path,
-                              e->stages[2].oid.hash, &e->stages[2].mode);
-       get_tree_entry_if_blob(b->object.oid.hash, path,
-                              e->stages[3].oid.hash, &e->stages[3].mode);
 -      get_tree_entry(&o->object.oid, path,
 -                      &e->stages[1].oid, &e->stages[1].mode);
 -      get_tree_entry(&a->object.oid, path,
 -                      &e->stages[2].oid, &e->stages[2].mode);
 -      get_tree_entry(&b->object.oid, path,
 -                      &e->stages[3].oid, &e->stages[3].mode);
++      get_tree_entry_if_blob(o, path,
++                             &e->stages[1].oid, &e->stages[1].mode);
++      get_tree_entry_if_blob(a, path,
++                             &e->stages[2].oid, &e->stages[2].mode);
++      get_tree_entry_if_blob(b, path,
++                             &e->stages[3].oid, &e->stages[3].mode);
        item = string_list_insert(entries, path);
        item->util = e;
        return e;
@@@ -1521,754 -1390,6 +1521,754 @@@ static int conflict_rename_rename_2to1(
        return ret;
  }
  
-       unsigned char hashy[GIT_MAX_RAWSZ];
 +/*
 + * Get the diff_filepairs changed between o_tree and tree.
 + */
 +static struct diff_queue_struct *get_diffpairs(struct merge_options *o,
 +                                             struct tree *o_tree,
 +                                             struct tree *tree)
 +{
 +      struct diff_queue_struct *ret;
 +      struct diff_options opts;
 +
 +      diff_setup(&opts);
 +      opts.flags.recursive = 1;
 +      opts.flags.rename_empty = 0;
 +      opts.detect_rename = DIFF_DETECT_RENAME;
 +      opts.rename_limit = o->merge_rename_limit >= 0 ? o->merge_rename_limit :
 +                          o->diff_rename_limit >= 0 ? o->diff_rename_limit :
 +                          1000;
 +      opts.rename_score = o->rename_score;
 +      opts.show_rename_progress = o->show_rename_progress;
 +      opts.output_format = DIFF_FORMAT_NO_OUTPUT;
 +      diff_setup_done(&opts);
 +      diff_tree_oid(&o_tree->object.oid, &tree->object.oid, "", &opts);
 +      diffcore_std(&opts);
 +      if (opts.needed_rename_limit > o->needed_rename_limit)
 +              o->needed_rename_limit = opts.needed_rename_limit;
 +
 +      ret = xmalloc(sizeof(*ret));
 +      *ret = diff_queued_diff;
 +
 +      opts.output_format = DIFF_FORMAT_NO_OUTPUT;
 +      diff_queued_diff.nr = 0;
 +      diff_queued_diff.queue = NULL;
 +      diff_flush(&opts);
 +      return ret;
 +}
 +
 +static int tree_has_path(struct tree *tree, const char *path)
 +{
-       return !get_tree_entry(tree->object.oid.hash, path,
-                              hashy, &mode_o);
++      struct object_id hashy;
 +      unsigned int mode_o;
 +
-       get_tree_entry(tree->object.oid.hash,
++      return !get_tree_entry(&tree->object.oid, path,
++                             &hashy, &mode_o);
 +}
 +
 +/*
 + * Return a new string that replaces the beginning portion (which matches
 + * entry->dir), with entry->new_dir.  In perl-speak:
 + *   new_path_name = (old_path =~ s/entry->dir/entry->new_dir/);
 + * NOTE:
 + *   Caller must ensure that old_path starts with entry->dir + '/'.
 + */
 +static char *apply_dir_rename(struct dir_rename_entry *entry,
 +                            const char *old_path)
 +{
 +      struct strbuf new_path = STRBUF_INIT;
 +      int oldlen, newlen;
 +
 +      if (entry->non_unique_new_dir)
 +              return NULL;
 +
 +      oldlen = strlen(entry->dir);
 +      newlen = entry->new_dir.len + (strlen(old_path) - oldlen) + 1;
 +      strbuf_grow(&new_path, newlen);
 +      strbuf_addbuf(&new_path, &entry->new_dir);
 +      strbuf_addstr(&new_path, &old_path[oldlen]);
 +
 +      return strbuf_detach(&new_path, NULL);
 +}
 +
 +static void get_renamed_dir_portion(const char *old_path, const char *new_path,
 +                                  char **old_dir, char **new_dir)
 +{
 +      char *end_of_old, *end_of_new;
 +      int old_len, new_len;
 +
 +      *old_dir = NULL;
 +      *new_dir = NULL;
 +
 +      /*
 +       * For
 +       *    "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"
 +       * the "e/foo.c" part is the same, we just want to know that
 +       *    "a/b/c/d" was renamed to "a/b/some/thing/else"
 +       * so, for this example, this function returns "a/b/c/d" in
 +       * *old_dir and "a/b/some/thing/else" in *new_dir.
 +       *
 +       * Also, if the basename of the file changed, we don't care.  We
 +       * want to know which portion of the directory, if any, changed.
 +       */
 +      end_of_old = strrchr(old_path, '/');
 +      end_of_new = strrchr(new_path, '/');
 +
 +      if (end_of_old == NULL || end_of_new == NULL)
 +              return;
 +      while (*--end_of_new == *--end_of_old &&
 +             end_of_old != old_path &&
 +             end_of_new != new_path)
 +              ; /* Do nothing; all in the while loop */
 +      /*
 +       * We've found the first non-matching character in the directory
 +       * paths.  That means the current directory we were comparing
 +       * represents the rename.  Move end_of_old and end_of_new back
 +       * to the full directory name.
 +       */
 +      if (*end_of_old == '/')
 +              end_of_old++;
 +      if (*end_of_old != '/')
 +              end_of_new++;
 +      end_of_old = strchr(end_of_old, '/');
 +      end_of_new = strchr(end_of_new, '/');
 +
 +      /*
 +       * It may have been the case that old_path and new_path were the same
 +       * directory all along.  Don't claim a rename if they're the same.
 +       */
 +      old_len = end_of_old - old_path;
 +      new_len = end_of_new - new_path;
 +
 +      if (old_len != new_len || strncmp(old_path, new_path, old_len)) {
 +              *old_dir = xstrndup(old_path, old_len);
 +              *new_dir = xstrndup(new_path, new_len);
 +      }
 +}
 +
 +static void remove_hashmap_entries(struct hashmap *dir_renames,
 +                                 struct string_list *items_to_remove)
 +{
 +      int i;
 +      struct dir_rename_entry *entry;
 +
 +      for (i = 0; i < items_to_remove->nr; i++) {
 +              entry = items_to_remove->items[i].util;
 +              hashmap_remove(dir_renames, entry, NULL);
 +      }
 +      string_list_clear(items_to_remove, 0);
 +}
 +
 +/*
 + * See if there is a directory rename for path, and if there are any file
 + * level conflicts for the renamed location.  If there is a rename and
 + * there are no conflicts, return the new name.  Otherwise, return NULL.
 + */
 +static char *handle_path_level_conflicts(struct merge_options *o,
 +                                       const char *path,
 +                                       struct dir_rename_entry *entry,
 +                                       struct hashmap *collisions,
 +                                       struct tree *tree)
 +{
 +      char *new_path = NULL;
 +      struct collision_entry *collision_ent;
 +      int clean = 1;
 +      struct strbuf collision_paths = STRBUF_INIT;
 +
 +      /*
 +       * entry has the mapping of old directory name to new directory name
 +       * that we want to apply to path.
 +       */
 +      new_path = apply_dir_rename(entry, path);
 +
 +      if (!new_path) {
 +              /* This should only happen when entry->non_unique_new_dir set */
 +              if (!entry->non_unique_new_dir)
 +                      BUG("entry->non_unqiue_dir not set and !new_path");
 +              output(o, 1, _("CONFLICT (directory rename split): "
 +                             "Unclear where to place %s because directory "
 +                             "%s was renamed to multiple other directories, "
 +                             "with no destination getting a majority of the "
 +                             "files."),
 +                     path, entry->dir);
 +              clean = 0;
 +              return NULL;
 +      }
 +
 +      /*
 +       * The caller needs to have ensured that it has pre-populated
 +       * collisions with all paths that map to new_path.  Do a quick check
 +       * to ensure that's the case.
 +       */
 +      collision_ent = collision_find_entry(collisions, new_path);
 +      if (collision_ent == NULL)
 +              BUG("collision_ent is NULL");
 +
 +      /*
 +       * Check for one-sided add/add/.../add conflicts, i.e.
 +       * where implicit renames from the other side doing
 +       * directory rename(s) can affect this side of history
 +       * to put multiple paths into the same location.  Warn
 +       * and bail on directory renames for such paths.
 +       */
 +      if (collision_ent->reported_already) {
 +              clean = 0;
 +      } else if (tree_has_path(tree, new_path)) {
 +              collision_ent->reported_already = 1;
 +              strbuf_add_separated_string_list(&collision_paths, ", ",
 +                                               &collision_ent->source_files);
 +              output(o, 1, _("CONFLICT (implicit dir rename): Existing "
 +                             "file/dir at %s in the way of implicit "
 +                             "directory rename(s) putting the following "
 +                             "path(s) there: %s."),
 +                     new_path, collision_paths.buf);
 +              clean = 0;
 +      } else if (collision_ent->source_files.nr > 1) {
 +              collision_ent->reported_already = 1;
 +              strbuf_add_separated_string_list(&collision_paths, ", ",
 +                                               &collision_ent->source_files);
 +              output(o, 1, _("CONFLICT (implicit dir rename): Cannot map "
 +                             "more than one path to %s; implicit directory "
 +                             "renames tried to put these paths there: %s"),
 +                     new_path, collision_paths.buf);
 +              clean = 0;
 +      }
 +
 +      /* Free memory we no longer need */
 +      strbuf_release(&collision_paths);
 +      if (!clean && new_path) {
 +              free(new_path);
 +              return NULL;
 +      }
 +
 +      return new_path;
 +}
 +
 +/*
 + * There are a couple things we want to do at the directory level:
 + *   1. Check for both sides renaming to the same thing, in order to avoid
 + *      implicit renaming of files that should be left in place.  (See
 + *      testcase 6b in t6043 for details.)
 + *   2. Prune directory renames if there are still files left in the
 + *      the original directory.  These represent a partial directory rename,
 + *      i.e. a rename where only some of the files within the directory
 + *      were renamed elsewhere.  (Technically, this could be done earlier
 + *      in get_directory_renames(), except that would prevent us from
 + *      doing the previous check and thus failing testcase 6b.)
 + *   3. Check for rename/rename(1to2) conflicts (at the directory level).
 + *      In the future, we could potentially record this info as well and
 + *      omit reporting rename/rename(1to2) conflicts for each path within
 + *      the affected directories, thus cleaning up the merge output.
 + *   NOTE: We do NOT check for rename/rename(2to1) conflicts at the
 + *         directory level, because merging directories is fine.  If it
 + *         causes conflicts for files within those merged directories, then
 + *         that should be detected at the individual path level.
 + */
 +static void handle_directory_level_conflicts(struct merge_options *o,
 +                                           struct hashmap *dir_re_head,
 +                                           struct tree *head,
 +                                           struct hashmap *dir_re_merge,
 +                                           struct tree *merge)
 +{
 +      struct hashmap_iter iter;
 +      struct dir_rename_entry *head_ent;
 +      struct dir_rename_entry *merge_ent;
 +
 +      struct string_list remove_from_head = STRING_LIST_INIT_NODUP;
 +      struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;
 +
 +      hashmap_iter_init(dir_re_head, &iter);
 +      while ((head_ent = hashmap_iter_next(&iter))) {
 +              merge_ent = dir_rename_find_entry(dir_re_merge, head_ent->dir);
 +              if (merge_ent &&
 +                  !head_ent->non_unique_new_dir &&
 +                  !merge_ent->non_unique_new_dir &&
 +                  !strbuf_cmp(&head_ent->new_dir, &merge_ent->new_dir)) {
 +                      /* 1. Renamed identically; remove it from both sides */
 +                      string_list_append(&remove_from_head,
 +                                         head_ent->dir)->util = head_ent;
 +                      strbuf_release(&head_ent->new_dir);
 +                      string_list_append(&remove_from_merge,
 +                                         merge_ent->dir)->util = merge_ent;
 +                      strbuf_release(&merge_ent->new_dir);
 +              } else if (tree_has_path(head, head_ent->dir)) {
 +                      /* 2. This wasn't a directory rename after all */
 +                      string_list_append(&remove_from_head,
 +                                         head_ent->dir)->util = head_ent;
 +                      strbuf_release(&head_ent->new_dir);
 +              }
 +      }
 +
 +      remove_hashmap_entries(dir_re_head, &remove_from_head);
 +      remove_hashmap_entries(dir_re_merge, &remove_from_merge);
 +
 +      hashmap_iter_init(dir_re_merge, &iter);
 +      while ((merge_ent = hashmap_iter_next(&iter))) {
 +              head_ent = dir_rename_find_entry(dir_re_head, merge_ent->dir);
 +              if (tree_has_path(merge, merge_ent->dir)) {
 +                      /* 2. This wasn't a directory rename after all */
 +                      string_list_append(&remove_from_merge,
 +                                         merge_ent->dir)->util = merge_ent;
 +              } else if (head_ent &&
 +                         !head_ent->non_unique_new_dir &&
 +                         !merge_ent->non_unique_new_dir) {
 +                      /* 3. rename/rename(1to2) */
 +                      /*
 +                       * We can assume it's not rename/rename(1to1) because
 +                       * that was case (1), already checked above.  So we
 +                       * know that head_ent->new_dir and merge_ent->new_dir
 +                       * are different strings.
 +                       */
 +                      output(o, 1, _("CONFLICT (rename/rename): "
 +                                     "Rename directory %s->%s in %s. "
 +                                     "Rename directory %s->%s in %s"),
 +                             head_ent->dir, head_ent->new_dir.buf, o->branch1,
 +                             head_ent->dir, merge_ent->new_dir.buf, o->branch2);
 +                      string_list_append(&remove_from_head,
 +                                         head_ent->dir)->util = head_ent;
 +                      strbuf_release(&head_ent->new_dir);
 +                      string_list_append(&remove_from_merge,
 +                                         merge_ent->dir)->util = merge_ent;
 +                      strbuf_release(&merge_ent->new_dir);
 +              }
 +      }
 +
 +      remove_hashmap_entries(dir_re_head, &remove_from_head);
 +      remove_hashmap_entries(dir_re_merge, &remove_from_merge);
 +}
 +
 +static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs,
 +                                           struct tree *tree)
 +{
 +      struct hashmap *dir_renames;
 +      struct hashmap_iter iter;
 +      struct dir_rename_entry *entry;
 +      int i;
 +
 +      /*
 +       * Typically, we think of a directory rename as all files from a
 +       * certain directory being moved to a target directory.  However,
 +       * what if someone first moved two files from the original
 +       * directory in one commit, and then renamed the directory
 +       * somewhere else in a later commit?  At merge time, we just know
 +       * that files from the original directory went to two different
 +       * places, and that the bulk of them ended up in the same place.
 +       * We want each directory rename to represent where the bulk of the
 +       * files from that directory end up; this function exists to find
 +       * where the bulk of the files went.
 +       *
 +       * The first loop below simply iterates through the list of file
 +       * renames, finding out how often each directory rename pair
 +       * possibility occurs.
 +       */
 +      dir_renames = xmalloc(sizeof(struct hashmap));
 +      dir_rename_init(dir_renames);
 +      for (i = 0; i < pairs->nr; ++i) {
 +              struct string_list_item *item;
 +              int *count;
 +              struct diff_filepair *pair = pairs->queue[i];
 +              char *old_dir, *new_dir;
 +
 +              /* File not part of directory rename if it wasn't renamed */
 +              if (pair->status != 'R')
 +                      continue;
 +
 +              get_renamed_dir_portion(pair->one->path, pair->two->path,
 +                                      &old_dir,        &new_dir);
 +              if (!old_dir)
 +                      /* Directory didn't change at all; ignore this one. */
 +                      continue;
 +
 +              entry = dir_rename_find_entry(dir_renames, old_dir);
 +              if (!entry) {
 +                      entry = xmalloc(sizeof(struct dir_rename_entry));
 +                      dir_rename_entry_init(entry, old_dir);
 +                      hashmap_put(dir_renames, entry);
 +              } else {
 +                      free(old_dir);
 +              }
 +              item = string_list_lookup(&entry->possible_new_dirs, new_dir);
 +              if (!item) {
 +                      item = string_list_insert(&entry->possible_new_dirs,
 +                                                new_dir);
 +                      item->util = xcalloc(1, sizeof(int));
 +              } else {
 +                      free(new_dir);
 +              }
 +              count = item->util;
 +              *count += 1;
 +      }
 +
 +      /*
 +       * For each directory with files moved out of it, we find out which
 +       * target directory received the most files so we can declare it to
 +       * be the "winning" target location for the directory rename.  This
 +       * winner gets recorded in new_dir.  If there is no winner
 +       * (multiple target directories received the same number of files),
 +       * we set non_unique_new_dir.  Once we've determined the winner (or
 +       * that there is no winner), we no longer need possible_new_dirs.
 +       */
 +      hashmap_iter_init(dir_renames, &iter);
 +      while ((entry = hashmap_iter_next(&iter))) {
 +              int max = 0;
 +              int bad_max = 0;
 +              char *best = NULL;
 +
 +              for (i = 0; i < entry->possible_new_dirs.nr; i++) {
 +                      int *count = entry->possible_new_dirs.items[i].util;
 +
 +                      if (*count == max)
 +                              bad_max = max;
 +                      else if (*count > max) {
 +                              max = *count;
 +                              best = entry->possible_new_dirs.items[i].string;
 +                      }
 +              }
 +              if (bad_max == max)
 +                      entry->non_unique_new_dir = 1;
 +              else {
 +                      assert(entry->new_dir.len == 0);
 +                      strbuf_addstr(&entry->new_dir, best);
 +              }
 +              /*
 +               * The relevant directory sub-portion of the original full
 +               * filepaths were xstrndup'ed before inserting into
 +               * possible_new_dirs, and instead of manually iterating the
 +               * list and free'ing each, just lie and tell
 +               * possible_new_dirs that it did the strdup'ing so that it
 +               * will free them for us.
 +               */
 +              entry->possible_new_dirs.strdup_strings = 1;
 +              string_list_clear(&entry->possible_new_dirs, 1);
 +      }
 +
 +      return dir_renames;
 +}
 +
 +static struct dir_rename_entry *check_dir_renamed(const char *path,
 +                                                struct hashmap *dir_renames)
 +{
 +      char temp[PATH_MAX];
 +      char *end;
 +      struct dir_rename_entry *entry;
 +
 +      strcpy(temp, path);
 +      while ((end = strrchr(temp, '/'))) {
 +              *end = '\0';
 +              entry = dir_rename_find_entry(dir_renames, temp);
 +              if (entry)
 +                      return entry;
 +      }
 +      return NULL;
 +}
 +
 +static void compute_collisions(struct hashmap *collisions,
 +                             struct hashmap *dir_renames,
 +                             struct diff_queue_struct *pairs)
 +{
 +      int i;
 +
 +      /*
 +       * Multiple files can be mapped to the same path due to directory
 +       * renames done by the other side of history.  Since that other
 +       * side of history could have merged multiple directories into one,
 +       * if our side of history added the same file basename to each of
 +       * those directories, then all N of them would get implicitly
 +       * renamed by the directory rename detection into the same path,
 +       * and we'd get an add/add/.../add conflict, and all those adds
 +       * from *this* side of history.  This is not representable in the
 +       * index, and users aren't going to easily be able to make sense of
 +       * it.  So we need to provide a good warning about what's
 +       * happening, and fall back to no-directory-rename detection
 +       * behavior for those paths.
 +       *
 +       * See testcases 9e and all of section 5 from t6043 for examples.
 +       */
 +      collision_init(collisions);
 +
 +      for (i = 0; i < pairs->nr; ++i) {
 +              struct dir_rename_entry *dir_rename_ent;
 +              struct collision_entry *collision_ent;
 +              char *new_path;
 +              struct diff_filepair *pair = pairs->queue[i];
 +
 +              if (pair->status != 'A' && pair->status != 'R')
 +                      continue;
 +              dir_rename_ent = check_dir_renamed(pair->two->path,
 +                                                 dir_renames);
 +              if (!dir_rename_ent)
 +                      continue;
 +
 +              new_path = apply_dir_rename(dir_rename_ent, pair->two->path);
 +              if (!new_path)
 +                      /*
 +                       * dir_rename_ent->non_unique_new_path is true, which
 +                       * means there is no directory rename for us to use,
 +                       * which means it won't cause us any additional
 +                       * collisions.
 +                       */
 +                      continue;
 +              collision_ent = collision_find_entry(collisions, new_path);
 +              if (!collision_ent) {
 +                      collision_ent = xcalloc(1,
 +                                              sizeof(struct collision_entry));
 +                      hashmap_entry_init(collision_ent, strhash(new_path));
 +                      hashmap_put(collisions, collision_ent);
 +                      collision_ent->target_file = new_path;
 +              } else {
 +                      free(new_path);
 +              }
 +              string_list_insert(&collision_ent->source_files,
 +                                 pair->two->path);
 +      }
 +}
 +
 +static char *check_for_directory_rename(struct merge_options *o,
 +                                      const char *path,
 +                                      struct tree *tree,
 +                                      struct hashmap *dir_renames,
 +                                      struct hashmap *dir_rename_exclusions,
 +                                      struct hashmap *collisions,
 +                                      int *clean_merge)
 +{
 +      char *new_path = NULL;
 +      struct dir_rename_entry *entry = check_dir_renamed(path, dir_renames);
 +      struct dir_rename_entry *oentry = NULL;
 +
 +      if (!entry)
 +              return new_path;
 +
 +      /*
 +       * This next part is a little weird.  We do not want to do an
 +       * implicit rename into a directory we renamed on our side, because
 +       * that will result in a spurious rename/rename(1to2) conflict.  An
 +       * example:
 +       *   Base commit: dumbdir/afile, otherdir/bfile
 +       *   Side 1:      smrtdir/afile, otherdir/bfile
 +       *   Side 2:      dumbdir/afile, dumbdir/bfile
 +       * Here, while working on Side 1, we could notice that otherdir was
 +       * renamed/merged to dumbdir, and change the diff_filepair for
 +       * otherdir/bfile into a rename into dumbdir/bfile.  However, Side
 +       * 2 will notice the rename from dumbdir to smrtdir, and do the
 +       * transitive rename to move it from dumbdir/bfile to
 +       * smrtdir/bfile.  That gives us bfile in dumbdir vs being in
 +       * smrtdir, a rename/rename(1to2) conflict.  We really just want
 +       * the file to end up in smrtdir.  And the way to achieve that is
 +       * to not let Side1 do the rename to dumbdir, since we know that is
 +       * the source of one of our directory renames.
 +       *
 +       * That's why oentry and dir_rename_exclusions is here.
 +       *
 +       * As it turns out, this also prevents N-way transient rename
 +       * confusion; See testcases 9c and 9d of t6043.
 +       */
 +      oentry = dir_rename_find_entry(dir_rename_exclusions, entry->new_dir.buf);
 +      if (oentry) {
 +              output(o, 1, _("WARNING: Avoiding applying %s -> %s rename "
 +                             "to %s, because %s itself was renamed."),
 +                     entry->dir, entry->new_dir.buf, path, entry->new_dir.buf);
 +      } else {
 +              new_path = handle_path_level_conflicts(o, path, entry,
 +                                                     collisions, tree);
 +              *clean_merge &= (new_path != NULL);
 +      }
 +
 +      return new_path;
 +}
 +
 +static void apply_directory_rename_modifications(struct merge_options *o,
 +                                               struct diff_filepair *pair,
 +                                               char *new_path,
 +                                               struct rename *re,
 +                                               struct tree *tree,
 +                                               struct tree *o_tree,
 +                                               struct tree *a_tree,
 +                                               struct tree *b_tree,
 +                                               struct string_list *entries,
 +                                               int *clean)
 +{
 +      struct string_list_item *item;
 +      int stage = (tree == a_tree ? 2 : 3);
 +      int update_wd;
 +
 +      /*
 +       * In all cases where we can do directory rename detection,
 +       * unpack_trees() will have read pair->two->path into the
 +       * index and the working copy.  We need to remove it so that
 +       * we can instead place it at new_path.  It is guaranteed to
 +       * not be untracked (unpack_trees() would have errored out
 +       * saying the file would have been overwritten), but it might
 +       * be dirty, though.
 +       */
 +      update_wd = !was_dirty(o, pair->two->path);
 +      if (!update_wd)
 +              output(o, 1, _("Refusing to lose dirty file at %s"),
 +                     pair->two->path);
 +      remove_file(o, 1, pair->two->path, !update_wd);
 +
 +      /* Find or create a new re->dst_entry */
 +      item = string_list_lookup(entries, new_path);
 +      if (item) {
 +              /*
 +               * Since we're renaming on this side of history, and it's
 +               * due to a directory rename on the other side of history
 +               * (which we only allow when the directory in question no
 +               * longer exists on the other side of history), the
 +               * original entry for re->dst_entry is no longer
 +               * necessary...
 +               */
 +              re->dst_entry->processed = 1;
 +
 +              /*
 +               * ...because we'll be using this new one.
 +               */
 +              re->dst_entry = item->util;
 +      } else {
 +              /*
 +               * re->dst_entry is for the before-dir-rename path, and we
 +               * need it to hold information for the after-dir-rename
 +               * path.  Before creating a new entry, we need to mark the
 +               * old one as unnecessary (...unless it is shared by
 +               * src_entry, i.e. this didn't use to be a rename, in which
 +               * case we can just allow the normal processing to happen
 +               * for it).
 +               */
 +              if (pair->status == 'R')
 +                      re->dst_entry->processed = 1;
 +
 +              re->dst_entry = insert_stage_data(new_path,
 +                                                o_tree, a_tree, b_tree,
 +                                                entries);
 +              item = string_list_insert(entries, new_path);
 +              item->util = re->dst_entry;
 +      }
 +
 +      /*
 +       * Update the stage_data with the information about the path we are
 +       * moving into place.  That slot will be empty and available for us
 +       * to write to because of the collision checks in
 +       * handle_path_level_conflicts().  In other words,
 +       * re->dst_entry->stages[stage].oid will be the null_oid, so it's
 +       * open for us to write to.
 +       *
 +       * It may be tempting to actually update the index at this point as
 +       * well, using update_stages_for_stage_data(), but as per the big
 +       * "NOTE" in update_stages(), doing so will modify the current
 +       * in-memory index which will break calls to would_lose_untracked()
 +       * that we need to make.  Instead, we need to just make sure that
 +       * the various conflict_rename_*() functions update the index
 +       * explicitly rather than relying on unpack_trees() to have done it.
 +       */
-                      re->dst_entry->stages[stage].oid.hash,
++      get_tree_entry(&tree->object.oid,
 +                     pair->two->path,
++                     &re->dst_entry->stages[stage].oid,
 +                     &re->dst_entry->stages[stage].mode);
 +
 +      /* Update pair status */
 +      if (pair->status == 'A') {
 +              /*
 +               * Recording rename information for this add makes it look
 +               * like a rename/delete conflict.  Make sure we can
 +               * correctly handle this as an add that was moved to a new
 +               * directory instead of reporting a rename/delete conflict.
 +               */
 +              re->add_turned_into_rename = 1;
 +      }
 +      /*
 +       * We don't actually look at pair->status again, but it seems
 +       * pedagogically correct to adjust it.
 +       */
 +      pair->status = 'R';
 +
 +      /*
 +       * Finally, record the new location.
 +       */
 +      pair->two->path = new_path;
 +}
 +
 +/*
 + * Get information of all renames which occurred in 'pairs', making use of
 + * any implicit directory renames inferred from the other side of history.
 + * We need the three trees in the merge ('o_tree', 'a_tree' and 'b_tree')
 + * to be able to associate the correct cache entries with the rename
 + * information; tree is always equal to either a_tree or b_tree.
 + */
 +static struct string_list *get_renames(struct merge_options *o,
 +                                     struct diff_queue_struct *pairs,
 +                                     struct hashmap *dir_renames,
 +                                     struct hashmap *dir_rename_exclusions,
 +                                     struct tree *tree,
 +                                     struct tree *o_tree,
 +                                     struct tree *a_tree,
 +                                     struct tree *b_tree,
 +                                     struct string_list *entries,
 +                                     int *clean_merge)
 +{
 +      int i;
 +      struct hashmap collisions;
 +      struct hashmap_iter iter;
 +      struct collision_entry *e;
 +      struct string_list *renames;
 +
 +      compute_collisions(&collisions, dir_renames, pairs);
 +      renames = xcalloc(1, sizeof(struct string_list));
 +
 +      for (i = 0; i < pairs->nr; ++i) {
 +              struct string_list_item *item;
 +              struct rename *re;
 +              struct diff_filepair *pair = pairs->queue[i];
 +              char *new_path; /* non-NULL only with directory renames */
 +
 +              if (pair->status != 'A' && pair->status != 'R') {
 +                      diff_free_filepair(pair);
 +                      continue;
 +              }
 +              new_path = check_for_directory_rename(o, pair->two->path, tree,
 +                                                    dir_renames,
 +                                                    dir_rename_exclusions,
 +                                                    &collisions,
 +                                                    clean_merge);
 +              if (pair->status != 'R' && !new_path) {
 +                      diff_free_filepair(pair);
 +                      continue;
 +              }
 +
 +              re = xmalloc(sizeof(*re));
 +              re->processed = 0;
 +              re->add_turned_into_rename = 0;
 +              re->pair = pair;
 +              item = string_list_lookup(entries, re->pair->one->path);
 +              if (!item)
 +                      re->src_entry = insert_stage_data(re->pair->one->path,
 +                                      o_tree, a_tree, b_tree, entries);
 +              else
 +                      re->src_entry = item->util;
 +
 +              item = string_list_lookup(entries, re->pair->two->path);
 +              if (!item)
 +                      re->dst_entry = insert_stage_data(re->pair->two->path,
 +                                      o_tree, a_tree, b_tree, entries);
 +              else
 +                      re->dst_entry = item->util;
 +              item = string_list_insert(renames, pair->one->path);
 +              item->util = re;
 +              if (new_path)
 +                      apply_directory_rename_modifications(o, pair, new_path,
 +                                                           re, tree, o_tree,
 +                                                           a_tree, b_tree,
 +                                                           entries,
 +                                                           clean_merge);
 +      }
 +
 +      hashmap_iter_init(&collisions, &iter);
 +      while ((e = hashmap_iter_next(&iter))) {
 +              free(e->target_file);
 +              string_list_clear(&e->source_files, 0);
 +      }
 +      hashmap_free(&collisions, 1);
 +      return renames;
 +}
 +
  static int process_renames(struct merge_options *o,
                           struct string_list *a_renames,
                           struct string_list *b_renames)
diff --cc read-cache.c
Simple merge
diff --cc rerere.c
Simple merge
diff --cc sequencer.c
Simple merge
diff --cc sha1_file.c
@@@ -1259,22 -1263,17 +1263,22 @@@ int oid_object_info_extended(const stru
        }
  
        while (1) {
-               if (find_pack_entry(real, &e))
+               if (find_pack_entry(real->hash, &e))
                        break;
  
 +              if (flags & OBJECT_INFO_IGNORE_LOOSE)
 +                      return -1;
 +
                /* Most likely it's a loose object. */
-               if (!sha1_loose_object_info(real, oi, flags))
+               if (!sha1_loose_object_info(real->hash, oi, flags))
                        return 0;
  
                /* Not a loose object; someone else may have just packed it. */
 -              reprepare_packed_git();
 -              if (find_pack_entry(real->hash, &e))
 -                      break;
 +              if (!(flags & OBJECT_INFO_QUICK)) {
 +                      reprepare_packed_git();
-                       if (find_pack_entry(real, &e))
++                      if (find_pack_entry(real->hash, &e))
 +                              break;
 +              }
  
                /* Check if it is a missing object */
                if (fetch_if_missing && repository_format_partial_clone &&
diff --cc strbuf.c
Simple merge
diff --cc strbuf.h
Simple merge