Merge branch 'jc/error-message-in-cherry-pick'

* jc/error-message-in-cherry-pick:
Make error messages from cherry-pick/revert more sensible

diff --combined cache-tree.c
index bfc95d2dc9600083b73b61c06d2b32c983db8511,4e1e7b25cf3e5cdbff99524f197c8341d26ac10a..39da54d1e56b5905655eafed1aff0f51c2540a8e
--- 1/cache-tree.c
--- 2/cache-tree.c
+++ b/cache-tree.c
@@@ -320,13 -320,13 +320,13 @@@ static int update_one(struct cache_tre
                }
                else {
                        sha1 = ce->sha1;
 -                      mode = ntohl(ce->ce_mode);
 +                      mode = ce->ce_mode;
                        entlen = pathlen - baselen;
                }
                if (mode != S_IFGITLINK && !missing_ok && !has_sha1_file(sha1))
                        return error("invalid object %s", sha1_to_hex(sha1));
  
 -              if (!ce->ce_mode)
 +              if (ce->ce_flags & CE_REMOVE)
                        continue; /* entry being removed */
  
                strbuf_grow(&buffer, entlen + 100);
@@@ -529,3 -529,58 +529,58 @@@ struct cache_tree *cache_tree_find(stru
        }
        return it;
  }
+ 
+ int write_cache_as_tree(unsigned char *sha1, int missing_ok, const char *prefix)
+ {
+       int entries, was_valid, newfd;
+ 
+       /*
+        * We can't free this memory, it becomes part of a linked list
+        * parsed atexit()
+        */
+       struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
+ 
+       newfd = hold_locked_index(lock_file, 1);
+ 
+       entries = read_cache();
+       if (entries < 0)
+               return WRITE_TREE_UNREADABLE_INDEX;
+ 
+       if (!active_cache_tree)
+               active_cache_tree = cache_tree();
+ 
+       was_valid = cache_tree_fully_valid(active_cache_tree);
+ 
+       if (!was_valid) {
+               if (cache_tree_update(active_cache_tree,
+                                     active_cache, active_nr,
+                                     missing_ok, 0) < 0)
+                       return WRITE_TREE_UNMERGED_INDEX;
+               if (0 <= newfd) {
+                       if (!write_cache(newfd, active_cache, active_nr) &&
+                           !commit_lock_file(lock_file))
+                               newfd = -1;
+               }
+               /* Not being able to write is fine -- we are only interested
+                * in updating the cache-tree part, and if the next caller
+                * ends up using the old index with unupdated cache-tree part
+                * it misses the work we did here, but that is just a
+                * performance penalty and not a big deal.
+                */
+       }
+ 
+       if (prefix) {
+               struct cache_tree *subtree =
+                       cache_tree_find(active_cache_tree, prefix);
+               if (!subtree)
+                       return WRITE_TREE_PREFIX_ERROR;
+               hashcpy(sha1, subtree->sha1);
+       }
+       else
+               hashcpy(sha1, active_cache_tree->sha1);
+ 
+       if (0 <= newfd)
+               rollback_lock_file(lock_file);
+ 
+       return 0;
+ }