cmCTest*Command: Port away from cmCommand

Copy the necessary parts, but remove cloning and make all commands
immutable.

Source/CMakeLists.txt

@@ -1076,6 +1076,7 @@ add_library(
   CTest/cmCTestBuildAndTest.cxx
   CTest/cmCTestBuildCommand.cxx
   CTest/cmCTestBuildHandler.cxx
+  CTest/cmCTestCommand.cxx
   CTest/cmCTestConfigureCommand.cxx
   CTest/cmCTestConfigureHandler.cxx
   CTest/cmCTestCoverageCommand.cxx

Source/CTest/cmCTestBuildCommand.cxx

@@ -12,7 +12,6 @@
 #include "cmCTest.h"
 #include "cmCTestBuildHandler.h"
 #include "cmCTestGenericHandler.h"
-#include "cmCommand.h"
 #include "cmExecutionStatus.h"
 #include "cmGlobalGenerator.h"
 #include "cmMakefile.h"
@@ -22,15 +21,8 @@
 #include "cmValue.h"
 #include "cmake.h"
 
-std::unique_ptr<cmCommand> cmCTestBuildCommand::Clone()
-{
-  auto ni = cm::make_unique<cmCTestBuildCommand>();
-  ni->CTest = this->CTest;
-  return std::unique_ptr<cmCommand>(std::move(ni));
-}
-
 bool cmCTestBuildCommand::InitialPass(std::vector<std::string> const& args,
-                                      cmExecutionStatus& status)
+                                      cmExecutionStatus& status) const
 {
   static auto const parser =
     cmArgumentParser<BuildArguments>{ MakeHandlerParser<BuildArguments>() }

Source/CTest/cmCTestBuildCommand.h

@@ -12,7 +12,6 @@
 
 class cmExecutionStatus;
 class cmCTestGenericHandler;
-class cmCommand;
 
 class cmCTestBuildCommand : public cmCTestHandlerCommand
 {
@@ -32,8 +31,6 @@ protected:
   };
 
 private:
-  std::unique_ptr<cmCommand> Clone() override;
-
   std::string GetName() const override { return "ctest_build"; }
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
@@ -44,5 +41,5 @@ private:
                                cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };

Source/CTest/cmCTestCommand.cxx

@@ -0,0 +1,19 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestCommand.h"
+
+#include "cmExecutionStatus.h"
+#include "cmMakefile.h"
+
+bool cmCTestCommand::operator()(std::vector<cmListFileArgument> const& args,
+                                cmExecutionStatus& status) const
+{
+  cmMakefile& mf = status.GetMakefile();
+  std::vector<std::string> expandedArguments;
+  if (!mf.ExpandArguments(args, expandedArguments)) {
+    // There was an error expanding arguments.  It was already
+    // reported, so we can skip this command without error.
+    return true;
+  }
+  return this->InitialPass(expandedArguments, status);
+}

Source/CTest/cmCTestCommand.h

@@ -2,9 +2,14 @@
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #pragma once
 
-#include "cmCommand.h"
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
 
 class cmCTest;
+class cmExecutionStatus;
+struct cmListFileArgument;
 
 /** \class cmCTestCommand
  * \brief A superclass for all commands added to the CTestScriptHandler
@@ -13,8 +18,25 @@ class cmCTest;
  * the ctest script handlers parser.
  *
  */
-class cmCTestCommand : public cmCommand
+class cmCTestCommand
 {
 public:
+  cmCTestCommand(cmCTest* ctest)
+    : CTest(ctest)
+  {
+  }
+
+  virtual ~cmCTestCommand() = default;
+  cmCTestCommand(cmCTestCommand const&) = default;
+  cmCTestCommand& operator=(cmCTestCommand const&) = default;
+
+  bool operator()(std::vector<cmListFileArgument> const& args,
+                  cmExecutionStatus& status) const;
+
+private:
+  virtual bool InitialPass(std::vector<std::string> const& args,
+                           cmExecutionStatus&) const = 0;
+
+protected:
   cmCTest* CTest = nullptr;
 };

Source/CTest/cmCTestConfigureCommand.cxx

@@ -14,7 +14,6 @@
 #include "cmCTest.h"
 #include "cmCTestConfigureHandler.h"
 #include "cmCTestGenericHandler.h"
-#include "cmCommand.h"
 #include "cmExecutionStatus.h"
 #include "cmGlobalGenerator.h"
 #include "cmList.h"
@@ -24,13 +23,6 @@
 #include "cmValue.h"
 #include "cmake.h"
 
-std::unique_ptr<cmCommand> cmCTestConfigureCommand::Clone()
-{
-  auto ni = cm::make_unique<cmCTestConfigureCommand>();
-  ni->CTest = this->CTest;
-  return std::unique_ptr<cmCommand>(std::move(ni));
-}
-
 std::unique_ptr<cmCTestGenericHandler>
 cmCTestConfigureCommand::InitializeHandler(HandlerArguments& arguments,
                                            cmExecutionStatus& status) const
@@ -164,7 +156,7 @@ cmCTestConfigureCommand::InitializeHandler(HandlerArguments& arguments,
 }
 
 bool cmCTestConfigureCommand::InitialPass(std::vector<std::string> const& args,
-                                          cmExecutionStatus& status)
+                                          cmExecutionStatus& status) const
 {
   using Args = ConfigureArguments;
   static auto const parser =

Source/CTest/cmCTestConfigureCommand.h

@@ -12,7 +12,6 @@
 
 class cmExecutionStatus;
 class cmCTestGenericHandler;
-class cmCommand;
 
 class cmCTestConfigureCommand : public cmCTestHandlerCommand
 {
@@ -26,13 +25,11 @@ protected:
   };
 
 private:
-  std::unique_ptr<cmCommand> Clone() override;
-
   std::string GetName() const override { return "ctest_configure"; }
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
     HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };

Source/CTest/cmCTestCoverageCommand.cxx

@@ -12,18 +12,10 @@
 #include "cmCTest.h"
 #include "cmCTestCoverageHandler.h"
 #include "cmCTestGenericHandler.h"
-#include "cmCommand.h"
 #include "cmExecutionStatus.h"
 
 class cmMakefile;
 
-std::unique_ptr<cmCommand> cmCTestCoverageCommand::Clone()
-{
-  auto ni = cm::make_unique<cmCTestCoverageCommand>();
-  ni->CTest = this->CTest;
-  return std::unique_ptr<cmCommand>(std::move(ni));
-}
-
 std::unique_ptr<cmCTestGenericHandler>
 cmCTestCoverageCommand::InitializeHandler(HandlerArguments& arguments,
                                           cmExecutionStatus& status) const
@@ -47,7 +39,7 @@ cmCTestCoverageCommand::InitializeHandler(HandlerArguments& arguments,
 }
 
 bool cmCTestCoverageCommand::InitialPass(std::vector<std::string> const& args,
-                                         cmExecutionStatus& status)
+                                         cmExecutionStatus& status) const
 {
   using Args = CoverageArguments;
   static auto const parser =

Source/CTest/cmCTestCoverageCommand.h

@@ -15,7 +15,6 @@
 
 class cmExecutionStatus;
 class cmCTestGenericHandler;
-class cmCommand;
 
 class cmCTestCoverageCommand : public cmCTestHandlerCommand
 {
@@ -29,13 +28,11 @@ protected:
   };
 
 private:
-  std::unique_ptr<cmCommand> Clone() override;
-
   std::string GetName() const override { return "ctest_coverage"; }
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
     HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };

Source/CTest/cmCTestMemCheckCommand.cxx

@@ -11,17 +11,9 @@
 #include "cmCTest.h"
 #include "cmCTestMemCheckHandler.h"
 #include "cmCTestTestHandler.h"
-#include "cmCommand.h"
 #include "cmExecutionStatus.h"
 #include "cmMakefile.h"
 
-std::unique_ptr<cmCommand> cmCTestMemCheckCommand::Clone()
-{
-  auto ni = cm::make_unique<cmCTestMemCheckCommand>();
-  ni->CTest = this->CTest;
-  return std::unique_ptr<cmCommand>(std::move(ni));
-}
-
 std::unique_ptr<cmCTestTestHandler>
 cmCTestMemCheckCommand::InitializeActualHandler(
   HandlerArguments& args, cmExecutionStatus& status) const
@@ -62,7 +54,7 @@ void cmCTestMemCheckCommand::ProcessAdditionalValues(
 }
 
 bool cmCTestMemCheckCommand::InitialPass(std::vector<std::string> const& args,
-                                         cmExecutionStatus& status)
+                                         cmExecutionStatus& status) const
 {
   static auto const parser =
     cmArgumentParser<MemCheckArguments>{ MakeTestParser<MemCheckArguments>() }

Source/CTest/cmCTestMemCheckCommand.h

@@ -13,7 +13,6 @@
 class cmExecutionStatus;
 class cmCTestGenericHandler;
 class cmCTestTestHandler;
-class cmCommand;
 
 class cmCTestMemCheckCommand : public cmCTestTestCommand
 {
@@ -27,8 +26,6 @@ protected:
   };
 
 private:
-  std::unique_ptr<cmCommand> Clone() override;
-
   std::string GetName() const override { return "ctest_memcheck"; }
 
   std::unique_ptr<cmCTestTestHandler> InitializeActualHandler(
@@ -39,5 +36,5 @@ private:
                                cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };

Source/CTest/cmCTestReadCustomFilesCommand.cxx

@@ -8,7 +8,7 @@
 class cmMakefile;
 
 bool cmCTestReadCustomFilesCommand::InitialPass(
-  std::vector<std::string> const& args, cmExecutionStatus& status)
+  std::vector<std::string> const& args, cmExecutionStatus& status) const
 {
   if (args.empty()) {
     status.SetError("called with incorrect number of arguments");

Source/CTest/cmCTestReadCustomFilesCommand.h

@@ -5,13 +5,9 @@
 #include "cmConfigure.h" // IWYU pragma: keep
 
 #include <string>
-#include <utility>
 #include <vector>
 
-#include <cm/memory>
-
 #include "cmCTestCommand.h"
-#include "cmCommand.h"
 
 class cmExecutionStatus;
 
@@ -24,22 +20,12 @@ class cmExecutionStatus;
 class cmCTestReadCustomFilesCommand : public cmCTestCommand
 {
 public:
-  cmCTestReadCustomFilesCommand() {}
+  using cmCTestCommand::cmCTestCommand;
-
-  /**
-   * This is a virtual constructor for the command.
-   */
-  std::unique_ptr<cmCommand> Clone() override
-  {
-    auto ni = cm::make_unique<cmCTestReadCustomFilesCommand>();
-    ni->CTest = this->CTest;
-    return std::unique_ptr<cmCommand>(std::move(ni));
-  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };

Source/CTest/cmCTestRunScriptCommand.cxx

@@ -8,7 +8,7 @@
 #include "cmSystemTools.h"
 
 bool cmCTestRunScriptCommand::InitialPass(std::vector<std::string> const& args,
-                                          cmExecutionStatus& status)
+                                          cmExecutionStatus& status) const
 {
   if (args.empty()) {
     status.SetError("called with incorrect number of arguments");

Source/CTest/cmCTestRunScriptCommand.h

@@ -5,13 +5,9 @@
 #include "cmConfigure.h" // IWYU pragma: keep
 
 #include <string>
-#include <utility>
 #include <vector>
 
-#include <cm/memory>
-
 #include "cmCTestCommand.h"
-#include "cmCommand.h"
 
 class cmExecutionStatus;
 
@@ -24,22 +20,12 @@ class cmExecutionStatus;
 class cmCTestRunScriptCommand : public cmCTestCommand
 {
 public:
-  cmCTestRunScriptCommand() {}
+  using cmCTestCommand::cmCTestCommand;
-
-  /**
-   * This is a virtual constructor for the command.
-   */
-  std::unique_ptr<cmCommand> Clone() override
-  {
-    auto ni = cm::make_unique<cmCTestRunScriptCommand>();
-    ni->CTest = this->CTest;
-    return std::unique_ptr<cmCommand>(std::move(ni));
-  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };

Source/CTest/cmCTestScriptHandler.cxx

@@ -15,7 +15,6 @@
 
 #include "cmCTest.h"
 #include "cmCTestBuildCommand.h"
-#include "cmCTestCommand.h"
 #include "cmCTestConfigureCommand.h"
 #include "cmCTestCoverageCommand.h"
 #include "cmCTestEmptyBinaryDirectoryCommand.h"
@@ -28,7 +27,6 @@
 #include "cmCTestTestCommand.h"
 #include "cmCTestUpdateCommand.h"
 #include "cmCTestUploadCommand.h"
-#include "cmCommand.h"
 #include "cmDuration.h"
 #include "cmGlobalGenerator.h"
 #include "cmMakefile.h"
@@ -81,13 +79,6 @@ void cmCTestScriptHandler::UpdateElapsedTime()
   }
 }
 
-void cmCTestScriptHandler::AddCTestCommand(
-  std::string const& name, std::unique_ptr<cmCTestCommand> command)
-{
-  command->CTest = this->CTest;
-  this->CMake->GetState()->AddBuiltinCommand(name, std::move(command));
-}
-
 int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
 {
   // execute the script passing in the arguments to the script as well as the
@@ -206,28 +197,25 @@ void cmCTestScriptHandler::CreateCMake()
     });
 
   cmState* state = this->CMake->GetState();
-  this->AddCTestCommand("ctest_build", cm::make_unique<cmCTestBuildCommand>());
+  state->AddBuiltinCommand("ctest_build", cmCTestBuildCommand(this->CTest));
-  this->AddCTestCommand("ctest_configure",
+  state->AddBuiltinCommand("ctest_configure",
-                        cm::make_unique<cmCTestConfigureCommand>());
+                           cmCTestConfigureCommand(this->CTest));
-  this->AddCTestCommand("ctest_coverage",
+  state->AddBuiltinCommand("ctest_coverage",
-                        cm::make_unique<cmCTestCoverageCommand>());
+                           cmCTestCoverageCommand(this->CTest));
   state->AddBuiltinCommand("ctest_empty_binary_directory",
                            cmCTestEmptyBinaryDirectoryCommand);
-  this->AddCTestCommand("ctest_memcheck",
+  state->AddBuiltinCommand("ctest_memcheck",
-                        cm::make_unique<cmCTestMemCheckCommand>());
+                           cmCTestMemCheckCommand(this->CTest));
-  this->AddCTestCommand("ctest_read_custom_files",
+  state->AddBuiltinCommand("ctest_read_custom_files",
-                        cm::make_unique<cmCTestReadCustomFilesCommand>());
+                           cmCTestReadCustomFilesCommand(this->CTest));
-  this->AddCTestCommand("ctest_run_script",
+  state->AddBuiltinCommand("ctest_run_script",
-                        cm::make_unique<cmCTestRunScriptCommand>());
+                           cmCTestRunScriptCommand(this->CTest));
   state->AddBuiltinCommand("ctest_sleep", cmCTestSleepCommand);
-  this->AddCTestCommand("ctest_start", cm::make_unique<cmCTestStartCommand>());
+  state->AddBuiltinCommand("ctest_start", cmCTestStartCommand(this->CTest));
-  this->AddCTestCommand("ctest_submit",
+  state->AddBuiltinCommand("ctest_submit", cmCTestSubmitCommand(this->CTest));
-                        cm::make_unique<cmCTestSubmitCommand>());
+  state->AddBuiltinCommand("ctest_test", cmCTestTestCommand(this->CTest));
-  this->AddCTestCommand("ctest_test", cm::make_unique<cmCTestTestCommand>());
+  state->AddBuiltinCommand("ctest_update", cmCTestUpdateCommand(this->CTest));
-  this->AddCTestCommand("ctest_update",
+  state->AddBuiltinCommand("ctest_upload", cmCTestUploadCommand(this->CTest));
-                        cm::make_unique<cmCTestUpdateCommand>());
-  this->AddCTestCommand("ctest_upload",
-                        cm::make_unique<cmCTestUploadCommand>());
 }
 
 // this sets up some variables for the script to use, creates the required

Source/CTest/cmCTestScriptHandler.h

@@ -9,7 +9,6 @@
 #include <vector>
 
 class cmCTest;
-class cmCTestCommand;
 class cmGlobalGenerator;
 class cmMakefile;
 class cmake;
@@ -58,10 +57,6 @@ private:
 
   int RunConfigurationScript(const std::string& script, bool pscope);
 
-  // Add ctest command
-  void AddCTestCommand(std::string const& name,
-                       std::unique_ptr<cmCTestCommand> command);
-
   cmCTest* CTest = nullptr;
   std::vector<std::string> ConfigurationScripts;
   std::vector<bool> ScriptProcessScope;

Source/CTest/cmCTestStartCommand.cxx

@@ -15,7 +15,7 @@
 #include "cmValue.h"
 
 bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
-                                      cmExecutionStatus& status)
+                                      cmExecutionStatus& status) const
 {
   if (args.empty()) {
     status.SetError("called with incorrect number of arguments");
@@ -226,7 +226,7 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
 
 bool cmCTestStartCommand::InitialCheckout(std::ostream& ofs,
                                           std::string const& sourceDir,
-                                          cmExecutionStatus& status)
+                                          cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   // Use the user-provided command to create the source tree.

Source/CTest/cmCTestStartCommand.h

@@ -6,13 +6,9 @@
 
 #include <iosfwd>
 #include <string>
-#include <utility>
 #include <vector>
 
-#include <cm/memory>
-
 #include "cmCTestCommand.h"
-#include "cmCommand.h"
 
 class cmExecutionStatus;
 
@@ -24,24 +20,16 @@ class cmExecutionStatus;
 class cmCTestStartCommand : public cmCTestCommand
 {
 public:
-  /**
+  using cmCTestCommand::cmCTestCommand;
-   * This is a virtual constructor for the command.
-   */
-  std::unique_ptr<cmCommand> Clone() override
-  {
-    auto ni = cm::make_unique<cmCTestStartCommand>();
-    ni->CTest = this->CTest;
-    return std::unique_ptr<cmCommand>(std::move(ni));
-  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 
 private:
   bool InitialCheckout(std::ostream& ofs, std::string const& sourceDir,
-                       cmExecutionStatus& status);
+                       cmExecutionStatus& status) const;
 };

Source/CTest/cmCTestSubmitCommand.cxx

@@ -14,7 +14,6 @@
 #include "cmCTest.h"
 #include "cmCTestGenericHandler.h"
 #include "cmCTestSubmitHandler.h"
-#include "cmCommand.h"
 #include "cmExecutionStatus.h"
 #include "cmList.h"
 #include "cmMakefile.h"
@@ -23,13 +22,6 @@
 #include "cmSystemTools.h"
 #include "cmValue.h"
 
-std::unique_ptr<cmCommand> cmCTestSubmitCommand::Clone()
-{
-  auto ni = cm::make_unique<cmCTestSubmitCommand>();
-  ni->CTest = this->CTest;
-  return std::unique_ptr<cmCommand>(std::move(ni));
-}
-
 std::unique_ptr<cmCTestGenericHandler> cmCTestSubmitCommand::InitializeHandler(
   HandlerArguments& arguments, cmExecutionStatus& status) const
 {
@@ -174,7 +166,7 @@ std::unique_ptr<cmCTestGenericHandler> cmCTestSubmitCommand::InitializeHandler(
 }
 
 bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args,
-                                       cmExecutionStatus& status)
+                                       cmExecutionStatus& status) const
 {
   // Arguments used by both modes.
   static auto const parserBase =

Source/CTest/cmCTestSubmitCommand.h

@@ -15,7 +15,6 @@
 
 class cmExecutionStatus;
 class cmCTestGenericHandler;
-class cmCommand;
 
 class cmCTestSubmitCommand : public cmCTestHandlerCommand
 {
@@ -41,8 +40,6 @@ protected:
   };
 
 private:
-  std::unique_ptr<cmCommand> Clone() override;
-
   std::string GetName() const override { return "ctest_submit"; }
 
   void CheckArguments(HandlerArguments& arguments,
@@ -56,5 +53,5 @@ private:
                                cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };

Source/CTest/cmCTestTestCommand.cxx

@@ -14,20 +14,12 @@
 #include "cmCTest.h"
 #include "cmCTestGenericHandler.h"
 #include "cmCTestTestHandler.h"
-#include "cmCommand.h"
 #include "cmDuration.h"
 #include "cmExecutionStatus.h"
 #include "cmMakefile.h"
 #include "cmStringAlgorithms.h"
 #include "cmValue.h"
 
-std::unique_ptr<cmCommand> cmCTestTestCommand::Clone()
-{
-  auto ni = cm::make_unique<cmCTestTestCommand>();
-  ni->CTest = this->CTest;
-  return std::unique_ptr<cmCommand>(std::move(ni));
-}
-
 std::unique_ptr<cmCTestGenericHandler> cmCTestTestCommand::InitializeHandler(
   HandlerArguments& arguments, cmExecutionStatus& status) const
 {
@@ -154,7 +146,7 @@ cmCTestTestCommand::InitializeActualHandler(HandlerArguments&,
 }
 
 bool cmCTestTestCommand::InitialPass(std::vector<std::string> const& args,
-                                     cmExecutionStatus& status)
+                                     cmExecutionStatus& status) const
 {
   static auto const parser = MakeTestParser<TestArguments>();
 

Source/CTest/cmCTestTestCommand.h

@@ -19,7 +19,6 @@
 class cmExecutionStatus;
 class cmCTestGenericHandler;
 class cmCTestTestHandler;
-class cmCommand;
 
 class cmCTestTestCommand : public cmCTestHandlerCommand
 {
@@ -79,8 +78,6 @@ protected:
   }
 
 private:
-  std::unique_ptr<cmCommand> Clone() override;
-
   std::string GetName() const override { return "ctest_test"; }
 
   virtual std::unique_ptr<cmCTestTestHandler> InitializeActualHandler(
@@ -90,5 +87,5 @@ private:
     HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };

Source/CTest/cmCTestUpdateCommand.cxx

@@ -9,18 +9,10 @@
 #include "cmCTest.h"
 #include "cmCTestGenericHandler.h"
 #include "cmCTestUpdateHandler.h"
-#include "cmCommand.h"
 #include "cmExecutionStatus.h"
 #include "cmMakefile.h"
 #include "cmSystemTools.h"
 
-std::unique_ptr<cmCommand> cmCTestUpdateCommand::Clone()
-{
-  auto ni = cm::make_unique<cmCTestUpdateCommand>();
-  ni->CTest = this->CTest;
-  return std::unique_ptr<cmCommand>(std::move(ni));
-}
-
 std::unique_ptr<cmCTestGenericHandler> cmCTestUpdateCommand::InitializeHandler(
   HandlerArguments& args, cmExecutionStatus& status) const
 {
@@ -93,7 +85,7 @@ std::unique_ptr<cmCTestGenericHandler> cmCTestUpdateCommand::InitializeHandler(
 }
 
 bool cmCTestUpdateCommand::InitialPass(std::vector<std::string> const& args,
-                                       cmExecutionStatus& status)
+                                       cmExecutionStatus& status) const
 {
   static auto const parser = MakeHandlerParser<HandlerArguments>();
 

Source/CTest/cmCTestUpdateCommand.h

@@ -12,7 +12,6 @@
 
 class cmExecutionStatus;
 class cmCTestGenericHandler;
-class cmCommand;
 
 class cmCTestUpdateCommand : public cmCTestHandlerCommand
 {
@@ -20,13 +19,11 @@ public:
   using cmCTestHandlerCommand::cmCTestHandlerCommand;
 
 private:
-  std::unique_ptr<cmCommand> Clone() override;
-
   std::string GetName() const override { return "ctest_update"; }
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
     HandlerArguments& args, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };

Source/CTest/cmCTestUploadCommand.cxx

@@ -13,19 +13,11 @@
 #include "cmArgumentParser.h"
 #include "cmCTestGenericHandler.h"
 #include "cmCTestUploadHandler.h"
-#include "cmCommand.h"
 #include "cmExecutionStatus.h"
 #include "cmMakefile.h"
 #include "cmMessageType.h"
 #include "cmSystemTools.h"
 
-std::unique_ptr<cmCommand> cmCTestUploadCommand::Clone()
-{
-  auto ni = cm::make_unique<cmCTestUploadCommand>();
-  ni->CTest = this->CTest;
-  return std::unique_ptr<cmCommand>(std::move(ni));
-}
-
 void cmCTestUploadCommand::CheckArguments(HandlerArguments& arguments,
                                           cmExecutionStatus& status) const
 {
@@ -55,7 +47,7 @@ std::unique_ptr<cmCTestGenericHandler> cmCTestUploadCommand::InitializeHandler(
 }
 
 bool cmCTestUploadCommand::InitialPass(std::vector<std::string> const& args,
-                                       cmExecutionStatus& status)
+                                       cmExecutionStatus& status) const
 {
   static auto const parser =
     cmArgumentParser<UploadArguments>{ MakeHandlerParser<UploadArguments>() }

Source/CTest/cmCTestUploadCommand.h

@@ -13,7 +13,6 @@
 
 class cmExecutionStatus;
 class cmCTestGenericHandler;
-class cmCommand;
 
 class cmCTestUploadCommand : public cmCTestHandlerCommand
 {
@@ -27,8 +26,6 @@ protected:
   };
 
 private:
-  std::unique_ptr<cmCommand> Clone() override;
-
   std::string GetName() const override { return "ctest_upload"; }
 
   void CheckArguments(HandlerArguments& arguments,
@@ -38,5 +35,5 @@ private:
     HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
+                   cmExecutionStatus& status) const override;
 };