status: preserve clean-status proofs across mixed Git writers

attr-fingerprint.c

@@ -215,6 +215,97 @@ int attr_fingerprint_repository(struct repository *repo,
 	return ret;
 }
 
+static int legacy_absent_path_is_stable(const char *path)
+{
+	struct path_namespace_snapshot *before = NULL, *after = NULL;
+	struct strbuf normalized = STRBUF_INIT;
+	char *absolute = NULL;
+	int stable = 0;
+
+	if (!path)
+		return 0;
+	absolute = absolute_pathdup(path);
+	strbuf_addstr(&normalized, absolute);
+	if (!strbuf_normalize_path(&normalized) &&
+	    !path_namespace_capture(normalized.buf, &before) &&
+	    !path_namespace_target_present(before) &&
+	    !path_namespace_capture(normalized.buf, &after) &&
+	    !path_namespace_target_present(after) &&
+	    path_namespace_equal(before, after))
+		stable = 1;
+	free(absolute);
+	path_namespace_clear(before);
+	path_namespace_clear(after);
+	strbuf_release(&normalized);
+	return stable;
+}
+
+static void legacy_absent_source_hash(
+	const struct attr_fingerprint_source *sources,
+	const char *system_path, const struct git_hash_algo *algo,
+	unsigned char *hash)
+{
+	struct git_hash_ctx ctx;
+	uint32_t value;
+
+	git_hash_init(&ctx, algo);
+	hash_optional_cstring(&ctx, "attribute-source-content-v1");
+	put_be32(&value, ATTR_SOURCE_SNAPSHOT_NR);
+	hash_length_delimited(&ctx, &value, sizeof(value));
+	for (size_t i = 0; i < ATTR_SOURCE_SNAPSHOT_NR; i++) {
+		const char *path = i == ATTR_SOURCE_SNAPSHOT_SYSTEM ?
+			system_path : sources[i].path;
+
+		hash_optional_cstring(&ctx, path);
+		put_be32(&value, sources[i].enabled);
+		hash_length_delimited(&ctx, &value, sizeof(value));
+		if (!sources[i].enabled || !path)
+			continue;
+		put_be32(&value, 0);
+		hash_length_delimited(&ctx, &value, sizeof(value));
+	}
+	git_hash_final(hash, &ctx);
+}
+
+int attr_fingerprint_matches_legacy_absent_sources(
+	struct repository *repo, const unsigned char *expected)
+{
+	static const char shipped_system_path[] = "//etc/gitattributes";
+	struct attr_fingerprint_source sources[ATTR_SOURCE_SNAPSHOT_NR];
+	struct attr_fingerprint before, after;
+	unsigned char legacy[GIT_MAX_RAWSZ];
+	char *info_attributes = NULL;
+	int matches = 0;
+
+	if (!expected || !fstat_is_reliable() ||
+	    repository_sources(repo, sources, &info_attributes) ||
+	    !sources[ATTR_SOURCE_SNAPSHOT_SYSTEM].enabled ||
+	    attr_fingerprint_repository(repo, &before) ||
+	    before.sources_present)
+		goto done;
+	legacy_absent_source_hash(
+		sources, sources[ATTR_SOURCE_SNAPSHOT_SYSTEM].path,
+		repo->hash_algo, legacy);
+	if (!memcmp(legacy, expected, repo->hash_algo->rawsz)) {
+		matches = 1;
+	} else if (legacy_absent_path_is_stable(shipped_system_path)) {
+		legacy_absent_source_hash(
+			sources, shipped_system_path, repo->hash_algo, legacy);
+		matches = !memcmp(legacy, expected, repo->hash_algo->rawsz);
+	}
+	if (!matches || attr_fingerprint_repository(repo, &after) ||
+	    after.sources_present ||
+	    memcmp(before.content_hash, after.content_hash,
+		   repo->hash_algo->rawsz) ||
+	    memcmp(before.namespace_hash, after.namespace_hash,
+		   repo->hash_algo->rawsz))
+		matches = 0;
+
+done:
+	free(info_attributes);
+	return matches;
+}
+
 int attr_source_snapshot_repository(struct repository *repo,
 				    struct attr_source_snapshot **result)
 {

attr-fingerprint.h

@@ -31,6 +31,8 @@ int attr_fingerprint_sources(
 	const struct git_hash_algo *algo, struct attr_fingerprint *result);
 int attr_fingerprint_repository(struct repository *repo,
 				struct attr_fingerprint *result);
+int attr_fingerprint_matches_legacy_absent_sources(
+	struct repository *repo, const unsigned char *expected);
 int attr_source_snapshot_repository(struct repository *repo,
 				    struct attr_source_snapshot **result);
 int attr_source_snapshot_matches_repository(

attr-manifest.c

@@ -1,4 +1,5 @@
 #include "git-compat-util.h"
+#include "attr.h"
 #include "attr-manifest.h"
 #include "environment.h"
 #include "read-cache-ll.h"
@@ -45,6 +46,86 @@ static int attr_manifest_entry_equal(const struct attr_manifest_entry *a,
 		!memcmp(a->hash, b->hash, algo->rawsz);
 }
 
+static void release_parsed_attr(struct match_attr *match)
+{
+	for (size_t i = 0; i < match->num_attr; i++) {
+		const char *value = match->state[i].setto;
+
+		if (!ATTR_TRUE(value) && !ATTR_FALSE(value) &&
+		    !ATTR_UNSET(value))
+			free((char *)value);
+	}
+	free(match);
+}
+
+static int normalize_conversion_attributes(
+	const char *data, size_t len, struct strbuf *normalized)
+{
+	struct strbuf line = STRBUF_INIT;
+	size_t offset = 0;
+	int lineno = 0, ret = -1;
+
+	if ((!data && len) || memchr(data, '\0', len))
+		goto done;
+	while (offset < len) {
+		const char *start = data + offset;
+		const char *newline = memchr(start, '\n', len - offset);
+		const char *trimmed;
+		struct match_attr *match;
+		size_t line_len = newline ?
+			(size_t)(newline - start) + 1 : len - offset;
+		int display_only;
+
+		strbuf_reset(&line);
+		strbuf_add(&line, start, line_len);
+		trimmed = line.buf + strspn(line.buf, " \t\r\n");
+		lineno++;
+		if (!*trimmed || *trimmed == '#') {
+			strbuf_add(normalized, start, line_len);
+			offset += line_len;
+			continue;
+		}
+		if (starts_with(trimmed, ATTRIBUTE_MACRO_PREFIX))
+			goto done;
+		match = parse_attr_line(line.buf, GITATTRIBUTES_FILE, lineno, 0);
+		if (!match || match->is_macro || !match->num_attr) {
+			if (match)
+				release_parsed_attr(match);
+			goto done;
+		}
+		display_only = 1;
+		for (size_t i = 0; i < match->num_attr; i++)
+			if (strcmp(git_attr_name(match->state[i].attr),
+				   "linguist-generated"))
+				display_only = 0;
+		release_parsed_attr(match);
+		if (!display_only)
+			strbuf_add(normalized, start, line_len);
+		offset += line_len;
+	}
+	ret = 0;
+
+done:
+	strbuf_release(&line);
+	return ret;
+}
+
+int attr_manifest_only_linguist_generated_changed(
+	const char *old_data, size_t old_len,
+	const char *new_data, size_t new_len)
+{
+	struct strbuf old = STRBUF_INIT, new = STRBUF_INIT;
+	int equal = 0;
+
+	if (!normalize_conversion_attributes(old_data, old_len, &old) &&
+	    !normalize_conversion_attributes(new_data, new_len, &new))
+		equal = old.len == new.len &&
+			!memcmp(old.buf, new.buf, old.len);
+	strbuf_release(&old);
+	strbuf_release(&new);
+	return equal;
+}
+
 void attr_manifest_writer_init(struct attr_manifest_writer *writer,
 			       struct strbuf *buf,
 			       const struct git_hash_algo *algo)

attr-manifest.h

@@ -55,5 +55,8 @@ int attr_manifest_for_each_changed(const void *old_data, size_t old_len,
 				   const void *new_data, size_t new_len,
 				   const struct git_hash_algo *algo,
 				   attr_manifest_change_fn fn, void *data);
+int attr_manifest_only_linguist_generated_changed(
+	const char *old_data, size_t old_len,
+	const char *new_data, size_t new_len);
 
 #endif /* ATTR_MANIFEST_H */

builtin/add.c

@@ -511,11 +511,13 @@ int cmd_add(int argc,
 	 * add/remove decision below.
 	 */
 	if (refresh_only) {
+		clean_status_enable_external_history(repo);
 		clean_status_set_config_digest(repo, &clean_digest);
 	} else if (!show_only && !intent_to_add && !add_renormalize &&
 		   !chmod_arg && !include_sparse && !ignore_add_errors) {
 		preserve_add_history = 1;
 		flags |= ADD_CACHE_TRACK_CLEAN_HISTORY;
+		clean_status_enable_external_history(repo);
 		clean_status_set_config_digest(repo, &clean_digest);
 	}
 

builtin/checkout.c

@@ -671,9 +671,11 @@ static int checkout_paths(const struct checkout_opts *opts,
 		!opts->merge && !opts->writeout_stage;
 	if ((opts->checkout_worktree && !opts->source_tree &&
 	     !opts->merge && !opts->writeout_stage) ||
-	    preserve_source_tree_history)
+	    preserve_source_tree_history) {
+		clean_status_enable_external_history(the_repository);
 		clean_status_set_config_digest(the_repository,
 					       &opts->clean_digest);
+	}
 	if (repo_read_index_preload(the_repository, &opts->pathspec, 0) < 0)
 		return error(_("index file corrupt"));
 
@@ -916,9 +918,11 @@ static int merge_working_tree(const struct checkout_opts *opts,
 	 * proof only after it proves that the rebuilt index is identical.
 	 */
 	if (opts->discard_changes ||
-	    (!opts->merge && !opts->new_orphan_branch))
+	    (!opts->merge && !opts->new_orphan_branch)) {
+		clean_status_enable_external_history(the_repository);
 		clean_status_set_config_digest(the_repository,
 					       &opts->clean_digest);
+	}
 	if (repo_read_index_preload(the_repository, NULL, 0) < 0) {
 		rollback_lock_file(&lock_file);
 		return error(_("index file corrupt"));