HashType: Rename to HashAlgorithm

To be consistent with CLI, nix API
and many other references.

As part of this, we also converted it to a scoped enum.

#8876

perl/lib/Nix/Store.xs

@@ -205,7 +205,7 @@ void importPaths(int fd, int dontCheckSigs)
 SV * hashPath(char * algo, int base32, char * path)
  PPCODE:
  try {
- Hash h = hashPath(parseHashType(algo), path).first;
+ Hash h = hashPath(parseHashAlgo(algo), path).first;
  auto s = h.to_string(base32 ? HashFormat::Base32 : HashFormat::Base16, false);
  XPUSHs(sv_2mortal(newSVpv(s.c_str(), 0)));
  } catch (Error & e) {
@@ -216,7 +216,7 @@ SV * hashPath(char * algo, int base32, char * path)
 SV * hashFile(char * algo, int base32, char * path)
  PPCODE:
  try {
- Hash h = hashFile(parseHashType(algo), path);
+ Hash h = hashFile(parseHashAlgo(algo), path);
  auto s = h.to_string(base32 ? HashFormat::Base32 : HashFormat::Base16, false);
  XPUSHs(sv_2mortal(newSVpv(s.c_str(), 0)));
  } catch (Error & e) {
@@ -227,7 +227,7 @@ SV * hashFile(char * algo, int base32, char * path)
 SV * hashString(char * algo, int base32, char * s)
  PPCODE:
  try {
- Hash h = hashString(parseHashType(algo), s);
+ Hash h = hashString(parseHashAlgo(algo), s);
  auto s = h.to_string(base32 ? HashFormat::Base32 : HashFormat::Base16, false);
  XPUSHs(sv_2mortal(newSVpv(s.c_str(), 0)));
  } catch (Error & e) {
@@ -238,7 +238,7 @@ SV * hashString(char * algo, int base32, char * s)
 SV * convertHash(char * algo, char * s, int toBase32)
  PPCODE:
  try {
- auto h = Hash::parseAny(s, parseHashType(algo));
+ auto h = Hash::parseAny(s, parseHashAlgo(algo));
  auto s = h.to_string(toBase32 ? HashFormat::Base32 : HashFormat::Base16, false);
  XPUSHs(sv_2mortal(newSVpv(s.c_str(), 0)));
  } catch (Error & e) {
@@ -281,7 +281,7 @@ SV * addToStore(char * srcPath, int recursive, char * algo)
  PPCODE:
  try {
  auto method = recursive ? FileIngestionMethod::Recursive : FileIngestionMethod::Flat;
- auto path = store()->addToStore(std::string(baseNameOf(srcPath)), srcPath, method, parseHashType(algo));
+ auto path = store()->addToStore(std::string(baseNameOf(srcPath)), srcPath, method, parseHashAlgo(algo));
  XPUSHs(sv_2mortal(newSVpv(store()->printStorePath(path).c_str(), 0)));
  } catch (Error & e) {
  croak("%s", e.what());
@@ -291,7 +291,7 @@ SV * addToStore(char * srcPath, int recursive, char * algo)
 SV * makeFixedOutputPath(int recursive, char * algo, char * hash, char * name)
  PPCODE:
  try {
- auto h = Hash::parseAny(hash, parseHashType(algo));
+ auto h = Hash::parseAny(hash, parseHashAlgo(algo));
  auto method = recursive ? FileIngestionMethod::Recursive : FileIngestionMethod::Flat;
  auto path = store()->makeFixedOutputPath(name, FixedOutputInfo {
  .method = method,

src/libexpr/flake/flake.cc

@@ -904,7 +904,7 @@ Fingerprint LockedFlake::getFingerprint() const
  // FIXME: as an optimization, if the flake contains a lock file
  // and we haven't changed it, then it's sufficient to use
  // flake.sourceInfo.storePath for the fingerprint.
- return hashString(htSHA256,
+ return hashString(HashAlgorithm::SHA256,
  fmt("%s;%s;%d;%d;%s",
  flake.storePath.to_string(),
  flake.lockedRef.subdir,

src/libexpr/primops.cc

@@ -1317,7 +1317,7 @@ drvName, Bindings * attrs, Value & v)
  .errPos = state.positions[noPos]
  }));
 
- auto h = newHashAllowEmpty(*outputHash, parseHashTypeOpt(outputHashAlgo));
+ auto h = newHashAllowEmpty(*outputHash, parseHashAlgoOpt(outputHashAlgo));
 
  auto method = ingestionMethod.value_or(FileIngestionMethod::Flat);
 
@@ -1339,7 +1339,7 @@ drvName, Bindings * attrs, Value & v)
  .errPos = state.positions[noPos]
  });
 
- auto ht = parseHashTypeOpt(outputHashAlgo).value_or(htSHA256);
+ auto ht = parseHashAlgoOpt(outputHashAlgo).value_or(HashAlgorithm::SHA256);
  auto method = ingestionMethod.value_or(FileIngestionMethod::Recursive);
 
  for (auto & i : outputs) {
@@ -1348,13 +1348,13 @@ drvName, Bindings * attrs, Value & v)
  drv.outputs.insert_or_assign(i,
  DerivationOutput::Impure {
  .method = method,
- .hashType = ht,
+ .hashAlgo = ht,
  });
  else
  drv.outputs.insert_or_assign(i,
  DerivationOutput::CAFloating {
  .method = method,
- .hashType = ht,
+ .hashAlgo = ht,
  });
  }
  }
@@ -1754,17 +1754,17 @@ static RegisterPrimOp primop_findFile(PrimOp {
 /* Return the cryptographic hash of a file in base-16. */
 static void prim_hashFile(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
- auto type = state.forceStringNoCtx(*args[0], pos, "while evaluating the first argument passed to builtins.hashFile");
- std::optional<HashType> ht = parseHashType(type);
- if (!ht)
+ auto algo = state.forceStringNoCtx(*args[0], pos, "while evaluating the first argument passed to builtins.hashFile");
+ std::optional<HashAlgorithm> ha = parseHashAlgo(algo);
+ if (!ha)
  state.debugThrowLastTrace(Error({
- .msg = hintfmt("unknown hash type '%1%'", type),
+ .msg = hintfmt("unknown hash algo '%1%'", algo),
  .errPos = state.positions[pos]
  }));
 
  auto path = realisePath(state, pos, *args[1]);
 
- v.mkString(hashString(*ht, path.readFile()).to_string(HashFormat::Base16, false));
+ v.mkString(hashString(*ha, path.readFile()).to_string(HashFormat::Base16, false));
 }
 
 static RegisterPrimOp primop_hashFile({
@@ -2341,7 +2341,7 @@ static void prim_path(EvalState & state, const PosIdx pos, Value * * args, Value
  else if (n == "recursive")
  method = FileIngestionMethod { state.forceBool(*attr.value, attr.pos, "while evaluating the `recursive` attribute passed to builtins.path") };
  else if (n == "sha256")
- expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the `sha256` attribute passed to builtins.path"), htSHA256);
+ expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the `sha256` attribute passed to builtins.path"), HashAlgorithm::SHA256);
  else
  state.debugThrowLastTrace(EvalError({
  .msg = hintfmt("unsupported argument '%1%' to 'addPath'", state.symbols[attr.name]),
@@ -3766,18 +3766,18 @@ static RegisterPrimOp primop_stringLength({
 /* Return the cryptographic hash of a string in base-16. */
 static void prim_hashString(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
- auto type = state.forceStringNoCtx(*args[0], pos, "while evaluating the first argument passed to builtins.hashString");
- std::optional<HashType> ht = parseHashType(type);
- if (!ht)
+ auto algo = state.forceStringNoCtx(*args[0], pos, "while evaluating the first argument passed to builtins.hashString");
+ std::optional<HashAlgorithm> ha = parseHashAlgo(algo);
+ if (!ha)
  state.debugThrowLastTrace(Error({
- .msg = hintfmt("unknown hash type '%1%'", type),
+ .msg = hintfmt("unknown hash algo '%1%'", algo),
  .errPos = state.positions[pos]
  }));
 
  NixStringContext context; // discarded
  auto s = state.forceString(*args[1], context, pos, "while evaluating the second argument passed to builtins.hashString");
 
- v.mkString(hashString(*ht, s).to_string(HashFormat::Base16, false));
+ v.mkString(hashString(*ha, s).to_string(HashFormat::Base16, false));
 }
 
 static RegisterPrimOp primop_hashString({
@@ -3800,15 +3800,15 @@ static void prim_convertHash(EvalState & state, const PosIdx pos, Value * * args
  auto hash = state.forceStringNoCtx(*iteratorHash->value, pos, "while evaluating the attribute 'hash'");
 
  Bindings::iterator iteratorHashAlgo = inputAttrs->find(state.symbols.create("hashAlgo"));
- std::optional<HashType> ht = std::nullopt;
+ std::optional<HashAlgorithm> ha = std::nullopt;
  if (iteratorHashAlgo != inputAttrs->end()) {
- ht = parseHashType(state.forceStringNoCtx(*iteratorHashAlgo->value, pos, "while evaluating the attribute 'hashAlgo'"));
+ ha = parseHashAlgo(state.forceStringNoCtx(*iteratorHashAlgo->value, pos, "while evaluating the attribute 'hashAlgo'"));
  }
 
  Bindings::iterator iteratorToHashFormat = getAttr(state, state.symbols.create("toHashFormat"), args[0]->attrs, "while locating the attribute 'toHashFormat'");
  HashFormat hf = parseHashFormat(state.forceStringNoCtx(*iteratorToHashFormat->value, pos, "while evaluating the attribute 'toHashFormat'"));
 
- v.mkString(Hash::parseAny(hash, ht).to_string(hf, hf == HashFormat::SRI));
+ v.mkString(Hash::parseAny(hash, ha).to_string(hf, hf == HashFormat::SRI));
 }
 
 static RegisterPrimOp primop_convertHash({

src/libexpr/primops/fetchMercurial.cc

@@ -31,7 +31,7 @@ static void prim_fetchMercurial(EvalState & state, const PosIdx pos, Value * * a
  // be both a revision or a branch/tag name.
  auto value = state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the `rev` attribute passed to builtins.fetchMercurial");
  if (std::regex_match(value.begin(), value.end(), revRegex))
- rev = Hash::parseAny(value, htSHA1);
+ rev = Hash::parseAny(value, HashAlgorithm::SHA1);
  else
  ref = value;
  }
@@ -79,7 +79,7 @@ static void prim_fetchMercurial(EvalState & state, const PosIdx pos, Value * * a
  attrs2.alloc("branch").mkString(*input2.getRef());
  // Backward compatibility: set 'rev' to
  // 0000000000000000000000000000000000000000 for a dirty tree.
- auto rev2 = input2.getRev().value_or(Hash(htSHA1));
+ auto rev2 = input2.getRev().value_or(Hash(HashAlgorithm::SHA1));
  attrs2.alloc("rev").mkString(rev2.gitRev());
  attrs2.alloc("shortRev").mkString(rev2.gitRev().substr(0, 12));
  if (auto revCount = input2.getRevCount())

src/libexpr/primops/fetchTree.cc

@@ -46,7 +46,7 @@ void emitTreeAttrs(
  attrs.alloc("shortRev").mkString(rev->gitShortRev());
  } else if (emptyRevFallback) {
  // Backwards compat for `builtins.fetchGit`: dirty repos return an empty sha1 as rev
- auto emptyHash = Hash(htSHA1);
+ auto emptyHash = Hash(HashAlgorithm::SHA1);
  attrs.alloc("rev").mkString(emptyHash.gitRev());
  attrs.alloc("shortRev").mkString(emptyHash.gitShortRev());
  }
@@ -246,7 +246,7 @@ static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v
  if (n == "url")
  url = state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the url we should fetch");
  else if (n == "sha256")
- expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the sha256 of the content we should fetch"), htSHA256);
+ expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the sha256 of the content we should fetch"), HashAlgorithm::SHA256);
  else if (n == "name")
  name = state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the name of the content we should fetch");
  else
@@ -276,7 +276,7 @@ static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v
  state.debugThrowLastTrace(EvalError("in pure evaluation mode, '%s' requires a 'sha256' argument", who));
 
  // early exit if pinned and already in the store
- if (expectedHash && expectedHash->type == htSHA256) {
+ if (expectedHash && expectedHash->algo == HashAlgorithm::SHA256) {
  auto expectedPath = state.store->makeFixedOutputPath(
  name,
  FixedOutputInfo {
@@ -301,7 +301,7 @@ static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v
  if (expectedHash) {
  auto hash = unpack
  ? state.store->queryPathInfo(storePath)->narHash
- : hashFile(htSHA256, state.store->toRealPath(storePath));
+ : hashFile(HashAlgorithm::SHA256, state.store->toRealPath(storePath));
  if (hash != *expectedHash)
  state.debugThrowLastTrace(EvalError((unsigned int) 102, "hash mismatch in file downloaded from '%s':\n specified: %s\n got: %s",
  *url, expectedHash->to_string(HashFormat::Base32, true), hash.to_string(HashFormat::Base32, true)));

src/libfetchers/fetchers.cc

@@ -289,8 +289,8 @@ std::string Input::getType() const
 std::optional<Hash> Input::getNarHash() const
 {
  if (auto s = maybeGetStrAttr(attrs, "narHash")) {
- auto hash = s->empty() ? Hash(htSHA256) : Hash::parseSRI(*s);
- if (hash.type != htSHA256)
+ auto hash = s->empty() ? Hash(HashAlgorithm::SHA256) : Hash::parseSRI(*s);
+ if (hash.algo != HashAlgorithm::SHA256)
  throw UsageError("narHash must use SHA-256");
  return hash;
  }
@@ -314,7 +314,7 @@ std::optional<Hash> Input::getRev() const
  } catch (BadHash &e) {
  // Default to sha1 for backwards compatibility with existing
  // usages (e.g. `builtins.fetchTree` calls or flake inputs).
- hash = Hash::parseAny(*s, htSHA1);
+ hash = Hash::parseAny(*s, HashAlgorithm::SHA1);
  }
  }
 

src/libfetchers/git-utils.cc

@@ -91,7 +91,7 @@ Hash toHash(const git_oid & oid)
  #ifdef GIT_EXPERIMENTAL_SHA256
  assert(oid.type == GIT_OID_SHA1);
  #endif
- Hash hash(htSHA1);
+ Hash hash(HashAlgorithm::SHA1);
  memcpy(hash.hash, oid.id, hash.hashSize);
  return hash;
 }
@@ -439,7 +439,7 @@ struct GitRepoImpl : GitRepo, std::enable_shared_from_this<GitRepoImpl>
  std::string re = R"(Good "git" signature for \* with .* key SHA256:[)";
  for (const fetchers::PublicKey & k : publicKeys){
  // Calculate sha256 fingerprint from public key and escape the regex symbol '+' to match the key literally
- auto fingerprint = trim(hashString(htSHA256, base64Decode(k.key)).to_string(nix::HashFormat::Base64, false), "=");
+ auto fingerprint = trim(hashString(HashAlgorithm::SHA256, base64Decode(k.key)).to_string(nix::HashFormat::Base64, false), "=");
  auto escaped_fingerprint = std::regex_replace(fingerprint, std::regex("\\+"), "\\+" );
  re += "(" + escaped_fingerprint + ")";
  }

src/libfetchers/git.cc

@@ -52,7 +52,7 @@ bool touchCacheFile(const Path & path, time_t touch_time)
 Path getCachePath(std::string_view key)
 {
  return getCacheDir() + "/nix/gitv3/" +
- hashString(htSHA256, key).to_string(HashFormat::Base32, false);
+ hashString(HashAlgorithm::SHA256, key).to_string(HashFormat::Base32, false);
 }
 
 // Returns the name of the HEAD branch.
@@ -369,7 +369,7 @@ struct GitInputScheme : InputScheme
  {
  auto checkHashType = [&](const std::optional<Hash> & hash)
  {
- if (hash.has_value() && !(hash->type == htSHA1 || hash->type == htSHA256))
+ if (hash.has_value() && !(hash->algo == HashAlgorithm::SHA1 || hash->algo == HashAlgorithm::SHA256))
  throw Error("Hash '%s' is not supported by Git. Supported types are sha1 and sha256.", hash->to_string(HashFormat::Base16, true));
  };
 
@@ -559,7 +559,7 @@ struct GitInputScheme : InputScheme
  repoInfo.url
  );
  } else
- input.attrs.insert_or_assign("rev", Hash::parseAny(chomp(readFile(localRefFile)), htSHA1).gitRev());
+ input.attrs.insert_or_assign("rev", Hash::parseAny(chomp(readFile(localRefFile)), HashAlgorithm::SHA1).gitRev());
 
  // cache dir lock is removed at scope end; we will only use read-only operations on specific revisions in the remainder
  }

src/libfetchers/github.cc

@@ -42,7 +42,7 @@ struct GitArchiveInputScheme : InputScheme
  auto size = path.size();
  if (size == 3) {
  if (std::regex_match(path[2], revRegex))
- rev = Hash::parseAny(path[2], htSHA1);
+ rev = Hash::parseAny(path[2], HashAlgorithm::SHA1);
  else if (std::regex_match(path[2], refRegex))
  ref = path[2];
  else
@@ -68,7 +68,7 @@ struct GitArchiveInputScheme : InputScheme
  if (name == "rev") {
  if (rev)
  throw BadURL("URL '%s' contains multiple commit hashes", url.url);
- rev = Hash::parseAny(value, htSHA1);
+ rev = Hash::parseAny(value, HashAlgorithm::SHA1);
  }
  else if (name == "ref") {
  if (!std::regex_match(value, refRegex))
@@ -284,7 +284,7 @@ struct GitHubInputScheme : GitArchiveInputScheme
  readFile(
  store->toRealPath(
  downloadFile(store, url, "source", false, headers).storePath)));
- auto rev = Hash::parseAny(std::string { json["sha"] }, htSHA1);
+ auto rev = Hash::parseAny(std::string { json["sha"] }, HashAlgorithm::SHA1);
  debug("HEAD revision for '%s' is %s", url, rev.gitRev());
  return rev;
  }
@@ -356,7 +356,7 @@ struct GitLabInputScheme : GitArchiveInputScheme
  readFile(
  store->toRealPath(
  downloadFile(store, url, "source", false, headers).storePath)));
- auto rev = Hash::parseAny(std::string(json[0]["id"]), htSHA1);
+ auto rev = Hash::parseAny(std::string(json[0]["id"]), HashAlgorithm::SHA1);
  debug("HEAD revision for '%s' is %s", url, rev.gitRev());
  return rev;
  }
@@ -448,7 +448,7 @@ struct SourceHutInputScheme : GitArchiveInputScheme
  if(!id)
  throw BadURL("in '%d', couldn't find ref '%d'", input.to_string(), ref);
 
- auto rev = Hash::parseAny(*id, htSHA1);
+ auto rev = Hash::parseAny(*id, HashAlgorithm::SHA1);
  debug("HEAD revision for '%s' is %s", fmt("%s/%s", base_url, ref), rev.gitRev());
  return rev;
  }

src/libfetchers/indirect.cc

@@ -20,7 +20,7 @@ struct IndirectInputScheme : InputScheme
  if (path.size() == 1) {
  } else if (path.size() == 2) {
  if (std::regex_match(path[1], revRegex))
- rev = Hash::parseAny(path[1], htSHA1);
+ rev = Hash::parseAny(path[1], HashAlgorithm::SHA1);
  else if (std::regex_match(path[1], refRegex))
  ref = path[1];
  else
@@ -31,7 +31,7 @@ struct IndirectInputScheme : InputScheme
  ref = path[1];
  if (!std::regex_match(path[2], revRegex))
  throw BadURL("in flake URL '%s', '%s' is not a commit hash", url.url, path[2]);
- rev = Hash::parseAny(path[2], htSHA1);
+ rev = Hash::parseAny(path[2], HashAlgorithm::SHA1);
  } else
  throw BadURL("GitHub URL '%s' is invalid", url.url);
 

src/libfetchers/input-accessor.cc

@@ -44,8 +44,8 @@ StorePath InputAccessor::fetchToStore(
 
  auto storePath =
  settings.readOnlyMode
- ? store->computeStorePathFromDump(*source, name, method, htSHA256).first
- : store->addToStoreFromDump(*source, name, method, htSHA256, repair);
+ ? store->computeStorePathFromDump(*source, name, method, HashAlgorithm::SHA256).first
+ : store->addToStoreFromDump(*source, name, method, HashAlgorithm::SHA256, repair);
 
  if (cacheKey)
  fetchers::getCache()->add(store, *cacheKey, {}, storePath, true);