Merge branch 'jk/diff-submodule-diff-inline'
authorJunio C Hamano <gitster@pobox.com>
Mon, 29 May 2017 03:34:42 +0000 (12:34 +0900)
committerJunio C Hamano <gitster@pobox.com>
Mon, 29 May 2017 03:34:42 +0000 (12:34 +0900)
"git diff --submodule=diff" now recurses into nested submodules.

* jk/diff-submodule-diff-inline:
  diff: recurse into nested submodules for inline diff

1  2 
submodule.c
t/t4060-diff-submodule-option-diff-format.sh

diff --combined submodule.c
  #include "blob.h"
  #include "thread-utils.h"
  #include "quote.h"
 +#include "remote.h"
 +#include "worktree.h"
  
  static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
 +static int config_update_recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
  static int parallel_jobs = 1;
 -static struct string_list changed_submodule_paths = STRING_LIST_INIT_NODUP;
 +static struct string_list changed_submodule_paths = STRING_LIST_INIT_DUP;
  static int initialized_fetch_ref_tips;
 -static struct sha1_array ref_tips_before_fetch;
 -static struct sha1_array ref_tips_after_fetch;
 +static struct oid_array ref_tips_before_fetch;
 +static struct oid_array ref_tips_after_fetch;
  
  /*
   * The following flag is set if the .gitmodules file is unmerged. We then
@@@ -126,7 -123,9 +126,7 @@@ void stage_updated_gitmodules(void
  static int add_submodule_odb(const char *path)
  {
        struct strbuf objects_directory = STRBUF_INIT;
 -      struct alternate_object_database *alt_odb;
        int ret = 0;
 -      size_t alloc;
  
        ret = strbuf_git_path_submodule(&objects_directory, path, "objects/");
        if (ret)
                ret = -1;
                goto done;
        }
 -      /* avoid adding it twice */
 -      prepare_alt_odb();
 -      for (alt_odb = alt_odb_list; alt_odb; alt_odb = alt_odb->next)
 -              if (alt_odb->name - alt_odb->base == objects_directory.len &&
 -                              !strncmp(alt_odb->base, objects_directory.buf,
 -                                      objects_directory.len))
 -                      goto done;
 -
 -      alloc = st_add(objects_directory.len, 42); /* for "12/345..." sha1 */
 -      alt_odb = xmalloc(st_add(sizeof(*alt_odb), alloc));
 -      alt_odb->next = alt_odb_list;
 -      xsnprintf(alt_odb->base, alloc, "%s", objects_directory.buf);
 -      alt_odb->name = alt_odb->base + objects_directory.len;
 -      alt_odb->name[2] = '/';
 -      alt_odb->name[40] = '\0';
 -      alt_odb->name[41] = '\0';
 -      alt_odb_list = alt_odb;
 -
 -      /* add possible alternates from the submodule */
 -      read_info_alternates(objects_directory.buf, 0);
 +      add_to_alternates_memory(objects_directory.buf);
  done:
        strbuf_release(&objects_directory);
        return ret;
@@@ -201,87 -219,6 +201,87 @@@ void gitmodules_config(void
        }
  }
  
 +void gitmodules_config_sha1(const unsigned char *commit_sha1)
 +{
 +      struct strbuf rev = STRBUF_INIT;
 +      unsigned char sha1[20];
 +
 +      if (gitmodule_sha1_from_commit(commit_sha1, sha1, &rev)) {
 +              git_config_from_blob_sha1(submodule_config, rev.buf,
 +                                        sha1, NULL);
 +      }
 +      strbuf_release(&rev);
 +}
 +
 +/*
 + * NEEDSWORK: With the addition of different configuration options to determine
 + * if a submodule is of interests, the validity of this function's name comes
 + * into question.  Once the dust has settled and more concrete terminology is
 + * decided upon, come up with a more proper name for this function.  One
 + * potential candidate could be 'is_submodule_active()'.
 + *
 + * Determine if a submodule has been initialized at a given 'path'
 + */
 +int is_submodule_initialized(const char *path)
 +{
 +      int ret = 0;
 +      char *key = NULL;
 +      char *value = NULL;
 +      const struct string_list *sl;
 +      const struct submodule *module = submodule_from_path(null_sha1, path);
 +
 +      /* early return if there isn't a path->module mapping */
 +      if (!module)
 +              return 0;
 +
 +      /* submodule.<name>.active is set */
 +      key = xstrfmt("submodule.%s.active", module->name);
 +      if (!git_config_get_bool(key, &ret)) {
 +              free(key);
 +              return ret;
 +      }
 +      free(key);
 +
 +      /* submodule.active is set */
 +      sl = git_config_get_value_multi("submodule.active");
 +      if (sl) {
 +              struct pathspec ps;
 +              struct argv_array args = ARGV_ARRAY_INIT;
 +              const struct string_list_item *item;
 +
 +              for_each_string_list_item(item, sl) {
 +                      argv_array_push(&args, item->string);
 +              }
 +
 +              parse_pathspec(&ps, 0, 0, NULL, args.argv);
 +              ret = match_pathspec(&ps, path, strlen(path), 0, NULL, 1);
 +
 +              argv_array_clear(&args);
 +              clear_pathspec(&ps);
 +              return ret;
 +      }
 +
 +      /* fallback to checking if the URL is set */
 +      key = xstrfmt("submodule.%s.url", module->name);
 +      ret = !git_config_get_string(key, &value);
 +
 +      free(value);
 +      free(key);
 +      return ret;
 +}
 +
 +int is_submodule_populated_gently(const char *path, int *return_error_code)
 +{
 +      int ret = 0;
 +      char *gitdir = xstrfmt("%s/.git", path);
 +
 +      if (resolve_gitdir_gently(gitdir, return_error_code))
 +              ret = 1;
 +
 +      free(gitdir);
 +      return ret;
 +}
 +
  int parse_submodule_update_strategy(const char *value,
                struct submodule_update_strategy *dst)
  {
@@@ -391,23 -328,6 +391,23 @@@ static void print_submodule_summary(str
        strbuf_release(&sb);
  }
  
 +static void prepare_submodule_repo_env_no_git_dir(struct argv_array *out)
 +{
 +      const char * const *var;
 +
 +      for (var = local_repo_env; *var; var++) {
 +              if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
 +                      argv_array_push(out, *var);
 +      }
 +}
 +
 +void prepare_submodule_repo_env(struct argv_array *out)
 +{
 +      prepare_submodule_repo_env_no_git_dir(out);
 +      argv_array_pushf(out, "%s=%s", GIT_DIR_ENVIRONMENT,
 +                       DEFAULT_GIT_DIR_ENVIRONMENT);
 +}
 +
  /* Helper function to display the submodule header line prior to the full
   * summary output. If it can locate the submodule objects directory it will
   * attempt to lookup both the left and right commits and put them into the
@@@ -472,10 -392,11 +472,10 @@@ static void show_submodule_header(FILE 
        }
  
  output_header:
 -      strbuf_addf(&sb, "%s%sSubmodule %s %s..", line_prefix, meta, path,
 -                      find_unique_abbrev(one->hash, DEFAULT_ABBREV));
 -      if (!fast_backward && !fast_forward)
 -              strbuf_addch(&sb, '.');
 -      strbuf_addf(&sb, "%s", find_unique_abbrev(two->hash, DEFAULT_ABBREV));
 +      strbuf_addf(&sb, "%s%sSubmodule %s ", line_prefix, meta, path);
 +      strbuf_add_unique_abbrev(&sb, one->hash, DEFAULT_ABBREV);
 +      strbuf_addstr(&sb, (fast_backward || fast_forward) ? ".." : "...");
 +      strbuf_add_unique_abbrev(&sb, two->hash, DEFAULT_ABBREV);
        if (message)
                strbuf_addf(&sb, " %s%s\n", message, reset);
        else
@@@ -554,7 -475,8 +554,8 @@@ void show_submodule_inline_diff(FILE *f
        cp.no_stdin = 1;
  
        /* TODO: other options may need to be passed here. */
-       argv_array_push(&cp.args, "diff");
+       argv_array_pushl(&cp.args, "diff", "--submodule=diff", NULL);
        argv_array_pushf(&cp.args, "--line-prefix=%s", line_prefix);
        if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
                argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
        if (!(dirty_submodule & DIRTY_SUBMODULE_MODIFIED))
                argv_array_push(&cp.args, oid_to_hex(new));
  
 +      prepare_submodule_repo_env(&cp.env_array);
        if (run_command(&cp))
                fprintf(f, "(diff failed)\n");
  
@@@ -596,216 -517,33 +597,216 @@@ void set_config_fetch_recurse_submodule
        config_fetch_recurse_submodules = value;
  }
  
 +void set_config_update_recurse_submodules(int value)
 +{
 +      config_update_recurse_submodules = value;
 +}
 +
 +int should_update_submodules(void)
 +{
 +      return config_update_recurse_submodules == RECURSE_SUBMODULES_ON;
 +}
 +
 +const struct submodule *submodule_from_ce(const struct cache_entry *ce)
 +{
 +      if (!S_ISGITLINK(ce->ce_mode))
 +              return NULL;
 +
 +      if (!should_update_submodules())
 +              return NULL;
 +
 +      return submodule_from_path(null_sha1, ce->name);
 +}
 +
 +static struct oid_array *submodule_commits(struct string_list *submodules,
 +                                         const char *path)
 +{
 +      struct string_list_item *item;
 +
 +      item = string_list_insert(submodules, path);
 +      if (item->util)
 +              return (struct oid_array *) item->util;
 +
 +      /* NEEDSWORK: should we have oid_array_init()? */
 +      item->util = xcalloc(1, sizeof(struct oid_array));
 +      return (struct oid_array *) item->util;
 +}
 +
 +static void collect_changed_submodules_cb(struct diff_queue_struct *q,
 +                                        struct diff_options *options,
 +                                        void *data)
 +{
 +      int i;
 +      struct string_list *changed = data;
 +
 +      for (i = 0; i < q->nr; i++) {
 +              struct diff_filepair *p = q->queue[i];
 +              struct oid_array *commits;
 +              if (!S_ISGITLINK(p->two->mode))
 +                      continue;
 +
 +              if (S_ISGITLINK(p->one->mode)) {
 +                      /*
 +                       * NEEDSWORK: We should honor the name configured in
 +                       * the .gitmodules file of the commit we are examining
 +                       * here to be able to correctly follow submodules
 +                       * being moved around.
 +                       */
 +                      commits = submodule_commits(changed, p->two->path);
 +                      oid_array_append(commits, &p->two->oid);
 +              } else {
 +                      /* Submodule is new or was moved here */
 +                      /*
 +                       * NEEDSWORK: When the .git directories of submodules
 +                       * live inside the superprojects .git directory some
 +                       * day we should fetch new submodules directly into
 +                       * that location too when config or options request
 +                       * that so they can be checked out from there.
 +                       */
 +                      continue;
 +              }
 +      }
 +}
 +
 +/*
 + * Collect the paths of submodules in 'changed' which have changed based on
 + * the revisions as specified in 'argv'.  Each entry in 'changed' will also
 + * have a corresponding 'struct oid_array' (in the 'util' field) which lists
 + * what the submodule pointers were updated to during the change.
 + */
 +static void collect_changed_submodules(struct string_list *changed,
 +                                     struct argv_array *argv)
 +{
 +      struct rev_info rev;
 +      const struct commit *commit;
 +
 +      init_revisions(&rev, NULL);
 +      setup_revisions(argv->argc, argv->argv, &rev, NULL);
 +      if (prepare_revision_walk(&rev))
 +              die("revision walk setup failed");
 +
 +      while ((commit = get_revision(&rev))) {
 +              struct rev_info diff_rev;
 +
 +              init_revisions(&diff_rev, NULL);
 +              diff_rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
 +              diff_rev.diffopt.format_callback = collect_changed_submodules_cb;
 +              diff_rev.diffopt.format_callback_data = changed;
 +              diff_tree_combined_merge(commit, 1, &diff_rev);
 +      }
 +
 +      reset_revision_walk();
 +}
 +
 +static void free_submodules_oids(struct string_list *submodules)
 +{
 +      struct string_list_item *item;
 +      for_each_string_list_item(item, submodules)
 +              oid_array_clear((struct oid_array *) item->util);
 +      string_list_clear(submodules, 1);
 +}
 +
  static int has_remote(const char *refname, const struct object_id *oid,
                      int flags, void *cb_data)
  {
        return 1;
  }
  
 -static int submodule_needs_pushing(const char *path, const unsigned char sha1[20])
 +static int append_oid_to_argv(const struct object_id *oid, void *data)
 +{
 +      struct argv_array *argv = data;
 +      argv_array_push(argv, oid_to_hex(oid));
 +      return 0;
 +}
 +
 +static int check_has_commit(const struct object_id *oid, void *data)
 +{
 +      int *has_commit = data;
 +
 +      if (!lookup_commit_reference(oid->hash))
 +              *has_commit = 0;
 +
 +      return 0;
 +}
 +
 +static int submodule_has_commits(const char *path, struct oid_array *commits)
 +{
 +      int has_commit = 1;
 +
 +      /*
 +       * Perform a cheap, but incorrect check for the existance of 'commits'.
 +       * This is done by adding the submodule's object store to the in-core
 +       * object store, and then querying for each commit's existance.  If we
 +       * do not have the commit object anywhere, there is no chance we have
 +       * it in the object store of the correct submodule and have it
 +       * reachable from a ref, so we can fail early without spawning rev-list
 +       * which is expensive.
 +       */
 +      if (add_submodule_odb(path))
 +              return 0;
 +
 +      oid_array_for_each_unique(commits, check_has_commit, &has_commit);
 +
 +      if (has_commit) {
 +              /*
 +               * Even if the submodule is checked out and the commit is
 +               * present, make sure it exists in the submodule's object store
 +               * and that it is reachable from a ref.
 +               */
 +              struct child_process cp = CHILD_PROCESS_INIT;
 +              struct strbuf out = STRBUF_INIT;
 +
 +              argv_array_pushl(&cp.args, "rev-list", "-n", "1", NULL);
 +              oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
 +              argv_array_pushl(&cp.args, "--not", "--all", NULL);
 +
 +              prepare_submodule_repo_env(&cp.env_array);
 +              cp.git_cmd = 1;
 +              cp.no_stdin = 1;
 +              cp.dir = path;
 +
 +              if (capture_command(&cp, &out, GIT_MAX_HEXSZ + 1) || out.len)
 +                      has_commit = 0;
 +
 +              strbuf_release(&out);
 +      }
 +
 +      return has_commit;
 +}
 +
 +static int submodule_needs_pushing(const char *path, struct oid_array *commits)
  {
 -      if (add_submodule_odb(path) || !lookup_commit_reference(sha1))
 +      if (!submodule_has_commits(path, commits))
 +              /*
 +               * NOTE: We do consider it safe to return "no" here. The
 +               * correct answer would be "We do not know" instead of
 +               * "No push needed", but it is quite hard to change
 +               * the submodule pointer without having the submodule
 +               * around. If a user did however change the submodules
 +               * without having the submodule around, this indicates
 +               * an expert who knows what they are doing or a
 +               * maintainer integrating work from other people. In
 +               * both cases it should be safe to skip this check.
 +               */
                return 0;
  
        if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
                struct child_process cp = CHILD_PROCESS_INIT;
 -              const char *argv[] = {"rev-list", NULL, "--not", "--remotes", "-n", "1" , NULL};
                struct strbuf buf = STRBUF_INIT;
                int needs_pushing = 0;
  
 -              argv[1] = sha1_to_hex(sha1);
 -              cp.argv = argv;
 +              argv_array_push(&cp.args, "rev-list");
 +              oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
 +              argv_array_pushl(&cp.args, "--not", "--remotes", "-n", "1" , NULL);
 +
                prepare_submodule_repo_env(&cp.env_array);
                cp.git_cmd = 1;
                cp.no_stdin = 1;
                cp.out = -1;
                cp.dir = path;
                if (start_command(&cp))
 -                      die("Could not run 'git rev-list %s --not --remotes -n 1' command in submodule %s",
 -                              sha1_to_hex(sha1), path);
 +                      die("Could not run 'git rev-list <commits> --not --remotes -n 1' command in submodule %s",
 +                                      path);
                if (strbuf_read(&buf, cp.out, 41))
                        needs_pushing = 1;
                finish_command(&cp);
        return 0;
  }
  
 -static void collect_submodules_from_diff(struct diff_queue_struct *q,
 -                                       struct diff_options *options,
 -                                       void *data)
 -{
 -      int i;
 -      struct string_list *needs_pushing = data;
 -
 -      for (i = 0; i < q->nr; i++) {
 -              struct diff_filepair *p = q->queue[i];
 -              if (!S_ISGITLINK(p->two->mode))
 -                      continue;
 -              if (submodule_needs_pushing(p->two->path, p->two->oid.hash))
 -                      string_list_insert(needs_pushing, p->two->path);
 -      }
 -}
 -
 -static void find_unpushed_submodule_commits(struct commit *commit,
 -              struct string_list *needs_pushing)
 -{
 -      struct rev_info rev;
 -
 -      init_revisions(&rev, NULL);
 -      rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
 -      rev.diffopt.format_callback = collect_submodules_from_diff;
 -      rev.diffopt.format_callback_data = needs_pushing;
 -      diff_tree_combined_merge(commit, 1, &rev);
 -}
 -
 -int find_unpushed_submodules(unsigned char new_sha1[20],
 +int find_unpushed_submodules(struct oid_array *commits,
                const char *remotes_name, struct string_list *needs_pushing)
  {
 -      struct rev_info rev;
 -      struct commit *commit;
 -      const char *argv[] = {NULL, NULL, "--not", "NULL", NULL};
 -      int argc = ARRAY_SIZE(argv) - 1;
 -      char *sha1_copy;
 +      struct string_list submodules = STRING_LIST_INIT_DUP;
 +      struct string_list_item *submodule;
 +      struct argv_array argv = ARGV_ARRAY_INIT;
  
 -      struct strbuf remotes_arg = STRBUF_INIT;
 +      /* argv.argv[0] will be ignored by setup_revisions */
 +      argv_array_push(&argv, "find_unpushed_submodules");
 +      oid_array_for_each_unique(commits, append_oid_to_argv, &argv);
 +      argv_array_push(&argv, "--not");
 +      argv_array_pushf(&argv, "--remotes=%s", remotes_name);
  
 -      strbuf_addf(&remotes_arg, "--remotes=%s", remotes_name);
 -      init_revisions(&rev, NULL);
 -      sha1_copy = xstrdup(sha1_to_hex(new_sha1));
 -      argv[1] = sha1_copy;
 -      argv[3] = remotes_arg.buf;
 -      setup_revisions(argc, argv, &rev, NULL);
 -      if (prepare_revision_walk(&rev))
 -              die("revision walk setup failed");
 +      collect_changed_submodules(&submodules, &argv);
  
 -      while ((commit = get_revision(&rev)) != NULL)
 -              find_unpushed_submodule_commits(commit, needs_pushing);
 +      for_each_string_list_item(submodule, &submodules) {
 +              struct oid_array *commits = submodule->util;
 +              const char *path = submodule->string;
  
 -      reset_revision_walk();
 -      free(sha1_copy);
 -      strbuf_release(&remotes_arg);
 +              if (submodule_needs_pushing(path, commits))
 +                      string_list_insert(needs_pushing, path);
 +      }
 +
 +      free_submodules_oids(&submodules);
 +      argv_array_clear(&argv);
  
        return needs_pushing->nr;
  }
  
 -static int push_submodule(const char *path)
 +static int push_submodule(const char *path,
 +                        const struct remote *remote,
 +                        const char **refspec, int refspec_nr,
 +                        const struct string_list *push_options,
 +                        int dry_run)
  {
        if (add_submodule_odb(path))
                return 1;
  
        if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
                struct child_process cp = CHILD_PROCESS_INIT;
 -              const char *argv[] = {"push", NULL};
 +              argv_array_push(&cp.args, "push");
 +              if (dry_run)
 +                      argv_array_push(&cp.args, "--dry-run");
 +
 +              if (push_options && push_options->nr) {
 +                      const struct string_list_item *item;
 +                      for_each_string_list_item(item, push_options)
 +                              argv_array_pushf(&cp.args, "--push-option=%s",
 +                                               item->string);
 +              }
 +
 +              if (remote->origin != REMOTE_UNCONFIGURED) {
 +                      int i;
 +                      argv_array_push(&cp.args, remote->name);
 +                      for (i = 0; i < refspec_nr; i++)
 +                              argv_array_push(&cp.args, refspec[i]);
 +              }
  
 -              cp.argv = argv;
                prepare_submodule_repo_env(&cp.env_array);
                cp.git_cmd = 1;
                cp.no_stdin = 1;
        return 1;
  }
  
 -int push_unpushed_submodules(unsigned char new_sha1[20], const char *remotes_name)
 +/*
 + * Perform a check in the submodule to see if the remote and refspec work.
 + * Die if the submodule can't be pushed.
 + */
 +static void submodule_push_check(const char *path, const struct remote *remote,
 +                               const char **refspec, int refspec_nr)
 +{
 +      struct child_process cp = CHILD_PROCESS_INIT;
 +      int i;
 +
 +      argv_array_push(&cp.args, "submodule--helper");
 +      argv_array_push(&cp.args, "push-check");
 +      argv_array_push(&cp.args, remote->name);
 +
 +      for (i = 0; i < refspec_nr; i++)
 +              argv_array_push(&cp.args, refspec[i]);
 +
 +      prepare_submodule_repo_env(&cp.env_array);
 +      cp.git_cmd = 1;
 +      cp.no_stdin = 1;
 +      cp.no_stdout = 1;
 +      cp.dir = path;
 +
 +      /*
 +       * Simply indicate if 'submodule--helper push-check' failed.
 +       * More detailed error information will be provided by the
 +       * child process.
 +       */
 +      if (run_command(&cp))
 +              die("process for submodule '%s' failed", path);
 +}
 +
 +int push_unpushed_submodules(struct oid_array *commits,
 +                           const struct remote *remote,
 +                           const char **refspec, int refspec_nr,
 +                           const struct string_list *push_options,
 +                           int dry_run)
  {
        int i, ret = 1;
        struct string_list needs_pushing = STRING_LIST_INIT_DUP;
  
 -      if (!find_unpushed_submodules(new_sha1, remotes_name, &needs_pushing))
 +      if (!find_unpushed_submodules(commits, remote->name, &needs_pushing))
                return 1;
  
 +      /*
 +       * Verify that the remote and refspec can be propagated to all
 +       * submodules.  This check can be skipped if the remote and refspec
 +       * won't be propagated due to the remote being unconfigured (e.g. a URL
 +       * instead of a remote name).
 +       */
 +      if (remote->origin != REMOTE_UNCONFIGURED)
 +              for (i = 0; i < needs_pushing.nr; i++)
 +                      submodule_push_check(needs_pushing.items[i].string,
 +                                           remote, refspec, refspec_nr);
 +
 +      /* Actually push the submodules */
        for (i = 0; i < needs_pushing.nr; i++) {
                const char *path = needs_pushing.items[i].string;
                fprintf(stderr, "Pushing submodule '%s'\n", path);
 -              if (!push_submodule(path)) {
 +              if (!push_submodule(path, remote, refspec, refspec_nr,
 +                                  push_options, dry_run)) {
                        fprintf(stderr, "Unable to push submodule '%s'\n", path);
                        ret = 0;
                }
        return ret;
  }
  
 -static int is_submodule_commit_present(const char *path, unsigned char sha1[20])
 -{
 -      int is_present = 0;
 -      if (!add_submodule_odb(path) && lookup_commit_reference(sha1)) {
 -              /* Even if the submodule is checked out and the commit is
 -               * present, make sure it is reachable from a ref. */
 -              struct child_process cp = CHILD_PROCESS_INIT;
 -              const char *argv[] = {"rev-list", "-n", "1", NULL, "--not", "--all", NULL};
 -              struct strbuf buf = STRBUF_INIT;
 -
 -              argv[3] = sha1_to_hex(sha1);
 -              cp.argv = argv;
 -              prepare_submodule_repo_env(&cp.env_array);
 -              cp.git_cmd = 1;
 -              cp.no_stdin = 1;
 -              cp.dir = path;
 -              if (!capture_command(&cp, &buf, 1024) && !buf.len)
 -                      is_present = 1;
 -
 -              strbuf_release(&buf);
 -      }
 -      return is_present;
 -}
 -
 -static void submodule_collect_changed_cb(struct diff_queue_struct *q,
 -                                       struct diff_options *options,
 -                                       void *data)
 -{
 -      int i;
 -      for (i = 0; i < q->nr; i++) {
 -              struct diff_filepair *p = q->queue[i];
 -              if (!S_ISGITLINK(p->two->mode))
 -                      continue;
 -
 -              if (S_ISGITLINK(p->one->mode)) {
 -                      /* NEEDSWORK: We should honor the name configured in
 -                       * the .gitmodules file of the commit we are examining
 -                       * here to be able to correctly follow submodules
 -                       * being moved around. */
 -                      struct string_list_item *path;
 -                      path = unsorted_string_list_lookup(&changed_submodule_paths, p->two->path);
 -                      if (!path && !is_submodule_commit_present(p->two->path, p->two->oid.hash))
 -                              string_list_append(&changed_submodule_paths, xstrdup(p->two->path));
 -              } else {
 -                      /* Submodule is new or was moved here */
 -                      /* NEEDSWORK: When the .git directories of submodules
 -                       * live inside the superprojects .git directory some
 -                       * day we should fetch new submodules directly into
 -                       * that location too when config or options request
 -                       * that so they can be checked out from there. */
 -                      continue;
 -              }
 -      }
 -}
 -
 -static int add_sha1_to_array(const char *ref, const struct object_id *oid,
 -                           int flags, void *data)
 +static int append_oid_to_array(const char *ref, const struct object_id *oid,
 +                             int flags, void *data)
  {
 -      sha1_array_append(data, oid->hash);
 +      struct oid_array *array = data;
 +      oid_array_append(array, oid);
        return 0;
  }
  
 -void check_for_new_submodule_commits(unsigned char new_sha1[20])
 +void check_for_new_submodule_commits(struct object_id *oid)
  {
        if (!initialized_fetch_ref_tips) {
 -              for_each_ref(add_sha1_to_array, &ref_tips_before_fetch);
 +              for_each_ref(append_oid_to_array, &ref_tips_before_fetch);
                initialized_fetch_ref_tips = 1;
        }
  
 -      sha1_array_append(&ref_tips_after_fetch, new_sha1);
 -}
 -
 -static void add_sha1_to_argv(const unsigned char sha1[20], void *data)
 -{
 -      argv_array_push(data, sha1_to_hex(sha1));
 +      oid_array_append(&ref_tips_after_fetch, oid);
  }
  
  static void calculate_changed_submodule_paths(void)
  {
 -      struct rev_info rev;
 -      struct commit *commit;
        struct argv_array argv = ARGV_ARRAY_INIT;
 +      struct string_list changed_submodules = STRING_LIST_INIT_DUP;
 +      const struct string_list_item *item;
  
        /* No need to check if there are no submodules configured */
        if (!submodule_from_path(NULL, NULL))
                return;
  
 -      init_revisions(&rev, NULL);
        argv_array_push(&argv, "--"); /* argv[0] program name */
 -      sha1_array_for_each_unique(&ref_tips_after_fetch,
 -                                 add_sha1_to_argv, &argv);
 +      oid_array_for_each_unique(&ref_tips_after_fetch,
 +                                 append_oid_to_argv, &argv);
        argv_array_push(&argv, "--not");
 -      sha1_array_for_each_unique(&ref_tips_before_fetch,
 -                                 add_sha1_to_argv, &argv);
 -      setup_revisions(argv.argc, argv.argv, &rev, NULL);
 -      if (prepare_revision_walk(&rev))
 -              die("revision walk setup failed");
 +      oid_array_for_each_unique(&ref_tips_before_fetch,
 +                                 append_oid_to_argv, &argv);
  
        /*
         * Collect all submodules (whether checked out or not) for which new
         * commits have been recorded upstream in "changed_submodule_paths".
         */
 -      while ((commit = get_revision(&rev))) {
 -              struct commit_list *parent = commit->parents;
 -              while (parent) {
 -                      struct diff_options diff_opts;
 -                      diff_setup(&diff_opts);
 -                      DIFF_OPT_SET(&diff_opts, RECURSIVE);
 -                      diff_opts.output_format |= DIFF_FORMAT_CALLBACK;
 -                      diff_opts.format_callback = submodule_collect_changed_cb;
 -                      diff_setup_done(&diff_opts);
 -                      diff_tree_sha1(parent->item->object.oid.hash, commit->object.oid.hash, "", &diff_opts);
 -                      diffcore_std(&diff_opts);
 -                      diff_flush(&diff_opts);
 -                      parent = parent->next;
 -              }
 +      collect_changed_submodules(&changed_submodules, &argv);
 +
 +      for_each_string_list_item(item, &changed_submodules) {
 +              struct oid_array *commits = item->util;
 +              const char *path = item->string;
 +
 +              if (!submodule_has_commits(path, commits))
 +                      string_list_append(&changed_submodule_paths, path);
        }
  
 +      free_submodules_oids(&changed_submodules);
        argv_array_clear(&argv);
 -      sha1_array_clear(&ref_tips_before_fetch);
 -      sha1_array_clear(&ref_tips_after_fetch);
 +      oid_array_clear(&ref_tips_before_fetch);
 +      oid_array_clear(&ref_tips_after_fetch);
        initialized_fetch_ref_tips = 0;
  }
  
  
  unsigned is_submodule_modified(const char *path, int ignore_untracked)
  {
 -      ssize_t len;
        struct child_process cp = CHILD_PROCESS_INIT;
 -      const char *argv[] = {
 -              "status",
 -              "--porcelain",
 -              NULL,
 -              NULL,
 -      };
        struct strbuf buf = STRBUF_INIT;
 +      FILE *fp;
        unsigned dirty_submodule = 0;
 -      const char *line, *next_line;
        const char *git_dir;
 +      int ignore_cp_exit_code = 0;
  
        strbuf_addf(&buf, "%s/.git", path);
        git_dir = read_gitfile(buf.buf);
        if (!git_dir)
                git_dir = buf.buf;
 -      if (!is_directory(git_dir)) {
 +      if (!is_git_directory(git_dir)) {
 +              if (is_directory(git_dir))
 +                      die(_("'%s' not recognized as a git repository"), git_dir);
                strbuf_release(&buf);
                /* The submodule is not checked out, so it is not modified */
                return 0;
 -
        }
        strbuf_reset(&buf);
  
 +      argv_array_pushl(&cp.args, "status", "--porcelain=2", NULL);
        if (ignore_untracked)
 -              argv[2] = "-uno";
 +              argv_array_push(&cp.args, "-uno");
  
 -      cp.argv = argv;
        prepare_submodule_repo_env(&cp.env_array);
        cp.git_cmd = 1;
        cp.no_stdin = 1;
        cp.out = -1;
        cp.dir = path;
        if (start_command(&cp))
 -              die("Could not run 'git status --porcelain' in submodule %s", path);
 +              die("Could not run 'git status --porcelain=2' in submodule %s", path);
  
 -      len = strbuf_read(&buf, cp.out, 1024);
 -      line = buf.buf;
 -      while (len > 2) {
 -              if ((line[0] == '?') && (line[1] == '?')) {
 +      fp = xfdopen(cp.out, "r");
 +      while (strbuf_getwholeline(&buf, fp, '\n') != EOF) {
 +              /* regular untracked files */
 +              if (buf.buf[0] == '?')
                        dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
 -                      if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
 -                              break;
 -              } else {
 -                      dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
 -                      if (ignore_untracked ||
 -                          (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED))
 -                              break;
 +
 +              if (buf.buf[0] == 'u' ||
 +                  buf.buf[0] == '1' ||
 +                  buf.buf[0] == '2') {
 +                      /* T = line type, XY = status, SSSS = submodule state */
 +                      if (buf.len < strlen("T XY SSSS"))
 +                              die("BUG: invalid status --porcelain=2 line %s",
 +                                  buf.buf);
 +
 +                      if (buf.buf[5] == 'S' && buf.buf[8] == 'U')
 +                              /* nested untracked file */
 +                              dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
 +
 +                      if (buf.buf[0] == 'u' ||
 +                          buf.buf[0] == '2' ||
 +                          memcmp(buf.buf + 5, "S..U", 4))
 +                              /* other change */
 +                              dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
                }
 -              next_line = strchr(line, '\n');
 -              if (!next_line)
 +
 +              if ((dirty_submodule & DIRTY_SUBMODULE_MODIFIED) &&
 +                  ((dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) ||
 +                   ignore_untracked)) {
 +                      /*
 +                       * We're not interested in any further information from
 +                       * the child any more, neither output nor its exit code.
 +                       */
 +                      ignore_cp_exit_code = 1;
                        break;
 -              next_line++;
 -              len -= (next_line - line);
 -              line = next_line;
 +              }
        }
 -      close(cp.out);
 +      fclose(fp);
  
 -      if (finish_command(&cp))
 -              die("'git status --porcelain' failed in submodule %s", path);
 +      if (finish_command(&cp) && !ignore_cp_exit_code)
 +              die("'git status --porcelain=2' failed in submodule %s", path);
  
        strbuf_release(&buf);
        return dirty_submodule;
@@@ -1284,232 -1040,45 +1285,232 @@@ int submodule_uses_gitfile(const char *
        return 1;
  }
  
 -int ok_to_remove_submodule(const char *path)
 +/*
 + * Check if it is a bad idea to remove a submodule, i.e. if we'd lose data
 + * when doing so.
 + *
 + * Return 1 if we'd lose data, return 0 if the removal is fine,
 + * and negative values for errors.
 + */
 +int bad_to_remove_submodule(const char *path, unsigned flags)
  {
        ssize_t len;
        struct child_process cp = CHILD_PROCESS_INIT;
 -      const char *argv[] = {
 -              "status",
 -              "--porcelain",
 -              "-u",
 -              "--ignore-submodules=none",
 -              NULL,
 -      };
        struct strbuf buf = STRBUF_INIT;
 -      int ok_to_remove = 1;
 +      int ret = 0;
  
        if (!file_exists(path) || is_empty_dir(path))
 -              return 1;
 +              return 0;
  
        if (!submodule_uses_gitfile(path))
 -              return 0;
 +              return 1;
 +
 +      argv_array_pushl(&cp.args, "status", "--porcelain",
 +                                 "--ignore-submodules=none", NULL);
 +
 +      if (flags & SUBMODULE_REMOVAL_IGNORE_UNTRACKED)
 +              argv_array_push(&cp.args, "-uno");
 +      else
 +              argv_array_push(&cp.args, "-uall");
 +
 +      if (!(flags & SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED))
 +              argv_array_push(&cp.args, "--ignored");
  
 -      cp.argv = argv;
        prepare_submodule_repo_env(&cp.env_array);
        cp.git_cmd = 1;
        cp.no_stdin = 1;
        cp.out = -1;
        cp.dir = path;
 -      if (start_command(&cp))
 -              die("Could not run 'git status --porcelain -uall --ignore-submodules=none' in submodule %s", path);
 +      if (start_command(&cp)) {
 +              if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
 +                      die(_("could not start 'git status' in submodule '%s'"),
 +                              path);
 +              ret = -1;
 +              goto out;
 +      }
  
        len = strbuf_read(&buf, cp.out, 1024);
        if (len > 2)
 -              ok_to_remove = 0;
 +              ret = 1;
        close(cp.out);
  
 -      if (finish_command(&cp))
 -              die("'git status --porcelain -uall --ignore-submodules=none' failed in submodule %s", path);
 -
 +      if (finish_command(&cp)) {
 +              if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
 +                      die(_("could not run 'git status' in submodule '%s'"),
 +                              path);
 +              ret = -1;
 +      }
 +out:
        strbuf_release(&buf);
 -      return ok_to_remove;
 +      return ret;
 +}
 +
 +static const char *get_super_prefix_or_empty(void)
 +{
 +      const char *s = get_super_prefix();
 +      if (!s)
 +              s = "";
 +      return s;
 +}
 +
 +static int submodule_has_dirty_index(const struct submodule *sub)
 +{
 +      struct child_process cp = CHILD_PROCESS_INIT;
 +
 +      prepare_submodule_repo_env(&cp.env_array);
 +
 +      cp.git_cmd = 1;
 +      argv_array_pushl(&cp.args, "diff-index", "--quiet",
 +                                 "--cached", "HEAD", NULL);
 +      cp.no_stdin = 1;
 +      cp.no_stdout = 1;
 +      cp.dir = sub->path;
 +      if (start_command(&cp))
 +              die("could not recurse into submodule '%s'", sub->path);
 +
 +      return finish_command(&cp);
 +}
 +
 +static void submodule_reset_index(const char *path)
 +{
 +      struct child_process cp = CHILD_PROCESS_INIT;
 +      prepare_submodule_repo_env(&cp.env_array);
 +
 +      cp.git_cmd = 1;
 +      cp.no_stdin = 1;
 +      cp.dir = path;
 +
 +      argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
 +                                 get_super_prefix_or_empty(), path);
 +      argv_array_pushl(&cp.args, "read-tree", "-u", "--reset", NULL);
 +
 +      argv_array_push(&cp.args, EMPTY_TREE_SHA1_HEX);
 +
 +      if (run_command(&cp))
 +              die("could not reset submodule index");
 +}
 +
 +/**
 + * Moves a submodule at a given path from a given head to another new head.
 + * For edge cases (a submodule coming into existence or removing a submodule)
 + * pass NULL for old or new respectively.
 + */
 +int submodule_move_head(const char *path,
 +                       const char *old,
 +                       const char *new,
 +                       unsigned flags)
 +{
 +      int ret = 0;
 +      struct child_process cp = CHILD_PROCESS_INIT;
 +      const struct submodule *sub;
 +      int *error_code_ptr, error_code;
 +
 +      if (!is_submodule_initialized(path))
 +              return 0;
 +
 +      if (flags & SUBMODULE_MOVE_HEAD_FORCE)
 +              /*
 +               * Pass non NULL pointer to is_submodule_populated_gently
 +               * to prevent die()-ing. We'll use connect_work_tree_and_git_dir
 +               * to fixup the submodule in the force case later.
 +               */
 +              error_code_ptr = &error_code;
 +      else
 +              error_code_ptr = NULL;
 +
 +      if (old && !is_submodule_populated_gently(path, error_code_ptr))
 +              return 0;
 +
 +      sub = submodule_from_path(null_sha1, path);
 +
 +      if (!sub)
 +              die("BUG: could not get submodule information for '%s'", path);
 +
 +      if (old && !(flags & SUBMODULE_MOVE_HEAD_FORCE)) {
 +              /* Check if the submodule has a dirty index. */
 +              if (submodule_has_dirty_index(sub))
 +                      return error(_("submodule '%s' has dirty index"), path);
 +      }
 +
 +      if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
 +              if (old) {
 +                      if (!submodule_uses_gitfile(path))
 +                              absorb_git_dir_into_superproject("", path,
 +                                      ABSORB_GITDIR_RECURSE_SUBMODULES);
 +              } else {
 +                      char *gitdir = xstrfmt("%s/modules/%s",
 +                                  get_git_common_dir(), sub->name);
 +                      connect_work_tree_and_git_dir(path, gitdir);
 +                      free(gitdir);
 +
 +                      /* make sure the index is clean as well */
 +                      submodule_reset_index(path);
 +              }
 +
 +              if (old && (flags & SUBMODULE_MOVE_HEAD_FORCE)) {
 +                      char *gitdir = xstrfmt("%s/modules/%s",
 +                                  get_git_common_dir(), sub->name);
 +                      connect_work_tree_and_git_dir(path, gitdir);
 +                      free(gitdir);
 +              }
 +      }
 +
 +      prepare_submodule_repo_env(&cp.env_array);
 +
 +      cp.git_cmd = 1;
 +      cp.no_stdin = 1;
 +      cp.dir = path;
 +
 +      argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
 +                      get_super_prefix_or_empty(), path);
 +      argv_array_pushl(&cp.args, "read-tree", "--recurse-submodules", NULL);
 +
 +      if (flags & SUBMODULE_MOVE_HEAD_DRY_RUN)
 +              argv_array_push(&cp.args, "-n");
 +      else
 +              argv_array_push(&cp.args, "-u");
 +
 +      if (flags & SUBMODULE_MOVE_HEAD_FORCE)
 +              argv_array_push(&cp.args, "--reset");
 +      else
 +              argv_array_push(&cp.args, "-m");
 +
 +      argv_array_push(&cp.args, old ? old : EMPTY_TREE_SHA1_HEX);
 +      argv_array_push(&cp.args, new ? new : EMPTY_TREE_SHA1_HEX);
 +
 +      if (run_command(&cp)) {
 +              ret = -1;
 +              goto out;
 +      }
 +
 +      if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
 +              if (new) {
 +                      child_process_init(&cp);
 +                      /* also set the HEAD accordingly */
 +                      cp.git_cmd = 1;
 +                      cp.no_stdin = 1;
 +                      cp.dir = path;
 +
 +                      prepare_submodule_repo_env(&cp.env_array);
 +                      argv_array_pushl(&cp.args, "update-ref", "HEAD", new, NULL);
 +
 +                      if (run_command(&cp)) {
 +                              ret = -1;
 +                              goto out;
 +                      }
 +              } else {
 +                      struct strbuf sb = STRBUF_INIT;
 +
 +                      strbuf_addf(&sb, "%s/.git", path);
 +                      unlink_or_warn(sb.buf);
 +                      strbuf_release(&sb);
 +
 +                      if (is_empty_dir(path))
 +                              rmdir_or_warn(path);
 +              }
 +      }
 +out:
 +      return ret;
  }
  
  static int find_first_merges(struct object_array *result, const char *path,
        memset(&rev_opts, 0, sizeof(rev_opts));
  
        /* get all revisions that merge commit a */
 -      snprintf(merged_revision, sizeof(merged_revision), "^%s",
 +      xsnprintf(merged_revision, sizeof(merged_revision), "^%s",
                        oid_to_hex(&a->object.oid));
        init_revisions(&revs, NULL);
        rev_opts.submodule = path;
@@@ -1675,241 -1244,41 +1676,241 @@@ int merge_submodule(unsigned char resul
        return 0;
  }
  
 -/* Update gitfile and core.worktree setting to connect work tree and git dir */
 -void connect_work_tree_and_git_dir(const char *work_tree, const char *git_dir)
 +int parallel_submodules(void)
  {
 -      struct strbuf file_name = STRBUF_INIT;
 -      struct strbuf rel_path = STRBUF_INIT;
 -      const char *real_work_tree = xstrdup(real_path(work_tree));
 -
 -      /* Update gitfile */
 -      strbuf_addf(&file_name, "%s/.git", work_tree);
 -      write_file(file_name.buf, "gitdir: %s",
 -                 relative_path(git_dir, real_work_tree, &rel_path));
 -
 -      /* Update core.worktree setting */
 -      strbuf_reset(&file_name);
 -      strbuf_addf(&file_name, "%s/config", git_dir);
 -      git_config_set_in_file(file_name.buf, "core.worktree",
 -                             relative_path(real_work_tree, git_dir,
 -                                           &rel_path));
 -
 -      strbuf_release(&file_name);
 -      strbuf_release(&rel_path);
 -      free((void *)real_work_tree);
 +      return parallel_jobs;
  }
  
 -int parallel_submodules(void)
 +/*
 + * Embeds a single submodules git directory into the superprojects git dir,
 + * non recursively.
 + */
 +static void relocate_single_git_dir_into_superproject(const char *prefix,
 +                                                    const char *path)
  {
 -      return parallel_jobs;
 +      char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
 +      const char *new_git_dir;
 +      const struct submodule *sub;
 +
 +      if (submodule_uses_worktrees(path))
 +              die(_("relocate_gitdir for submodule '%s' with "
 +                    "more than one worktree not supported"), path);
 +
 +      old_git_dir = xstrfmt("%s/.git", path);
 +      if (read_gitfile(old_git_dir))
 +              /* If it is an actual gitfile, it doesn't need migration. */
 +              return;
 +
 +      real_old_git_dir = real_pathdup(old_git_dir, 1);
 +
 +      sub = submodule_from_path(null_sha1, path);
 +      if (!sub)
 +              die(_("could not lookup name for submodule '%s'"), path);
 +
 +      new_git_dir = git_path("modules/%s", sub->name);
 +      if (safe_create_leading_directories_const(new_git_dir) < 0)
 +              die(_("could not create directory '%s'"), new_git_dir);
 +      real_new_git_dir = real_pathdup(new_git_dir, 1);
 +
 +      fprintf(stderr, _("Migrating git directory of '%s%s' from\n'%s' to\n'%s'\n"),
 +              get_super_prefix_or_empty(), path,
 +              real_old_git_dir, real_new_git_dir);
 +
 +      relocate_gitdir(path, real_old_git_dir, real_new_git_dir);
 +
 +      free(old_git_dir);
 +      free(real_old_git_dir);
 +      free(real_new_git_dir);
  }
  
 -void prepare_submodule_repo_env(struct argv_array *out)
 +/*
 + * Migrate the git directory of the submodule given by path from
 + * having its git directory within the working tree to the git dir nested
 + * in its superprojects git dir under modules/.
 + */
 +void absorb_git_dir_into_superproject(const char *prefix,
 +                                    const char *path,
 +                                    unsigned flags)
  {
 -      const char * const *var;
 +      int err_code;
 +      const char *sub_git_dir;
 +      struct strbuf gitdir = STRBUF_INIT;
 +      strbuf_addf(&gitdir, "%s/.git", path);
 +      sub_git_dir = resolve_gitdir_gently(gitdir.buf, &err_code);
 +
 +      /* Not populated? */
 +      if (!sub_git_dir) {
 +              const struct submodule *sub;
 +
 +              if (err_code == READ_GITFILE_ERR_STAT_FAILED) {
 +                      /* unpopulated as expected */
 +                      strbuf_release(&gitdir);
 +                      return;
 +              }
  
 -      for (var = local_repo_env; *var; var++) {
 -              if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
 -                      argv_array_push(out, *var);
 +              if (err_code != READ_GITFILE_ERR_NOT_A_REPO)
 +                      /* We don't know what broke here. */
 +                      read_gitfile_error_die(err_code, path, NULL);
 +
 +              /*
 +              * Maybe populated, but no git directory was found?
 +              * This can happen if the superproject is a submodule
 +              * itself and was just absorbed. The absorption of the
 +              * superproject did not rewrite the git file links yet,
 +              * fix it now.
 +              */
 +              sub = submodule_from_path(null_sha1, path);
 +              if (!sub)
 +                      die(_("could not lookup name for submodule '%s'"), path);
 +              connect_work_tree_and_git_dir(path,
 +                      git_path("modules/%s", sub->name));
 +      } else {
 +              /* Is it already absorbed into the superprojects git dir? */
 +              char *real_sub_git_dir = real_pathdup(sub_git_dir, 1);
 +              char *real_common_git_dir = real_pathdup(get_git_common_dir(), 1);
 +
 +              if (!starts_with(real_sub_git_dir, real_common_git_dir))
 +                      relocate_single_git_dir_into_superproject(prefix, path);
 +
 +              free(real_sub_git_dir);
 +              free(real_common_git_dir);
        }
 +      strbuf_release(&gitdir);
 +
 +      if (flags & ABSORB_GITDIR_RECURSE_SUBMODULES) {
 +              struct child_process cp = CHILD_PROCESS_INIT;
 +              struct strbuf sb = STRBUF_INIT;
 +
 +              if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
 +                      die("BUG: we don't know how to pass the flags down?");
 +
 +              strbuf_addstr(&sb, get_super_prefix_or_empty());
 +              strbuf_addstr(&sb, path);
 +              strbuf_addch(&sb, '/');
 +
 +              cp.dir = path;
 +              cp.git_cmd = 1;
 +              cp.no_stdin = 1;
 +              argv_array_pushl(&cp.args, "--super-prefix", sb.buf,
 +                                         "submodule--helper",
 +                                         "absorb-git-dirs", NULL);
 +              prepare_submodule_repo_env(&cp.env_array);
 +              if (run_command(&cp))
 +                      die(_("could not recurse into submodule '%s'"), path);
 +
 +              strbuf_release(&sb);
 +      }
 +}
 +
 +const char *get_superproject_working_tree(void)
 +{
 +      struct child_process cp = CHILD_PROCESS_INIT;
 +      struct strbuf sb = STRBUF_INIT;
 +      const char *one_up = real_path_if_valid("../");
 +      const char *cwd = xgetcwd();
 +      const char *ret = NULL;
 +      const char *subpath;
 +      int code;
 +      ssize_t len;
 +
 +      if (!is_inside_work_tree())
 +              /*
 +               * FIXME:
 +               * We might have a superproject, but it is harder
 +               * to determine.
 +               */
 +              return NULL;
 +
 +      if (!one_up)
 +              return NULL;
 +
 +      subpath = relative_path(cwd, one_up, &sb);
 +
 +      prepare_submodule_repo_env(&cp.env_array);
 +      argv_array_pop(&cp.env_array);
 +
 +      argv_array_pushl(&cp.args, "--literal-pathspecs", "-C", "..",
 +                      "ls-files", "-z", "--stage", "--full-name", "--",
 +                      subpath, NULL);
 +      strbuf_reset(&sb);
 +
 +      cp.no_stdin = 1;
 +      cp.no_stderr = 1;
 +      cp.out = -1;
 +      cp.git_cmd = 1;
 +
 +      if (start_command(&cp))
 +              die(_("could not start ls-files in .."));
 +
 +      len = strbuf_read(&sb, cp.out, PATH_MAX);
 +      close(cp.out);
 +
 +      if (starts_with(sb.buf, "160000")) {
 +              int super_sub_len;
 +              int cwd_len = strlen(cwd);
 +              char *super_sub, *super_wt;
 +
 +              /*
 +               * There is a superproject having this repo as a submodule.
 +               * The format is <mode> SP <hash> SP <stage> TAB <full name> \0,
 +               * We're only interested in the name after the tab.
 +               */
 +              super_sub = strchr(sb.buf, '\t') + 1;
 +              super_sub_len = sb.buf + sb.len - super_sub - 1;
 +
 +              if (super_sub_len > cwd_len ||
 +                  strcmp(&cwd[cwd_len - super_sub_len], super_sub))
 +                      die (_("BUG: returned path string doesn't match cwd?"));
 +
 +              super_wt = xstrdup(cwd);
 +              super_wt[cwd_len - super_sub_len] = '\0';
 +
 +              ret = real_path(super_wt);
 +              free(super_wt);
 +      }
 +      strbuf_release(&sb);
 +
 +      code = finish_command(&cp);
 +
 +      if (code == 128)
 +              /* '../' is not a git repository */
 +              return NULL;
 +      if (code == 0 && len == 0)
 +              /* There is an unrelated git repository at '../' */
 +              return NULL;
 +      if (code)
 +              die(_("ls-tree returned unexpected return code %d"), code);
 +
 +      return ret;
 +}
 +
 +int submodule_to_gitdir(struct strbuf *buf, const char *submodule)
 +{
 +      const struct submodule *sub;
 +      const char *git_dir;
 +      int ret = 0;
 +
 +      strbuf_reset(buf);
 +      strbuf_addstr(buf, submodule);
 +      strbuf_complete(buf, '/');
 +      strbuf_addstr(buf, ".git");
 +
 +      git_dir = read_gitfile(buf->buf);
 +      if (git_dir) {
 +              strbuf_reset(buf);
 +              strbuf_addstr(buf, git_dir);
 +      }
 +      if (!is_git_directory(buf->buf)) {
 +              gitmodules_config();
 +              sub = submodule_from_path(null_sha1, submodule);
 +              if (!sub) {
 +                      ret = -1;
 +                      goto cleanup;
 +              }
 +              strbuf_reset(buf);
 +              strbuf_git_path(buf, "%s/%s", "modules", sub->name);
 +      }
 +
 +cleanup:
 +      return ret;
  }
@@@ -745,34 -745,46 +745,75 @@@ test_expect_success 'diff --submodule=d
        EOF
        test_cmp expected actual
  '
 +
 +test_expect_success 'setup nested submodule' '
 +      git submodule add -f ./sm2 &&
 +      git commit -a -m "add sm2" &&
 +      git -C sm2 submodule add ../sm2 nested &&
 +      git -C sm2 commit -a -m "nested sub"
 +'
 +
 +test_expect_success 'move nested submodule HEAD' '
 +      echo "nested content" >sm2/nested/file &&
 +      git -C sm2/nested add file &&
 +      git -C sm2/nested commit --allow-empty -m "new HEAD"
 +'
 +
 +test_expect_success 'diff --submodule=diff with moved nested submodule HEAD' '
 +      cat >expected <<-EOF &&
 +      Submodule nested a5a65c9..b55928c:
 +      diff --git a/nested/file b/nested/file
 +      new file mode 100644
 +      index 0000000..ca281f5
 +      --- /dev/null
 +      +++ b/nested/file
 +      @@ -0,0 +1 @@
 +      +nested content
 +      EOF
 +      git -C sm2 diff --submodule=diff >actual 2>err &&
 +      test_must_be_empty err &&
 +      test_cmp expected actual
 +'
  
+ test_expect_success 'diff --submodule=diff recurses into nested submodules' '
+       cat >expected <<-EOF &&
+       Submodule sm2 contains modified content
+       Submodule sm2 a5a65c9..280969a:
+       diff --git a/sm2/.gitmodules b/sm2/.gitmodules
+       new file mode 100644
+       index 0000000..3a816b8
+       --- /dev/null
+       +++ b/sm2/.gitmodules
+       @@ -0,0 +1,3 @@
+       +[submodule "nested"]
+       +       path = nested
+       +       url = ../sm2
+       Submodule nested 0000000...b55928c (new submodule)
+       diff --git a/sm2/nested/file b/sm2/nested/file
+       new file mode 100644
+       index 0000000..ca281f5
+       --- /dev/null
+       +++ b/sm2/nested/file
+       @@ -0,0 +1 @@
+       +nested content
+       diff --git a/sm2/nested/foo8 b/sm2/nested/foo8
+       new file mode 100644
+       index 0000000..db9916b
+       --- /dev/null
+       +++ b/sm2/nested/foo8
+       @@ -0,0 +1 @@
+       +foo8
+       diff --git a/sm2/nested/foo9 b/sm2/nested/foo9
+       new file mode 100644
+       index 0000000..9c3b4f6
+       --- /dev/null
+       +++ b/sm2/nested/foo9
+       @@ -0,0 +1 @@
+       +foo9
+       EOF
+       git diff --submodule=diff >actual 2>err &&
+       test_must_be_empty err &&
+       test_cmp expected actual
+ '
  test_done