rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/iterator.c

@@ -6,137 +6,376 @@
  */
 
 #include "iterator.h"
+
 #include "tree.h"
 #include "index.h"
-#include "ignore.h"
-#include "buffer.h"
-#include "git2/submodule.h"
-#include <ctype.h>
-
-#define ITERATOR_SET_CB(P,NAME_LC) do { \
-	(P)->cb.current = NAME_LC ## _iterator__current; \
-	(P)->cb.advance = NAME_LC ## _iterator__advance; \
-	(P)->cb.advance_into = NAME_LC ## _iterator__advance_into; \
-	(P)->cb.seek    = NAME_LC ## _iterator__seek; \
-	(P)->cb.reset   = NAME_LC ## _iterator__reset; \
-	(P)->cb.at_end  = NAME_LC ## _iterator__at_end; \
-	(P)->cb.free    = NAME_LC ## _iterator__free; \
-	} while (0)
-
-#define ITERATOR_CASE_FLAGS \
-	(GIT_ITERATOR_IGNORE_CASE | GIT_ITERATOR_DONT_IGNORE_CASE)
-
-#define ITERATOR_BASE_INIT(P,NAME_LC,NAME_UC,REPO) do { \
-	(P)->base.type    = GIT_ITERATOR_TYPE_ ## NAME_UC; \
-	(P)->base.cb      = &(P)->cb; \
-	ITERATOR_SET_CB(P,NAME_LC); \
-	(P)->base.repo    = (REPO); \
-	(P)->base.start   = start ? git__strdup(start) : NULL; \
-	(P)->base.end     = end ? git__strdup(end) : NULL; \
-	if ((start && !(P)->base.start) || (end && !(P)->base.end)) { \
-		git__free(P); return -1; } \
-	(P)->base.prefixcomp = git__prefixcmp; \
-	(P)->base.flags = flags & ~ITERATOR_CASE_FLAGS; \
-	if ((P)->base.flags & GIT_ITERATOR_DONT_AUTOEXPAND) \
-		(P)->base.flags |= GIT_ITERATOR_INCLUDE_TREES; \
-	} while (0)
 
-#define iterator__flag(I,F) ((((git_iterator *)(I))->flags & GIT_ITERATOR_ ## F) != 0)
-#define iterator__ignore_case(I)     iterator__flag(I,IGNORE_CASE)
-#define iterator__include_trees(I)   iterator__flag(I,INCLUDE_TREES)
-#define iterator__dont_autoexpand(I) iterator__flag(I,DONT_AUTOEXPAND)
-#define iterator__do_autoexpand(I)   !iterator__flag(I,DONT_AUTOEXPAND)
+#define GIT_ITERATOR_FIRST_ACCESS   (1 << 15)
+#define GIT_ITERATOR_HONOR_IGNORES  (1 << 16)
+#define GIT_ITERATOR_IGNORE_DOT_GIT (1 << 17)
 
-#define GIT_ITERATOR_FIRST_ACCESS (1 << 15)
+#define iterator__flag(I,F) ((((git_iterator *)(I))->flags & GIT_ITERATOR_ ## F) != 0)
+#define iterator__ignore_case(I)       iterator__flag(I,IGNORE_CASE)
+#define iterator__include_trees(I)     iterator__flag(I,INCLUDE_TREES)
+#define iterator__dont_autoexpand(I)   iterator__flag(I,DONT_AUTOEXPAND)
+#define iterator__do_autoexpand(I)    !iterator__flag(I,DONT_AUTOEXPAND)
+#define iterator__include_conflicts(I) iterator__flag(I,INCLUDE_CONFLICTS)
 #define iterator__has_been_accessed(I) iterator__flag(I,FIRST_ACCESS)
+#define iterator__honor_ignores(I)     iterator__flag(I,HONOR_IGNORES)
+#define iterator__ignore_dot_git(I)    iterator__flag(I,IGNORE_DOT_GIT)
+#define iterator__descend_symlinks(I)  iterator__flag(I,DESCEND_SYMLINKS)
+
 
-#define iterator__end(I) ((git_iterator *)(I))->end
-#define iterator__past_end(I,PATH) \
-	(iterator__end(I) && ((git_iterator *)(I))->prefixcomp((PATH),iterator__end(I)) > 0)
+static void iterator_set_ignore_case(git_iterator *iter, bool ignore_case)
+{
+	if (ignore_case)
+		iter->flags |= GIT_ITERATOR_IGNORE_CASE;
+	else
+		iter->flags &= ~GIT_ITERATOR_IGNORE_CASE;
 
+	iter->strcomp = ignore_case ? git__strcasecmp : git__strcmp;
+	iter->strncomp = ignore_case ? git__strncasecmp : git__strncmp;
+	iter->prefixcomp = ignore_case ? git__prefixcmp_icase : git__prefixcmp;
+	iter->entry_srch = ignore_case ? git_index_entry_isrch : git_index_entry_srch;
+
+	git_vector_set_cmp(&iter->pathlist, (git_vector_cmp)iter->strcomp);
+}
 
-static int iterator__reset_range(
+static int iterator_range_init(
 	git_iterator *iter, const char *start, const char *end)
 {
-	if (start) {
-		if (iter->start)
-			git__free(iter->start);
+	if (start && *start) {
 		iter->start = git__strdup(start);
-		GITERR_CHECK_ALLOC(iter->start);
+		GIT_ERROR_CHECK_ALLOC(iter->start);
+
+		iter->start_len = strlen(iter->start);
 	}
 
-	if (end) {
-		if (iter->end)
-			git__free(iter->end);
+	if (end && *end) {
 		iter->end = git__strdup(end);
-		GITERR_CHECK_ALLOC(iter->end);
+		GIT_ERROR_CHECK_ALLOC(iter->end);
+
+		iter->end_len = strlen(iter->end);
 	}
 
-	iter->flags &= ~GIT_ITERATOR_FIRST_ACCESS;
+	iter->started = (iter->start == NULL);
+	iter->ended = false;
+
+	return 0;
+}
+
+static void iterator_range_free(git_iterator *iter)
+{
+	if (iter->start) {
+		git__free(iter->start);
+		iter->start = NULL;
+		iter->start_len = 0;
+	}
+
+	if (iter->end) {
+		git__free(iter->end);
+		iter->end = NULL;
+		iter->end_len = 0;
+	}
+}
+
+static int iterator_reset_range(
+	git_iterator *iter, const char *start, const char *end)
+{
+	iterator_range_free(iter);
+	return iterator_range_init(iter, start, end);
+}
+
+static int iterator_pathlist_init(git_iterator *iter, git_strarray *pathlist)
+{
+	size_t i;
+
+	if (git_vector_init(&iter->pathlist, pathlist->count, NULL) < 0)
+		return -1;
+
+	for (i = 0; i < pathlist->count; i++) {
+		if (!pathlist->strings[i])
+			continue;
+
+		if (git_vector_insert(&iter->pathlist, pathlist->strings[i]) < 0)
+			return -1;
+	}
 
 	return 0;
 }
 
-static int iterator__update_ignore_case(
+static int iterator_init_common(
 	git_iterator *iter,
-	git_iterator_flag_t flags)
+	git_repository *repo,
+	git_index *index,
+	git_iterator_options *given_opts)
 {
-	int error = 0, ignore_case = -1;
+	static git_iterator_options default_opts = GIT_ITERATOR_OPTIONS_INIT;
+	git_iterator_options *options = given_opts ? given_opts : &default_opts;
+	bool ignore_case;
+	int precompose;
+	int error;
+
+	iter->repo = repo;
+	iter->index = index;
+	iter->flags = options->flags;
 
-	if ((flags & GIT_ITERATOR_IGNORE_CASE) != 0)
+	if ((iter->flags & GIT_ITERATOR_IGNORE_CASE) != 0) {
 		ignore_case = true;
-	else if ((flags & GIT_ITERATOR_DONT_IGNORE_CASE) != 0)
+	} else if ((iter->flags & GIT_ITERATOR_DONT_IGNORE_CASE) != 0) {
 		ignore_case = false;
-	else {
+	} else if (repo) {
 		git_index *index;
 
-		if (!(error = git_repository_index__weakptr(&index, iter->repo)))
-			ignore_case = (index->ignore_case != false);
+		if ((error = git_repository_index__weakptr(&index, iter->repo)) < 0)
+			return error;
+
+		ignore_case = !!index->ignore_case;
+
+		if (ignore_case == 1)
+			iter->flags |= GIT_ITERATOR_IGNORE_CASE;
+		else
+			iter->flags |= GIT_ITERATOR_DONT_IGNORE_CASE;
+	} else {
+		ignore_case = false;
+	}
+
+	/* try to look up precompose and set flag if appropriate */
+	if (repo &&
+		(iter->flags & GIT_ITERATOR_PRECOMPOSE_UNICODE) == 0 &&
+		(iter->flags & GIT_ITERATOR_DONT_PRECOMPOSE_UNICODE) == 0) {
+
+		if (git_repository__cvar(&precompose, repo, GIT_CVAR_PRECOMPOSE) < 0)
+			git_error_clear();
+		else if (precompose)
+			iter->flags |= GIT_ITERATOR_PRECOMPOSE_UNICODE;
 	}
 
-	if (ignore_case > 0)
-		iter->flags = (iter->flags | GIT_ITERATOR_IGNORE_CASE);
-	else if (ignore_case == 0)
-		iter->flags = (iter->flags & ~GIT_ITERATOR_IGNORE_CASE);
+	if ((iter->flags & GIT_ITERATOR_DONT_AUTOEXPAND))
+		iter->flags |= GIT_ITERATOR_INCLUDE_TREES;
 
-	iter->prefixcomp = iterator__ignore_case(iter) ?
-		git__prefixcmp_icase : git__prefixcmp;
+	if ((error = iterator_range_init(iter, options->start, options->end)) < 0 ||
+		(error = iterator_pathlist_init(iter, &options->pathlist)) < 0)
+		return error;
 
-	return error;
+	iterator_set_ignore_case(iter, ignore_case);
+	return 0;
 }
 
-GIT_INLINE(void) iterator__clear_entry(const git_index_entry **entry)
+static void iterator_clear(git_iterator *iter)
 {
-	if (entry) *entry = NULL;
+	iter->started = false;
+	iter->ended = false;
+	iter->stat_calls = 0;
+	iter->pathlist_walk_idx = 0;
+	iter->flags &= ~GIT_ITERATOR_FIRST_ACCESS;
 }
 
+GIT_INLINE(bool) iterator_has_started(
+	git_iterator *iter, const char *path, bool is_submodule)
+{
+	size_t path_len;
+
+	if (iter->start == NULL || iter->started == true)
+		return true;
+
+	/* the starting path is generally a prefix - we have started once we
+	 * are prefixed by this path
+	 */
+	iter->started = (iter->prefixcomp(path, iter->start) >= 0);
+
+	if (iter->started)
+		return true;
+
+	path_len = strlen(path);
 
-static int empty_iterator__noop(const git_index_entry **e, git_iterator *i)
+	/* if, however, we are a submodule, then we support `start` being
+	 * suffixed with a `/` for crazy legacy reasons.  match `submod`
+	 * with a start path of `submod/`.
+	 */
+	if (is_submodule && iter->start_len && path_len == iter->start_len - 1 &&
+		iter->start[iter->start_len-1] == '/')
+		return true;
+
+	/* if, however, our current path is a directory, and our starting path
+	 * is _beneath_ that directory, then recurse into the directory (even
+	 * though we have not yet "started")
+	 */
+	if (path_len > 0 && path[path_len-1] == '/' &&
+		iter->strncomp(path, iter->start, path_len) == 0)
+		return true;
+
+	return false;
+}
+
+GIT_INLINE(bool) iterator_has_ended(git_iterator *iter, const char *path)
 {
-	GIT_UNUSED(i);
-	iterator__clear_entry(e);
-	return GIT_ITEROVER;
+	if (iter->end == NULL)
+		return false;
+	else if (iter->ended)
+		return true;
+
+	iter->ended = (iter->prefixcomp(path, iter->end) > 0);
+	return iter->ended;
+}
+
+/* walker for the index and tree iterator that allows it to walk the sorted
+ * pathlist entries alongside sorted iterator entries.
+ */
+static bool iterator_pathlist_next_is(git_iterator *iter, const char *path)
+{
+	char *p;
+	size_t path_len, p_len, cmp_len, i;
+	int cmp;
+
+	if (iter->pathlist.length == 0)
+		return true;
+
+	git_vector_sort(&iter->pathlist);
+
+	path_len = strlen(path);
+
+	/* for comparison, drop the trailing slash on the current '/' */
+	if (path_len && path[path_len-1] == '/')
+		path_len--;
+
+	for (i = iter->pathlist_walk_idx; i < iter->pathlist.length; i++) {
+		p = iter->pathlist.contents[i];
+		p_len = strlen(p);
+
+		if (p_len && p[p_len-1] == '/')
+			p_len--;
+
+		cmp_len = min(path_len, p_len);
+
+		/* see if the pathlist entry is a prefix of this path */
+		cmp = iter->strncomp(p, path, cmp_len);
+
+		/* prefix match - see if there's an exact match, or if we were
+		 * given a path that matches the directory
+		 */
+		if (cmp == 0) {
+			/* if this pathlist entry is not suffixed with a '/' then
+			 * it matches a path that is a file or a directory.
+			 * (eg, pathlist = "foo" and path is "foo" or "foo/" or
+			 * "foo/something")
+			 */
+			if (p[cmp_len] == '\0' &&
+				(path[cmp_len] == '\0' || path[cmp_len] == '/'))
+				return true;
+
+			/* if this pathlist entry _is_ suffixed with a '/' then
+			 * it matches only paths that are directories.
+			 * (eg, pathlist = "foo/" and path is "foo/" or "foo/something")
+			 */
+			if (p[cmp_len] == '/' && path[cmp_len] == '/')
+				return true;
+		}
+
+		/* this pathlist entry sorts before the given path, try the next */
+		else if (cmp < 0) {
+			iter->pathlist_walk_idx++;
+			continue;
+		}
+
+		/* this pathlist sorts after the given path, no match. */
+		else if (cmp > 0) {
+			break;
+		}
+	}
+
+	return false;
+}
+
+typedef enum {
+	ITERATOR_PATHLIST_NONE = 0,
+	ITERATOR_PATHLIST_IS_FILE = 1,
+	ITERATOR_PATHLIST_IS_DIR = 2,
+	ITERATOR_PATHLIST_IS_PARENT = 3,
+	ITERATOR_PATHLIST_FULL = 4,
+} iterator_pathlist_search_t;
+
+static iterator_pathlist_search_t iterator_pathlist_search(
+	git_iterator *iter, const char *path, size_t path_len)
+{
+	const char *p;
+	size_t idx;
+	int error;
+
+	if (iter->pathlist.length == 0)
+		return ITERATOR_PATHLIST_FULL;
+
+	git_vector_sort(&iter->pathlist);
+
+	error = git_vector_bsearch2(&idx, &iter->pathlist,
+		(git_vector_cmp)iter->strcomp, path);
+
+	/* the given path was found in the pathlist.  since the pathlist only
+	 * matches directories when they're suffixed with a '/', analyze the
+	 * path string to determine whether it's a directory or not.
+	 */
+	if (error == 0) {
+		if (path_len && path[path_len-1] == '/')
+			return ITERATOR_PATHLIST_IS_DIR;
+
+		return ITERATOR_PATHLIST_IS_FILE;
+	}
+
+	/* at this point, the path we're examining may be a directory (though we
+	 * don't know that yet, since we're avoiding a stat unless it's necessary)
+	 * so walk the pathlist looking for the given path with a '/' after it,
+	 */
+	while ((p = git_vector_get(&iter->pathlist, idx)) != NULL) {
+		if (iter->prefixcomp(p, path) != 0)
+			break;
+
+		/* an exact match would have been matched by the bsearch above */
+		assert(p[path_len]);
+
+		/* is this a literal directory entry (eg `foo/`) or a file beneath */
+		if (p[path_len] == '/') {
+			return (p[path_len+1] == '\0') ?
+				ITERATOR_PATHLIST_IS_DIR :
+				ITERATOR_PATHLIST_IS_PARENT;
+		}
+
+		if (p[path_len] > '/')
+			break;
+
+		idx++;
+	}
+
+	return ITERATOR_PATHLIST_NONE;
 }
 
-static int empty_iterator__seek(git_iterator *i, const char *p)
+/* Empty iterator */
+
+static int empty_iterator_noop(const git_index_entry **e, git_iterator *i)
 {
-	GIT_UNUSED(i); GIT_UNUSED(p);
-	return -1;
+	GIT_UNUSED(i);
+
+	if (e)
+		*e = NULL;
+
+	return GIT_ITEROVER;
 }
 
-static int empty_iterator__reset(git_iterator *i, const char *s, const char *e)
+static int empty_iterator_advance_over(
+	const git_index_entry **e,
+	git_iterator_status_t *s,
+	git_iterator *i)
 {
-	GIT_UNUSED(i); GIT_UNUSED(s); GIT_UNUSED(e);
-	return 0;
+	*s = GIT_ITERATOR_STATUS_EMPTY;
+	return empty_iterator_noop(e, i);
 }
 
-static int empty_iterator__at_end(git_iterator *i)
+static int empty_iterator_reset(git_iterator *i)
 {
 	GIT_UNUSED(i);
-	return 1;
+	return 0;
 }
 
-static void empty_iterator__free(git_iterator *i)
+static void empty_iterator_free(git_iterator *i)
 {
 	GIT_UNUSED(i);
 }
@@ -147,1347 +386,2029 @@ typedef struct {
 } empty_iterator;
 
 int git_iterator_for_nothing(
-	git_iterator **iter,
-	git_iterator_flag_t flags,
-	const char *start,
-	const char *end)
+	git_iterator **out,
+	git_iterator_options *options)
 {
-	empty_iterator *i = git__calloc(1, sizeof(empty_iterator));
-	GITERR_CHECK_ALLOC(i);
+	empty_iterator *iter;
 
-#define empty_iterator__current empty_iterator__noop
-#define empty_iterator__advance empty_iterator__noop
-#define empty_iterator__advance_into empty_iterator__noop
+	static git_iterator_callbacks callbacks = {
+		empty_iterator_noop,
+		empty_iterator_noop,
+		empty_iterator_noop,
+		empty_iterator_advance_over,
+		empty_iterator_reset,
+		empty_iterator_free
+	};
 
-	ITERATOR_BASE_INIT(i, empty, EMPTY, NULL);
+	*out = NULL;
 
-	if ((flags & GIT_ITERATOR_IGNORE_CASE) != 0)
-		i->base.flags |= GIT_ITERATOR_IGNORE_CASE;
+	iter = git__calloc(1, sizeof(empty_iterator));
+	GIT_ERROR_CHECK_ALLOC(iter);
 
-	*iter = (git_iterator *)i;
+	iter->base.type = GIT_ITERATOR_TYPE_EMPTY;
+	iter->base.cb = &callbacks;
+	iter->base.flags = options->flags;
+
+	*out = &iter->base;
 	return 0;
 }
 
+/* Tree iterator */
+
+typedef struct {
+	git_tree_entry *tree_entry;
+	const char *parent_path;
+} tree_iterator_entry;
 
-typedef struct tree_iterator_entry tree_iterator_entry;
-struct tree_iterator_entry {
-	tree_iterator_entry *parent;
-	const git_tree_entry *te;
+typedef struct {
 	git_tree *tree;
-};
 
-typedef struct tree_iterator_frame tree_iterator_frame;
-struct tree_iterator_frame {
-	tree_iterator_frame *up, *down;
+	/* path to this particular frame (folder) */
+	git_buf path;
 
-	size_t n_entries; /* items in this frame */
-	size_t current;   /* start of currently active range in frame */
-	size_t next;      /* start of next range in frame */
+	/* a sorted list of the entries for this frame (folder), these are
+	 * actually pointers to the iterator's entry pool.
+	 */
+	git_vector entries;
+	tree_iterator_entry *current;
 
-	const char *start;
-	size_t startlen;
+	size_t next_idx;
 
-	tree_iterator_entry *entries[GIT_FLEX_ARRAY];
-};
+	/* on case insensitive iterations, we also have an array of other
+	 * paths that were case insensitively equal to this one, and their
+	 * tree objects.  we have coalesced the tree entries into this frame.
+	 * a child `tree_iterator_entry` will contain a pointer to its actual
+	 * parent path.
+	 */
+	git_vector similar_trees;
+	git_array_t(git_buf) similar_paths;
+} tree_iterator_frame;
 
 typedef struct {
 	git_iterator base;
-	git_iterator_callbacks cb;
-	tree_iterator_frame *head, *root;
-	git_pool pool;
+	git_tree *root;
+	git_array_t(tree_iterator_frame) frames;
+
 	git_index_entry entry;
-	git_buf path;
-	int path_ambiguities;
-	bool path_has_filename;
-	bool entry_is_current;
-	int (*strncomp)(const char *a, const char *b, size_t sz);
+	git_buf entry_path;
+
+	/* a pool of entries to reduce the number of allocations */
+	git_pool entry_pool;
 } tree_iterator;
 
-static char *tree_iterator__current_filename(
-	tree_iterator *ti, const git_tree_entry *te)
+GIT_INLINE(tree_iterator_frame *) tree_iterator_parent_frame(
+	tree_iterator *iter)
 {
-	if (!ti->path_has_filename) {
-		if (git_buf_joinpath(&ti->path, ti->path.ptr, te->filename) < 0)
-			return NULL;
-
-		if (git_tree_entry__is_tree(te) && git_buf_putc(&ti->path, '/') < 0)
-			return NULL;
-
-		ti->path_has_filename = true;
-	}
-
-	return ti->path.ptr;
+	return iter->frames.size > 1 ?
+		&iter->frames.ptr[iter->frames.size-2] : NULL;
 }
 
-static void tree_iterator__rewrite_filename(tree_iterator *ti)
+GIT_INLINE(tree_iterator_frame *) tree_iterator_current_frame(
+	tree_iterator *iter)
 {
-	tree_iterator_entry *scan = ti->head->entries[ti->head->current];
-	ssize_t strpos = ti->path.size;
-	const git_tree_entry *te;
-
-	if (strpos && ti->path.ptr[strpos - 1] == '/')
-		strpos--;
-
-	for (; scan && (te = scan->te); scan = scan->parent) {
-		strpos -= te->filename_len;
-		memcpy(&ti->path.ptr[strpos], te->filename, te->filename_len);
-		strpos -= 1; /* separator */
-	}
+	return iter->frames.size ? &iter->frames.ptr[iter->frames.size-1] : NULL;
 }
 
-static int tree_iterator__te_cmp(
-	const git_tree_entry *a,
-	const git_tree_entry *b,
-	int (*compare)(const char *, const char *, size_t))
+GIT_INLINE(int) tree_entry_cmp(
+	const git_tree_entry *a, const git_tree_entry *b, bool icase)
 {
 	return git_path_cmp(
 		a->filename, a->filename_len, a->attr == GIT_FILEMODE_TREE,
 		b->filename, b->filename_len, b->attr == GIT_FILEMODE_TREE,
-		compare);
+		icase ? git__strncasecmp : git__strncmp);
 }
 
-static int tree_iterator__ci_cmp(const void *a, const void *b, void *p)
+GIT_INLINE(int) tree_iterator_entry_cmp_icase(
+	const void *ptr_a, const void *ptr_b)
 {
-	const tree_iterator_entry *ae = a, *be = b;
-	int cmp = tree_iterator__te_cmp(ae->te, be->te, git__strncasecmp);
-
-	if (!cmp) {
-		/* stabilize sort order among equivalent names */
-		if (!ae->parent->te || !be->parent->te)
-			cmp = tree_iterator__te_cmp(ae->te, be->te, git__strncmp);
-		else
-			cmp = tree_iterator__ci_cmp(ae->parent, be->parent, p);
-	}
+	const tree_iterator_entry *a = (const tree_iterator_entry *)ptr_a;
+	const tree_iterator_entry *b = (const tree_iterator_entry *)ptr_b;
 
-	return cmp;
+	return tree_entry_cmp(a->tree_entry, b->tree_entry, true);
 }
 
-static int tree_iterator__search_cmp(const void *key, const void *val, void *p)
+static int tree_iterator_entry_sort_icase(const void *ptr_a, const void *ptr_b)
 {
-	const tree_iterator_frame *tf = key;
-	const git_tree_entry *te = ((tree_iterator_entry *)val)->te;
+	const tree_iterator_entry *a = (const tree_iterator_entry *)ptr_a;
+	const tree_iterator_entry *b = (const tree_iterator_entry *)ptr_b;
 
-	return git_path_cmp(
-		tf->start, tf->startlen, false,
-		te->filename, te->filename_len, te->attr == GIT_FILEMODE_TREE,
-		((tree_iterator *)p)->strncomp);
+	int c = tree_entry_cmp(a->tree_entry, b->tree_entry, true);
+
+	/* stabilize the sort order for filenames that are (case insensitively)
+	 * the same by examining the parent path (case sensitively) before
+	 * falling back to a case sensitive sort of the filename.
+	 */
+	if (!c && a->parent_path != b->parent_path)
+		c = git__strcmp(a->parent_path, b->parent_path);
+
+	if (!c)
+		c = tree_entry_cmp(a->tree_entry, b->tree_entry, false);
+
+	return c;
 }
 
-static bool tree_iterator__move_to_next(
-	tree_iterator *ti, tree_iterator_frame *tf)
+static int tree_iterator_compute_path(
+	git_buf *out,
+	tree_iterator_entry *entry)
 {
-	if (tf->next > tf->current + 1)
-		ti->path_ambiguities--;
+	git_buf_clear(out);
 
-	if (!tf->up) { /* at root */
-		tf->current = tf->next;
-		return false;
-	}
+	if (entry->parent_path)
+		git_buf_joinpath(out, entry->parent_path, entry->tree_entry->filename);
+	else
+		git_buf_puts(out, entry->tree_entry->filename);
 
-	for (; tf->current < tf->next; tf->current++) {
-		git_tree_free(tf->entries[tf->current]->tree);
-		tf->entries[tf->current]->tree = NULL;
-	}
+	if (git_tree_entry__is_tree(entry->tree_entry))
+		git_buf_putc(out, '/');
+
+	if (git_buf_oom(out))
+		return -1;
 
-	return (tf->current < tf->n_entries);
+	return 0;
 }
 
-static int tree_iterator__set_next(tree_iterator *ti, tree_iterator_frame *tf)
+static int tree_iterator_frame_init(
+	tree_iterator *iter,
+	git_tree *tree,
+	tree_iterator_entry *frame_entry)
 {
+	tree_iterator_frame *new_frame = NULL;
+	tree_iterator_entry *new_entry;
+	git_tree *dup = NULL;
+	git_tree_entry *tree_entry;
+	git_vector_cmp cmp;
+	size_t i;
 	int error = 0;
-	const git_tree_entry *te, *last = NULL;
 
-	tf->next = tf->current;
+	new_frame = git_array_alloc(iter->frames);
+	GIT_ERROR_CHECK_ALLOC(new_frame);
 
-	for (; tf->next < tf->n_entries; tf->next++, last = te) {
-		te = tf->entries[tf->next]->te;
+	memset(new_frame, 0, sizeof(tree_iterator_frame));
 
-		if (last && tree_iterator__te_cmp(last, te, ti->strncomp))
-			break;
+	if ((error = git_tree_dup(&dup, tree)) < 0)
+		goto done;
+
+	memset(new_frame, 0x0, sizeof(tree_iterator_frame));
+	new_frame->tree = dup;
+
+	if (frame_entry &&
+		(error = tree_iterator_compute_path(&new_frame->path, frame_entry)) < 0)
+		goto done;
+
+	cmp = iterator__ignore_case(&iter->base) ?
+		tree_iterator_entry_sort_icase : NULL;
 
-		/* try to load trees for items in [current,next) range */
-		if (!error && git_tree_entry__is_tree(te))
-			error = git_tree_lookup(
-				&tf->entries[tf->next]->tree, ti->base.repo, &te->oid);
+	if ((error = git_vector_init(
+		&new_frame->entries, dup->entries.size, cmp)) < 0)
+		goto done;
+
+	git_array_foreach(dup->entries, i, tree_entry) {
+		new_entry = git_pool_malloc(&iter->entry_pool, 1);
+		GIT_ERROR_CHECK_ALLOC(new_entry);
+
+		new_entry->tree_entry = tree_entry;
+		new_entry->parent_path = new_frame->path.ptr;
+
+		if ((error = git_vector_insert(&new_frame->entries, new_entry)) < 0)
+			goto done;
 	}
 
-	if (tf->next > tf->current + 1)
-		ti->path_ambiguities++;
+	git_vector_set_sorted(&new_frame->entries,
+		!iterator__ignore_case(&iter->base));
 
-	/* if a tree lookup failed, advance over this span and return failure */
+done:
 	if (error < 0) {
-		tree_iterator__move_to_next(ti, tf);
-		return error;
+		git_tree_free(dup);
+		git_array_pop(iter->frames);
 	}
 
-	if (last && !tree_iterator__current_filename(ti, last))
-		return -1; /* must have been allocation failure */
-
-	return 0;
+	return error;
 }
 
-GIT_INLINE(bool) tree_iterator__at_tree(tree_iterator *ti)
+GIT_INLINE(tree_iterator_entry *) tree_iterator_current_entry(
+	tree_iterator_frame *frame)
 {
-	return (ti->head->current < ti->head->n_entries &&
-			ti->head->entries[ti->head->current]->tree != NULL);
+	return frame->current;
 }
 
-static int tree_iterator__push_frame(tree_iterator *ti)
+GIT_INLINE(int) tree_iterator_frame_push_neighbors(
+	tree_iterator *iter,
+	tree_iterator_frame *parent_frame,
+	tree_iterator_frame *frame,
+	const char *filename)
 {
+	tree_iterator_entry *entry, *new_entry;
+	git_tree *tree = NULL;
+	git_tree_entry *tree_entry;
+	git_buf *path;
+	size_t new_size, i;
 	int error = 0;
-	tree_iterator_frame *head = ti->head, *tf = NULL;
-	size_t i, n_entries = 0;
 
-	if (head->current >= head->n_entries || !head->entries[head->current]->tree)
-		return GIT_ITEROVER;
+	while (parent_frame->next_idx < parent_frame->entries.length) {
+		entry = parent_frame->entries.contents[parent_frame->next_idx];
+
+		if (strcasecmp(filename, entry->tree_entry->filename) != 0)
+			break;
+
+		if ((error = git_tree_lookup(&tree,
+			iter->base.repo, entry->tree_entry->oid)) < 0)
+			break;
 
-	for (i = head->current; i < head->next; ++i)
-		n_entries += git_tree_entrycount(head->entries[i]->tree);
+		if (git_vector_insert(&parent_frame->similar_trees, tree) < 0)
+			break;
 
-	tf = git__calloc(sizeof(tree_iterator_frame) +
-		n_entries * sizeof(tree_iterator_entry *), 1);
-	GITERR_CHECK_ALLOC(tf);
+		path = git_array_alloc(parent_frame->similar_paths);
+		GIT_ERROR_CHECK_ALLOC(path);
 
-	tf->n_entries = n_entries;
+		memset(path, 0, sizeof(git_buf));
 
-	tf->up     = head;
-	head->down = tf;
-	ti->head   = tf;
+		if ((error = tree_iterator_compute_path(path, entry)) < 0)
+			break;
 
-	for (i = head->current, n_entries = 0; i < head->next; ++i) {
-		git_tree *tree = head->entries[i]->tree;
-		size_t j, max_j = git_tree_entrycount(tree);
+		GIT_ERROR_CHECK_ALLOC_ADD(&new_size,
+			frame->entries.length, tree->entries.size);
+		git_vector_size_hint(&frame->entries, new_size);
 
-		for (j = 0; j < max_j; ++j) {
-			tree_iterator_entry *entry = git_pool_malloc(&ti->pool, 1);
-			GITERR_CHECK_ALLOC(entry);
+		git_array_foreach(tree->entries, i, tree_entry) {
+			new_entry = git_pool_malloc(&iter->entry_pool, 1);
+			GIT_ERROR_CHECK_ALLOC(new_entry);
 
-			entry->parent = head->entries[i];
-			entry->te     = git_tree_entry_byindex(tree, j);
-			entry->tree   = NULL;
+			new_entry->tree_entry = tree_entry;
+			new_entry->parent_path = path->ptr;
 
-			tf->entries[n_entries++] = entry;
+			if ((error = git_vector_insert(&frame->entries, new_entry)) < 0)
+				break;
 		}
-	}
 
-	/* if ignore_case, sort entries case insensitively */
-	if (iterator__ignore_case(ti))
-		git__tsort_r(
-			(void **)tf->entries, tf->n_entries, tree_iterator__ci_cmp, tf);
+		if (error)
+			break;
 
-	/* pick tf->current based on "start" (or start at zero) */
-	if (head->startlen > 0) {
-		git__bsearch_r((void **)tf->entries, tf->n_entries, head,
-			tree_iterator__search_cmp, ti, &tf->current);
+		parent_frame->next_idx++;
+	}
 
-		while (tf->current &&
-			   !tree_iterator__search_cmp(head, tf->entries[tf->current-1], ti))
-			tf->current--;
+	return error;
+}
 
-		if ((tf->start = strchr(head->start, '/')) != NULL) {
-			tf->start++;
-			tf->startlen = strlen(tf->start);
-		}
-	}
+GIT_INLINE(int) tree_iterator_frame_push(
+	tree_iterator *iter, tree_iterator_entry *entry)
+{
+	tree_iterator_frame *parent_frame, *frame;
+	git_tree *tree = NULL;
+	int error;
 
-	ti->path_has_filename = ti->entry_is_current = false;
+	if ((error = git_tree_lookup(&tree,
+			iter->base.repo, entry->tree_entry->oid)) < 0 ||
+		(error = tree_iterator_frame_init(iter, tree, entry)) < 0)
+		goto done;
 
-	if ((error = tree_iterator__set_next(ti, tf)) < 0)
-		return error;
+	parent_frame = tree_iterator_parent_frame(iter);
+	frame = tree_iterator_current_frame(iter);
 
-	/* autoexpand as needed */
-	if (!iterator__include_trees(ti) && tree_iterator__at_tree(ti))
-		return tree_iterator__push_frame(ti);
+	/* if we're case insensitive, then we may have another directory that
+	 * is (case insensitively) equal to this one.  coalesce those children
+	 * into this tree.
+	 */
+	if (iterator__ignore_case(&iter->base))
+		error = tree_iterator_frame_push_neighbors(iter,
+			parent_frame, frame, entry->tree_entry->filename);
 
-	return 0;
+done:
+	git_tree_free(tree);
+	return error;
 }
 
-static bool tree_iterator__pop_frame(tree_iterator *ti, bool final)
+static void tree_iterator_frame_pop(tree_iterator *iter)
 {
-	tree_iterator_frame *tf = ti->head;
+	tree_iterator_frame *frame;
+	git_buf *buf = NULL;
+	git_tree *tree;
+	size_t i;
 
-	if (!tf->up)
-		return false;
+	assert(iter->frames.size);
 
-	ti->head = tf->up;
-	ti->head->down = NULL;
+	frame = git_array_pop(iter->frames);
 
-	tree_iterator__move_to_next(ti, tf);
+	git_vector_free(&frame->entries);
+	git_tree_free(frame->tree);
 
-	if (!final) { /* if final, don't bother to clean up */
-		git_pool_free_array(&ti->pool, tf->n_entries, (void **)tf->entries);
-		git_buf_rtruncate_at_char(&ti->path, '/');
-	}
+	do {
+		buf = git_array_pop(frame->similar_paths);
+		git_buf_dispose(buf);
+	} while (buf != NULL);
 
-	git__free(tf);
+	git_array_clear(frame->similar_paths);
 
-	return true;
+	git_vector_foreach(&frame->similar_trees, i, tree)
+		git_tree_free(tree);
+
+	git_vector_free(&frame->similar_trees);
+
+	git_buf_dispose(&frame->path);
 }
 
-static void tree_iterator__pop_all(tree_iterator *ti, bool to_end, bool final)
+static int tree_iterator_current(
+	const git_index_entry **out, git_iterator *i)
 {
-	while (tree_iterator__pop_frame(ti, final)) /* pop to root */;
+	tree_iterator *iter = (tree_iterator *)i;
 
-	if (!final) {
-		ti->head->current = to_end ? ti->head->n_entries : 0;
-		ti->path_ambiguities = 0;
-		git_buf_clear(&ti->path);
+	if (!iterator__has_been_accessed(i))
+		return iter->base.cb->advance(out, i);
+
+	if (!iter->frames.size) {
+		*out = NULL;
+		return GIT_ITEROVER;
 	}
+
+	*out = &iter->entry;
+	return 0;
 }
 
-static int tree_iterator__update_entry(tree_iterator *ti)
+static void tree_iterator_set_current(
+	tree_iterator *iter,
+	tree_iterator_frame *frame,
+	tree_iterator_entry *entry)
 {
-	tree_iterator_frame *tf;
-    const git_tree_entry *te;
+	git_tree_entry *tree_entry = entry->tree_entry;
 
-	if (ti->entry_is_current)
-        return 0;
+	frame->current = entry;
 
-	tf = ti->head;
-    te = tf->entries[tf->current]->te;
+	memset(&iter->entry, 0x0, sizeof(git_index_entry));
+
+	iter->entry.mode = tree_entry->attr;
+	iter->entry.path = iter->entry_path.ptr;
+	git_oid_cpy(&iter->entry.id, tree_entry->oid);
+}
 
-	ti->entry.mode = te->attr;
-	git_oid_cpy(&ti->entry.oid, &te->oid);
+static int tree_iterator_advance(const git_index_entry **out, git_iterator *i)
+{
+	tree_iterator *iter = (tree_iterator *)i;
+	int error = 0;
 
-	ti->entry.path = tree_iterator__current_filename(ti, te);
-	GITERR_CHECK_ALLOC(ti->entry.path);
+	iter->base.flags |= GIT_ITERATOR_FIRST_ACCESS;
 
-	if (ti->path_ambiguities > 0)
-		tree_iterator__rewrite_filename(ti);
+	/* examine tree entries until we find the next one to return */
+	while (true) {
+		tree_iterator_entry *prev_entry, *entry;
+		tree_iterator_frame *frame;
+		bool is_tree;
 
-	if (iterator__past_end(ti, ti->entry.path)) {
-		tree_iterator__pop_all(ti, true, false);
-		return GIT_ITEROVER;
-	}
+		if ((frame = tree_iterator_current_frame(iter)) == NULL) {
+			error = GIT_ITEROVER;
+			break;
+		}
 
-	ti->entry_is_current = true;
+		/* no more entries in this frame.  pop the frame out */
+		if (frame->next_idx == frame->entries.length) {
+			tree_iterator_frame_pop(iter);
+			continue;
+		}
 
-	return 0;
-}
+		/* we may have coalesced the contents of case-insensitively same-named
+		 * directories, so do the sort now.
+		 */
+		if (frame->next_idx == 0 && !git_vector_is_sorted(&frame->entries))
+			git_vector_sort(&frame->entries);
+
+		/* we have more entries in the current frame, that's our next entry */
+		prev_entry = tree_iterator_current_entry(frame);
+		entry = frame->entries.contents[frame->next_idx];
+		frame->next_idx++;
+
+		/* we can have collisions when iterating case insensitively.  (eg,
+		 * 'A/a' and 'a/A').  squash this one if it's already been seen.
+		 */
+		if (iterator__ignore_case(&iter->base) &&
+			prev_entry &&
+			tree_iterator_entry_cmp_icase(prev_entry, entry) == 0)
+			continue;
+
+		if ((error = tree_iterator_compute_path(&iter->entry_path, entry)) < 0)
+			break;
 
-static int tree_iterator__current(
-	const git_index_entry **entry, git_iterator *self)
-{
-	int error;
-	tree_iterator *ti = (tree_iterator *)self;
-	tree_iterator_frame *tf = ti->head;
+		/* if this path is before our start, advance over this entry */
+		if (!iterator_has_started(&iter->base, iter->entry_path.ptr, false))
+			continue;
 
-	iterator__clear_entry(entry);
+		/* if this path is after our end, stop */
+		if (iterator_has_ended(&iter->base, iter->entry_path.ptr)) {
+			error = GIT_ITEROVER;
+			break;
+		}
 
-	if (tf->current >= tf->n_entries)
-		return GIT_ITEROVER;
+		/* if we have a list of paths we're interested in, examine it */
+		if (!iterator_pathlist_next_is(&iter->base, iter->entry_path.ptr))
+			continue;
 
-	if ((error = tree_iterator__update_entry(ti)) < 0)
-		return error;
+		is_tree = git_tree_entry__is_tree(entry->tree_entry);
 
-	if (entry)
-		*entry = &ti->entry;
+		/* if we are *not* including trees then advance over this entry */
+		if (is_tree && !iterator__include_trees(iter)) {
 
-	ti->base.flags |= GIT_ITERATOR_FIRST_ACCESS;
+			/* if we've found a tree (and are not returning it to the caller)
+			 * and we are autoexpanding, then we want to return the first
+			 * child.  push the new directory and advance.
+			 */
+			if (iterator__do_autoexpand(iter)) {
+				if ((error = tree_iterator_frame_push(iter, entry)) < 0)
+					break;
+			}
 
-	return 0;
-}
+			continue;
+		}
 
-static int tree_iterator__advance_into(
-	const git_index_entry **entry, git_iterator *self)
-{
-	int error = 0;
-	tree_iterator *ti = (tree_iterator *)self;
+		tree_iterator_set_current(iter, frame, entry);
 
-	iterator__clear_entry(entry);
+		/* if we are autoexpanding, then push this as a new frame, so that
+		 * the next call to `advance` will dive into this directory.
+		 */
+		if (is_tree && iterator__do_autoexpand(iter))
+			error = tree_iterator_frame_push(iter, entry);
 
-	if (tree_iterator__at_tree(ti))
-		error = tree_iterator__push_frame(ti);
+		break;
+	}
 
-	if (!error && entry)
-		error = tree_iterator__current(entry, self);
+	if (out)
+		*out = (error == 0) ? &iter->entry : NULL;
 
 	return error;
 }
 
-static int tree_iterator__advance(
-	const git_index_entry **entry, git_iterator *self)
+static int tree_iterator_advance_into(
+	const git_index_entry **out, git_iterator *i)
 {
+	tree_iterator *iter = (tree_iterator *)i;
+    tree_iterator_frame *frame;
+	tree_iterator_entry *prev_entry;
 	int error;
-	tree_iterator *ti = (tree_iterator *)self;
-	tree_iterator_frame *tf = ti->head;
 
-	iterator__clear_entry(entry);
+	if (out)
+		*out = NULL;
 
-	if (tf->current >= tf->n_entries)
+	if ((frame = tree_iterator_current_frame(iter)) == NULL)
 		return GIT_ITEROVER;
 
-	if (!iterator__has_been_accessed(ti))
-		return tree_iterator__current(entry, self);
+	/* get the last seen entry */
+	prev_entry = tree_iterator_current_entry(frame);
 
-	if (iterator__do_autoexpand(ti) && iterator__include_trees(ti) &&
-		tree_iterator__at_tree(ti))
-		return tree_iterator__advance_into(entry, self);
-
-	if (ti->path_has_filename) {
-		git_buf_rtruncate_at_char(&ti->path, '/');
-		ti->path_has_filename = ti->entry_is_current = false;
-	}
-
-	/* scan forward and up, advancing in frame or popping frame when done */
-	while (!tree_iterator__move_to_next(ti, tf) &&
-		   tree_iterator__pop_frame(ti, false))
-		tf = ti->head;
+	/* it's legal to call advance_into when auto-expand is on.  in this case,
+	 * we will have pushed a new (empty) frame on to the stack for this
+	 * new directory.  since it's empty, its current_entry should be null.
+	 */
+	assert(iterator__do_autoexpand(i) ^ (prev_entry != NULL));
 
-	/* find next and load trees */
-	if ((error = tree_iterator__set_next(ti, tf)) < 0)
-		return error;
+	if (prev_entry) {
+		if (!git_tree_entry__is_tree(prev_entry->tree_entry))
+			return 0;
 
-	/* deal with include_trees / auto_expand as needed */
-	if (!iterator__include_trees(ti) && tree_iterator__at_tree(ti))
-		return tree_iterator__advance_into(entry, self);
+		if ((error = tree_iterator_frame_push(iter, prev_entry)) < 0)
+			return error;
+	}
 
-	return tree_iterator__current(entry, self);
+	/* we've advanced into the directory in question, let advance
+	 * find the first entry
+	 */
+	return tree_iterator_advance(out, i);
 }
 
-static int tree_iterator__seek(git_iterator *self, const char *prefix)
+static int tree_iterator_advance_over(
+	const git_index_entry **out,
+	git_iterator_status_t *status,
+	git_iterator *i)
 {
-	GIT_UNUSED(self); GIT_UNUSED(prefix);
-	return -1;
+	*status = GIT_ITERATOR_STATUS_NORMAL;
+	return git_iterator_advance(out, i);
 }
 
-static int tree_iterator__reset(
-	git_iterator *self, const char *start, const char *end)
+static void tree_iterator_clear(tree_iterator *iter)
 {
-	tree_iterator *ti = (tree_iterator *)self;
+	while (iter->frames.size)
+		tree_iterator_frame_pop(iter);
 
-	tree_iterator__pop_all(ti, false, false);
+	git_array_clear(iter->frames);
 
-	if (iterator__reset_range(self, start, end) < 0)
-		return -1;
+	git_pool_clear(&iter->entry_pool);
+	git_buf_clear(&iter->entry_path);
 
-	return tree_iterator__push_frame(ti); /* re-expand root tree */
+	iterator_clear(&iter->base);
 }
 
-static int tree_iterator__at_end(git_iterator *self)
+static int tree_iterator_init(tree_iterator *iter)
 {
-	tree_iterator *ti = (tree_iterator *)self;
-	return (ti->head->current >= ti->head->n_entries);
-}
+	int error;
 
-static void tree_iterator__free(git_iterator *self)
-{
-	tree_iterator *ti = (tree_iterator *)self;
+	git_pool_init(&iter->entry_pool, sizeof(tree_iterator_entry));
+
+	if ((error = tree_iterator_frame_init(iter, iter->root, NULL)) < 0)
+		return error;
 
-	tree_iterator__pop_all(ti, true, false);
+	iter->base.flags &= ~GIT_ITERATOR_FIRST_ACCESS;
 
-	git_tree_free(ti->head->entries[0]->tree);
-	git__free(ti->head);
-	git_pool_clear(&ti->pool);
-	git_buf_free(&ti->path);
+	return 0;
 }
 
-static int tree_iterator__create_root_frame(tree_iterator *ti, git_tree *tree)
+static int tree_iterator_reset(git_iterator *i)
 {
-	size_t sz = sizeof(tree_iterator_frame) + sizeof(tree_iterator_entry);
-	tree_iterator_frame *root = git__calloc(sz, sizeof(char));
-	GITERR_CHECK_ALLOC(root);
+	tree_iterator *iter = (tree_iterator *)i;
 
-	root->n_entries  = 1;
-	root->next       = 1;
-	root->start      = ti->base.start;
-	root->startlen   = root->start ? strlen(root->start) : 0;
-	root->entries[0] = git_pool_mallocz(&ti->pool, 1);
-	GITERR_CHECK_ALLOC(root->entries[0]);
-	root->entries[0]->tree = tree;
+	tree_iterator_clear(iter);
+	return tree_iterator_init(iter);
+}
+
+static void tree_iterator_free(git_iterator *i)
+{
+	tree_iterator *iter = (tree_iterator *)i;
 
-	ti->head = ti->root = root;
+	tree_iterator_clear(iter);
 
-	return 0;
+	git_tree_free(iter->root);
+	git_buf_dispose(&iter->entry_path);
 }
 
 int git_iterator_for_tree(
-	git_iterator **iter,
+	git_iterator **out,
 	git_tree *tree,
-	git_iterator_flag_t flags,
-	const char *start,
-	const char *end)
+	git_iterator_options *options)
 {
+	tree_iterator *iter;
 	int error;
-	tree_iterator *ti;
 
-	if (tree == NULL)
-		return git_iterator_for_nothing(iter, flags, start, end);
+	static git_iterator_callbacks callbacks = {
+		tree_iterator_current,
+		tree_iterator_advance,
+		tree_iterator_advance_into,
+		tree_iterator_advance_over,
+		tree_iterator_reset,
+		tree_iterator_free
+	};
 
-	if ((error = git_object_dup((git_object **)&tree, (git_object *)tree)) < 0)
-		return error;
+	*out = NULL;
 
-	ti = git__calloc(1, sizeof(tree_iterator));
-	GITERR_CHECK_ALLOC(ti);
+	if (tree == NULL)
+		return git_iterator_for_nothing(out, options);
 
-	ITERATOR_BASE_INIT(ti, tree, TREE, git_tree_owner(tree));
+	iter = git__calloc(1, sizeof(tree_iterator));
+	GIT_ERROR_CHECK_ALLOC(iter);
 
-	if ((error = iterator__update_ignore_case((git_iterator *)ti, flags)) < 0)
-		goto fail;
-	ti->strncomp = iterator__ignore_case(ti) ? git__strncasecmp : git__strncmp;
+	iter->base.type = GIT_ITERATOR_TYPE_TREE;
+	iter->base.cb = &callbacks;
 
-	if ((error = git_pool_init(&ti->pool, sizeof(tree_iterator_entry),0)) < 0 ||
-		(error = tree_iterator__create_root_frame(ti, tree)) < 0 ||
-		(error = tree_iterator__push_frame(ti)) < 0) /* expand root now */
-		goto fail;
+	if ((error = iterator_init_common(&iter->base,
+			git_tree_owner(tree), NULL, options)) < 0 ||
+		(error = git_tree_dup(&iter->root, tree)) < 0 ||
+		(error = tree_iterator_init(iter)) < 0)
+		goto on_error;
 
-	*iter = (git_iterator *)ti;
+	*out = &iter->base;
 	return 0;
 
-fail:
-	git_iterator_free((git_iterator *)ti);
+on_error:
+	git_iterator_free(&iter->base);
 	return error;
 }
 
-
-typedef struct {
-	git_iterator base;
-	git_iterator_callbacks cb;
-	git_index *index;
-	size_t current;
-	/* when not in autoexpand mode, use these to represent "tree" state */
-	git_buf partial;
-	size_t partial_pos;
-	char restore_terminator;
-	git_index_entry tree_entry;
-} index_iterator;
-
-static const git_index_entry *index_iterator__index_entry(index_iterator *ii)
+int git_iterator_current_tree_entry(
+	const git_tree_entry **tree_entry, git_iterator *i)
 {
-	const git_index_entry *ie = git_index_get_byindex(ii->index, ii->current);
-
-	if (ie != NULL && iterator__past_end(ii, ie->path)) {
-		ii->current = git_index_entrycount(ii->index);
-		ie = NULL;
-	}
+	tree_iterator *iter;
+	tree_iterator_frame *frame;
+	tree_iterator_entry *entry;
 
-	return ie;
-}
+	assert(i->type == GIT_ITERATOR_TYPE_TREE);
 
-static const git_index_entry *index_iterator__skip_conflicts(index_iterator *ii)
-{
-	const git_index_entry *ie;
+	iter = (tree_iterator *)i;
 
-	while ((ie = index_iterator__index_entry(ii)) != NULL &&
-		   git_index_entry_stage(ie) != 0)
-		ii->current++;
+	frame = tree_iterator_current_frame(iter);
+	entry = tree_iterator_current_entry(frame);
 
-	return ie;
+	*tree_entry = entry->tree_entry;
+	return 0;
 }
 
-static void index_iterator__next_prefix_tree(index_iterator *ii)
+int git_iterator_current_parent_tree(
+	const git_tree **parent_tree, git_iterator *i, size_t depth)
 {
-	const char *slash;
+	tree_iterator *iter;
+	tree_iterator_frame *frame;
 
-	if (!iterator__include_trees(ii))
-		return;
+	assert(i->type == GIT_ITERATOR_TYPE_TREE);
 
-	slash = strchr(&ii->partial.ptr[ii->partial_pos], '/');
+	iter = (tree_iterator *)i;
 
-	if (slash != NULL) {
-		ii->partial_pos = (slash - ii->partial.ptr) + 1;
-		ii->restore_terminator = ii->partial.ptr[ii->partial_pos];
-		ii->partial.ptr[ii->partial_pos] = '\0';
-	} else {
-		ii->partial_pos = ii->partial.size;
-	}
+	assert(depth < iter->frames.size);
+	frame = &iter->frames.ptr[iter->frames.size-depth-1];
 
-	if (index_iterator__index_entry(ii) == NULL)
-		ii->partial_pos = ii->partial.size;
+	*parent_tree = frame->tree;
+	return 0;
 }
 
-static int index_iterator__first_prefix_tree(index_iterator *ii)
-{
-	const git_index_entry *ie = index_iterator__skip_conflicts(ii);
-	const char *scan, *prior, *slash;
+/* Filesystem iterator */
 
-	if (!ie || !iterator__include_trees(ii))
-		return 0;
+typedef struct {
+	struct stat st;
+	size_t path_len;
+	iterator_pathlist_search_t match;
+	git_oid id;
+	char path[GIT_FLEX_ARRAY];
+} filesystem_iterator_entry;
 
-	/* find longest common prefix with prior index entry */
-	for (scan = slash = ie->path, prior = ii->partial.ptr;
-		 *scan && *scan == *prior; ++scan, ++prior)
-		if (*scan == '/')
-			slash = scan;
+typedef struct {
+	git_vector entries;
+	git_pool entry_pool;
+	size_t next_idx;
 
-	if (git_buf_sets(&ii->partial, ie->path) < 0)
-		return -1;
+	size_t path_len;
+	int is_ignored;
+} filesystem_iterator_frame;
+
+typedef struct {
+	git_iterator base;
+	char *root;
+	size_t root_len;
 
-	ii->partial_pos = (slash - ie->path) + 1;
-	index_iterator__next_prefix_tree(ii);
+	unsigned int dirload_flags;
 
-	return 0;
-}
+	git_tree *tree;
+	git_index *index;
+	git_vector index_snapshot;
 
-#define index_iterator__at_tree(I) \
-	(iterator__include_trees(I) && (I)->partial_pos < (I)->partial.size)
+	git_array_t(filesystem_iterator_frame) frames;
+	git_ignores ignores;
+
+	/* info about the current entry */
+	git_index_entry entry;
+	git_buf current_path;
+	int current_is_ignored;
+
+	/* temporary buffer for advance_over */
+	git_buf tmp_buf;
+} filesystem_iterator;
 
-static int index_iterator__current(
-	const git_index_entry **entry, git_iterator *self)
+
+GIT_INLINE(filesystem_iterator_frame *) filesystem_iterator_parent_frame(
+	filesystem_iterator *iter)
 {
-	index_iterator *ii = (index_iterator *)self;
-	const git_index_entry *ie = git_index_get_byindex(ii->index, ii->current);
+	return iter->frames.size > 1 ?
+		&iter->frames.ptr[iter->frames.size-2] : NULL;
+}
 
-	if (ie != NULL && index_iterator__at_tree(ii)) {
-		ii->tree_entry.path = ii->partial.ptr;
-		ie = &ii->tree_entry;
-	}
+GIT_INLINE(filesystem_iterator_frame *) filesystem_iterator_current_frame(
+	filesystem_iterator *iter)
+{
+	return iter->frames.size ? &iter->frames.ptr[iter->frames.size-1] : NULL;
+}
 
-	if (entry)
-		*entry = ie;
+GIT_INLINE(filesystem_iterator_entry *) filesystem_iterator_current_entry(
+	filesystem_iterator_frame *frame)
+{
+	return frame->next_idx == 0 ?
+		NULL : frame->entries.contents[frame->next_idx-1];
+}
 
-	ii->base.flags |= GIT_ITERATOR_FIRST_ACCESS;
+static int filesystem_iterator_entry_cmp(const void *_a, const void *_b)
+{
+	const filesystem_iterator_entry *a = (const filesystem_iterator_entry *)_a;
+	const filesystem_iterator_entry *b = (const filesystem_iterator_entry *)_b;
 
-	return (ie != NULL) ? 0 : GIT_ITEROVER;
+	return git__strcmp(a->path, b->path);
 }
 
-static int index_iterator__at_end(git_iterator *self)
+static int filesystem_iterator_entry_cmp_icase(const void *_a, const void *_b)
 {
-	index_iterator *ii = (index_iterator *)self;
-	return (ii->current >= git_index_entrycount(ii->index));
+	const filesystem_iterator_entry *a = (const filesystem_iterator_entry *)_a;
+	const filesystem_iterator_entry *b = (const filesystem_iterator_entry *)_b;
+
+	return git__strcasecmp(a->path, b->path);
 }
 
-static int index_iterator__advance(
-	const git_index_entry **entry, git_iterator *self)
+#define FILESYSTEM_MAX_DEPTH 100
+
+/**
+ * Figure out if an entry is a submodule.
+ *
+ * We consider it a submodule if the path is listed as a submodule in
+ * either the tree or the index.
+ */
+static int filesystem_iterator_is_submodule(
+	bool *out, filesystem_iterator *iter, const char *path, size_t path_len)
 {
-	index_iterator *ii = (index_iterator *)self;
-	size_t entrycount = git_index_entrycount(ii->index);
-	const git_index_entry *ie;
+	bool is_submodule = false;
+	int error;
 
-	if (!iterator__has_been_accessed(ii))
-		return index_iterator__current(entry, self);
+	*out = false;
 
-	if (index_iterator__at_tree(ii)) {
-		if (iterator__do_autoexpand(ii)) {
-			ii->partial.ptr[ii->partial_pos] = ii->restore_terminator;
-			index_iterator__next_prefix_tree(ii);
-		} else {
-			/* advance to sibling tree (i.e. find entry with new prefix) */
-			while (ii->current < entrycount) {
-				ii->current++;
+	/* first see if this path is a submodule in HEAD */
+	if (iter->tree) {
+		git_tree_entry *entry;
 
-				if (!(ie = git_index_get_byindex(ii->index, ii->current)) ||
-					ii->base.prefixcomp(ie->path, ii->partial.ptr) != 0)
-					break;
-			}
+		error = git_tree_entry_bypath(&entry, iter->tree, path);
 
-			if (index_iterator__first_prefix_tree(ii) < 0)
-				return -1;
-		}
-	} else {
-		if (ii->current < entrycount)
-			ii->current++;
+		if (error < 0 && error != GIT_ENOTFOUND)
+			return error;
 
-		if (index_iterator__first_prefix_tree(ii) < 0)
-			return -1;
+		if (!error) {
+			is_submodule = (entry->attr == GIT_FILEMODE_COMMIT);
+			git_tree_entry_free(entry);
+		}
 	}
 
-	return index_iterator__current(entry, self);
-}
+	if (!is_submodule && iter->base.index) {
+		size_t pos;
 
-static int index_iterator__advance_into(
-	const git_index_entry **entry, git_iterator *self)
-{
-	index_iterator *ii = (index_iterator *)self;
-	const git_index_entry *ie = git_index_get_byindex(ii->index, ii->current);
+		error = git_index_snapshot_find(&pos,
+			&iter->index_snapshot, iter->base.entry_srch, path, path_len, 0);
 
-	if (ie != NULL && index_iterator__at_tree(ii)) {
-		if (ii->restore_terminator)
-			ii->partial.ptr[ii->partial_pos] = ii->restore_terminator;
-		index_iterator__next_prefix_tree(ii);
-	}
+		if (error < 0 && error != GIT_ENOTFOUND)
+			return error;
 
-	return index_iterator__current(entry, self);
-}
+		if (!error) {
+			git_index_entry *e = git_vector_get(&iter->index_snapshot, pos);
+			is_submodule = (e->mode == GIT_FILEMODE_COMMIT);
+		}
+	}
 
-static int index_iterator__seek(git_iterator *self, const char *prefix)
-{
-	GIT_UNUSED(self); GIT_UNUSED(prefix);
-	return -1;
+	*out = is_submodule;
+	return 0;
 }
 
-static int index_iterator__reset(
-	git_iterator *self, const char *start, const char *end)
+static void filesystem_iterator_frame_push_ignores(
+	filesystem_iterator *iter,
+	filesystem_iterator_entry *frame_entry,
+	filesystem_iterator_frame *new_frame)
 {
-	index_iterator *ii = (index_iterator *)self;
-	const git_index_entry *ie;
+	filesystem_iterator_frame *previous_frame;
+	const char *path = frame_entry ? frame_entry->path : "";
 
-	if (iterator__reset_range(self, start, end) < 0)
-		return -1;
+	if (!iterator__honor_ignores(&iter->base))
+		return;
 
-	ii->current = ii->base.start ?
-		git_index__prefix_position(ii->index, ii->base.start) : 0;
+	if (git_ignore__lookup(&new_frame->is_ignored,
+			&iter->ignores, path, GIT_DIR_FLAG_TRUE) < 0) {
+		git_error_clear();
+		new_frame->is_ignored = GIT_IGNORE_NOTFOUND;
+	}
 
-	if ((ie = index_iterator__skip_conflicts(ii)) == NULL)
-		return 0;
+	/* if this is not the top level directory... */
+	if (frame_entry) {
+		const char *relative_path;
 
-	if (git_buf_sets(&ii->partial, ie->path) < 0)
-		return -1;
+		previous_frame = filesystem_iterator_parent_frame(iter);
 
-	ii->partial_pos = 0;
+		/* push new ignores for files in this directory */
+		relative_path = frame_entry->path + previous_frame->path_len;
 
-	if (ii->base.start) {
-		size_t startlen = strlen(ii->base.start);
+		/* inherit ignored from parent if no rule specified */
+		if (new_frame->is_ignored <= GIT_IGNORE_NOTFOUND)
+			new_frame->is_ignored = previous_frame->is_ignored;
 
-		ii->partial_pos = (startlen > ii->partial.size) ?
-			ii->partial.size : startlen;
+		git_ignore__push_dir(&iter->ignores, relative_path);
 	}
-
-	index_iterator__next_prefix_tree(ii);
-
-	return 0;
 }
 
-static void index_iterator__free(git_iterator *self)
+static void filesystem_iterator_frame_pop_ignores(
+	filesystem_iterator *iter)
 {
-	index_iterator *ii = (index_iterator *)self;
-	git_index_free(ii->index);
-	ii->index = NULL;
-
-	git_buf_free(&ii->partial);
+	if (iterator__honor_ignores(&iter->base))
+		git_ignore__pop_dir(&iter->ignores);
 }
 
-int git_iterator_for_index(
-	git_iterator **iter,
-	git_index  *index,
-	git_iterator_flag_t flags,
-	const char *start,
-	const char *end)
+GIT_INLINE(bool) filesystem_iterator_examine_path(
+	bool *is_dir_out,
+	iterator_pathlist_search_t *match_out,
+	filesystem_iterator *iter,
+	filesystem_iterator_entry *frame_entry,
+	const char *path,
+	size_t path_len)
 {
-	index_iterator *ii = git__calloc(1, sizeof(index_iterator));
-	GITERR_CHECK_ALLOC(ii);
+	bool is_dir = 0;
+	iterator_pathlist_search_t match = ITERATOR_PATHLIST_FULL;
+
+	*is_dir_out = false;
+	*match_out = ITERATOR_PATHLIST_NONE;
+
+	if (iter->base.start_len) {
+		int cmp = iter->base.strncomp(path, iter->base.start, path_len);
+
+		/* we haven't stat'ed `path` yet, so we don't yet know if it's a
+		 * directory or not.  special case if the current path may be a
+		 * directory that matches the start prefix.
+		 */
+		if (cmp == 0) {
+			if (iter->base.start[path_len] == '/')
+				is_dir = true;
 
-	ITERATOR_BASE_INIT(ii, index, INDEX, git_index_owner(index));
+			else if (iter->base.start[path_len] != '\0')
+				cmp = -1;
+		}
 
-	if (index->ignore_case) {
-		ii->base.flags |= GIT_ITERATOR_IGNORE_CASE;
-		ii->base.prefixcomp = git__prefixcmp_icase;
+		if (cmp < 0)
+			return false;
 	}
 
-	ii->index = index;
-	GIT_REFCOUNT_INC(index);
+	if (iter->base.end_len) {
+		int cmp = iter->base.strncomp(path, iter->base.end, iter->base.end_len);
 
-	git_buf_init(&ii->partial, 0);
-	ii->tree_entry.mode = GIT_FILEMODE_TREE;
+		if (cmp > 0)
+			return false;
+	}
 
-	index_iterator__reset((git_iterator *)ii, NULL, NULL);
+	/* if we have a pathlist that we're limiting to, examine this path now
+	 * to avoid a `stat` if we're not interested in the path.
+	 */
+	if (iter->base.pathlist.length) {
+		/* if our parent was explicitly included, so too are we */
+		if (frame_entry && frame_entry->match != ITERATOR_PATHLIST_IS_PARENT)
+			match = ITERATOR_PATHLIST_FULL;
+		else
+			match = iterator_pathlist_search(&iter->base, path, path_len);
 
-	*iter = (git_iterator *)ii;
+		if (match == ITERATOR_PATHLIST_NONE)
+			return false;
 
-	return 0;
+		/* Ensure that the pathlist entry lines up with what we expected */
+		if (match == ITERATOR_PATHLIST_IS_DIR ||
+			match == ITERATOR_PATHLIST_IS_PARENT)
+			is_dir = true;
+	}
+
+	*is_dir_out = is_dir;
+	*match_out = match;
+	return true;
 }
 
+GIT_INLINE(bool) filesystem_iterator_is_dot_git(
+	filesystem_iterator *iter, const char *path, size_t path_len)
+{
+	size_t len;
 
-typedef struct fs_iterator_frame fs_iterator_frame;
-struct fs_iterator_frame {
-	fs_iterator_frame *next;
-	git_vector entries;
-	size_t index;
-};
+	if (!iterator__ignore_dot_git(&iter->base))
+		return false;
 
-typedef struct fs_iterator fs_iterator;
-struct fs_iterator {
-	git_iterator base;
-	git_iterator_callbacks cb;
-	fs_iterator_frame *stack;
-	git_index_entry entry;
-	git_buf path;
-	size_t root_len;
-	int depth;
+	if ((len = path_len) < 4)
+		return false;
 
-	int (*enter_dir_cb)(fs_iterator *self);
-	int (*leave_dir_cb)(fs_iterator *self);
-	int (*update_entry_cb)(fs_iterator *self);
-};
+	if (path[len - 1] == '/')
+		len--;
 
-#define FS_MAX_DEPTH 100
+	if (git__tolower(path[len - 1]) != 't' ||
+		git__tolower(path[len - 2]) != 'i' ||
+		git__tolower(path[len - 3]) != 'g' ||
+		git__tolower(path[len - 4]) != '.')
+		return false;
 
-static fs_iterator_frame *fs_iterator__alloc_frame(fs_iterator *fi)
+	return (len == 4 || path[len - 5] == '/');
+}
+
+static int filesystem_iterator_entry_hash(
+	filesystem_iterator *iter,
+	filesystem_iterator_entry *entry)
 {
-	fs_iterator_frame *ff = git__calloc(1, sizeof(fs_iterator_frame));
-	git_vector_cmp entry_compare = CASESELECT(
-		iterator__ignore_case(fi),
-		git_path_with_stat_cmp_icase, git_path_with_stat_cmp);
+	git_buf fullpath = GIT_BUF_INIT;
+	int error;
 
-	if (ff && git_vector_init(&ff->entries, 0, entry_compare) < 0) {
-		git__free(ff);
-		ff = NULL;
+	if (S_ISDIR(entry->st.st_mode)) {
+		memset(&entry->id, 0, GIT_OID_RAWSZ);
+		return 0;
 	}
 
-	return ff;
-}
+	if (iter->base.type == GIT_ITERATOR_TYPE_WORKDIR)
+		return git_repository_hashfile(&entry->id,
+			iter->base.repo, entry->path, GIT_OBJECT_BLOB, NULL);
 
-static void fs_iterator__free_frame(fs_iterator_frame *ff)
-{
-	size_t i;
-	git_path_with_stat *path;
+	if (!(error = git_buf_joinpath(&fullpath, iter->root, entry->path)))
+		error = git_odb_hashfile(&entry->id, fullpath.ptr, GIT_OBJECT_BLOB);
 
-	git_vector_foreach(&ff->entries, i, path)
-		git__free(path);
-	git_vector_free(&ff->entries);
-	git__free(ff);
+	git_buf_dispose(&fullpath);
+	return error;
 }
 
-static void fs_iterator__pop_frame(
-	fs_iterator *fi, fs_iterator_frame *ff, bool pop_last)
+static int filesystem_iterator_entry_init(
+	filesystem_iterator_entry **out,
+	filesystem_iterator *iter,
+	filesystem_iterator_frame *frame,
+	const char *path,
+	size_t path_len,
+	struct stat *statbuf,
+	iterator_pathlist_search_t pathlist_match)
 {
-	if (fi && fi->stack == ff) {
-		if (!ff->next && !pop_last) {
-			memset(&fi->entry, 0, sizeof(fi->entry));
-			return;
-		}
+	filesystem_iterator_entry *entry;
+	size_t entry_size;
+	int error = 0;
 
-		if (fi->leave_dir_cb)
-			(void)fi->leave_dir_cb(fi);
+	*out = NULL;
 
-		fi->stack = ff->next;
-		fi->depth--;
-	}
+	/* Make sure to append two bytes, one for the path's null
+	 * termination, one for a possible trailing '/' for folders.
+	 */
+	GIT_ERROR_CHECK_ALLOC_ADD(&entry_size,
+		sizeof(filesystem_iterator_entry), path_len);
+	GIT_ERROR_CHECK_ALLOC_ADD(&entry_size, entry_size, 2);
 
-	fs_iterator__free_frame(ff);
-}
+	entry = git_pool_malloc(&frame->entry_pool, entry_size);
+	GIT_ERROR_CHECK_ALLOC(entry);
 
-static int fs_iterator__update_entry(fs_iterator *fi);
-static int fs_iterator__advance_over(
-	const git_index_entry **entry, git_iterator *self);
+	entry->path_len = path_len;
+	entry->match = pathlist_match;
+	memcpy(entry->path, path, path_len);
+	memcpy(&entry->st, statbuf, sizeof(struct stat));
 
-static int fs_iterator__entry_cmp(const void *i, const void *item)
-{
-	const fs_iterator *fi = (const fs_iterator *)i;
-	const git_path_with_stat *ps = item;
-	return fi->base.prefixcomp(fi->base.start, ps->path);
-}
+	/* Suffix directory paths with a '/' */
+	if (S_ISDIR(entry->st.st_mode))
+		entry->path[entry->path_len++] = '/';
 
-static void fs_iterator__seek_frame_start(
-	fs_iterator *fi, fs_iterator_frame *ff)
-{
-	if (!ff)
-		return;
+	entry->path[entry->path_len] = '\0';
 
-	if (fi->base.start)
-		git_vector_bsearch2(
-			&ff->index, &ff->entries, fs_iterator__entry_cmp, fi);
-	else
-		ff->index = 0;
+	if (iter->base.flags & GIT_ITERATOR_INCLUDE_HASH)
+		error = filesystem_iterator_entry_hash(iter, entry);
+
+	if (!error)
+		*out = entry;
+
+	return error;
 }
 
-static int fs_iterator__expand_dir(fs_iterator *fi)
+static int filesystem_iterator_frame_push(
+	filesystem_iterator *iter,
+	filesystem_iterator_entry *frame_entry)
 {
+	filesystem_iterator_frame *new_frame = NULL;
+	git_path_diriter diriter = GIT_PATH_DIRITER_INIT;
+	git_buf root = GIT_BUF_INIT;
+	const char *path;
+	filesystem_iterator_entry *entry;
+	struct stat statbuf;
+	size_t path_len;
 	int error;
-	fs_iterator_frame *ff;
 
-	if (fi->depth > FS_MAX_DEPTH) {
-		giterr_set(GITERR_REPOSITORY,
-			"Directory nesting is too deep (%d)", fi->depth);
+	if (iter->frames.size == FILESYSTEM_MAX_DEPTH) {
+		git_error_set(GIT_ERROR_REPOSITORY,
+			"directory nesting too deep (%"PRIuZ")", iter->frames.size);
 		return -1;
 	}
 
-	ff = fs_iterator__alloc_frame(fi);
-	GITERR_CHECK_ALLOC(ff);
+	new_frame = git_array_alloc(iter->frames);
+	GIT_ERROR_CHECK_ALLOC(new_frame);
 
-	error = git_path_dirload_with_stat(
-		fi->path.ptr, fi->root_len, iterator__ignore_case(fi),
-		fi->base.start, fi->base.end, &ff->entries);
+	memset(new_frame, 0, sizeof(filesystem_iterator_frame));
 
-	if (error < 0) {
-		fs_iterator__free_frame(ff);
-		fs_iterator__advance_over(NULL, (git_iterator *)fi);
-		return error;
+	if (frame_entry)
+		git_buf_joinpath(&root, iter->root, frame_entry->path);
+	else
+		git_buf_puts(&root, iter->root);
+
+	if (git_buf_oom(&root)) {
+		error = -1;
+		goto done;
 	}
 
-	if (ff->entries.length == 0) {
-		fs_iterator__free_frame(ff);
-		return GIT_ENOTFOUND;
+	new_frame->path_len = frame_entry ? frame_entry->path_len : 0;
+
+	/* Any error here is equivalent to the dir not existing, skip over it */
+	if ((error = git_path_diriter_init(
+			&diriter, root.ptr, iter->dirload_flags)) < 0) {
+		error = GIT_ENOTFOUND;
+		goto done;
 	}
 
-	fs_iterator__seek_frame_start(fi, ff);
+	if ((error = git_vector_init(&new_frame->entries, 64,
+			iterator__ignore_case(&iter->base) ?
+			filesystem_iterator_entry_cmp_icase :
+			filesystem_iterator_entry_cmp)) < 0)
+		goto done;
 
-	ff->next  = fi->stack;
-	fi->stack = ff;
-	fi->depth++;
+	git_pool_init(&new_frame->entry_pool, 1);
 
-	if (fi->enter_dir_cb && (error = fi->enter_dir_cb(fi)) < 0)
-		return error;
+	/* check if this directory is ignored */
+	filesystem_iterator_frame_push_ignores(iter, frame_entry, new_frame);
+
+	while ((error = git_path_diriter_next(&diriter)) == 0) {
+		iterator_pathlist_search_t pathlist_match = ITERATOR_PATHLIST_FULL;
+		bool dir_expected = false;
 
-	return fs_iterator__update_entry(fi);
+		if ((error = git_path_diriter_fullpath(&path, &path_len, &diriter)) < 0)
+			goto done;
+
+		assert(path_len > iter->root_len);
+
+		/* remove the prefix if requested */
+		path += iter->root_len;
+		path_len -= iter->root_len;
+
+		/* examine start / end and the pathlist to see if this path is in it.
+		 * note that since we haven't yet stat'ed the path, we cannot know
+		 * whether it's a directory yet or not, so this can give us an
+		 * expected type (S_IFDIR or S_IFREG) that we should examine)
+		 */
+		if (!filesystem_iterator_examine_path(&dir_expected, &pathlist_match,
+			iter, frame_entry, path, path_len))
+			continue;
+
+		/* TODO: don't need to stat if assume unchanged for this path and
+		 * we have an index, we can just copy the data out of it.
+		 */
+
+		if ((error = git_path_diriter_stat(&statbuf, &diriter)) < 0) {
+			/* file was removed between readdir and lstat */
+			if (error == GIT_ENOTFOUND)
+				continue;
+
+			/* treat the file as unreadable */
+			memset(&statbuf, 0, sizeof(statbuf));
+			statbuf.st_mode = GIT_FILEMODE_UNREADABLE;
+
+			error = 0;
+		}
+
+		iter->base.stat_calls++;
+
+		/* Ignore wacky things in the filesystem */
+		if (!S_ISDIR(statbuf.st_mode) &&
+			!S_ISREG(statbuf.st_mode) &&
+			!S_ISLNK(statbuf.st_mode) &&
+			statbuf.st_mode != GIT_FILEMODE_UNREADABLE)
+			continue;
+
+		if (filesystem_iterator_is_dot_git(iter, path, path_len))
+			continue;
+
+		/* convert submodules to GITLINK and remove trailing slashes */
+		if (S_ISDIR(statbuf.st_mode)) {
+			bool submodule = false;
+
+			if ((error = filesystem_iterator_is_submodule(&submodule,
+					iter, path, path_len)) < 0)
+				goto done;
+
+			if (submodule)
+				statbuf.st_mode = GIT_FILEMODE_COMMIT;
+		}
+
+		/* Ensure that the pathlist entry lines up with what we expected */
+		else if (dir_expected)
+			continue;
+
+		if ((error = filesystem_iterator_entry_init(&entry,
+			iter, new_frame, path, path_len, &statbuf, pathlist_match)) < 0)
+			goto done;
+
+		git_vector_insert(&new_frame->entries, entry);
+	}
+
+	if (error == GIT_ITEROVER)
+		error = 0;
+
+	/* sort now that directory suffix is added */
+	git_vector_sort(&new_frame->entries);
+
+done:
+	if (error < 0)
+		git_array_pop(iter->frames);
+
+	git_buf_dispose(&root);
+	git_path_diriter_free(&diriter);
+	return error;
 }
 
-static int fs_iterator__current(
-	const git_index_entry **entry, git_iterator *self)
+GIT_INLINE(void) filesystem_iterator_frame_pop(filesystem_iterator *iter)
 {
-	fs_iterator *fi = (fs_iterator *)self;
-	const git_index_entry *fe = (fi->entry.path == NULL) ? NULL : &fi->entry;
+	filesystem_iterator_frame *frame;
 
-	if (entry)
-		*entry = fe;
+	assert(iter->frames.size);
 
-	fi->base.flags |= GIT_ITERATOR_FIRST_ACCESS;
+	frame = git_array_pop(iter->frames);
+	filesystem_iterator_frame_pop_ignores(iter);
 
-	return (fe != NULL) ? 0 : GIT_ITEROVER;
+	git_pool_clear(&frame->entry_pool);
+	git_vector_free(&frame->entries);
 }
 
-static int fs_iterator__at_end(git_iterator *self)
+static void filesystem_iterator_set_current(
+	filesystem_iterator *iter,
+	filesystem_iterator_entry *entry)
 {
-	return (((fs_iterator *)self)->entry.path == NULL);
+	/*
+	 * Index entries are limited to 32 bit timestamps.  We can safely
+	 * cast this since workdir times are only used in the cache; any
+	 * mismatch will cause a hash recomputation which is unfortunate
+	 * but affects only people who set their filetimes to 2038.
+	 * (Same with the file size.)
+	 */
+	iter->entry.ctime.seconds = (int32_t)entry->st.st_ctime;
+	iter->entry.mtime.seconds = (int32_t)entry->st.st_mtime;
+
+#if defined(GIT_USE_NSEC)
+	iter->entry.ctime.nanoseconds = entry->st.st_ctime_nsec;
+	iter->entry.mtime.nanoseconds = entry->st.st_mtime_nsec;
+#else
+	iter->entry.ctime.nanoseconds = 0;
+	iter->entry.mtime.nanoseconds = 0;
+#endif
+
+	iter->entry.dev = entry->st.st_dev;
+	iter->entry.ino = entry->st.st_ino;
+	iter->entry.mode = git_futils_canonical_mode(entry->st.st_mode);
+	iter->entry.uid = entry->st.st_uid;
+	iter->entry.gid = entry->st.st_gid;
+	iter->entry.file_size = (uint32_t)entry->st.st_size;
+
+	if (iter->base.flags & GIT_ITERATOR_INCLUDE_HASH)
+		git_oid_cpy(&iter->entry.id, &entry->id);
+
+	iter->entry.path = entry->path;
+
+	iter->current_is_ignored = GIT_IGNORE_UNCHECKED;
 }
 
-static int fs_iterator__advance_into(
-	const git_index_entry **entry, git_iterator *iter)
+static int filesystem_iterator_current(
+	const git_index_entry **out, git_iterator *i)
 {
+	filesystem_iterator *iter = (filesystem_iterator *)i;
+
+	if (!iterator__has_been_accessed(i))
+		return iter->base.cb->advance(out, i);
+
+	if (!iter->frames.size) {
+		*out = NULL;
+		return GIT_ITEROVER;
+	}
+
+	*out = &iter->entry;
+	return 0;
+}
+
+static int filesystem_iterator_is_dir(
+	bool *is_dir,
+	const filesystem_iterator *iter,
+	const filesystem_iterator_entry *entry)
+{
+	struct stat st;
+	git_buf fullpath = GIT_BUF_INIT;
 	int error = 0;
-	fs_iterator *fi = (fs_iterator *)iter;
 
-	iterator__clear_entry(entry);
+	if (S_ISDIR(entry->st.st_mode)) {
+		*is_dir = 1;
+		goto done;
+	}
 
-	/* Allow you to explicitly advance into a commit/submodule (as well as a
-	 * tree) to avoid cases where an entry is mislabeled as a submodule in
-	 * the working directory.  The fs iterator will never have COMMMIT
-	 * entries on it's own, but a wrapper might add them.
-	 */
-	if (fi->entry.path != NULL &&
-		(fi->entry.mode == GIT_FILEMODE_TREE ||
-		 fi->entry.mode == GIT_FILEMODE_COMMIT))
-		/* returns GIT_ENOTFOUND if the directory is empty */
-		error = fs_iterator__expand_dir(fi);
+	if (!iterator__descend_symlinks(iter) || !S_ISLNK(entry->st.st_mode)) {
+		*is_dir = 0;
+		goto done;
+	}
 
-	if (!error && entry)
-		error = fs_iterator__current(entry, iter);
+	if ((error = git_buf_joinpath(&fullpath, iter->root, entry->path)) < 0 ||
+		(error = p_stat(fullpath.ptr, &st)) < 0)
+		goto done;
 
-	if (!error && !fi->entry.path)
-		error = GIT_ITEROVER;
+	*is_dir = S_ISDIR(st.st_mode);
 
+done:
+	git_buf_dispose(&fullpath);
 	return error;
 }
 
-static int fs_iterator__advance_over(
-	const git_index_entry **entry, git_iterator *self)
+static int filesystem_iterator_advance(
+	const git_index_entry **out, git_iterator *i)
 {
+	filesystem_iterator *iter = (filesystem_iterator *)i;
+	bool is_dir;
 	int error = 0;
-	fs_iterator *fi = (fs_iterator *)self;
-	fs_iterator_frame *ff;
-	git_path_with_stat *next;
 
-	if (entry != NULL)
-		*entry = NULL;
+	iter->base.flags |= GIT_ITERATOR_FIRST_ACCESS;
 
-	while (fi->entry.path != NULL) {
-		ff   = fi->stack;
-		next = git_vector_get(&ff->entries, ++ff->index);
+	/* examine filesystem entries until we find the next one to return */
+	while (true) {
+		filesystem_iterator_frame *frame;
+		filesystem_iterator_entry *entry;
 
-		if (next != NULL)
+		if ((frame = filesystem_iterator_current_frame(iter)) == NULL) {
+			error = GIT_ITEROVER;
 			break;
+		}
 
-		fs_iterator__pop_frame(fi, ff, false);
-	}
+		/* no more entries in this frame.  pop the frame out */
+		if (frame->next_idx == frame->entries.length) {
+			filesystem_iterator_frame_pop(iter);
+			continue;
+		}
 
-	error = fs_iterator__update_entry(fi);
+		/* we have more entries in the current frame, that's our next entry */
+		entry = frame->entries.contents[frame->next_idx];
+		frame->next_idx++;
 
-	if (!error && entry != NULL)
-		error = fs_iterator__current(entry, self);
+		if ((error = filesystem_iterator_is_dir(&is_dir, iter, entry)) < 0)
+			break;
+
+		if (is_dir) {
+			if (iterator__do_autoexpand(iter)) {
+				error = filesystem_iterator_frame_push(iter, entry);
+
+				/* may get GIT_ENOTFOUND due to races or permission problems
+				 * that we want to quietly swallow
+				 */
+				if (error == GIT_ENOTFOUND)
+					continue;
+				else if (error < 0)
+					break;
+			}
+
+			if (!iterator__include_trees(iter))
+				continue;
+		}
+
+		filesystem_iterator_set_current(iter, entry);
+		break;
+	}
+
+	if (out)
+		*out = (error == 0) ? &iter->entry : NULL;
 
 	return error;
 }
 
-static int fs_iterator__advance(
-	const git_index_entry **entry, git_iterator *self)
+static int filesystem_iterator_advance_into(
+	const git_index_entry **out, git_iterator *i)
 {
-	fs_iterator *fi = (fs_iterator *)self;
+	filesystem_iterator *iter = (filesystem_iterator *)i;
+	filesystem_iterator_frame *frame;
+	filesystem_iterator_entry *prev_entry;
+	int error;
+
+	if (out)
+		*out = NULL;
+
+	if ((frame = filesystem_iterator_current_frame(iter)) == NULL)
+		return GIT_ITEROVER;
+
+	/* get the last seen entry */
+	prev_entry = filesystem_iterator_current_entry(frame);
 
-	if (!iterator__has_been_accessed(fi))
-		return fs_iterator__current(entry, self);
+	/* it's legal to call advance_into when auto-expand is on.  in this case,
+	 * we will have pushed a new (empty) frame on to the stack for this
+	 * new directory.  since it's empty, its current_entry should be null.
+	 */
+	assert(iterator__do_autoexpand(i) ^ (prev_entry != NULL));
 
-	/* given include_trees & autoexpand, we might have to go into a tree */
-	if (iterator__do_autoexpand(fi) &&
-		fi->entry.path != NULL &&
-		fi->entry.mode == GIT_FILEMODE_TREE)
-	{
-		int error = fs_iterator__advance_into(entry, self);
-		if (error != GIT_ENOTFOUND)
+	if (prev_entry) {
+		if (prev_entry->st.st_mode != GIT_FILEMODE_COMMIT &&
+			!S_ISDIR(prev_entry->st.st_mode))
+			return 0;
+
+		if ((error = filesystem_iterator_frame_push(iter, prev_entry)) < 0)
 			return error;
-		/* continue silently past empty directories if autoexpanding */
-		giterr_clear();
 	}
 
-	return fs_iterator__advance_over(entry, self);
+	/* we've advanced into the directory in question, let advance
+	 * find the first entry
+	 */
+	return filesystem_iterator_advance(out, i);
 }
 
-static int fs_iterator__seek(git_iterator *self, const char *prefix)
+int git_iterator_current_workdir_path(git_buf **out, git_iterator *i)
 {
-	GIT_UNUSED(self);
-	GIT_UNUSED(prefix);
-	/* pop stack until matching prefix */
-	/* find prefix item in current frame */
-	/* push subdirectories as deep as possible while matching */
+	filesystem_iterator *iter = (filesystem_iterator *)i;
+	const git_index_entry *entry;
+
+	if (i->type != GIT_ITERATOR_TYPE_FS &&
+		i->type != GIT_ITERATOR_TYPE_WORKDIR) {
+		*out = NULL;
+		return 0;
+	}
+
+	git_buf_truncate(&iter->current_path, iter->root_len);
+
+	if (git_iterator_current(&entry, i) < 0 ||
+		git_buf_puts(&iter->current_path, entry->path) < 0)
+		return -1;
+
+	*out = &iter->current_path;
 	return 0;
 }
 
-static int fs_iterator__reset(
-	git_iterator *self, const char *start, const char *end)
+GIT_INLINE(git_dir_flag) entry_dir_flag(git_index_entry *entry)
 {
-	int error;
-	fs_iterator *fi = (fs_iterator *)self;
+#if defined(GIT_WIN32) && !defined(__MINGW32__)
+	return (entry && entry->mode) ?
+		(S_ISDIR(entry->mode) ? GIT_DIR_FLAG_TRUE : GIT_DIR_FLAG_FALSE) :
+		GIT_DIR_FLAG_UNKNOWN;
+#else
+	GIT_UNUSED(entry);
+	return GIT_DIR_FLAG_UNKNOWN;
+#endif
+}
 
-	while (fi->stack != NULL && fi->stack->next != NULL)
-		fs_iterator__pop_frame(fi, fi->stack, false);
-	fi->depth = 0;
+static void filesystem_iterator_update_ignored(filesystem_iterator *iter)
+{
+	filesystem_iterator_frame *frame;
+	git_dir_flag dir_flag = entry_dir_flag(&iter->entry);
 
-	if ((error = iterator__reset_range(self, start, end)) < 0)
-		return error;
+	if (git_ignore__lookup(&iter->current_is_ignored,
+			&iter->ignores, iter->entry.path, dir_flag) < 0) {
+		git_error_clear();
+		iter->current_is_ignored = GIT_IGNORE_NOTFOUND;
+	}
 
-	fs_iterator__seek_frame_start(fi, fi->stack);
+	/* use ignore from containing frame stack */
+	if (iter->current_is_ignored <= GIT_IGNORE_NOTFOUND) {
+		frame = filesystem_iterator_current_frame(iter);
+		iter->current_is_ignored = frame->is_ignored;
+	}
+}
 
-	error = fs_iterator__update_entry(fi);
-	if (error == GIT_ITEROVER)
-		error = 0;
+GIT_INLINE(bool) filesystem_iterator_current_is_ignored(
+	filesystem_iterator *iter)
+{
+	if (iter->current_is_ignored == GIT_IGNORE_UNCHECKED)
+		filesystem_iterator_update_ignored(iter);
 
-	return error;
+	return (iter->current_is_ignored == GIT_IGNORE_TRUE);
 }
 
-static void fs_iterator__free(git_iterator *self)
+bool git_iterator_current_is_ignored(git_iterator *i)
 {
-	fs_iterator *fi = (fs_iterator *)self;
-
-	while (fi->stack != NULL)
-		fs_iterator__pop_frame(fi, fi->stack, true);
+	if (i->type != GIT_ITERATOR_TYPE_WORKDIR)
+		return false;
 
-	git_buf_free(&fi->path);
+	return filesystem_iterator_current_is_ignored((filesystem_iterator *)i);
 }
 
-static int fs_iterator__update_entry(fs_iterator *fi)
+bool git_iterator_current_tree_is_ignored(git_iterator *i)
 {
-	git_path_with_stat *ps;
+	filesystem_iterator *iter = (filesystem_iterator *)i;
+	filesystem_iterator_frame *frame;
 
-	memset(&fi->entry, 0, sizeof(fi->entry));
+	if (i->type != GIT_ITERATOR_TYPE_WORKDIR)
+		return false;
 
-	if (!fi->stack)
-		return GIT_ITEROVER;
+	frame = filesystem_iterator_current_frame(iter);
+	return (frame->is_ignored == GIT_IGNORE_TRUE);
+}
 
-	ps = git_vector_get(&fi->stack->entries, fi->stack->index);
-	if (!ps)
-		return GIT_ITEROVER;
+static int filesystem_iterator_advance_over(
+	const git_index_entry **out,
+	git_iterator_status_t *status,
+	git_iterator *i)
+{
+	filesystem_iterator *iter = (filesystem_iterator *)i;
+	filesystem_iterator_frame *current_frame;
+	filesystem_iterator_entry *current_entry;
+	const git_index_entry *entry = NULL;
+	const char *base;
+	int error = 0;
 
-	git_buf_truncate(&fi->path, fi->root_len);
-	if (git_buf_put(&fi->path, ps->path, ps->path_len) < 0)
-		return -1;
+	*out = NULL;
+	*status = GIT_ITERATOR_STATUS_NORMAL;
 
-	if (iterator__past_end(fi, fi->path.ptr + fi->root_len))
-		return GIT_ITEROVER;
+	assert(iterator__has_been_accessed(i));
 
-	fi->entry.path = ps->path;
-	git_index_entry__init_from_stat(&fi->entry, &ps->st);
+	current_frame = filesystem_iterator_current_frame(iter);
+	assert(current_frame);
+	current_entry = filesystem_iterator_current_entry(current_frame);
+	assert(current_entry);
 
-	/* need different mode here to keep directories during iteration */
-	fi->entry.mode = git_futils_canonical_mode(ps->st.st_mode);
+	if ((error = git_iterator_current(&entry, i)) < 0)
+		return error;
 
-	/* allow wrapper to check/update the entry (can force skip) */
-	if (fi->update_entry_cb &&
-		fi->update_entry_cb(fi) == GIT_ENOTFOUND)
-		return fs_iterator__advance_over(NULL, (git_iterator *)fi);
+	if (!S_ISDIR(entry->mode)) {
+		if (filesystem_iterator_current_is_ignored(iter))
+			*status = GIT_ITERATOR_STATUS_IGNORED;
 
-	/* if this is a tree and trees aren't included, then skip */
-	if (fi->entry.mode == GIT_FILEMODE_TREE && !iterator__include_trees(fi)) {
-		int error = fs_iterator__advance_into(NULL, (git_iterator *)fi);
-		if (error != GIT_ENOTFOUND)
-			return error;
-		giterr_clear();
-		return fs_iterator__advance_over(NULL, (git_iterator *)fi);
+		return filesystem_iterator_advance(out, i);
 	}
 
-	return 0;
-}
+	git_buf_clear(&iter->tmp_buf);
+	if ((error = git_buf_puts(&iter->tmp_buf, entry->path)) < 0)
+		return error;
 
-static int fs_iterator__initialize(
-	git_iterator **out, fs_iterator *fi, const char *root)
-{
-	int error;
+	base = iter->tmp_buf.ptr;
+
+	/* scan inside the directory looking for files.  if we find nothing,
+	 * we will remain EMPTY.  if we find any ignored item, upgrade EMPTY to
+	 * IGNORED.  if we find a real actual item, upgrade all the way to NORMAL
+	 * and then stop.
+	 *
+	 * however, if we're here looking for a pathlist item (but are not
+	 * actually in the pathlist ourselves) then start at FILTERED instead of
+	 * EMPTY.  callers then know that this path was not something they asked
+	 * about.
+	 */
+	*status = current_entry->match == ITERATOR_PATHLIST_IS_PARENT ?
+		GIT_ITERATOR_STATUS_FILTERED : GIT_ITERATOR_STATUS_EMPTY;
+
+	while (entry && !iter->base.prefixcomp(entry->path, base)) {
+		if (filesystem_iterator_current_is_ignored(iter)) {
+			/* if we found an explicitly ignored item, then update from
+			 * EMPTY to IGNORED
+			 */
+			*status = GIT_ITERATOR_STATUS_IGNORED;
+		} else if (S_ISDIR(entry->mode)) {
+			error = filesystem_iterator_advance_into(&entry, i);
+
+			if (!error)
+				continue;
+
+			/* this directory disappeared, ignore it */
+			else if (error == GIT_ENOTFOUND)
+				error = 0;
+
+			/* a real error occurred */
+			else
+				break;
+		} else {
+			/* we found a non-ignored item, treat parent as untracked */
+			*status = GIT_ITERATOR_STATUS_NORMAL;
+			break;
+		}
 
-	if (git_buf_sets(&fi->path, root) < 0 || git_path_to_dir(&fi->path) < 0) {
-		git__free(fi);
-		return -1;
+		if ((error = git_iterator_advance(&entry, i)) < 0)
+			break;
 	}
-	fi->root_len = fi->path.size;
 
-	if ((error = fs_iterator__expand_dir(fi)) < 0) {
-		if (error == GIT_ENOTFOUND || error == GIT_ITEROVER) {
-			giterr_clear();
-			error = 0;
-		} else {
-			git_iterator_free((git_iterator *)fi);
-			fi = NULL;
-		}
+	/* wrap up scan back to base directory */
+	while (entry && !iter->base.prefixcomp(entry->path, base)) {
+		if ((error = git_iterator_advance(&entry, i)) < 0)
+			break;
 	}
 
-	*out = (git_iterator *)fi;
+	if (!error)
+		*out = entry;
+
 	return error;
 }
 
-int git_iterator_for_filesystem(
-	git_iterator **out,
-	const char *root,
-	git_iterator_flag_t flags,
-	const char *start,
-	const char *end)
+static void filesystem_iterator_clear(filesystem_iterator *iter)
 {
-	fs_iterator *fi = git__calloc(1, sizeof(fs_iterator));
-	GITERR_CHECK_ALLOC(fi);
+	while (iter->frames.size)
+		filesystem_iterator_frame_pop(iter);
 
-	ITERATOR_BASE_INIT(fi, fs, FS, NULL);
+	git_array_clear(iter->frames);
+	git_ignore__free(&iter->ignores);
 
-	if ((flags & GIT_ITERATOR_IGNORE_CASE) != 0)
-		fi->base.flags |= GIT_ITERATOR_IGNORE_CASE;
+	git_buf_dispose(&iter->tmp_buf);
 
-	return fs_iterator__initialize(out, fi, root);
+	iterator_clear(&iter->base);
 }
 
-
-typedef struct {
-	fs_iterator fi;
-	git_ignores ignores;
-	int is_ignored;
-} workdir_iterator;
-
-GIT_INLINE(bool) workdir_path_is_dotgit(const git_buf *path)
+static int filesystem_iterator_init(filesystem_iterator *iter)
 {
-	size_t len;
+	int error;
 
-	if (!path || (len = path->size) < 4)
-		return false;
+	if (iterator__honor_ignores(&iter->base) &&
+		(error = git_ignore__for_path(iter->base.repo,
+			".gitignore", &iter->ignores)) < 0)
+		return error;
 
-	if (path->ptr[len - 1] == '/')
-		len--;
+	if ((error = filesystem_iterator_frame_push(iter, NULL)) < 0)
+		return error;
 
-	if (tolower(path->ptr[len - 1]) != 't' ||
-		tolower(path->ptr[len - 2]) != 'i' ||
-		tolower(path->ptr[len - 3]) != 'g' ||
-		tolower(path->ptr[len - 4]) != '.')
-		return false;
+	iter->base.flags &= ~GIT_ITERATOR_FIRST_ACCESS;
 
-	return (len == 4 || path->ptr[len - 5] == '/');
+	return 0;
 }
 
-static int workdir_iterator__enter_dir(fs_iterator *fi)
+static int filesystem_iterator_reset(git_iterator *i)
 {
-	/* only push new ignores if this is not top level directory */
-	if (fi->stack->next != NULL) {
-		workdir_iterator *wi = (workdir_iterator *)fi;
-		ssize_t slash_pos = git_buf_rfind_next(&fi->path, '/');
-
-		(void)git_ignore__push_dir(&wi->ignores, &fi->path.ptr[slash_pos + 1]);
-	}
+	filesystem_iterator *iter = (filesystem_iterator *)i;
 
-	return 0;
+	filesystem_iterator_clear(iter);
+	return filesystem_iterator_init(iter);
 }
 
-static int workdir_iterator__leave_dir(fs_iterator *fi)
+static void filesystem_iterator_free(git_iterator *i)
 {
-	workdir_iterator *wi = (workdir_iterator *)fi;
-	git_ignore__pop_dir(&wi->ignores);
-	return 0;
+	filesystem_iterator *iter = (filesystem_iterator *)i;
+	git__free(iter->root);
+	git_buf_dispose(&iter->current_path);
+	git_tree_free(iter->tree);
+	if (iter->index)
+		git_index_snapshot_release(&iter->index_snapshot, iter->index);
+	filesystem_iterator_clear(iter);
 }
 
-static int workdir_iterator__update_entry(fs_iterator *fi)
+static int iterator_for_filesystem(
+	git_iterator **out,
+	git_repository *repo,
+	const char *root,
+	git_index *index,
+	git_tree *tree,
+	git_iterator_type_t type,
+	git_iterator_options *options)
 {
-	int error = 0;
-	workdir_iterator *wi = (workdir_iterator *)fi;
+	filesystem_iterator *iter;
+	size_t root_len;
+	int error;
 
-	/* skip over .git entries */
-	if (workdir_path_is_dotgit(&fi->path))
-		return GIT_ENOTFOUND;
+	static git_iterator_callbacks callbacks = {
+		filesystem_iterator_current,
+		filesystem_iterator_advance,
+		filesystem_iterator_advance_into,
+		filesystem_iterator_advance_over,
+		filesystem_iterator_reset,
+		filesystem_iterator_free
+	};
 
-	/* reset is_ignored since we haven't checked yet */
-	wi->is_ignored = -1;
+	*out = NULL;
 
-	/* check if apparent tree entries are actually submodules */
-	if (fi->entry.mode != GIT_FILEMODE_TREE)
-		return 0;
+	if (root == NULL)
+		return git_iterator_for_nothing(out, options);
 
-	error = git_submodule_lookup(NULL, fi->base.repo, fi->entry.path);
-	if (error < 0)
-		giterr_clear();
+	iter = git__calloc(1, sizeof(filesystem_iterator));
+	GIT_ERROR_CHECK_ALLOC(iter);
 
-	/* mark submodule (or any dir with .git) as GITLINK and remove slash */
-	if (!error || error == GIT_EEXISTS) {
-		fi->entry.mode = S_IFGITLINK;
-		fi->entry.path[strlen(fi->entry.path) - 1] = '\0';
+	iter->base.type = type;
+	iter->base.cb = &callbacks;
+
+	root_len = strlen(root);
+
+	iter->root = git__malloc(root_len+2);
+	GIT_ERROR_CHECK_ALLOC(iter->root);
+
+	memcpy(iter->root, root, root_len);
+
+	if (root_len == 0 || root[root_len-1] != '/') {
+		iter->root[root_len] = '/';
+		root_len++;
 	}
+	iter->root[root_len] = '\0';
+	iter->root_len = root_len;
+
+	if ((error = git_buf_puts(&iter->current_path, iter->root)) < 0)
+		goto on_error;
+
+	if ((error = iterator_init_common(&iter->base, repo, index, options)) < 0)
+		goto on_error;
+
+	if (tree && (error = git_tree_dup(&iter->tree, tree)) < 0)
+		goto on_error;
 
+	if (index &&
+		(error = git_index_snapshot_new(&iter->index_snapshot, index)) < 0)
+		goto on_error;
+
+	iter->index = index;
+	iter->dirload_flags =
+		(iterator__ignore_case(&iter->base) ? GIT_PATH_DIR_IGNORE_CASE : 0) |
+		(iterator__flag(&iter->base, PRECOMPOSE_UNICODE) ?
+			 GIT_PATH_DIR_PRECOMPOSE_UNICODE : 0);
+
+	if ((error = filesystem_iterator_init(iter)) < 0)
+		goto on_error;
+
+	*out = &iter->base;
 	return 0;
+
+on_error:
+	git_iterator_free(&iter->base);
+	return error;
 }
 
-static void workdir_iterator__free(git_iterator *self)
+int git_iterator_for_filesystem(
+	git_iterator **out,
+	const char *root,
+	git_iterator_options *options)
 {
-	workdir_iterator *wi = (workdir_iterator *)self;
-	fs_iterator__free(self);
-	git_ignore__free(&wi->ignores);
+	return iterator_for_filesystem(out,
+		NULL, root, NULL, NULL, GIT_ITERATOR_TYPE_FS, options);
 }
 
 int git_iterator_for_workdir_ext(
 	git_iterator **out,
 	git_repository *repo,
 	const char *repo_workdir,
-	git_iterator_flag_t flags,
-	const char *start,
-	const char *end)
+	git_index *index,
+	git_tree *tree,
+	git_iterator_options *given_opts)
 {
-	int error;
-	workdir_iterator *wi;
+	git_iterator_options options = GIT_ITERATOR_OPTIONS_INIT;
 
 	if (!repo_workdir) {
 		if (git_repository__ensure_not_bare(repo, "scan working directory") < 0)
 			return GIT_EBAREREPO;
+
 		repo_workdir = git_repository_workdir(repo);
 	}
 
-	/* initialize as an fs iterator then do overrides */
-	wi = git__calloc(1, sizeof(workdir_iterator));
-	GITERR_CHECK_ALLOC(wi);
-	ITERATOR_BASE_INIT((&wi->fi), fs, FS, repo);
-
-	wi->fi.base.type = GIT_ITERATOR_TYPE_WORKDIR;
-	wi->fi.cb.free = workdir_iterator__free;
-	wi->fi.enter_dir_cb = workdir_iterator__enter_dir;
-	wi->fi.leave_dir_cb = workdir_iterator__leave_dir;
-	wi->fi.update_entry_cb = workdir_iterator__update_entry;
-
-	if ((error = iterator__update_ignore_case((git_iterator *)wi, flags)) < 0 ||
-		(error = git_ignore__for_path(repo, "", &wi->ignores)) < 0)
-	{
-		git_iterator_free((git_iterator *)wi);
-		return error;
-	}
+	/* upgrade to a workdir iterator, adding necessary internal flags */
+	if (given_opts)
+		memcpy(&options, given_opts, sizeof(git_iterator_options));
 
-	return fs_iterator__initialize(out, &wi->fi, repo_workdir);
+	options.flags |= GIT_ITERATOR_HONOR_IGNORES |
+		GIT_ITERATOR_IGNORE_DOT_GIT;
+
+	return iterator_for_filesystem(out,
+		repo, repo_workdir, index, tree, GIT_ITERATOR_TYPE_WORKDIR, &options);
 }
 
 
-void git_iterator_free(git_iterator *iter)
+/* Index iterator */
+
+
+typedef struct {
+	git_iterator base;
+	git_vector entries;
+	size_t next_idx;
+
+	/* the pseudotree entry */
+	git_index_entry tree_entry;
+	git_buf tree_buf;
+	bool skip_tree;
+
+	const git_index_entry *entry;
+} index_iterator;
+
+static int index_iterator_current(
+	const git_index_entry **out, git_iterator *i)
 {
-	if (iter == NULL)
-		return;
+	index_iterator *iter = (index_iterator *)i;
 
-	iter->cb->free(iter);
+	if (!iterator__has_been_accessed(i))
+		return iter->base.cb->advance(out, i);
 
-	git__free(iter->start);
-	git__free(iter->end);
+	if (iter->entry == NULL) {
+		*out = NULL;
+		return GIT_ITEROVER;
+	}
 
-	memset(iter, 0, sizeof(*iter));
+	*out = iter->entry;
+	return 0;
+}
 
-	git__free(iter);
+static bool index_iterator_create_pseudotree(
+	const git_index_entry **out,
+	index_iterator *iter,
+	const char *path)
+{
+	const char *prev_path, *relative_path, *dirsep;
+	size_t common_len;
+
+	prev_path = iter->entry ? iter->entry->path : "";
+
+	/* determine if the new path is in a different directory from the old */
+	common_len = git_path_common_dirlen(prev_path, path);
+	relative_path = path + common_len;
+
+	if ((dirsep = strchr(relative_path, '/')) == NULL)
+		return false;
+
+	git_buf_clear(&iter->tree_buf);
+	git_buf_put(&iter->tree_buf, path, (dirsep - path) + 1);
+
+	iter->tree_entry.mode = GIT_FILEMODE_TREE;
+	iter->tree_entry.path = iter->tree_buf.ptr;
+
+	*out = &iter->tree_entry;
+	return true;
 }
 
-int git_iterator_set_ignore_case(git_iterator *iter, bool ignore_case)
+static int index_iterator_skip_pseudotree(index_iterator *iter)
 {
-	bool desire_ignore_case  = (ignore_case != 0);
+	assert(iterator__has_been_accessed(&iter->base));
+	assert(S_ISDIR(iter->entry->mode));
 
-	if (iterator__ignore_case(iter) == desire_ignore_case)
-		return 0;
+	while (true) {
+		const git_index_entry *next_entry = NULL;
 
-	if (iter->type == GIT_ITERATOR_TYPE_EMPTY) {
-		if (desire_ignore_case)
-			iter->flags |= GIT_ITERATOR_IGNORE_CASE;
-		else
-			iter->flags &= ~GIT_ITERATOR_IGNORE_CASE;
-	} else {
-		giterr_set(GITERR_INVALID,
-			"Cannot currently set ignore case on non-empty iterators");
-		return -1;
+		if (++iter->next_idx >= iter->entries.length)
+			return GIT_ITEROVER;
+
+		next_entry = iter->entries.contents[iter->next_idx];
+
+		if (iter->base.strncomp(iter->tree_buf.ptr, next_entry->path,
+			iter->tree_buf.size) != 0)
+			break;
 	}
 
+	iter->skip_tree = false;
 	return 0;
 }
 
-git_index *git_iterator_get_index(git_iterator *iter)
+static int index_iterator_advance(
+	const git_index_entry **out, git_iterator *i)
 {
-	if (iter->type == GIT_ITERATOR_TYPE_INDEX)
-		return ((index_iterator *)iter)->index;
-	return NULL;
+	index_iterator *iter = (index_iterator *)i;
+	const git_index_entry *entry = NULL;
+	bool is_submodule;
+	int error = 0;
+
+	iter->base.flags |= GIT_ITERATOR_FIRST_ACCESS;
+
+	while (true) {
+		if (iter->next_idx >= iter->entries.length) {
+			error = GIT_ITEROVER;
+			break;
+		}
+
+		/* we were not asked to expand this pseudotree.  advance over it. */
+		if (iter->skip_tree) {
+			index_iterator_skip_pseudotree(iter);
+			continue;
+		}
+
+		entry = iter->entries.contents[iter->next_idx];
+		is_submodule = S_ISGITLINK(entry->mode);
+
+		if (!iterator_has_started(&iter->base, entry->path, is_submodule)) {
+			iter->next_idx++;
+			continue;
+		}
+
+		if (iterator_has_ended(&iter->base, entry->path)) {
+			error = GIT_ITEROVER;
+			break;
+		}
+
+		/* if we have a list of paths we're interested in, examine it */
+		if (!iterator_pathlist_next_is(&iter->base, entry->path)) {
+			iter->next_idx++;
+			continue;
+		}
+
+		/* if this is a conflict, skip it unless we're including conflicts */
+		if (git_index_entry_is_conflict(entry) &&
+			!iterator__include_conflicts(&iter->base)) {
+			iter->next_idx++;
+			continue;
+		}
+
+		/* we've found what will be our next _file_ entry.  but if we are
+		 * returning trees entries, we may need to return a pseudotree
+		 * entry that will contain this.  don't advance over this entry,
+		 * though, we still need to return it on the next `advance`.
+		 */
+		if (iterator__include_trees(&iter->base) &&
+			index_iterator_create_pseudotree(&entry, iter, entry->path)) {
+
+			/* Note whether this pseudo tree should be expanded or not */
+			iter->skip_tree = iterator__dont_autoexpand(&iter->base);
+			break;
+		}
+
+		iter->next_idx++;
+		break;
+	}
+
+	iter->entry = (error == 0) ? entry : NULL;
+
+	if (out)
+		*out = iter->entry;
+
+	return error;
 }
 
-int git_iterator_current_tree_entry(
-	const git_tree_entry **tree_entry, git_iterator *iter)
-{
-	if (iter->type != GIT_ITERATOR_TYPE_TREE)
-		*tree_entry = NULL;
-	else {
-		tree_iterator_frame *tf = ((tree_iterator *)iter)->head;
-		*tree_entry = (tf->current < tf->n_entries) ?
-			tf->entries[tf->current]->te : NULL;
+static int index_iterator_advance_into(
+	const git_index_entry **out, git_iterator *i)
+{
+	index_iterator *iter = (index_iterator *)i;
+
+	if (! S_ISDIR(iter->tree_entry.mode)) {
+		if (out)
+			*out = NULL;
+
+		return 0;
 	}
 
+	iter->skip_tree = false;
+	return index_iterator_advance(out, i);
+}
+
+static int index_iterator_advance_over(
+	const git_index_entry **out,
+	git_iterator_status_t *status,
+	git_iterator *i)
+{
+	index_iterator *iter = (index_iterator *)i;
+	const git_index_entry *entry;
+	int error;
+
+	if ((error = index_iterator_current(&entry, i)) < 0)
+		return error;
+
+	if (S_ISDIR(entry->mode))
+		index_iterator_skip_pseudotree(iter);
+
+	*status = GIT_ITERATOR_STATUS_NORMAL;
+	return index_iterator_advance(out, i);
+}
+
+static void index_iterator_clear(index_iterator *iter)
+{
+	iterator_clear(&iter->base);
+}
+
+static int index_iterator_init(index_iterator *iter)
+{
+	iter->base.flags &= ~GIT_ITERATOR_FIRST_ACCESS;
+	iter->next_idx = 0;
+	iter->skip_tree = false;
 	return 0;
 }
 
-int git_iterator_current_parent_tree(
-	const git_tree **tree_ptr,
-	git_iterator *iter,
-	const char *parent_path)
+static int index_iterator_reset(git_iterator *i)
 {
-	tree_iterator *ti = (tree_iterator *)iter;
-	tree_iterator_frame *tf;
-	const char *scan = parent_path;
-	const git_tree_entry *te;
+	index_iterator *iter = (index_iterator *)i;
 
-	*tree_ptr = NULL;
+	index_iterator_clear(iter);
+	return index_iterator_init(iter);
+}
 
-	if (iter->type != GIT_ITERATOR_TYPE_TREE)
-		return 0;
+static void index_iterator_free(git_iterator *i)
+{
+	index_iterator *iter = (index_iterator *)i;
 
-	for (tf = ti->root; *scan; ) {
-		if (!(tf = tf->down) ||
-			tf->current >= tf->n_entries ||
-			!(te = tf->entries[tf->current]->te) ||
-			ti->strncomp(scan, te->filename, te->filename_len) != 0)
-			return 0;
+	git_index_snapshot_release(&iter->entries, iter->base.index);
+	git_buf_dispose(&iter->tree_buf);
+}
 
-		scan += te->filename_len;
-		if (*scan == '/')
-			scan++;
-	}
+int git_iterator_for_index(
+	git_iterator **out,
+	git_repository *repo,
+	git_index  *index,
+	git_iterator_options *options)
+{
+	index_iterator *iter;
+	int error;
+
+	static git_iterator_callbacks callbacks = {
+		index_iterator_current,
+		index_iterator_advance,
+		index_iterator_advance_into,
+		index_iterator_advance_over,
+		index_iterator_reset,
+		index_iterator_free
+	};
+
+	*out = NULL;
+
+	if (index == NULL)
+		return git_iterator_for_nothing(out, options);
+
+	iter = git__calloc(1, sizeof(index_iterator));
+	GIT_ERROR_CHECK_ALLOC(iter);
+
+	iter->base.type = GIT_ITERATOR_TYPE_INDEX;
+	iter->base.cb = &callbacks;
+
+	if ((error = iterator_init_common(&iter->base, repo, index, options)) < 0 ||
+		(error = git_index_snapshot_new(&iter->entries, index)) < 0 ||
+		(error = index_iterator_init(iter)) < 0)
+		goto on_error;
+
+	git_vector_set_cmp(&iter->entries, iterator__ignore_case(&iter->base) ?
+		git_index_entry_icmp : git_index_entry_cmp);
+	git_vector_sort(&iter->entries);
 
-	*tree_ptr = tf->entries[tf->current]->tree;
+	*out = &iter->base;
 	return 0;
+
+on_error:
+	git_iterator_free(&iter->base);
+	return error;
 }
 
-bool git_iterator_current_is_ignored(git_iterator *iter)
+
+/* Iterator API */
+
+int git_iterator_reset_range(
+	git_iterator *i, const char *start, const char *end)
 {
-	workdir_iterator *wi = (workdir_iterator *)iter;
+	if (iterator_reset_range(i, start, end) < 0)
+		return -1;
 
-	if (iter->type != GIT_ITERATOR_TYPE_WORKDIR)
-		return false;
+	return i->cb->reset(i);
+}
 
-	if (wi->is_ignored != -1)
-		return (bool)(wi->is_ignored != 0);
+void git_iterator_set_ignore_case(git_iterator *i, bool ignore_case)
+{
+	assert(!iterator__has_been_accessed(i));
+	iterator_set_ignore_case(i, ignore_case);
+}
 
-	if (git_ignore__lookup(
-			&wi->ignores, wi->fi.entry.path, &wi->is_ignored) < 0)
-		wi->is_ignored = true;
+void git_iterator_free(git_iterator *iter)
+{
+	if (iter == NULL)
+		return;
 
-	return (bool)wi->is_ignored;
+	iter->cb->free(iter);
+
+	git_vector_free(&iter->pathlist);
+	git__free(iter->start);
+	git__free(iter->end);
+
+	memset(iter, 0, sizeof(*iter));
+
+	git__free(iter);
 }
 
-int git_iterator_cmp(git_iterator *iter, const char *path_prefix)
+int git_iterator_foreach(
+	git_iterator *iterator,
+	git_iterator_foreach_cb cb,
+	void *data)
 {
-	const git_index_entry *entry;
+	const git_index_entry *iterator_item;
+	int error = 0;
 
-	/* a "done" iterator is after every prefix */
-	if (git_iterator_current(&entry, iter) < 0 || entry == NULL)
-		return 1;
+	if ((error = git_iterator_current(&iterator_item, iterator)) < 0)
+		goto done;
 
-	/* a NULL prefix is after any valid iterator */
-	if (!path_prefix)
-		return -1;
+	if ((error = cb(iterator_item, data)) != 0)
+		goto done;
+
+	while (true) {
+		if ((error = git_iterator_advance(&iterator_item, iterator)) < 0)
+			goto done;
+
+		if ((error = cb(iterator_item, data)) != 0)
+			goto done;
+	}
 
-	return iter->prefixcomp(entry->path, path_prefix);
+done:
+	if (error == GIT_ITEROVER)
+		error = 0;
+
+	return error;
 }
 
-int git_iterator_current_workdir_path(git_buf **path, git_iterator *iter)
+int git_iterator_walk(
+	git_iterator **iterators,
+	size_t cnt,
+	git_iterator_walk_cb cb,
+	void *data)
 {
-	workdir_iterator *wi = (workdir_iterator *)iter;
+	const git_index_entry **iterator_item;	/* next in each iterator */
+	const git_index_entry **cur_items;		/* current path in each iter */
+	const git_index_entry *first_match;
+	size_t i, j;
+	int error = 0;
 
-	if (iter->type != GIT_ITERATOR_TYPE_WORKDIR || !wi->fi.entry.path)
-		*path = NULL;
-	else
-		*path = &wi->fi.path;
+	iterator_item = git__calloc(cnt, sizeof(git_index_entry *));
+	cur_items = git__calloc(cnt, sizeof(git_index_entry *));
 
-	return 0;
+	GIT_ERROR_CHECK_ALLOC(iterator_item);
+	GIT_ERROR_CHECK_ALLOC(cur_items);
+
+	/* Set up the iterators */
+	for (i = 0; i < cnt; i++) {
+		error = git_iterator_current(&iterator_item[i], iterators[i]);
+
+		if (error < 0 && error != GIT_ITEROVER)
+			goto done;
+	}
+
+	while (true) {
+		for (i = 0; i < cnt; i++)
+			cur_items[i] = NULL;
+
+		first_match = NULL;
+
+		/* Find the next path(s) to consume from each iterator */
+		for (i = 0; i < cnt; i++) {
+			if (iterator_item[i] == NULL)
+				continue;
+
+			if (first_match == NULL) {
+				first_match = iterator_item[i];
+				cur_items[i] = iterator_item[i];
+			} else {
+				int path_diff = git_index_entry_cmp(iterator_item[i], first_match);
+
+				if (path_diff < 0) {
+					/* Found an index entry that sorts before the one we're
+					 * looking at.  Forget that we've seen the other and
+					 * look at the other iterators for this path.
+					 */
+					for (j = 0; j < i; j++)
+						cur_items[j] = NULL;
+
+					first_match = iterator_item[i];
+					cur_items[i] = iterator_item[i];
+				} else if (path_diff == 0) {
+					cur_items[i] = iterator_item[i];
+				}
+			}
+		}
+
+		if (first_match == NULL)
+			break;
+
+		if ((error = cb(cur_items, data)) != 0)
+			goto done;
+
+		/* Advance each iterator that participated */
+		for (i = 0; i < cnt; i++) {
+			if (cur_items[i] == NULL)
+				continue;
+
+			error = git_iterator_advance(&iterator_item[i], iterators[i]);
+
+			if (error < 0 && error != GIT_ITEROVER)
+				goto done;
+		}
+	}
+
+done:
+	git__free((git_index_entry **)iterator_item);
+	git__free((git_index_entry **)cur_items);
+
+	if (error == GIT_ITEROVER)
+		error = 0;
+
+	return error;
 }