Enable readability-inconsistent-declaration-parameter-name

Databean · Databean · commit b9cdc42d0350 · 2024-11-14T16:01:01.000-08:00
See https://clang.llvm.org/extra/clang-tidy/checks/readability/inconsistent-declaration-parameter-name.html
diff --git a/base/cvd/.clang-tidy b/base/cvd/.clang-tidy
@@ -8,6 +8,7 @@ Checks: &checks >-
   readability-avoid-const-params-in-decls,
   readability-const-return-type,
   readability-container-size-empty,
+  readability-inconsistent-declaration-parameter-name,
 
 UseColor: true
 
diff --git a/base/cvd/cuttlefish/common/libs/fs/shared_fd.h b/base/cvd/cuttlefish/common/libs/fs/shared_fd.h
@@ -249,7 +249,7 @@ class WeakFD {
 class ScopedMMap {
  public:
   ScopedMMap();
-  ScopedMMap(void* ptr, size_t size);
+  ScopedMMap(void* ptr, size_t len);
   ScopedMMap(const ScopedMMap& other) = delete;
   ScopedMMap& operator=(const ScopedMMap& other) = delete;
   ScopedMMap(ScopedMMap&& other);
diff --git a/base/cvd/cuttlefish/common/libs/fs/shared_fd_stream.cpp b/base/cvd/cuttlefish/common/libs/fs/shared_fd_stream.cpp
@@ -57,7 +57,7 @@ int SharedFDStreambuf::underflow() {
   return static_cast<int>(*gptr());
 }
 
-std::streamsize SharedFDStreambuf::xsgetn(char* dst, std::streamsize count) {
+std::streamsize SharedFDStreambuf::xsgetn(char* dest, std::streamsize count) {
   std::streamsize bytes_read = 0;
   while (bytes_read < count) {
     if (in_avail() == 0) {
@@ -67,7 +67,7 @@ std::streamsize SharedFDStreambuf::xsgetn(char* dst, std::streamsize count) {
     }
     std::streamsize buffer_count =
         std::min(static_cast<std::streamsize>(in_avail()), count - bytes_read);
-    std::memcpy(dst + bytes_read, gptr(), buffer_count);
+    std::memcpy(dest + bytes_read, gptr(), buffer_count);
     gbump(buffer_count);
     bytes_read += buffer_count;
   }
@@ -84,10 +84,10 @@ int SharedFDStreambuf::overflow(int c) {
   return c;
 }
 
-std::streamsize SharedFDStreambuf::xsputn(const char* src,
+std::streamsize SharedFDStreambuf::xsputn(const char* source,
                                           std::streamsize count) {
   return static_cast<std::streamsize>(
-    WriteAll(shared_fd_, src, static_cast<std::size_t>(count)));
+      WriteAll(shared_fd_, source, static_cast<std::size_t>(count)));
 }
 
 int SharedFDStreambuf::pbackfail(int c) {
@@ -107,4 +107,4 @@ SharedFDOstream::SharedFDOstream(SharedFD shared_fd)
 SharedFDIstream::SharedFDIstream(SharedFD shared_fd)
   : std::istream(nullptr), buf_(shared_fd) { rdbuf(&buf_); }
 
-} // namespace cuttlefish
+}  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/common/libs/utils/files.h b/base/cvd/cuttlefish/common/libs/utils/files.h
@@ -28,9 +28,11 @@
 namespace cuttlefish {
 bool FileExists(const std::string& path, bool follow_symlinks = true);
 Result<dev_t> FileDeviceId(const std::string& path);
-Result<bool> CanHardLink(const std::string& path1, const std::string& path2);
+Result<bool> CanHardLink(const std::string& source,
+                         const std::string& destination);
 Result<ino_t> FileInodeNumber(const std::string& path);
-Result<bool> AreHardLinked(const std::string& path1, const std::string& path2);
+Result<bool> AreHardLinked(const std::string& source,
+                           const std::string& destination);
 Result<std::string> CreateHardLink(const std::string& target,
                                    const std::string& hardlink,
                                    bool overwrite_existing = false);
diff --git a/base/cvd/cuttlefish/common/libs/utils/flag_parser.cpp b/base/cvd/cuttlefish/common/libs/utils/flag_parser.cpp
@@ -591,10 +591,11 @@ Flag GflagsCompatFlag(const std::string& name,
 }
 
 Flag GflagsCompatFlag(const std::string& name, std::vector<bool>& value,
-                      const bool def_val) {
+                      const bool default_value) {
   return GflagsCompatFlag(name)
       .Getter([&value]() { return fmt::format("{}", fmt::join(value, ",")); })
-      .Setter([&name, &value, def_val](const FlagMatch& match) -> Result<void> {
+      .Setter([&name, &value,
+               default_value](const FlagMatch& match) -> Result<void> {
         if (match.value.empty()) {
           value.clear();
           return {};
@@ -606,7 +607,7 @@ Flag GflagsCompatFlag(const std::string& name, std::vector<bool>& value,
         output_vals.reserve(str_vals.size());
         for (const auto& str_val : str_vals) {
           if (str_val.empty()) {
-            output_vals.push_back(def_val);
+            output_vals.push_back(default_value);
           } else {
             output_vals.push_back(CF_EXPECT(ParseBool(str_val, name)));
           }
diff --git a/base/cvd/cuttlefish/common/libs/utils/flag_parser.h b/base/cvd/cuttlefish/common/libs/utils/flag_parser.h
@@ -89,8 +89,8 @@ class Flag {
   /* Examines a list of arguments, removing any matches from the list and
    * invoking the `Setter` for every match. Returns `false` if the callback ever
    * returns `false`. Non-matches are left in place. */
-  Result<void> Parse(std::vector<std::string>& flags) const;
-  Result<void> Parse(std::vector<std::string>&& flags) const;
+  Result<void> Parse(std::vector<std::string>& arguments) const;
+  Result<void> Parse(std::vector<std::string>&& arguments) const;
 
   /* Write gflags `--helpxml` style output for a string-type flag. */
   bool WriteGflagsCompatXml(std::ostream&) const;
diff --git a/base/cvd/cuttlefish/common/libs/utils/subprocess.cpp b/base/cvd/cuttlefish/common/libs/utils/subprocess.cpp
@@ -131,12 +131,12 @@ SubprocessOptions SubprocessOptions::Verbose(bool verbose) && {
 }
 
 #ifdef __linux__
-SubprocessOptions& SubprocessOptions::ExitWithParent(bool v) & {
-  exit_with_parent_ = v;
+SubprocessOptions& SubprocessOptions::ExitWithParent(bool exit_with_parent) & {
+  exit_with_parent_ = exit_with_parent;
   return *this;
 }
-SubprocessOptions SubprocessOptions::ExitWithParent(bool v) && {
-  exit_with_parent_ = v;
+SubprocessOptions SubprocessOptions::ExitWithParent(bool exit_with_parent) && {
+  exit_with_parent_ = exit_with_parent;
   return std::move(*this);
 }
 #endif
diff --git a/base/cvd/cuttlefish/common/libs/utils/subprocess.h b/base/cvd/cuttlefish/common/libs/utils/subprocess.h
@@ -340,7 +340,7 @@ std::ostream& operator<<(std::ostream& out, const Command& command);
  * If some setup fails, `command` fails to start, or `command` exits due to a
  * signal, the return value will be negative.
  */
-int RunWithManagedStdio(Command&& command, const std::string* stdin,
+int RunWithManagedStdio(Command&& cmd_tmp, const std::string* stdin,
                         std::string* stdout, std::string* stderr,
                         SubprocessOptions options = SubprocessOptions());
 
diff --git a/base/cvd/cuttlefish/common/libs/utils/tee_logging.cpp b/base/cvd/cuttlefish/common/libs/utils/tee_logging.cpp
@@ -274,19 +274,19 @@ static std::vector<SeverityTarget> SeverityTargetsForFiles(
 }
 
 TeeLogger LogToFiles(const std::vector<std::string>& files,
-                     const std::string& prefix) {
-  return TeeLogger(SeverityTargetsForFiles(files), prefix);
+                     const std::string& log_prefix) {
+  return TeeLogger(SeverityTargetsForFiles(files), log_prefix);
 }
 
 TeeLogger LogToStderrAndFiles(
-    const std::vector<std::string>& files, const std::string& prefix,
+    const std::vector<std::string>& files, const std::string& log_prefix,
     MetadataLevel stderr_level,
     std::optional<android::base::LogSeverity> stderr_severity) {
   std::vector<SeverityTarget> log_severities = SeverityTargetsForFiles(files);
   log_severities.push_back(
       SeverityTarget{stderr_severity ? *stderr_severity : ConsoleSeverity(),
                      SharedFD::Dup(/* stderr */ 2), stderr_level});
-  return TeeLogger(log_severities, prefix);
+  return TeeLogger(log_severities, log_prefix);
 }
 
 }  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/common/libs/utils/tee_logging.h b/base/cvd/cuttlefish/common/libs/utils/tee_logging.h
@@ -67,7 +67,7 @@ TeeLogger LogToFiles(const std::vector<std::string>& files,
 TeeLogger LogToStderrAndFiles(
     const std::vector<std::string>& files, const std::string& log_prefix = "",
     MetadataLevel stderr_level = MetadataLevel::ONLY_MESSAGE,
-    std::optional<android::base::LogSeverity> stderr_serverity = std::nullopt);
+    std::optional<android::base::LogSeverity> stderr_severity = std::nullopt);
 
 std::string StripColorCodes(const std::string& str);
 
diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/command_request.h b/base/cvd/cuttlefish/host/commands/cvd/cli/command_request.h
@@ -45,7 +45,7 @@ class CommandRequest {
  private:
   friend class CommandRequestBuilder;
   CommandRequest(cvd_common::Args args, cvd_common::Envs env,
-                 selector::SelectorOptions cvd_args);
+                 selector::SelectorOptions selectors);
 
   cvd_common::Args args_;
   cvd_common::Envs env_;
diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/commands/help.cpp b/base/cvd/cuttlefish/host/commands/cvd/cli/commands/help.cpp
@@ -147,9 +147,8 @@ class CvdHelpHandler : public CvdServerHandler {
 };
 
 std::unique_ptr<CvdServerHandler> NewCvdHelpHandler(
-    const std::vector<std::unique_ptr<CvdServerHandler>>& request_handlers) {
-  return std::unique_ptr<CvdServerHandler>(
-      new CvdHelpHandler(request_handlers));
+    const std::vector<std::unique_ptr<CvdServerHandler>>& server_handlers) {
+  return std::unique_ptr<CvdServerHandler>(new CvdHelpHandler(server_handlers));
 }
 
 }  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/frontline_parser.cpp b/base/cvd/cuttlefish/host/commands/cvd/cli/frontline_parser.cpp
@@ -59,9 +59,9 @@ Result<std::unique_ptr<FrontlineParser>> FrontlineParser::Parse(
   return frontline_parser;
 }
 
-FrontlineParser::FrontlineParser(const ParserParam& param)
-    : server_supported_subcmds_{param.server_supported_subcmds},
-      all_args_(param.all_args) {}
+FrontlineParser::FrontlineParser(const ParserParam& parser_param)
+    : server_supported_subcmds_{parser_param.server_supported_subcmds},
+      all_args_(parser_param.all_args) {}
 
 Result<void> FrontlineParser::Separate() {
   arguments_separator_ = CF_EXPECT(CallSeparator());
diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/frontline_parser.h b/base/cvd/cuttlefish/host/commands/cvd/cli/frontline_parser.h
@@ -62,7 +62,7 @@ class FrontlineParser {
   const cvd_common::Args& CvdArgs() const;
 
  private:
-  FrontlineParser(const ParserParam& parser);
+  FrontlineParser(const ParserParam& parser_param);
 
   // internal workers in order
   Result<void> Separate();
diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/cf_configs_instances.h b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/cf_configs_instances.h
@@ -25,6 +25,6 @@
 namespace cuttlefish {
 
 Result<std::vector<std::string>> GenerateInstancesFlags(
-    const cvd::config::EnvironmentSpecification& config);
+    const cvd::config::EnvironmentSpecification& cfg);
 
 };  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_security_configs.h b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_security_configs.h
@@ -24,6 +24,6 @@
 namespace cuttlefish {
 
 std::vector<std::string> GenerateSecurityFlags(
-    const cvd::config::EnvironmentSpecification& root);
+    const cvd::config::EnvironmentSpecification& cfg);
 
 };  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/selector/creation_analyzer.cpp b/base/cvd/cuttlefish/host/commands/cvd/cli/selector/creation_analyzer.cpp
@@ -46,10 +46,10 @@ Result<CreationAnalyzer> CreationAnalyzer::Create(
 CreationAnalyzer::CreationAnalyzer(
     const CreationAnalyzerParam& param,
     StartSelectorParser&& selector_options_parser,
-    InstanceLockFileManager& instance_file_lock_manager)
+    InstanceLockFileManager& instance_lock_file_manager)
     : envs_(param.envs),
       selector_options_parser_{std::move(selector_options_parser)},
-      instance_file_lock_manager_{instance_file_lock_manager} {}
+      instance_lock_file_manager_{instance_lock_file_manager} {}
 
 static std::unordered_map<unsigned, InstanceLockFile> ConstructIdLockFileMap(
     std::vector<InstanceLockFile>&& lock_files) {
@@ -91,7 +91,7 @@ CreationAnalyzer::AnalyzeInstanceIdsInternal(
     return instance_info;
   }
   auto acquired_all_file_locks =
-      CF_EXPECT(instance_file_lock_manager_.LockAllAvailable());
+      CF_EXPECT(instance_lock_file_manager_.LockAllAvailable());
   auto id_to_lockfile_map =
       ConstructIdLockFileMap(std::move(acquired_all_file_locks));
   for (const auto& [id, instance_name] : id_name_pairs) {
@@ -113,7 +113,7 @@ CreationAnalyzer::AnalyzeInstanceIdsInternal(bool acquire_file_locks) {
   // As this test was done earlier, this line must not fail
   const auto n_instances = selector_options_parser_.RequestedNumInstances();
   auto acquired_all_file_locks =
-      CF_EXPECT(instance_file_lock_manager_.LockAllAvailable());
+      CF_EXPECT(instance_lock_file_manager_.LockAllAvailable());
   auto id_to_lockfile_map =
       ConstructIdLockFileMap(std::move(acquired_all_file_locks));
 
diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/selector/creation_analyzer.h b/base/cvd/cuttlefish/host/commands/cvd/cli/selector/creation_analyzer.h
@@ -161,7 +161,7 @@ class CreationAnalyzer {
 
   // internal, temporary
   StartSelectorParser selector_options_parser_;
-  InstanceLockFileManager& instance_file_lock_manager_;
+  InstanceLockFileManager& instance_lock_file_manager_;
 };
 
 }  // namespace selector
diff --git a/base/cvd/cuttlefish/host/commands/cvd/instances/instance_database.h b/base/cvd/cuttlefish/host/commands/cvd/instances/instance_database.h
@@ -95,7 +95,7 @@ class InstanceDatabase {
   }
 
   static std::vector<LocalInstanceGroup> FindGroups(
-      const cvd::PersistentData& data, const Filter& param);
+      const cvd::PersistentData& data, const Filter& filter);
 
   DataViewer viewer_;
 };
diff --git a/base/cvd/cuttlefish/host/commands/cvd/instances/instance_database_types.h b/base/cvd/cuttlefish/host/commands/cvd/instances/instance_database_types.h
@@ -28,7 +28,7 @@ namespace cuttlefish {
 using CvdServerClock = std::chrono::system_clock;
 using TimeStamp = std::chrono::time_point<CvdServerClock>;
 
-Result<TimeStamp> DeserializeTimePoint(const Json::Value& group_json);
+Result<TimeStamp> DeserializeTimePoint(const Json::Value& time_point_json);
 std::string Format(const TimeStamp&);
 
 }  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/host/commands/cvd/instances/reset_client_utils.cpp b/base/cvd/cuttlefish/host/commands/cvd/instances/reset_client_utils.cpp
@@ -121,9 +121,9 @@ Result<void> RunCvdProcessManager::RunStopCvd(const GroupProcInfo& group_info,
   return {};
 }
 
-Result<void> RunCvdProcessManager::RunStopCvdAll(bool clear_instance_dirs) {
+Result<void> RunCvdProcessManager::RunStopCvdAll(bool clear_runtime_dirs) {
   for (const auto& group_info : run_cvd_process_collector_.CfGroups()) {
-    auto stop_cvd_result = RunStopCvd(group_info, clear_instance_dirs);
+    auto stop_cvd_result = RunStopCvd(group_info, clear_runtime_dirs);
     if (!stop_cvd_result.ok()) {
       LOG(ERROR) << stop_cvd_result.error().FormatForEnv();
       continue;
@@ -194,9 +194,9 @@ Result<void> RunCvdProcessManager::DeleteLockFile(
   return {};
 }
 
-Result<void> KillAllCuttlefishInstances(bool clear_instance_dirs) {
+Result<void> KillAllCuttlefishInstances(bool clear_runtime_dirs) {
   RunCvdProcessManager manager = CF_EXPECT(RunCvdProcessManager::Get());
-  CF_EXPECT(manager.KillAllCuttlefishInstances(clear_instance_dirs));
+  CF_EXPECT(manager.KillAllCuttlefishInstances(clear_runtime_dirs));
   return {};
 }
 
@@ -269,10 +269,12 @@ Result<void> RunCvdProcessManager::KillAllCuttlefishInstances(
   return {};
 }
 
-Result<void> RunCvdProcessManager::ForcefullyStopGroup(const uid_t id) {
+Result<void> RunCvdProcessManager::ForcefullyStopGroup(
+    const uid_t any_id_in_group) {
   auto groups_info = run_cvd_process_collector_.CfGroups();
   for (const auto& group_info : groups_info) {
-    if (!Contains(group_info.instances_, static_cast<unsigned>(id))) {
+    if (!Contains(group_info.instances_,
+                  static_cast<unsigned>(any_id_in_group))) {
       continue;
     }
     CF_EXPECT(ForcefullyStopGroup(group_info));
diff --git a/base/cvd/cuttlefish/host/commands/cvd/instances/reset_client_utils.h b/base/cvd/cuttlefish/host/commands/cvd/instances/reset_client_utils.h
@@ -36,7 +36,7 @@ class RunCvdProcessManager {
  private:
   RunCvdProcessManager() = delete;
   RunCvdProcessManager(RunCvdProcessCollector&&);
-  static Result<void> RunStopCvd(const GroupProcInfo& run_cvd_info,
+  static Result<void> RunStopCvd(const GroupProcInfo& group_info,
                                  bool clear_runtime_dirs);
   Result<void> RunStopCvdAll(bool clear_runtime_dirs);
   Result<void> SendSignal(const GroupProcInfo&);
diff --git a/base/cvd/cuttlefish/host/libs/config/config_utils.h b/base/cvd/cuttlefish/host/libs/config/config_utils.h
@@ -48,8 +48,8 @@ std::string RandomSerialNumber(const std::string& prefix);
 
 std::string DefaultHostArtifactsPath(const std::string& file);
 std::string DefaultQemuBinaryDir();
-std::string HostBinaryPath(const std::string& file);
-std::string HostUsrSharePath(const std::string& file);
+std::string HostBinaryPath(const std::string& binary_name);
+std::string HostUsrSharePath(const std::string& binary_name);
 std::string HostQemuBiosPath();
 std::string DefaultGuestImagePath(const std::string& file);
 std::string DefaultEnvironmentPath(const char* environment_key,
diff --git a/base/cvd/cuttlefish/host/libs/web/android_build_api.cpp b/base/cvd/cuttlefish/host/libs/web/android_build_api.cpp
@@ -402,17 +402,16 @@ Result<void> AndroidBuildApi::ArtifactToFile(const DeviceBuild& build,
 
 Result<void> AndroidBuildApi::ArtifactToFile(const DirectoryBuild& build,
                                              const std::string& artifact,
-                                             const std::string& destination) {
+                                             const std::string& path) {
   for (const auto& path : build.paths) {
     auto source = path + "/" + artifact;
     if (!FileExists(source)) {
       continue;
     }
-    unlink(destination.c_str());
-    CF_EXPECT(symlink(source.c_str(), destination.c_str()) == 0,
-              "Could not create symlink from " << source << " to "
-                                               << destination << ": "
-                                               << strerror(errno));
+    unlink(path.c_str());
+    CF_EXPECT(symlink(source.c_str(), path.c_str()) == 0,
+              "Could not create symlink from " << source << " to " << path
+                                               << ": " << strerror(errno));
     return {};
   }
   return CF_ERR("Could not find artifact \"" << artifact << "\" in build \""
diff --git a/base/cvd/cuttlefish/host/libs/web/credential_source.cc b/base/cvd/cuttlefish/host/libs/web/credential_source.cc
@@ -106,7 +106,7 @@ class RefreshTokenCredentialSource : public RefreshingCredentialSource {
  public:
   static Result<std::unique_ptr<RefreshTokenCredentialSource>>
   FromOauth2ClientFile(HttpClient& http_client,
-                       const std::string& oauthcontents);
+                       const std::string& oauth_contents);
 
   RefreshTokenCredentialSource(HttpClient& http_client,
                                const std::string& client_id,

Original file line number	Diff line number	Diff line change
`@@ -131,12 +131,12 @@ SubprocessOptions SubprocessOptions::Verbose(bool verbose) && {`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`#ifdef __linux__`
`134`		`-SubprocessOptions& SubprocessOptions::ExitWithParent(bool v) & {`
`135`		`- exit_with_parent_ = v;`
	`134`	`+SubprocessOptions& SubprocessOptions::ExitWithParent(bool exit_with_parent) & {`
	`135`	`+ exit_with_parent_ = exit_with_parent;`
`136`	`136`	`return *this;`
`137`	`137`	`}`
`138`		`-SubprocessOptions SubprocessOptions::ExitWithParent(bool v) && {`
`139`		`- exit_with_parent_ = v;`
	`138`	`+SubprocessOptions SubprocessOptions::ExitWithParent(bool exit_with_parent) && {`
	`139`	`+ exit_with_parent_ = exit_with_parent;`
`140`	`140`	`return std::move(*this);`
`141`	`141`	`}`
`142`	`142`	`#endif`