about summary refs log tree commit diff
path: root/third_party/git/dir.c
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/git/dir.c')
-rw-r--r--third_party/git/dir.c842
1 files changed, 224 insertions, 618 deletions
diff --git a/third_party/git/dir.c b/third_party/git/dir.c
index 0ffb1b330245..d021c908e5d1 100644
--- a/third_party/git/dir.c
+++ b/third_party/git/dir.c
@@ -2,6 +2,8 @@
  * This handles recursive filename detection with exclude
  * files, index knowledge etc..
  *
+ * See Documentation/technical/api-directory-listing.txt
+ *
  * Copyright (C) Linus Torvalds, 2005-2006
  *		 Junio Hamano, 2005-2006
  */
@@ -41,8 +43,7 @@ struct cached_dir {
 	int nr_files;
 	int nr_dirs;
 
-	const char *d_name;
-	int d_type;
+	struct dirent *de;
 	const char *file;
 	struct untracked_cache_dir *ucd;
 };
@@ -51,8 +52,8 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir,
 	struct index_state *istate, const char *path, int len,
 	struct untracked_cache_dir *untracked,
 	int check_only, int stop_at_first_file, const struct pathspec *pathspec);
-static int resolve_dtype(int dtype, struct index_state *istate,
-			 const char *path, int len);
+static int get_dtype(struct dirent *de, struct index_state *istate,
+		     const char *path, int len);
 
 int count_slashes(const char *s)
 {
@@ -138,7 +139,7 @@ static size_t common_prefix_len(const struct pathspec *pathspec)
 	 * ":(icase)path" is treated as a pathspec full of
 	 * wildcard. In other words, only prefix is considered common
 	 * prefix. If the pathspec is abc/foo abc/bar, running in
-	 * subdir xyz, the common prefix is still xyz, not xyz/abc as
+	 * subdir xyz, the common prefix is still xyz, not xuz/abc as
 	 * in non-:(icase).
 	 */
 	GUARD_PATHSPEC(pathspec,
@@ -272,30 +273,19 @@ static int do_read_blob(const struct object_id *oid, struct oid_stat *oid_stat,
 
 #define DO_MATCH_EXCLUDE   (1<<0)
 #define DO_MATCH_DIRECTORY (1<<1)
-#define DO_MATCH_LEADING_PATHSPEC (1<<2)
+#define DO_MATCH_SUBMODULE (1<<2)
 
 /*
- * Does the given pathspec match the given name?  A match is found if
- *
- * (1) the pathspec string is leading directory of 'name' ("RECURSIVELY"), or
- * (2) the pathspec string has a leading part matching 'name' ("LEADING"), or
- * (3) the pathspec string is a wildcard and matches 'name' ("WILDCARD"), or
- * (4) the pathspec string is exactly the same as 'name' ("EXACT").
+ * Does 'match' match the given name?
+ * A match is found if
  *
- * Return value tells which case it was (1-4), or 0 when there is no match.
+ * (1) the 'match' string is leading directory of 'name', or
+ * (2) the 'match' string is a wildcard and matches 'name', or
+ * (3) the 'match' string is exactly the same as 'name'.
  *
- * It may be instructive to look at a small table of concrete examples
- * to understand the differences between 1, 2, and 4:
+ * and the return value tells which case it was.
  *
- *                              Pathspecs
- *                |    a/b    |   a/b/    |   a/b/c
- *          ------+-----------+-----------+------------
- *          a/b   |  EXACT    |  EXACT[1] | LEADING[2]
- *  Names   a/b/  | RECURSIVE |   EXACT   | LEADING[2]
- *          a/b/c | RECURSIVE | RECURSIVE |   EXACT
- *
- * [1] Only if DO_MATCH_DIRECTORY is passed; otherwise, this is NOT a match.
- * [2] Only if DO_MATCH_LEADING_PATHSPEC is passed; otherwise, not a match.
+ * It returns 0 when there is no match.
  */
 static int match_pathspec_item(const struct index_state *istate,
 			       const struct pathspec_item *item, int prefix,
@@ -363,29 +353,21 @@ static int match_pathspec_item(const struct index_state *istate,
 			 item->nowildcard_len - prefix))
 		return MATCHED_FNMATCH;
 
-	/* Perform checks to see if "name" is a leading string of the pathspec */
-	if (flags & DO_MATCH_LEADING_PATHSPEC) {
+	/* Perform checks to see if "name" is a super set of the pathspec */
+	if (flags & DO_MATCH_SUBMODULE) {
 		/* name is a literal prefix of the pathspec */
-		int offset = name[namelen-1] == '/' ? 1 : 0;
 		if ((namelen < matchlen) &&
-		    (match[namelen-offset] == '/') &&
+		    (match[namelen] == '/') &&
 		    !ps_strncmp(item, match, name, namelen))
-			return MATCHED_RECURSIVELY_LEADING_PATHSPEC;
+			return MATCHED_RECURSIVELY;
 
-		/* name doesn't match up to the first wild character */
+		/* name" doesn't match up to the first wild character */
 		if (item->nowildcard_len < item->len &&
 		    ps_strncmp(item, match, name,
 			       item->nowildcard_len - prefix))
 			return 0;
 
 		/*
-		 * name has no wildcard, and it didn't match as a leading
-		 * pathspec so return.
-		 */
-		if (item->nowildcard_len == item->len)
-			return 0;
-
-		/*
 		 * Here is where we would perform a wildmatch to check if
 		 * "name" can be matched as a directory (or a prefix) against
 		 * the pathspec.  Since wildmatch doesn't have this capability
@@ -394,7 +376,7 @@ static int match_pathspec_item(const struct index_state *istate,
 		 * The submodules themselves will be able to perform more
 		 * accurate matching to determine if the pathspec matches.
 		 */
-		return MATCHED_RECURSIVELY_LEADING_PATHSPEC;
+		return MATCHED_RECURSIVELY;
 	}
 
 	return 0;
@@ -515,7 +497,7 @@ int submodule_path_match(const struct index_state *istate,
 					strlen(submodule_name),
 					0, seen,
 					DO_MATCH_DIRECTORY |
-					DO_MATCH_LEADING_PATHSPEC);
+					DO_MATCH_SUBMODULE);
 	return matched;
 }
 
@@ -579,7 +561,7 @@ int no_wildcard(const char *string)
 	return string[simple_length(string)] == '\0';
 }
 
-void parse_path_pattern(const char **pattern,
+void parse_exclude_pattern(const char **pattern,
 			   int *patternlen,
 			   unsigned *flags,
 			   int *nowildcardlen)
@@ -589,20 +571,20 @@ void parse_path_pattern(const char **pattern,
 
 	*flags = 0;
 	if (*p == '!') {
-		*flags |= PATTERN_FLAG_NEGATIVE;
+		*flags |= EXC_FLAG_NEGATIVE;
 		p++;
 	}
 	len = strlen(p);
 	if (len && p[len - 1] == '/') {
 		len--;
-		*flags |= PATTERN_FLAG_MUSTBEDIR;
+		*flags |= EXC_FLAG_MUSTBEDIR;
 	}
 	for (i = 0; i < len; i++) {
 		if (p[i] == '/')
 			break;
 	}
 	if (i == len)
-		*flags |= PATTERN_FLAG_NODIR;
+		*flags |= EXC_FLAG_NODIR;
 	*nowildcardlen = simple_length(p);
 	/*
 	 * we should have excluded the trailing slash from 'p' too,
@@ -612,261 +594,35 @@ void parse_path_pattern(const char **pattern,
 	if (*nowildcardlen > len)
 		*nowildcardlen = len;
 	if (*p == '*' && no_wildcard(p + 1))
-		*flags |= PATTERN_FLAG_ENDSWITH;
+		*flags |= EXC_FLAG_ENDSWITH;
 	*pattern = p;
 	*patternlen = len;
 }
 
-int pl_hashmap_cmp(const void *unused_cmp_data,
-		   const struct hashmap_entry *a,
-		   const struct hashmap_entry *b,
-		   const void *key)
+void add_exclude(const char *string, const char *base,
+		 int baselen, struct exclude_list *el, int srcpos)
 {
-	const struct pattern_entry *ee1 =
-			container_of(a, struct pattern_entry, ent);
-	const struct pattern_entry *ee2 =
-			container_of(b, struct pattern_entry, ent);
-
-	size_t min_len = ee1->patternlen <= ee2->patternlen
-			 ? ee1->patternlen
-			 : ee2->patternlen;
-
-	if (ignore_case)
-		return strncasecmp(ee1->pattern, ee2->pattern, min_len);
-	return strncmp(ee1->pattern, ee2->pattern, min_len);
-}
-
-static char *dup_and_filter_pattern(const char *pattern)
-{
-	char *set, *read;
-	size_t count  = 0;
-	char *result = xstrdup(pattern);
-
-	set = result;
-	read = result;
-
-	while (*read) {
-		/* skip escape characters (once) */
-		if (*read == '\\')
-			read++;
-
-		*set = *read;
-
-		set++;
-		read++;
-		count++;
-	}
-	*set = 0;
-
-	if (count > 2 &&
-	    *(set - 1) == '*' &&
-	    *(set - 2) == '/')
-		*(set - 2) = 0;
-
-	return result;
-}
-
-static void add_pattern_to_hashsets(struct pattern_list *pl, struct path_pattern *given)
-{
-	struct pattern_entry *translated;
-	char *truncated;
-	char *data = NULL;
-	const char *prev, *cur, *next;
-
-	if (!pl->use_cone_patterns)
-		return;
-
-	if (given->flags & PATTERN_FLAG_NEGATIVE &&
-	    given->flags & PATTERN_FLAG_MUSTBEDIR &&
-	    !strcmp(given->pattern, "/*")) {
-		pl->full_cone = 0;
-		return;
-	}
-
-	if (!given->flags && !strcmp(given->pattern, "/*")) {
-		pl->full_cone = 1;
-		return;
-	}
-
-	if (given->patternlen < 2 ||
-	    *given->pattern == '*' ||
-	    strstr(given->pattern, "**")) {
-		/* Not a cone pattern. */
-		warning(_("unrecognized pattern: '%s'"), given->pattern);
-		goto clear_hashmaps;
-	}
-
-	prev = given->pattern;
-	cur = given->pattern + 1;
-	next = given->pattern + 2;
-
-	while (*cur) {
-		/* Watch for glob characters '*', '\', '[', '?' */
-		if (!is_glob_special(*cur))
-			goto increment;
-
-		/* But only if *prev != '\\' */
-		if (*prev == '\\')
-			goto increment;
-
-		/* But allow the initial '\' */
-		if (*cur == '\\' &&
-		    is_glob_special(*next))
-			goto increment;
-
-		/* But a trailing '/' then '*' is fine */
-		if (*prev == '/' &&
-		    *cur == '*' &&
-		    *next == 0)
-			goto increment;
-
-		/* Not a cone pattern. */
-		warning(_("unrecognized pattern: '%s'"), given->pattern);
-		goto clear_hashmaps;
-
-	increment:
-		prev++;
-		cur++;
-		next++;
-	}
-
-	if (given->patternlen > 2 &&
-	    !strcmp(given->pattern + given->patternlen - 2, "/*")) {
-		if (!(given->flags & PATTERN_FLAG_NEGATIVE)) {
-			/* Not a cone pattern. */
-			warning(_("unrecognized pattern: '%s'"), given->pattern);
-			goto clear_hashmaps;
-		}
-
-		truncated = dup_and_filter_pattern(given->pattern);
-
-		translated = xmalloc(sizeof(struct pattern_entry));
-		translated->pattern = truncated;
-		translated->patternlen = given->patternlen - 2;
-		hashmap_entry_init(&translated->ent,
-				   ignore_case ?
-				   strihash(translated->pattern) :
-				   strhash(translated->pattern));
-
-		if (!hashmap_get_entry(&pl->recursive_hashmap,
-				       translated, ent, NULL)) {
-			/* We did not see the "parent" included */
-			warning(_("unrecognized negative pattern: '%s'"),
-				given->pattern);
-			free(truncated);
-			free(translated);
-			goto clear_hashmaps;
-		}
-
-		hashmap_add(&pl->parent_hashmap, &translated->ent);
-		hashmap_remove(&pl->recursive_hashmap, &translated->ent, &data);
-		free(data);
-		return;
-	}
-
-	if (given->flags & PATTERN_FLAG_NEGATIVE) {
-		warning(_("unrecognized negative pattern: '%s'"),
-			given->pattern);
-		goto clear_hashmaps;
-	}
-
-	translated = xmalloc(sizeof(struct pattern_entry));
-
-	translated->pattern = dup_and_filter_pattern(given->pattern);
-	translated->patternlen = given->patternlen;
-	hashmap_entry_init(&translated->ent,
-			   ignore_case ?
-			   strihash(translated->pattern) :
-			   strhash(translated->pattern));
-
-	hashmap_add(&pl->recursive_hashmap, &translated->ent);
-
-	if (hashmap_get_entry(&pl->parent_hashmap, translated, ent, NULL)) {
-		/* we already included this at the parent level */
-		warning(_("your sparse-checkout file may have issues: pattern '%s' is repeated"),
-			given->pattern);
-		hashmap_remove(&pl->parent_hashmap, &translated->ent, &data);
-		free(data);
-		free(translated);
-	}
-
-	return;
-
-clear_hashmaps:
-	warning(_("disabling cone pattern matching"));
-	hashmap_free_entries(&pl->parent_hashmap, struct pattern_entry, ent);
-	hashmap_free_entries(&pl->recursive_hashmap, struct pattern_entry, ent);
-	pl->use_cone_patterns = 0;
-}
-
-static int hashmap_contains_path(struct hashmap *map,
-				 struct strbuf *pattern)
-{
-	struct pattern_entry p;
-
-	/* Check straight mapping */
-	p.pattern = pattern->buf;
-	p.patternlen = pattern->len;
-	hashmap_entry_init(&p.ent,
-			   ignore_case ?
-			   strihash(p.pattern) :
-			   strhash(p.pattern));
-	return !!hashmap_get_entry(map, &p, ent, NULL);
-}
-
-int hashmap_contains_parent(struct hashmap *map,
-			    const char *path,
-			    struct strbuf *buffer)
-{
-	char *slash_pos;
-
-	strbuf_setlen(buffer, 0);
-
-	if (path[0] != '/')
-		strbuf_addch(buffer, '/');
-
-	strbuf_addstr(buffer, path);
-
-	slash_pos = strrchr(buffer->buf, '/');
-
-	while (slash_pos > buffer->buf) {
-		strbuf_setlen(buffer, slash_pos - buffer->buf);
-
-		if (hashmap_contains_path(map, buffer))
-			return 1;
-
-		slash_pos = strrchr(buffer->buf, '/');
-	}
-
-	return 0;
-}
-
-void add_pattern(const char *string, const char *base,
-		 int baselen, struct pattern_list *pl, int srcpos)
-{
-	struct path_pattern *pattern;
+	struct exclude *x;
 	int patternlen;
 	unsigned flags;
 	int nowildcardlen;
 
-	parse_path_pattern(&string, &patternlen, &flags, &nowildcardlen);
-	if (flags & PATTERN_FLAG_MUSTBEDIR) {
-		FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen);
+	parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen);
+	if (flags & EXC_FLAG_MUSTBEDIR) {
+		FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen);
 	} else {
-		pattern = xmalloc(sizeof(*pattern));
-		pattern->pattern = string;
+		x = xmalloc(sizeof(*x));
+		x->pattern = string;
 	}
-	pattern->patternlen = patternlen;
-	pattern->nowildcardlen = nowildcardlen;
-	pattern->base = base;
-	pattern->baselen = baselen;
-	pattern->flags = flags;
-	pattern->srcpos = srcpos;
-	ALLOC_GROW(pl->patterns, pl->nr + 1, pl->alloc);
-	pl->patterns[pl->nr++] = pattern;
-	pattern->pl = pl;
-
-	add_pattern_to_hashsets(pl, pattern);
+	x->patternlen = patternlen;
+	x->nowildcardlen = nowildcardlen;
+	x->base = base;
+	x->baselen = baselen;
+	x->flags = flags;
+	x->srcpos = srcpos;
+	ALLOC_GROW(el->excludes, el->nr + 1, el->alloc);
+	el->excludes[el->nr++] = x;
+	x->el = el;
 }
 
 static int read_skip_worktree_file_from_index(const struct index_state *istate,
@@ -887,19 +643,19 @@ static int read_skip_worktree_file_from_index(const struct index_state *istate,
 }
 
 /*
- * Frees memory within pl which was allocated for exclude patterns and
- * the file buffer.  Does not free pl itself.
+ * Frees memory within el which was allocated for exclude patterns and
+ * the file buffer.  Does not free el itself.
  */
-void clear_pattern_list(struct pattern_list *pl)
+void clear_exclude_list(struct exclude_list *el)
 {
 	int i;
 
-	for (i = 0; i < pl->nr; i++)
-		free(pl->patterns[i]);
-	free(pl->patterns);
-	free(pl->filebuf);
+	for (i = 0; i < el->nr; i++)
+		free(el->excludes[i]);
+	free(el->excludes);
+	free(el->filebuf);
 
-	memset(pl, 0, sizeof(*pl));
+	memset(el, 0, sizeof(*el));
 }
 
 static void trim_trailing_spaces(char *buf)
@@ -1006,21 +762,21 @@ static void invalidate_directory(struct untracked_cache *uc,
 		dir->dirs[i]->recurse = 0;
 }
 
-static int add_patterns_from_buffer(char *buf, size_t size,
+static int add_excludes_from_buffer(char *buf, size_t size,
 				    const char *base, int baselen,
-				    struct pattern_list *pl);
+				    struct exclude_list *el);
 
 /*
  * Given a file with name "fname", read it (either from disk, or from
  * an index if 'istate' is non-null), parse it and store the
- * exclude rules in "pl".
+ * exclude rules in "el".
  *
  * If "ss" is not NULL, compute SHA-1 of the exclude file and fill
- * stat data from disk (only valid if add_patterns returns zero). If
+ * stat data from disk (only valid if add_excludes returns zero). If
  * ss_valid is non-zero, "ss" must contain good value as input.
  */
-static int add_patterns(const char *fname, const char *base, int baselen,
-			struct pattern_list *pl, struct index_state *istate,
+static int add_excludes(const char *fname, const char *base, int baselen,
+			struct exclude_list *el, struct index_state *istate,
 			struct oid_stat *oid_stat)
 {
 	struct stat st;
@@ -1074,31 +830,28 @@ static int add_patterns(const char *fname, const char *base, int baselen,
 				oidcpy(&oid_stat->oid,
 				       &istate->cache[pos]->oid);
 			else
-				hash_object_file(the_hash_algo, buf, size,
-						 "blob", &oid_stat->oid);
+				hash_object_file(buf, size, "blob",
+						 &oid_stat->oid);
 			fill_stat_data(&oid_stat->stat, &st);
 			oid_stat->valid = 1;
 		}
 	}
 
-	add_patterns_from_buffer(buf, size, base, baselen, pl);
+	add_excludes_from_buffer(buf, size, base, baselen, el);
 	return 0;
 }
 
-static int add_patterns_from_buffer(char *buf, size_t size,
+static int add_excludes_from_buffer(char *buf, size_t size,
 				    const char *base, int baselen,
-				    struct pattern_list *pl)
+				    struct exclude_list *el)
 {
 	int i, lineno = 1;
 	char *entry;
 
-	hashmap_init(&pl->recursive_hashmap, pl_hashmap_cmp, NULL, 0);
-	hashmap_init(&pl->parent_hashmap, pl_hashmap_cmp, NULL, 0);
-
-	pl->filebuf = buf;
+	el->filebuf = buf;
 
 	if (skip_utf8_bom(&buf, size))
-		size -= buf - pl->filebuf;
+		size -= buf - el->filebuf;
 
 	entry = buf;
 
@@ -1107,7 +860,7 @@ static int add_patterns_from_buffer(char *buf, size_t size,
 			if (entry != buf + i && entry[0] != '#') {
 				buf[i - (i && buf[i-1] == '\r')] = 0;
 				trim_trailing_spaces(entry);
-				add_pattern(entry, base, baselen, pl, lineno);
+				add_exclude(entry, base, baselen, el, lineno);
 			}
 			lineno++;
 			entry = buf + i + 1;
@@ -1116,17 +869,17 @@ static int add_patterns_from_buffer(char *buf, size_t size,
 	return 0;
 }
 
-int add_patterns_from_file_to_list(const char *fname, const char *base,
-				   int baselen, struct pattern_list *pl,
+int add_excludes_from_file_to_list(const char *fname, const char *base,
+				   int baselen, struct exclude_list *el,
 				   struct index_state *istate)
 {
-	return add_patterns(fname, base, baselen, pl, istate, NULL);
+	return add_excludes(fname, base, baselen, el, istate, NULL);
 }
 
-int add_patterns_from_blob_to_list(
+int add_excludes_from_blob_to_list(
 	struct object_id *oid,
 	const char *base, int baselen,
-	struct pattern_list *pl)
+	struct exclude_list *el)
 {
 	char *buf;
 	size_t size;
@@ -1136,31 +889,31 @@ int add_patterns_from_blob_to_list(
 	if (r != 1)
 		return r;
 
-	add_patterns_from_buffer(buf, size, base, baselen, pl);
+	add_excludes_from_buffer(buf, size, base, baselen, el);
 	return 0;
 }
 
-struct pattern_list *add_pattern_list(struct dir_struct *dir,
+struct exclude_list *add_exclude_list(struct dir_struct *dir,
 				      int group_type, const char *src)
 {
-	struct pattern_list *pl;
+	struct exclude_list *el;
 	struct exclude_list_group *group;
 
 	group = &dir->exclude_list_group[group_type];
-	ALLOC_GROW(group->pl, group->nr + 1, group->alloc);
-	pl = &group->pl[group->nr++];
-	memset(pl, 0, sizeof(*pl));
-	pl->src = src;
-	return pl;
+	ALLOC_GROW(group->el, group->nr + 1, group->alloc);
+	el = &group->el[group->nr++];
+	memset(el, 0, sizeof(*el));
+	el->src = src;
+	return el;
 }
 
 /*
  * Used to set up core.excludesfile and .git/info/exclude lists.
  */
-static void add_patterns_from_file_1(struct dir_struct *dir, const char *fname,
+static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname,
 				     struct oid_stat *oid_stat)
 {
-	struct pattern_list *pl;
+	struct exclude_list *el;
 	/*
 	 * catch setup_standard_excludes() that's called before
 	 * dir->untracked is assigned. That function behaves
@@ -1168,15 +921,15 @@ static void add_patterns_from_file_1(struct dir_struct *dir, const char *fname,
 	 */
 	if (!dir->untracked)
 		dir->unmanaged_exclude_files++;
-	pl = add_pattern_list(dir, EXC_FILE, fname);
-	if (add_patterns(fname, "", 0, pl, NULL, oid_stat) < 0)
+	el = add_exclude_list(dir, EXC_FILE, fname);
+	if (add_excludes(fname, "", 0, el, NULL, oid_stat) < 0)
 		die(_("cannot use %s as an exclude file"), fname);
 }
 
-void add_patterns_from_file(struct dir_struct *dir, const char *fname)
+void add_excludes_from_file(struct dir_struct *dir, const char *fname)
 {
 	dir->unmanaged_exclude_files++; /* see validate_untracked_cache() */
-	add_patterns_from_file_1(dir, fname, NULL);
+	add_excludes_from_file_1(dir, fname, NULL);
 }
 
 int match_basename(const char *basename, int basenamelen,
@@ -1187,7 +940,7 @@ int match_basename(const char *basename, int basenamelen,
 		if (patternlen == basenamelen &&
 		    !fspathncmp(pattern, basename, basenamelen))
 			return 1;
-	} else if (flags & PATTERN_FLAG_ENDSWITH) {
+	} else if (flags & EXC_FLAG_ENDSWITH) {
 		/* "*literal" matching against "fooliteral" */
 		if (patternlen - 1 <= basenamelen &&
 		    !fspathncmp(pattern + 1,
@@ -1268,138 +1021,85 @@ int match_pathname(const char *pathname, int pathlen,
  * any, determines the fate.  Returns the exclude_list element which
  * matched, or NULL for undecided.
  */
-static struct path_pattern *last_matching_pattern_from_list(const char *pathname,
+static struct exclude *last_exclude_matching_from_list(const char *pathname,
 						       int pathlen,
 						       const char *basename,
 						       int *dtype,
-						       struct pattern_list *pl,
+						       struct exclude_list *el,
 						       struct index_state *istate)
 {
-	struct path_pattern *res = NULL; /* undecided */
+	struct exclude *exc = NULL; /* undecided */
 	int i;
 
-	if (!pl->nr)
+	if (!el->nr)
 		return NULL;	/* undefined */
 
-	for (i = pl->nr - 1; 0 <= i; i--) {
-		struct path_pattern *pattern = pl->patterns[i];
-		const char *exclude = pattern->pattern;
-		int prefix = pattern->nowildcardlen;
+	for (i = el->nr - 1; 0 <= i; i--) {
+		struct exclude *x = el->excludes[i];
+		const char *exclude = x->pattern;
+		int prefix = x->nowildcardlen;
 
-		if (pattern->flags & PATTERN_FLAG_MUSTBEDIR) {
-			*dtype = resolve_dtype(*dtype, istate, pathname, pathlen);
+		if (x->flags & EXC_FLAG_MUSTBEDIR) {
+			if (*dtype == DT_UNKNOWN)
+				*dtype = get_dtype(NULL, istate, pathname, pathlen);
 			if (*dtype != DT_DIR)
 				continue;
 		}
 
-		if (pattern->flags & PATTERN_FLAG_NODIR) {
+		if (x->flags & EXC_FLAG_NODIR) {
 			if (match_basename(basename,
 					   pathlen - (basename - pathname),
-					   exclude, prefix, pattern->patternlen,
-					   pattern->flags)) {
-				res = pattern;
+					   exclude, prefix, x->patternlen,
+					   x->flags)) {
+				exc = x;
 				break;
 			}
 			continue;
 		}
 
-		assert(pattern->baselen == 0 ||
-		       pattern->base[pattern->baselen - 1] == '/');
+		assert(x->baselen == 0 || x->base[x->baselen - 1] == '/');
 		if (match_pathname(pathname, pathlen,
-				   pattern->base,
-				   pattern->baselen ? pattern->baselen - 1 : 0,
-				   exclude, prefix, pattern->patternlen,
-				   pattern->flags)) {
-			res = pattern;
+				   x->base, x->baselen ? x->baselen - 1 : 0,
+				   exclude, prefix, x->patternlen, x->flags)) {
+			exc = x;
 			break;
 		}
 	}
-	return res;
+	return exc;
 }
 
 /*
- * Scan the list of patterns to determine if the ordered list
- * of patterns matches on 'pathname'.
- *
- * Return 1 for a match, 0 for not matched and -1 for undecided.
+ * Scan the list and let the last match determine the fate.
+ * Return 1 for exclude, 0 for include and -1 for undecided.
  */
-enum pattern_match_result path_matches_pattern_list(
-				const char *pathname, int pathlen,
-				const char *basename, int *dtype,
-				struct pattern_list *pl,
-				struct index_state *istate)
-{
-	struct path_pattern *pattern;
-	struct strbuf parent_pathname = STRBUF_INIT;
-	int result = NOT_MATCHED;
-	const char *slash_pos;
-
-	if (!pl->use_cone_patterns) {
-		pattern = last_matching_pattern_from_list(pathname, pathlen, basename,
-							dtype, pl, istate);
-		if (pattern) {
-			if (pattern->flags & PATTERN_FLAG_NEGATIVE)
-				return NOT_MATCHED;
-			else
-				return MATCHED;
-		}
-
-		return UNDECIDED;
-	}
-
-	if (pl->full_cone)
-		return MATCHED;
-
-	strbuf_addch(&parent_pathname, '/');
-	strbuf_add(&parent_pathname, pathname, pathlen);
-
-	if (hashmap_contains_path(&pl->recursive_hashmap,
-				  &parent_pathname)) {
-		result = MATCHED_RECURSIVE;
-		goto done;
-	}
-
-	slash_pos = strrchr(parent_pathname.buf, '/');
-
-	if (slash_pos == parent_pathname.buf) {
-		/* include every file in root */
-		result = MATCHED;
-		goto done;
-	}
-
-	strbuf_setlen(&parent_pathname, slash_pos - parent_pathname.buf);
-
-	if (hashmap_contains_path(&pl->parent_hashmap, &parent_pathname)) {
-		result = MATCHED;
-		goto done;
-	}
-
-	if (hashmap_contains_parent(&pl->recursive_hashmap,
-				    pathname,
-				    &parent_pathname))
-		result = MATCHED_RECURSIVE;
-
-done:
-	strbuf_release(&parent_pathname);
-	return result;
+int is_excluded_from_list(const char *pathname,
+			  int pathlen, const char *basename, int *dtype,
+			  struct exclude_list *el, struct index_state *istate)
+{
+	struct exclude *exclude;
+	exclude = last_exclude_matching_from_list(pathname, pathlen, basename,
+						  dtype, el, istate);
+	if (exclude)
+		return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
+	return -1; /* undecided */
 }
 
-static struct path_pattern *last_matching_pattern_from_lists(
-		struct dir_struct *dir, struct index_state *istate,
-		const char *pathname, int pathlen,
-		const char *basename, int *dtype_p)
+static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,
+							struct index_state *istate,
+		const char *pathname, int pathlen, const char *basename,
+		int *dtype_p)
 {
 	int i, j;
 	struct exclude_list_group *group;
-	struct path_pattern *pattern;
+	struct exclude *exclude;
 	for (i = EXC_CMDL; i <= EXC_FILE; i++) {
 		group = &dir->exclude_list_group[i];
 		for (j = group->nr - 1; j >= 0; j--) {
-			pattern = last_matching_pattern_from_list(
+			exclude = last_exclude_matching_from_list(
 				pathname, pathlen, basename, dtype_p,
-				&group->pl[j], istate);
-			if (pattern)
-				return pattern;
+				&group->el[j], istate);
+			if (exclude)
+				return exclude;
 		}
 	}
 	return NULL;
@@ -1414,7 +1114,7 @@ static void prep_exclude(struct dir_struct *dir,
 			 const char *base, int baselen)
 {
 	struct exclude_list_group *group;
-	struct pattern_list *pl;
+	struct exclude_list *el;
 	struct exclude_stack *stk = NULL;
 	struct untracked_cache_dir *untracked;
 	int current;
@@ -1430,17 +1130,17 @@ static void prep_exclude(struct dir_struct *dir,
 		if (stk->baselen <= baselen &&
 		    !strncmp(dir->basebuf.buf, base, stk->baselen))
 			break;
-		pl = &group->pl[dir->exclude_stack->exclude_ix];
+		el = &group->el[dir->exclude_stack->exclude_ix];
 		dir->exclude_stack = stk->prev;
-		dir->pattern = NULL;
-		free((char *)pl->src); /* see strbuf_detach() below */
-		clear_pattern_list(pl);
+		dir->exclude = NULL;
+		free((char *)el->src); /* see strbuf_detach() below */
+		clear_exclude_list(el);
 		free(stk);
 		group->nr--;
 	}
 
 	/* Skip traversing into sub directories if the parent is excluded */
-	if (dir->pattern)
+	if (dir->exclude)
 		return;
 
 	/*
@@ -1481,7 +1181,7 @@ static void prep_exclude(struct dir_struct *dir,
 		stk->baselen = cp - base;
 		stk->exclude_ix = group->nr;
 		stk->ucd = untracked;
-		pl = add_pattern_list(dir, EXC_DIRS, NULL);
+		el = add_exclude_list(dir, EXC_DIRS, NULL);
 		strbuf_add(&dir->basebuf, base + current, stk->baselen - current);
 		assert(stk->baselen == dir->basebuf.len);
 
@@ -1489,15 +1189,15 @@ static void prep_exclude(struct dir_struct *dir,
 		if (stk->baselen) {
 			int dt = DT_DIR;
 			dir->basebuf.buf[stk->baselen - 1] = 0;
-			dir->pattern = last_matching_pattern_from_lists(dir,
+			dir->exclude = last_exclude_matching_from_lists(dir,
 									istate,
 				dir->basebuf.buf, stk->baselen - 1,
 				dir->basebuf.buf + current, &dt);
 			dir->basebuf.buf[stk->baselen - 1] = '/';
-			if (dir->pattern &&
-			    dir->pattern->flags & PATTERN_FLAG_NEGATIVE)
-				dir->pattern = NULL;
-			if (dir->pattern) {
+			if (dir->exclude &&
+			    dir->exclude->flags & EXC_FLAG_NEGATIVE)
+				dir->exclude = NULL;
+			if (dir->exclude) {
 				dir->exclude_stack = stk;
 				return;
 			}
@@ -1523,30 +1223,30 @@ static void prep_exclude(struct dir_struct *dir,
 			/*
 			 * dir->basebuf gets reused by the traversal, but we
 			 * need fname to remain unchanged to ensure the src
-			 * member of each struct path_pattern correctly
+			 * member of each struct exclude correctly
 			 * back-references its source file.  Other invocations
-			 * of add_pattern_list provide stable strings, so we
+			 * of add_exclude_list provide stable strings, so we
 			 * strbuf_detach() and free() here in the caller.
 			 */
 			struct strbuf sb = STRBUF_INIT;
 			strbuf_addbuf(&sb, &dir->basebuf);
 			strbuf_addstr(&sb, dir->exclude_per_dir);
-			pl->src = strbuf_detach(&sb, NULL);
-			add_patterns(pl->src, pl->src, stk->baselen, pl, istate,
+			el->src = strbuf_detach(&sb, NULL);
+			add_excludes(el->src, el->src, stk->baselen, el, istate,
 				     untracked ? &oid_stat : NULL);
 		}
 		/*
 		 * NEEDSWORK: when untracked cache is enabled, prep_exclude()
 		 * will first be called in valid_cached_dir() then maybe many
-		 * times more in last_matching_pattern(). When the cache is
-		 * used, last_matching_pattern() will not be called and
+		 * times more in last_exclude_matching(). When the cache is
+		 * used, last_exclude_matching() will not be called and
 		 * reading .gitignore content will be a waste.
 		 *
 		 * So when it's called by valid_cached_dir() and we can get
 		 * .gitignore SHA-1 from the index (i.e. .gitignore is not
 		 * modified on work tree), we could delay reading the
 		 * .gitignore content until we absolutely need it in
-		 * last_matching_pattern(). Be careful about ignore rule
+		 * last_exclude_matching(). Be careful about ignore rule
 		 * order, though, if you do that.
 		 */
 		if (untracked &&
@@ -1566,7 +1266,7 @@ static void prep_exclude(struct dir_struct *dir,
  * Returns the exclude_list element which matched, or NULL for
  * undecided.
  */
-struct path_pattern *last_matching_pattern(struct dir_struct *dir,
+struct exclude *last_exclude_matching(struct dir_struct *dir,
 				      struct index_state *istate,
 				      const char *pathname,
 				      int *dtype_p)
@@ -1577,10 +1277,10 @@ struct path_pattern *last_matching_pattern(struct dir_struct *dir,
 
 	prep_exclude(dir, istate, pathname, basename-pathname);
 
-	if (dir->pattern)
-		return dir->pattern;
+	if (dir->exclude)
+		return dir->exclude;
 
-	return last_matching_pattern_from_lists(dir, istate, pathname, pathlen,
+	return last_exclude_matching_from_lists(dir, istate, pathname, pathlen,
 			basename, dtype_p);
 }
 
@@ -1592,10 +1292,10 @@ struct path_pattern *last_matching_pattern(struct dir_struct *dir,
 int is_excluded(struct dir_struct *dir, struct index_state *istate,
 		const char *pathname, int *dtype_p)
 {
-	struct path_pattern *pattern =
-		last_matching_pattern(dir, istate, pathname, dtype_p);
-	if (pattern)
-		return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;
+	struct exclude *exclude =
+		last_exclude_matching(dir, istate, pathname, dtype_p);
+	if (exclude)
+		return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
 	return 0;
 }
 
@@ -1730,8 +1430,6 @@ static enum path_treatment treat_directory(struct dir_struct *dir,
 	const char *dirname, int len, int baselen, int exclude,
 	const struct pathspec *pathspec)
 {
-	int nested_repo = 0;
-
 	/* The "len-1" is to strip the final '/' */
 	switch (directory_exists_in_index(istate, dirname, len-1)) {
 	case index_directory:
@@ -1741,17 +1439,6 @@ static enum path_treatment treat_directory(struct dir_struct *dir,
 		return path_none;
 
 	case index_nonexistent:
-		if ((dir->flags & DIR_SKIP_NESTED_GIT) ||
-		    !(dir->flags & DIR_NO_GITLINKS)) {
-			struct strbuf sb = STRBUF_INIT;
-			strbuf_addstr(&sb, dirname);
-			nested_repo = is_nonbare_repository_dir(&sb);
-			strbuf_release(&sb);
-		}
-		if (nested_repo)
-			return ((dir->flags & DIR_SKIP_NESTED_GIT) ? path_none :
-				(exclude ? path_excluded : path_untracked));
-
 		if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)
 			break;
 		if (exclude &&
@@ -1778,6 +1465,13 @@ static enum path_treatment treat_directory(struct dir_struct *dir,
 
 			return path_none;
 		}
+		if (!(dir->flags & DIR_NO_GITLINKS)) {
+			struct strbuf sb = STRBUF_INIT;
+			strbuf_addstr(&sb, dirname);
+			if (is_nonbare_repository_dir(&sb))
+				return exclude ? path_excluded : path_untracked;
+			strbuf_release(&sb);
+		}
 		return path_recurse;
 	}
 
@@ -1913,9 +1607,10 @@ static int get_index_dtype(struct index_state *istate,
 	return DT_UNKNOWN;
 }
 
-static int resolve_dtype(int dtype, struct index_state *istate,
-			 const char *path, int len)
+static int get_dtype(struct dirent *de, struct index_state *istate,
+		     const char *path, int len)
 {
+	int dtype = de ? DTYPE(de) : DT_UNKNOWN;
 	struct stat st;
 
 	if (dtype != DT_UNKNOWN)
@@ -1940,13 +1635,14 @@ static enum path_treatment treat_one_path(struct dir_struct *dir,
 					  struct strbuf *path,
 					  int baselen,
 					  const struct pathspec *pathspec,
-					  int dtype)
+					  int dtype, struct dirent *de)
 {
 	int exclude;
 	int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);
 	enum path_treatment path_treatment;
 
-	dtype = resolve_dtype(dtype, istate, path->buf, path->len);
+	if (dtype == DT_UNKNOWN)
+		dtype = get_dtype(de, istate, path->buf, path->len);
 
 	/* Always exclude indexed files */
 	if (dtype != DT_DIR && has_path_in_index)
@@ -2054,18 +1750,21 @@ static enum path_treatment treat_path(struct dir_struct *dir,
 				      int baselen,
 				      const struct pathspec *pathspec)
 {
-	if (!cdir->d_name)
+	int dtype;
+	struct dirent *de = cdir->de;
+
+	if (!de)
 		return treat_path_fast(dir, untracked, cdir, istate, path,
 				       baselen, pathspec);
-	if (is_dot_or_dotdot(cdir->d_name) || !fspathcmp(cdir->d_name, ".git"))
+	if (is_dot_or_dotdot(de->d_name) || !fspathcmp(de->d_name, ".git"))
 		return path_none;
 	strbuf_setlen(path, baselen);
-	strbuf_addstr(path, cdir->d_name);
+	strbuf_addstr(path, de->d_name);
 	if (simplify_away(path->buf, path->len, pathspec))
 		return path_none;
 
-	return treat_one_path(dir, untracked, istate, path, baselen, pathspec,
-			      cdir->d_type);
+	dtype = DTYPE(de);
+	return treat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);
 }
 
 static void add_untracked(struct untracked_cache_dir *dir, const char *name)
@@ -2109,7 +1808,7 @@ static int valid_cached_dir(struct dir_struct *dir,
 
 	/*
 	 * prep_exclude will be called eventually on this directory,
-	 * but it's called much later in last_matching_pattern(). We
+	 * but it's called much later in last_exclude_matching(). We
 	 * need it now to determine the validity of the cache for this
 	 * path. The next calls will be nearly no-op, the way
 	 * prep_exclude() is designed.
@@ -2153,17 +1852,10 @@ static int open_cached_dir(struct cached_dir *cdir,
 
 static int read_cached_dir(struct cached_dir *cdir)
 {
-	struct dirent *de;
-
 	if (cdir->fdir) {
-		de = readdir(cdir->fdir);
-		if (!de) {
-			cdir->d_name = NULL;
-			cdir->d_type = DT_UNKNOWN;
+		cdir->de = readdir(cdir->fdir);
+		if (!cdir->de)
 			return -1;
-		}
-		cdir->d_name = de->d_name;
-		cdir->d_type = DTYPE(de);
 		return 0;
 	}
 	while (cdir->nr_dirs < cdir->untracked->dirs_nr) {
@@ -2199,40 +1891,6 @@ static void close_cached_dir(struct cached_dir *cdir)
 	}
 }
 
-static void add_path_to_appropriate_result_list(struct dir_struct *dir,
-	struct untracked_cache_dir *untracked,
-	struct cached_dir *cdir,
-	struct index_state *istate,
-	struct strbuf *path,
-	int baselen,
-	const struct pathspec *pathspec,
-	enum path_treatment state)
-{
-	/* add the path to the appropriate result list */
-	switch (state) {
-	case path_excluded:
-		if (dir->flags & DIR_SHOW_IGNORED)
-			dir_add_name(dir, istate, path->buf, path->len);
-		else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||
-			((dir->flags & DIR_COLLECT_IGNORED) &&
-			exclude_matches_pathspec(path->buf, path->len,
-						 pathspec)))
-			dir_add_ignored(dir, istate, path->buf, path->len);
-		break;
-
-	case path_untracked:
-		if (dir->flags & DIR_SHOW_IGNORED)
-			break;
-		dir_add_name(dir, istate, path->buf, path->len);
-		if (cdir->fdir)
-			add_untracked(untracked, path->buf + baselen);
-		break;
-
-	default:
-		break;
-	}
-}
-
 /*
  * Read a directory tree. We currently ignore anything but
  * directories, regular files and symlinks. That's because git
@@ -2257,15 +1915,6 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir,
 	struct untracked_cache_dir *untracked, int check_only,
 	int stop_at_first_file, const struct pathspec *pathspec)
 {
-	/*
-	 * WARNING WARNING WARNING:
-	 *
-	 * Any updates to the traversal logic here may need corresponding
-	 * updates in treat_leading_path().  See the commit message for the
-	 * commit adding this warning as well as the commit preceding it
-	 * for details.
-	 */
-
 	struct cached_dir cdir;
 	enum path_treatment state, subdir_state, dir_state = path_none;
 	struct strbuf path = STRBUF_INIT;
@@ -2289,11 +1938,8 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir,
 		/* recurse into subdir if instructed by treat_path */
 		if ((state == path_recurse) ||
 			((state == path_untracked) &&
-			 (resolve_dtype(cdir.d_type, istate, path.buf, path.len) == DT_DIR) &&
-			 ((dir->flags & DIR_SHOW_IGNORED_TOO) ||
-			  (pathspec &&
-			   do_match_pathspec(istate, pathspec, path.buf, path.len,
-					     baselen, NULL, DO_MATCH_LEADING_PATHSPEC) == MATCHED_RECURSIVELY_LEADING_PATHSPEC)))) {
+			 (dir->flags & DIR_SHOW_IGNORED_TOO) &&
+			 (get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) {
 			struct untracked_cache_dir *ud;
 			ud = lookup_untracked(dir->untracked, untracked,
 					      path.buf + baselen,
@@ -2304,12 +1950,6 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir,
 							 check_only, stop_at_first_file, pathspec);
 			if (subdir_state > dir_state)
 				dir_state = subdir_state;
-
-			if (pathspec &&
-			    !match_pathspec(istate, pathspec, path.buf, path.len,
-					    0 /* prefix */, NULL,
-					    0 /* do NOT special case dirs */))
-				state = path_none;
 		}
 
 		if (check_only) {
@@ -2345,9 +1985,29 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir,
 			continue;
 		}
 
-		add_path_to_appropriate_result_list(dir, untracked, &cdir,
-						    istate, &path, baselen,
-						    pathspec, state);
+		/* add the path to the appropriate result list */
+		switch (state) {
+		case path_excluded:
+			if (dir->flags & DIR_SHOW_IGNORED)
+				dir_add_name(dir, istate, path.buf, path.len);
+			else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||
+				((dir->flags & DIR_COLLECT_IGNORED) &&
+				exclude_matches_pathspec(path.buf, path.len,
+							 pathspec)))
+				dir_add_ignored(dir, istate, path.buf, path.len);
+			break;
+
+		case path_untracked:
+			if (dir->flags & DIR_SHOW_IGNORED)
+				break;
+			dir_add_name(dir, istate, path.buf, path.len);
+			if (cdir.fdir)
+				add_untracked(untracked, path.buf + baselen);
+			break;
+
+		default:
+			break;
+		}
 	}
 	close_cached_dir(&cdir);
  out:
@@ -2377,95 +2037,41 @@ static int treat_leading_path(struct dir_struct *dir,
 			      const char *path, int len,
 			      const struct pathspec *pathspec)
 {
-	/*
-	 * WARNING WARNING WARNING:
-	 *
-	 * Any updates to the traversal logic here may need corresponding
-	 * updates in read_directory_recursive().  See 777b420347 (dir:
-	 * synchronize treat_leading_path() and read_directory_recursive(),
-	 * 2019-12-19) and its parent commit for details.
-	 */
-
 	struct strbuf sb = STRBUF_INIT;
-	struct strbuf subdir = STRBUF_INIT;
-	int prevlen, baselen;
+	int baselen, rc = 0;
 	const char *cp;
-	struct cached_dir cdir;
-	enum path_treatment state = path_none;
-
-	/*
-	 * For each directory component of path, we are going to check whether
-	 * that path is relevant given the pathspec.  For example, if path is
-	 *    foo/bar/baz/
-	 * then we will ask treat_path() whether we should go into foo, then
-	 * whether we should go into bar, then whether baz is relevant.
-	 * Checking each is important because e.g. if path is
-	 *    .git/info/
-	 * then we need to check .git to know we shouldn't traverse it.
-	 * If the return from treat_path() is:
-	 *    * path_none, for any path, we return false.
-	 *    * path_recurse, for all path components, we return true
-	 *    * <anything else> for some intermediate component, we make sure
-	 *        to add that path to the relevant list but return false
-	 *        signifying that we shouldn't recurse into it.
-	 */
+	int old_flags = dir->flags;
 
 	while (len && path[len - 1] == '/')
 		len--;
 	if (!len)
 		return 1;
-
-	memset(&cdir, 0, sizeof(cdir));
-	cdir.d_type = DT_DIR;
 	baselen = 0;
-	prevlen = 0;
+	dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;
 	while (1) {
-		prevlen = baselen + !!baselen;
-		cp = path + prevlen;
+		cp = path + baselen + !!baselen;
 		cp = memchr(cp, '/', path + len - cp);
 		if (!cp)
 			baselen = len;
 		else
 			baselen = cp - path;
-		strbuf_reset(&sb);
+		strbuf_setlen(&sb, 0);
 		strbuf_add(&sb, path, baselen);
 		if (!is_directory(sb.buf))
 			break;
-		strbuf_reset(&sb);
-		strbuf_add(&sb, path, prevlen);
-		strbuf_reset(&subdir);
-		strbuf_add(&subdir, path+prevlen, baselen-prevlen);
-		cdir.d_name = subdir.buf;
-		state = treat_path(dir, NULL, &cdir, istate, &sb, prevlen,
-				    pathspec);
-		if (state == path_untracked &&
-		    resolve_dtype(cdir.d_type, istate, sb.buf, sb.len) == DT_DIR &&
-		    (dir->flags & DIR_SHOW_IGNORED_TOO ||
-		     do_match_pathspec(istate, pathspec, sb.buf, sb.len,
-				       baselen, NULL, DO_MATCH_LEADING_PATHSPEC) == MATCHED_RECURSIVELY_LEADING_PATHSPEC)) {
-			if (!match_pathspec(istate, pathspec, sb.buf, sb.len,
-					    0 /* prefix */, NULL,
-					    0 /* do NOT special case dirs */))
-				state = path_none;
-			add_path_to_appropriate_result_list(dir, NULL, &cdir,
-							    istate,
-							    &sb, baselen,
-							    pathspec, state);
-			state = path_recurse;
-		}
-
-		if (state != path_recurse)
+		if (simplify_away(sb.buf, sb.len, pathspec))
+			break;
+		if (treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,
+				   DT_DIR, NULL) == path_none)
 			break; /* do not recurse into it */
-		if (len <= baselen)
+		if (len <= baselen) {
+			rc = 1;
 			break; /* finished checking */
+		}
 	}
-	add_path_to_appropriate_result_list(dir, NULL, &cdir, istate,
-					    &sb, baselen, pathspec,
-					    state);
-
-	strbuf_release(&subdir);
 	strbuf_release(&sb);
-	return state == path_recurse;
+	dir->flags = old_flags;
+	return rc;
 }
 
 static const char *get_ident_string(void)
@@ -2840,7 +2446,7 @@ static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)
 				 * wanted anyway
 				 */
 				continue;
-			/* fall through */
+			/* fall thru */
 		} else if (S_ISDIR(st.st_mode)) {
 			if (!remove_dir_recurse(path, flag, &kept_down))
 				continue; /* happy */
@@ -2882,14 +2488,14 @@ void setup_standard_excludes(struct dir_struct *dir)
 	if (!excludes_file)
 		excludes_file = xdg_config_home("ignore");
 	if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))
-		add_patterns_from_file_1(dir, excludes_file,
+		add_excludes_from_file_1(dir, excludes_file,
 					 dir->untracked ? &dir->ss_excludes_file : NULL);
 
 	/* per repository user preference */
 	if (startup_info->have_repository) {
 		const char *path = git_path_info_exclude();
 		if (!access_or_warn(path, R_OK, 0))
-			add_patterns_from_file_1(dir, path,
+			add_excludes_from_file_1(dir, path,
 						 dir->untracked ? &dir->ss_info_exclude : NULL);
 	}
 }
@@ -2921,18 +2527,18 @@ void clear_directory(struct dir_struct *dir)
 {
 	int i, j;
 	struct exclude_list_group *group;
-	struct pattern_list *pl;
+	struct exclude_list *el;
 	struct exclude_stack *stk;
 
 	for (i = EXC_CMDL; i <= EXC_FILE; i++) {
 		group = &dir->exclude_list_group[i];
 		for (j = 0; j < group->nr; j++) {
-			pl = &group->pl[j];
+			el = &group->el[j];
 			if (i == EXC_DIRS)
-				free((char *)pl->src);
-			clear_pattern_list(pl);
+				free((char *)el->src);
+			clear_exclude_list(el);
 		}
-		free(group->pl);
+		free(group->el);
 	}
 
 	stk = dir->exclude_stack;