Utils: Move process arguments class out of QtcProcess

The main QtcProcess interface is nowadays a CommandLine, with no
explicit references left to QtcProcess::Arguments and related static
helper functions, so it only clutters the QtcProcess class interface

So move these items out of QtcProcess, later potentially to a separate
file pair.

Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7
Reviewed-by: Christian Stenger <christian.stenger@qt.io>

src/libs/ssh/sftpsession.cpp

@@ -102,7 +102,7 @@ struct SftpSession::SftpSessionPrivate
 
         // The second newline forces the prompt to appear after the command has finished.
         sftpProc.write(commandString(activeCommand.type) + ' '
-                       + QtcProcess::Arguments::createUnixArgs(activeCommand.paths)
+                       + ProcessArgs::createUnixArgs(activeCommand.paths)
                        .toString().toLocal8Bit() + "\n\n");
     }
 };

src/libs/ssh/sftptransfer.cpp

@@ -151,7 +151,7 @@ void SftpTransfer::doStart()
     for (const QString &dir : d->dirsToCreate()) {
         switch (d->transferType) {
         case Internal::FileTransferType::Upload:
-            batchFile.write("-mkdir " + QtcProcess::quoteArgUnix(dir).toLocal8Bit() + '\n');
+            batchFile.write("-mkdir " + ProcessArgs::quoteArgUnix(dir).toLocal8Bit() + '\n');
             break;
         case Internal::FileTransferType::Download:
             if (!QDir::root().mkpath(dir)) {
@@ -169,14 +169,14 @@ void SftpTransfer::doStart()
             QFileInfo fi(f.sourceFile);
             if (fi.isSymLink()) {
                 link = true;
-                batchFile.write("-rm " + QtcProcess::quoteArgUnix(f.targetFile).toLocal8Bit()
+                batchFile.write("-rm " + ProcessArgs::quoteArgUnix(f.targetFile).toLocal8Bit()
                                 + '\n');
                 sourceFileOrLinkTarget = fi.dir().relativeFilePath(fi.symLinkTarget()); // see QTBUG-5817.
             }
          }
          batchFile.write(d->transferCommand(link) + ' '
-                         + QtcProcess::quoteArgUnix(sourceFileOrLinkTarget).toLocal8Bit() + ' '
-                         + QtcProcess::quoteArgUnix(f.targetFile).toLocal8Bit() + '\n');
+                         + ProcessArgs::quoteArgUnix(sourceFileOrLinkTarget).toLocal8Bit() + ' '
+                         + ProcessArgs::quoteArgUnix(f.targetFile).toLocal8Bit() + '\n');
     }
     d->sftpProc.setStandardInputFile(batchFile.fileName());
     d->sftpProc.start(sftpBinary.toString(), d->connectionArgs);

src/libs/utils/consoleprocess.cpp

@@ -232,11 +232,11 @@ TerminalCommand ConsoleProcess::terminalEmulator(const QSettings *settings)
             const QString value = settings->value("General/TerminalEmulator").toString().trimmed();
             if (!value.isEmpty()) {
                 // split off command and options
-                const QStringList splitCommand = QtcProcess::splitArgs(value);
+                const QStringList splitCommand = ProcessArgs::splitArgs(value);
                 if (QTC_GUARD(!splitCommand.isEmpty())) {
                     const QString command = splitCommand.first();
                     const QStringList quotedArgs = Utils::transform(splitCommand.mid(1),
-                                                                    &QtcProcess::quoteArgUnix);
+                                                                    &ProcessArgs::quoteArgUnix);
                     const QString options = quotedArgs.join(' ');
                     return {command, "", options};
                 }
@@ -358,7 +358,7 @@ bool ConsoleProcess::startTerminalEmulator(QSettings *settings, const QString &w
     const TerminalCommand term = terminalEmulator(settings);
     QProcess process;
     process.setProgram(term.command);
-    process.setArguments(QtcProcess::splitArgs(term.openArgs));
+    process.setArguments(ProcessArgs::splitArgs(term.openArgs));
     process.setProcessEnvironment(env.toProcessEnvironment());
     process.setWorkingDirectory(workingDir);
 
@@ -394,11 +394,11 @@ bool ConsoleProcess::start()
         pcmd = d->m_commandLine.executable().toString();
         pargs = d->m_commandLine.arguments();
     } else {
-        QtcProcess::Arguments outArgs;
-        QtcProcess::prepareCommand(d->m_commandLine.executable().toString(),
-                                   d->m_commandLine.arguments(),
-                                   &pcmd, &outArgs, OsTypeWindows,
-                                   &d->m_environment, &d->m_workingDir);
+        ProcessArgs outArgs;
+        ProcessArgs::prepareCommand(d->m_commandLine.executable().toString(),
+                                    d->m_commandLine.arguments(),
+                                    &pcmd, &outArgs, OsTypeWindows,
+                                    &d->m_environment, &d->m_workingDir);
         pargs = outArgs.toWindowsArgs();
     }
 
@@ -452,7 +452,7 @@ bool ConsoleProcess::start()
             return false;
         }
         d->m_tempFile->flush();
-}
+    }
 
     STARTUPINFO si;
     ZeroMemory(&si, sizeof(si));
@@ -497,19 +497,19 @@ bool ConsoleProcess::start()
 
 #else
 
-    QtcProcess::SplitError perr;
-    QtcProcess::Arguments pargs = QtcProcess::prepareArgs(d->m_commandLine.arguments(),
-                                                          &perr,
-                                                          HostOsInfo::hostOs(),
-                                                          &d->m_environment,
-                                                          &d->m_workingDir,
-                                                          d->m_abortOnMetaChars);
+    ProcessArgs::SplitError perr;
+    ProcessArgs pargs = ProcessArgs::prepareArgs(d->m_commandLine.arguments(),
+                                                 &perr,
+                                                 HostOsInfo::hostOs(),
+                                                 &d->m_environment,
+                                                 &d->m_workingDir,
+                                                 d->m_abortOnMetaChars);
 
     QString pcmd;
-    if (perr == QtcProcess::SplitOk) {
+    if (perr == ProcessArgs::SplitOk) {
         pcmd = d->m_commandLine.executable().toString();
     } else {
-        if (perr != QtcProcess::FoundMeta) {
+        if (perr != ProcessArgs::FoundMeta) {
             emitError(QProcess::FailedToStart, tr("Quoting error in command."));
             return false;
         }
@@ -520,20 +520,20 @@ bool ConsoleProcess::start()
             return false;
         }
         pcmd = qEnvironmentVariable("SHELL", "/bin/sh");
-        pargs = QtcProcess::Arguments::createUnixArgs(
-                        {"-c", (QtcProcess::quoteArg(d->m_commandLine.executable().toString())
+        pargs = ProcessArgs::createUnixArgs(
+                        {"-c", (ProcessArgs::quoteArg(d->m_commandLine.executable().toString())
                          + ' ' + d->m_commandLine.arguments())});
     }
 
-    QtcProcess::SplitError qerr;
+    ProcessArgs::SplitError qerr;
     const TerminalCommand terminal = terminalEmulator(d->m_settings);
-    const QtcProcess::Arguments terminalArgs = QtcProcess::prepareArgs(terminal.executeArgs,
-                                                                       &qerr,
-                                                                       HostOsInfo::hostOs(),
-                                                                       &d->m_environment,
-                                                                       &d->m_workingDir);
-    if (qerr != QtcProcess::SplitOk) {
-        emitError(QProcess::FailedToStart, qerr == QtcProcess::BadQuoting
+    const ProcessArgs terminalArgs = ProcessArgs::prepareArgs(terminal.executeArgs,
+                                                              &qerr,
+                                                              HostOsInfo::hostOs(),
+                                                              &d->m_environment,
+                                                              &d->m_workingDir);
+    if (qerr != ProcessArgs::SplitOk) {
+        emitError(QProcess::FailedToStart, qerr == ProcessArgs::BadQuoting
                           ? tr("Quoting error in terminal command.")
                           : tr("Terminal command may not be a shell command."));
         return false;
@@ -589,7 +589,7 @@ bool ConsoleProcess::start()
             << pargs.toUnixArgs();
 
     if (terminal.needsQuotes)
-        allArgs = QStringList { QtcProcess::joinArgs(allArgs) };
+        allArgs = QStringList { ProcessArgs::joinArgs(allArgs) };
 
     d->m_process.setEnvironment(env);
     d->m_process.start(terminal.command, allArgs);

src/libs/utils/fileutils.cpp

@@ -100,7 +100,7 @@ CommandLine::CommandLine(const FilePath &exe, const QString &args, RawType)
 
 void CommandLine::addArg(const QString &arg, OsType osType)
 {
-    QtcProcess::addArg(&m_arguments, arg, osType);
+    ProcessArgs::addArg(&m_arguments, arg, osType);
 }
 
 void CommandLine::addArgs(const QStringList &inArgs, OsType osType)
@@ -119,7 +119,7 @@ void CommandLine::addArgs(const CommandLine &cmd, OsType osType)
 
 void CommandLine::addArgs(const QString &inArgs, RawType)
 {
-    QtcProcess::addArgs(&m_arguments, inArgs);
+    ProcessArgs::addArgs(&m_arguments, inArgs);
 }
 
 QString CommandLine::toUserOutput() const
@@ -132,7 +132,7 @@ QString CommandLine::toUserOutput() const
 
 QStringList CommandLine::splitArguments(OsType osType) const
 {
-    return QtcProcess::splitArgs(m_arguments, osType);
+    return ProcessArgs::splitArgs(m_arguments, osType);
 }
 
 /*! \class Utils::FileUtils

src/libs/utils/macroexpander.cpp

@@ -327,7 +327,7 @@ QVariant MacroExpander::expandVariant(const QVariant &v) const
 
 QString MacroExpander::expandProcessArgs(const QString &argsWithVariables) const
 {
-    return QtcProcess::expandMacros(argsWithVariables, d);
+    return ProcessArgs::expandMacros(argsWithVariables, d);
 }
 
 static QByteArray fullPrefix(const QByteArray &prefix)

src/libs/utils/qtcprocess.cpp

@@ -136,8 +136,8 @@ static void envExpandWin(QString &args, const Environment *env, const QString *p
     }
 }
 
-static QtcProcess::Arguments prepareArgsWin(const QString &_args, QtcProcess::SplitError *err,
-                                            const Environment *env, const QString *pwd)
+static ProcessArgs prepareArgsWin(const QString &_args, ProcessArgs::SplitError *err,
+                                  const Environment *env, const QString *pwd)
 {
     QString args(_args);
 
@@ -146,8 +146,8 @@ static QtcProcess::Arguments prepareArgsWin(const QString &_args, QtcProcess::Sp
     } else {
         if (args.indexOf(QLatin1Char('%')) >= 0) {
             if (err)
-                *err = QtcProcess::FoundMeta;
-            return QtcProcess::Arguments::createWindowsArgs(QString());
+                *err = ProcessArgs::FoundMeta;
+            return ProcessArgs::createWindowsArgs(QString());
         }
     }
 
@@ -165,14 +165,14 @@ static QtcProcess::Arguments prepareArgsWin(const QString &_args, QtcProcess::Sp
             } while (args.unicode()[p].unicode() != '"');
         } else if (isMetaCharWin(c)) {
             if (err)
-                *err = QtcProcess::FoundMeta;
-            return QtcProcess::Arguments::createWindowsArgs(QString());
+                *err = ProcessArgs::FoundMeta;
+            return ProcessArgs::createWindowsArgs(QString());
         }
     }
 
     if (err)
-        *err = QtcProcess::SplitOk;
-    return QtcProcess::Arguments::createWindowsArgs(args);
+        *err = ProcessArgs::SplitOk;
+    return ProcessArgs::createWindowsArgs(args);
 }
 
 inline static bool isWhiteSpaceWin(ushort c)
@@ -180,12 +180,12 @@ inline static bool isWhiteSpaceWin(ushort c)
     return c == ' ' || c == '\t';
 }
 
-static QStringList doSplitArgsWin(const QString &args, QtcProcess::SplitError *err)
+static QStringList doSplitArgsWin(const QString &args, ProcessArgs::SplitError *err)
 {
     QStringList ret;
 
     if (err)
-        *err = QtcProcess::SplitOk;
+        *err = ProcessArgs::SplitOk;
 
     int p = 0;
     const int length = args.length();
@@ -239,7 +239,7 @@ static QStringList doSplitArgsWin(const QString &args, QtcProcess::SplitError *e
                 ret.append(arg);
                 if (inquote) {
                     if (err)
-                        *err = QtcProcess::BadQuoting;
+                        *err = ProcessArgs::BadQuoting;
                     return QStringList();
                 }
                 break;
@@ -314,15 +314,15 @@ static QStringList doSplitArgsWin(const QString &args, QtcProcess::SplitError *e
 
 
 static QStringList splitArgsWin(const QString &_args, bool abortOnMeta,
-                                QtcProcess::SplitError *err,
+                                ProcessArgs::SplitError *err,
                                 const Environment *env, const QString *pwd)
 {
     if (abortOnMeta) {
-        QtcProcess::SplitError perr;
+        ProcessArgs::SplitError perr;
         if (!err)
             err = &perr;
         QString args = prepareArgsWin(_args, &perr, env, pwd).toWindowsArgs();
-        if (*err != QtcProcess::SplitOk)
+        if (*err != ProcessArgs::SplitOk)
             return QStringList();
         return doSplitArgsWin(args, err);
     } else {
@@ -347,7 +347,7 @@ static bool isMetaUnix(QChar cUnicode)
 }
 
 static QStringList splitArgsUnix(const QString &args, bool abortOnMeta,
-                                 QtcProcess::SplitError *err,
+                                 ProcessArgs::SplitError *err,
                                  const Environment *env, const QString *pwd)
 {
     static const QString pwdName = QLatin1String("PWD");
@@ -522,17 +522,17 @@ static QStringList splitArgsUnix(const QString &args, bool abortOnMeta,
 
   okret:
     if (err)
-        *err = QtcProcess::SplitOk;
+        *err = ProcessArgs::SplitOk;
     return ret;
 
   quoteerr:
     if (err)
-        *err = QtcProcess::BadQuoting;
+        *err = ProcessArgs::BadQuoting;
     return QStringList();
 
   metaerr:
     if (err)
-        *err = QtcProcess::FoundMeta;
+        *err = ProcessArgs::FoundMeta;
     return QStringList();
 }
 
@@ -555,9 +555,9 @@ inline static bool hasSpecialCharsUnix(const QString &arg)
     return false;
 }
 
-QStringList QtcProcess::splitArgs(const QString &args, OsType osType,
-                                  bool abortOnMeta, QtcProcess::SplitError *err,
-                                  const Environment *env, const QString *pwd)
+QStringList ProcessArgs::splitArgs(const QString &args, OsType osType,
+                                   bool abortOnMeta, ProcessArgs::SplitError *err,
+                                   const Environment *env, const QString *pwd)
 {
     if (osType == OsTypeWindows)
         return splitArgsWin(args, abortOnMeta, err, env, pwd);
@@ -565,7 +565,7 @@ QStringList QtcProcess::splitArgs(const QString &args, OsType osType,
         return splitArgsUnix(args, abortOnMeta, err, env, pwd);
 }
 
-QString QtcProcess::quoteArgUnix(const QString &arg)
+QString ProcessArgs::quoteArgUnix(const QString &arg)
 {
     if (arg.isEmpty())
         return QString::fromLatin1("''");
@@ -626,17 +626,17 @@ static QString quoteArgWin(const QString &arg)
     return ret;
 }
 
-QtcProcess::Arguments QtcProcess::prepareArgs(const QString &cmd, SplitError *err, OsType osType,
+ProcessArgs ProcessArgs::prepareArgs(const QString &cmd, SplitError *err, OsType osType,
                                    const Environment *env, const QString *pwd, bool abortOnMeta)
 {
     if (osType == OsTypeWindows)
         return prepareArgsWin(cmd, err, env, pwd);
     else
-        return Arguments::createUnixArgs(splitArgs(cmd, osType, abortOnMeta, err, env, pwd));
+        return createUnixArgs(splitArgs(cmd, osType, abortOnMeta, err, env, pwd));
 }
 
 
-QString QtcProcess::quoteArg(const QString &arg, OsType osType)
+QString ProcessArgs::quoteArg(const QString &arg, OsType osType)
 {
     if (osType == OsTypeWindows)
         return quoteArgWin(arg);
@@ -644,14 +644,14 @@ QString QtcProcess::quoteArg(const QString &arg, OsType osType)
         return quoteArgUnix(arg);
 }
 
-void QtcProcess::addArg(QString *args, const QString &arg, OsType osType)
+void ProcessArgs::addArg(QString *args, const QString &arg, OsType osType)
 {
     if (!args->isEmpty())
         *args += QLatin1Char(' ');
     *args += quoteArg(arg, osType);
 }
 
-QString QtcProcess::joinArgs(const QStringList &args, OsType osType)
+QString ProcessArgs::joinArgs(const QStringList &args, OsType osType)
 {
     QString ret;
     for (const QString &arg : args)
@@ -659,7 +659,7 @@ QString QtcProcess::joinArgs(const QStringList &args, OsType osType)
     return ret;
 }
 
-void QtcProcess::addArgs(QString *args, const QString &inArgs)
+void ProcessArgs::addArgs(QString *args, const QString &inArgs)
 {
     if (!inArgs.isEmpty()) {
         if (!args->isEmpty())
@@ -668,28 +668,28 @@ void QtcProcess::addArgs(QString *args, const QString &inArgs)
     }
 }
 
-void QtcProcess::addArgs(QString *args, const QStringList &inArgs)
+void ProcessArgs::addArgs(QString *args, const QStringList &inArgs)
 {
     for (const QString &arg : inArgs)
         addArg(args, arg);
 }
 
-bool QtcProcess::prepareCommand(const QString &command, const QString &arguments,
-                                QString *outCmd, Arguments *outArgs, OsType osType,
-                                const Environment *env, const QString *pwd)
+bool ProcessArgs::prepareCommand(const QString &command, const QString &arguments,
+                                 QString *outCmd, ProcessArgs *outArgs, OsType osType,
+                                 const Environment *env, const QString *pwd)
 {
-    QtcProcess::SplitError err;
-    *outArgs = QtcProcess::prepareArgs(arguments, &err, osType, env, pwd);
-    if (err == QtcProcess::SplitOk) {
+    ProcessArgs::SplitError err;
+    *outArgs = ProcessArgs::prepareArgs(arguments, &err, osType, env, pwd);
+    if (err == ProcessArgs::SplitOk) {
         *outCmd = command;
     } else {
         if (osType == OsTypeWindows) {
             *outCmd = QString::fromLatin1(qgetenv("COMSPEC"));
-            *outArgs = Arguments::createWindowsArgs(QLatin1String("/v:off /s /c \"")
+            *outArgs = ProcessArgs::createWindowsArgs(QLatin1String("/v:off /s /c \"")
                     + quoteArg(QDir::toNativeSeparators(command)) + QLatin1Char(' ') + arguments
                     + QLatin1Char('"'));
         } else {
-            if (err != QtcProcess::FoundMeta)
+            if (err != ProcessArgs::FoundMeta)
                 return false;
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
             *outCmd = qEnvironmentVariable("SHELL", "/bin/sh");
@@ -698,7 +698,7 @@ bool QtcProcess::prepareCommand(const QString &command, const QString &arguments
             *outCmd = qEnvironmentVariableIsSet("SHELL") ? QString::fromLocal8Bit(qgetenv("SHELL"))
                                                          : QString("/bin/sh");
 #endif
-            *outArgs = Arguments::createUnixArgs(
+            *outArgs = ProcessArgs::createUnixArgs(
                         QStringList({"-c", (quoteArg(command) + ' ' + arguments)}));
         }
     }
@@ -853,16 +853,16 @@ void QtcProcess::start()
 
     const QString &workDir = workingDirectory();
     QString command;
-    QtcProcess::Arguments arguments;
-    bool success = prepareCommand(d->m_commandLine.executable().toString(),
-                                  d->m_commandLine.arguments(),
-                                  &command, &arguments, osType, &env, &workDir);
+    ProcessArgs arguments;
+    bool success = ProcessArgs::prepareCommand(d->m_commandLine.executable().toString(),
+                                               d->m_commandLine.arguments(),
+                                               &command, &arguments, osType, &env, &workDir);
     if (osType == OsTypeWindows) {
         QString args;
         if (d->m_useCtrlCStub) {
             if (d->m_lowPriority)
-                addArg(&args, "-nice");
-            addArg(&args, QDir::toNativeSeparators(command));
+                ProcessArgs::addArg(&args, "-nice");
+            ProcessArgs::addArg(&args, QDir::toNativeSeparators(command));
             command = QCoreApplication::applicationDirPath()
                     + QLatin1String("/qtcreator_ctrlc_stub.exe");
         } else if (d->m_lowPriority) {
@@ -872,7 +872,7 @@ void QtcProcess::start()
             });
 #endif
         }
-        QtcProcess::addArgs(&args, arguments.toWindowsArgs());
+        ProcessArgs::addArgs(&args, arguments.toWindowsArgs());
 #ifdef Q_OS_WIN
         setNativeArguments(args);
 #endif
@@ -1046,7 +1046,7 @@ static int quoteArgInternalWin(QString &ret, int bslashes)
  * \return false if the string could not be parsed and therefore no safe
  *   substitution was possible
  */
-bool QtcProcess::expandMacros(QString *cmd, AbstractMacroExpander *mx, OsType osType)
+bool ProcessArgs::expandMacros(QString *cmd, AbstractMacroExpander *mx, OsType osType)
 {
     QString str = *cmd;
     if (str.isEmpty())
@@ -1180,7 +1180,7 @@ bool QtcProcess::expandMacros(QString *cmd, AbstractMacroExpander *mx, OsType os
                                     break;
                                 case CrtClosed:
                                     // Two consecutive quotes make a literal quote - and
-                                    // still close quoting. See QtcProcess::quoteArg().
+                                    // still close quoting. See quoteArg().
                                     crtState = CrtInWord;
                                     break;
                                 case CrtHadQuote:
@@ -1370,7 +1370,7 @@ bool QtcProcess::expandMacros(QString *cmd, AbstractMacroExpander *mx, OsType os
     return true;
 }
 
-QString QtcProcess::expandMacros(const QString &str, AbstractMacroExpander *mx, OsType osType)
+QString ProcessArgs::expandMacros(const QString &str, AbstractMacroExpander *mx, OsType osType)
 {
     QString ret = str;
     expandMacros(&ret, mx, osType);
@@ -1506,7 +1506,7 @@ bool QtcProcess::readDataFromProcess(int timeoutS,
     return finished;
 }
 
-bool QtcProcess::ArgIterator::next()
+bool ProcessArgs::ArgIterator::next()
 {
     // We delay the setting of m_prev so we can still delete the last argument
     // after we find that there are no more arguments. It's a bit of a hack ...
@@ -1775,7 +1775,7 @@ QString QtcProcess::normalizeNewlines(const QString &text)
     return res;
 }
 
-void QtcProcess::ArgIterator::deleteArg()
+void ProcessArgs::ArgIterator::deleteArg()
 {
     if (!m_prev)
         while (m_pos < m_str->length() && m_str->at(m_pos).isSpace())
@@ -1784,7 +1784,7 @@ void QtcProcess::ArgIterator::deleteArg()
     m_pos = m_prev;
 }
 
-void QtcProcess::ArgIterator::appendArg(const QString &str)
+void ProcessArgs::ArgIterator::appendArg(const QString &str)
 {
     const QString qstr = quoteArg(str);
     if (!m_pos)
@@ -1794,40 +1794,40 @@ void QtcProcess::ArgIterator::appendArg(const QString &str)
     m_pos += qstr.length() + 1;
 }
 
-QtcProcess::Arguments QtcProcess::Arguments::createWindowsArgs(const QString &args)
+ProcessArgs ProcessArgs::createWindowsArgs(const QString &args)
 {
-    Arguments result;
+    ProcessArgs result;
     result.m_windowsArgs = args;
     result.m_isWindows = true;
     return result;
 }
 
-QtcProcess::Arguments QtcProcess::Arguments::createUnixArgs(const QStringList &args)
+ProcessArgs ProcessArgs::createUnixArgs(const QStringList &args)
 {
-    Arguments result;
+    ProcessArgs result;
     result.m_unixArgs = args;
     result.m_isWindows = false;
     return result;
 }
 
-QString QtcProcess::Arguments::toWindowsArgs() const
+QString ProcessArgs::toWindowsArgs() const
 {
     QTC_CHECK(m_isWindows);
     return m_windowsArgs;
 }
 
-QStringList QtcProcess::Arguments::toUnixArgs() const
+QStringList ProcessArgs::toUnixArgs() const
 {
     QTC_CHECK(!m_isWindows);
     return m_unixArgs;
 }
 
-QString QtcProcess::Arguments::toString() const
+QString ProcessArgs::toString() const
 {
     if (m_isWindows)
         return m_windowsArgs;
     else
-        return QtcProcess::joinArgs(m_unixArgs, OsTypeLinux);
+        return ProcessArgs::joinArgs(m_unixArgs, OsTypeLinux);
 }
 
 // Path utilities

src/libs/utils/qtcprocess.h

@@ -119,21 +119,56 @@ public:
     void setStdOutCallback(const std::function<void(const QString &)> &callback);
     void setStdErrCallback(const std::function<void(const QString &)> &callback);
 
-    class QTCREATOR_UTILS_EXPORT Arguments
-    {
-    public:
-        static Arguments createWindowsArgs(const QString &args);
-        static Arguments createUnixArgs(const QStringList &args);
+    static void setRemoteStartProcessHook(const std::function<void (QtcProcess &)> &hook);
 
-        QString toWindowsArgs() const;
-        QStringList toUnixArgs() const;
-        QString toString() const;
+    bool isSynchronous() const;
+    void setSynchronous(bool on);
 
-    private:
-        QString m_windowsArgs;
-        QStringList m_unixArgs;
-        bool m_isWindows;
-    };
+    void setOpenMode(OpenMode mode);
+
+    bool stopProcess();
+    bool readDataFromProcess(int timeoutS, QByteArray *stdOut, QByteArray *stdErr,
+                             bool showTimeOutMessageBox);
+
+    static QString normalizeNewlines(const QString &text);
+
+    // Helpers to find binaries. Do not use it for other path variables
+    // and file types.
+    static QString locateBinary(const QString &binary);
+    static QString locateBinary(const QString &path, const QString &binary);
+
+private:
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+    void setupChildProcess() override;
+#endif
+    friend class SynchronousProcess;
+    Internal::QtcProcessPrivate *d = nullptr;
+
+    void setProcessEnvironment(const QProcessEnvironment &environment) = delete;
+    QProcessEnvironment processEnvironment() const = delete;
+};
+
+QTCREATOR_UTILS_EXPORT QDebug operator<<(QDebug str, const SynchronousProcessResponse &);
+
+QTCREATOR_UTILS_EXPORT SynchronousProcessResponse::Result defaultExitCodeInterpreter(int code);
+
+class QTCREATOR_UTILS_EXPORT SynchronousProcess : public QtcProcess
+{
+    Q_OBJECT
+public:
+    SynchronousProcess();
+    ~SynchronousProcess() override;
+};
+
+class QTCREATOR_UTILS_EXPORT ProcessArgs
+{
+public:
+    static ProcessArgs createWindowsArgs(const QString &args);
+    static ProcessArgs createUnixArgs(const QStringList &args);
+
+    QString toWindowsArgs() const;
+    QStringList toUnixArgs() const;
+    QString toString() const;
 
     enum SplitError {
         SplitOk = 0, //! All went just fine
@@ -150,13 +185,13 @@ public:
     //! Join an argument list into a shell command
     static QString joinArgs(const QStringList &args, OsType osType = HostOsInfo::hostOs());
     //! Prepare argument of a shell command for feeding into QProcess
-    static Arguments prepareArgs(const QString &cmd, SplitError *err,
-                                 OsType osType = HostOsInfo::hostOs(),
-                                 const Environment *env = nullptr, const QString *pwd = nullptr,
-                                 bool abortOnMeta = true);
+    static ProcessArgs prepareArgs(const QString &cmd, SplitError *err,
+                                   OsType osType = HostOsInfo::hostOs(),
+                                   const Environment *env = nullptr, const QString *pwd = nullptr,
+                                   bool abortOnMeta = true);
     //! Prepare a shell command for feeding into QProcess
     static bool prepareCommand(const QString &command, const QString &arguments,
-                               QString *outCmd, Arguments *outArgs, OsType osType = HostOsInfo::hostOs(),
+                               QString *outCmd, ProcessArgs *outArgs, OsType osType = HostOsInfo::hostOs(),
                                const Environment *env = nullptr, const QString *pwd = nullptr);
     //! Quote and append each argument to a shell command
     static void addArgs(QString *args, const QStringList &inArgs);
@@ -213,45 +248,10 @@ public:
         ArgIterator m_ait;
     };
 
-    static void setRemoteStartProcessHook(const std::function<void (QtcProcess &)> &hook);
-
-    bool isSynchronous() const;
-    void setSynchronous(bool on);
-
-    void setOpenMode(OpenMode mode);
-
-    bool stopProcess();
-    bool readDataFromProcess(int timeoutS, QByteArray *stdOut, QByteArray *stdErr,
-                             bool showTimeOutMessageBox);
-
-    static QString normalizeNewlines(const QString &text);
-
-    // Helpers to find binaries. Do not use it for other path variables
-    // and file types.
-    static QString locateBinary(const QString &binary);
-    static QString locateBinary(const QString &path, const QString &binary);
-
 private:
-#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
-    void setupChildProcess() override;
-#endif
-    friend class SynchronousProcess;
-    Internal::QtcProcessPrivate *d = nullptr;
-
-    void setProcessEnvironment(const QProcessEnvironment &environment) = delete;
-    QProcessEnvironment processEnvironment() const = delete;
-};
-
-QTCREATOR_UTILS_EXPORT QDebug operator<<(QDebug str, const SynchronousProcessResponse &);
-
-QTCREATOR_UTILS_EXPORT SynchronousProcessResponse::Result defaultExitCodeInterpreter(int code);
-
-class QTCREATOR_UTILS_EXPORT SynchronousProcess : public QtcProcess
-{
-    Q_OBJECT
-public:
-    SynchronousProcess();
-    ~SynchronousProcess() override;
+    QString m_windowsArgs;
+    QStringList m_unixArgs;
+    bool m_isWindows;
 };
 
 } // namespace Utils

src/plugins/android/androidpackageinstallationstep.cpp

@@ -96,8 +96,8 @@ bool AndroidPackageInstallationStep::init()
     QTC_ASSERT(tc, return false);
 
     QString dirPath = nativeAndroidBuildPath();
-    const QString innerQuoted = QtcProcess::quoteArg(dirPath);
-    const QString outerQuoted = QtcProcess::quoteArg("INSTALL_ROOT=" + innerQuoted);
+    const QString innerQuoted = ProcessArgs::quoteArg(dirPath);
+    const QString outerQuoted = ProcessArgs::quoteArg("INSTALL_ROOT=" + innerQuoted);
 
     CommandLine cmd{tc->makeCommand(buildEnvironment())};
     cmd.addArgs(outerQuoted + " install", CommandLine::Raw);

src/plugins/android/androidrunnerworker.cpp

@@ -293,7 +293,7 @@ AndroidRunnerWorker::AndroidRunnerWorker(RunWorker *runner, const QString &packa
     if (auto aspect = runControl->aspect(Constants::ANDROID_AMSTARTARGS)) {
         QTC_CHECK(aspect->value().type() == QVariant::String);
         const QString startArgs = aspect->value().toString();
-        m_amStartExtraArgs = QtcProcess::splitArgs(startArgs, OsTypeOtherUnix);
+        m_amStartExtraArgs = ProcessArgs::splitArgs(startArgs, OsTypeOtherUnix);
     }
 
     if (auto aspect = runControl->aspect(Constants::ANDROID_PRESTARTSHELLCMDLIST)) {
@@ -633,7 +633,7 @@ void AndroidRunnerWorker::asyncStartHelper()
 
     if (!m_extraAppParams.isEmpty()) {
         QStringList appArgs =
-                Utils::QtcProcess::splitArgs(m_extraAppParams, Utils::OsType::OsTypeLinux);
+                Utils::ProcessArgs::splitArgs(m_extraAppParams, Utils::OsType::OsTypeLinux);
         qCDebug(androidRunWorkerLog) << "Using application arguments: " << appArgs;
         args << "-e" << "extraappparams"
              << QString::fromLatin1(appArgs.join(' ').toUtf8().toBase64());

src/plugins/android/androidsettingswidget.cpp

@@ -825,7 +825,7 @@ void AndroidSettingsWidget::editEmulatorArgsAVD()
     if (dialog.exec() != QDialog::Accepted)
         return;
 
-    m_androidConfig.setEmulatorArgs(QtcProcess::splitArgs(dialog.textValue()));
+    m_androidConfig.setEmulatorArgs(ProcessArgs::splitArgs(dialog.textValue()));
 }
 
 void AndroidSettingsWidget::createKitToggled()

src/plugins/autotest/testrunner.cpp

@@ -641,7 +641,7 @@ void TestRunner::debugTests()
     inferior.executable = FilePath::fromString(commandFilePath);
 
     const QStringList args = config->argumentsForTestRunner(&omitted);
-    inferior.commandLineArguments = Utils::QtcProcess::joinArgs(args);
+    inferior.commandLineArguments = Utils::ProcessArgs::joinArgs(args);
     if (!omitted.isEmpty()) {
         const QString &details = constructOmittedDetailsString(omitted);
         reportResult(ResultType::MessageWarn, details.arg(config->displayName()));

src/plugins/autotoolsprojectmanager/makefileparser.cpp

@@ -441,7 +441,7 @@ QStringList MakefileParser::parseTermsAfterAssign(const QString &line)
     if (assignPos <= 0 || assignPos >= line.size())
         return QStringList();
 
-    const QStringList parts = Utils::QtcProcess::splitArgs(line.mid(assignPos));
+    const QStringList parts = Utils::ProcessArgs::splitArgs(line.mid(assignPos));
     QStringList result;
     for (int i = 0; i < parts.count(); ++i) {
         const QString cur = parts.at(i);

src/plugins/baremetal/debugservers/gdb/openocdgdbserverprovider.cpp

@@ -86,7 +86,7 @@ QString OpenOcdGdbServerProvider::channelString() const
         // otherwise running will be stuck.
         CommandLine cmd = command();
         QStringList args = {"|", cmd.executable().toString()};
-        for (const QString &a : QtcProcess::splitArgs(cmd.arguments())) {
+        for (const QString &a : ProcessArgs::splitArgs(cmd.arguments())) {
             if (a.startsWith('\"') && a.endsWith('\"'))
                 args << a;
             else

src/plugins/baremetal/iarewtoolchain.cpp

@@ -567,7 +567,7 @@ IarToolChainConfigWidget::IarToolChainConfigWidget(IarToolChain *tc) :
     m_compilerCommand->setHistoryCompleter("PE.IAREW.Command.History");
     m_mainLayout->addRow(tr("&Compiler path:"), m_compilerCommand);
     m_platformCodeGenFlagsLineEdit = new QLineEdit(this);
-    m_platformCodeGenFlagsLineEdit->setText(QtcProcess::joinArgs(tc->extraCodeModelFlags()));
+    m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
     m_mainLayout->addRow(tr("Platform codegen flags:"), m_platformCodeGenFlagsLineEdit);
     m_mainLayout->addRow(tr("&ABI:"), m_abiWidget);
 
@@ -609,7 +609,7 @@ bool IarToolChainConfigWidget::isDirtyImpl() const
 {
     const auto tc = static_cast<IarToolChain *>(toolChain());
     return m_compilerCommand->filePath() != tc->compilerCommand()
-            || m_platformCodeGenFlagsLineEdit->text() != QtcProcess::joinArgs(tc->extraCodeModelFlags())
+            || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
             || m_abiWidget->currentAbi() != tc->targetAbi()
             ;
 }
@@ -626,7 +626,7 @@ void IarToolChainConfigWidget::setFromToolchain()
     const QSignalBlocker blocker(this);
     const auto tc = static_cast<IarToolChain *>(toolChain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
-    m_platformCodeGenFlagsLineEdit->setText(QtcProcess::joinArgs(tc->extraCodeModelFlags()));
+    m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
     m_abiWidget->setAbis({}, tc->targetAbi());
     const bool haveCompiler = compilerExists(m_compilerCommand->filePath());
     m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected());
@@ -652,7 +652,7 @@ void IarToolChainConfigWidget::handleCompilerCommandChange()
 void IarToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
 {
     const QString str1 = m_platformCodeGenFlagsLineEdit->text();
-    const QString str2 = QtcProcess::joinArgs(splitString(str1));
+    const QString str2 = ProcessArgs::joinArgs(splitString(str1));
     if (str1 != str2)
         m_platformCodeGenFlagsLineEdit->setText(str2);
     else

src/plugins/baremetal/keiltoolchain.cpp

@@ -727,7 +727,7 @@ KeilToolChainConfigWidget::KeilToolChainConfigWidget(KeilToolChain *tc) :
     m_compilerCommand->setHistoryCompleter("PE.KEIL.Command.History");
     m_mainLayout->addRow(tr("&Compiler path:"), m_compilerCommand);
     m_platformCodeGenFlagsLineEdit = new QLineEdit(this);
-    m_platformCodeGenFlagsLineEdit->setText(QtcProcess::joinArgs(tc->extraCodeModelFlags()));
+    m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
     m_mainLayout->addRow(tr("Platform codegen flags:"), m_platformCodeGenFlagsLineEdit);
     m_mainLayout->addRow(tr("&ABI:"), m_abiWidget);
 
@@ -769,7 +769,7 @@ bool KeilToolChainConfigWidget::isDirtyImpl() const
 {
     const auto tc = static_cast<KeilToolChain *>(toolChain());
     return m_compilerCommand->filePath() != tc->compilerCommand()
-            || m_platformCodeGenFlagsLineEdit->text() != QtcProcess::joinArgs(tc->extraCodeModelFlags())
+            || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
             || m_abiWidget->currentAbi() != tc->targetAbi()
             ;
 }
@@ -786,7 +786,7 @@ void KeilToolChainConfigWidget::setFromToolChain()
     const QSignalBlocker blocker(this);
     const auto tc = static_cast<KeilToolChain *>(toolChain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
-    m_platformCodeGenFlagsLineEdit->setText(QtcProcess::joinArgs(tc->extraCodeModelFlags()));
+    m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
     m_abiWidget->setAbis({}, tc->targetAbi());
     const bool haveCompiler = compilerExists(m_compilerCommand->filePath());
     m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected());
@@ -802,7 +802,7 @@ void KeilToolChainConfigWidget::handleCompilerCommandChange()
         QStringList newExtraArgs = prevExtraArgs;
         addDefaultCpuArgs(compilerPath, newExtraArgs);
         if (prevExtraArgs != newExtraArgs)
-            m_platformCodeGenFlagsLineEdit->setText(QtcProcess::joinArgs(newExtraArgs));
+            m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(newExtraArgs));
         m_macros = dumpPredefinedMacros(compilerPath, newExtraArgs, env);
         const Abi guessed = guessAbi(m_macros);
         m_abiWidget->setAbis({}, guessed);
@@ -815,7 +815,7 @@ void KeilToolChainConfigWidget::handleCompilerCommandChange()
 void KeilToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
 {
     const QString str1 = m_platformCodeGenFlagsLineEdit->text();
-    const QString str2 = QtcProcess::joinArgs(splitString(str1));
+    const QString str2 = ProcessArgs::joinArgs(splitString(str1));
     if (str1 != str2)
         m_platformCodeGenFlagsLineEdit->setText(str2);
     else

src/plugins/clangtools/clangtoolsutils.cpp

@@ -324,7 +324,7 @@ ClangDiagnosticConfig diagnosticConfig(const Utils::Id &diagConfigId)
 QStringList splitArgs(QString &argsString)
 {
     QStringList result;
-    Utils::QtcProcess::ArgIterator it(&argsString);
+    Utils::ProcessArgs::ArgIterator it(&argsString);
     while (it.next())
         result.append(it.value());
     return result;

src/plugins/cmakeprojectmanager/fileapidataextractor.cpp

@@ -264,7 +264,7 @@ QList<CMakeBuildTarget> generateBuildTargets(const PreprocessedData &input,
                         continue;
 
                     // CMake sometimes mixes several shell-escaped pieces into one fragment. Disentangle that again:
-                    const QStringList parts = QtcProcess::splitArgs(f.fragment);
+                    const QStringList parts = ProcessArgs::splitArgs(f.fragment);
                     for (const QString &part : parts) {
                         // Some projects abuse linking to libraries to pass random flags to the linker, so ignore
                         // flags mixed into a fragment
@@ -315,7 +315,7 @@ static QStringList splitFragments(const QStringList &fragments)
 {
     QStringList result;
     for (const QString &f : fragments) {
-        result += QtcProcess::splitArgs(f);
+        result += ProcessArgs::splitArgs(f);
     }
     return result;
 }

src/plugins/coreplugin/fileutils.cpp

@@ -103,7 +103,7 @@ void FileUtils::showInGraphicalShell(QWidget *parent, const QString &pathIn)
         // we cannot select a file here, because no file browser really supports it...
         const QString folder = fileInfo.isDir() ? fileInfo.absoluteFilePath() : fileInfo.filePath();
         const QString app = UnixUtils::fileBrowser(ICore::settings());
-        QStringList browserArgs = Utils::QtcProcess::splitArgs(
+        QStringList browserArgs = ProcessArgs::splitArgs(
                     UnixUtils::substituteFileBrowserParameters(app, folder));
         QString error;
         if (browserArgs.isEmpty()) {

src/plugins/coreplugin/locator/spotlightlocatorfilter.cpp

@@ -263,7 +263,7 @@ void SpotlightLocatorFilter::prepareSearch(const QString &entry)
             caseSensitivity(fp.filePath) == Qt::CaseInsensitive ? m_arguments
                                                                 : m_caseSensitiveArguments);
         setFileIterator(
-            new SpotlightIterator(QStringList(m_command) + QtcProcess::splitArgs(argumentString)));
+            new SpotlightIterator(QStringList(m_command) + ProcessArgs::splitArgs(argumentString)));
     }
     BaseFileFilter::prepareSearch(entry);
 }

src/plugins/debugger/debuggerruncontrol.cpp

@@ -890,7 +890,7 @@ bool DebuggerRunTool::fixupParameters()
             QString qmlarg = rp.isCppDebugging() && rp.nativeMixedEnabled
                     ? QmlDebug::qmlDebugNativeArguments(service, false)
                     : QmlDebug::qmlDebugTcpArguments(service, rp.qmlServer);
-            QtcProcess::addArg(&rp.inferior.commandLineArguments, qmlarg);
+            ProcessArgs::addArg(&rp.inferior.commandLineArguments, qmlarg);
         }
     }
 
@@ -903,12 +903,12 @@ bool DebuggerRunTool::fixupParameters()
     }
 
     if (HostOsInfo::isWindowsHost()) {
-        QtcProcess::SplitError perr;
+        ProcessArgs::SplitError perr;
         rp.inferior.commandLineArguments =
-                QtcProcess::prepareArgs(rp.inferior.commandLineArguments, &perr,
-                                        HostOsInfo::hostOs(), nullptr,
-                                        &rp.inferior.workingDirectory).toWindowsArgs();
-        if (perr != QtcProcess::SplitOk) {
+                ProcessArgs::prepareArgs(rp.inferior.commandLineArguments, &perr,
+                                         HostOsInfo::hostOs(), nullptr,
+                                         &rp.inferior.workingDirectory).toWindowsArgs();
+        if (perr != ProcessArgs::SplitOk) {
             // perr == BadQuoting is never returned on Windows
             // FIXME? QTCREATORBUG-2809
             reportFailure(DebuggerPlugin::tr("Debugging complex command lines "
@@ -1130,7 +1130,7 @@ DebugServerRunner::DebugServerRunner(RunControl *runControl, DebugServerPortsGat
         debugServer.environment = mainRunnable.environment;
         debugServer.workingDirectory = mainRunnable.workingDirectory;
 
-        QStringList args = QtcProcess::splitArgs(mainRunnable.commandLineArguments, OsTypeLinux);
+        QStringList args = ProcessArgs::splitArgs(mainRunnable.commandLineArguments, OsTypeLinux);
 
         const bool isQmlDebugging = portsGatherer->useQmlServer();
         const bool isCppDebugging = portsGatherer->useGdbServer();
@@ -1162,7 +1162,7 @@ DebugServerRunner::DebugServerRunner(RunControl *runControl, DebugServerPortsGat
                     args.append(QString::number(m_pid.pid()));
             }
         }
-        debugServer.commandLineArguments = QtcProcess::joinArgs(args, OsTypeLinux);
+        debugServer.commandLineArguments = ProcessArgs::joinArgs(args, OsTypeLinux);
 
         doStart(debugServer, runControl->device());
     });

src/plugins/debugger/lldb/lldbengine.cpp

@@ -282,7 +282,7 @@ void LldbEngine::setupEngine()
     cmd2.arg("nativemixed", isNativeMixedActive());
     cmd2.arg("workingdirectory", rp.inferior.workingDirectory);
     cmd2.arg("environment", rp.inferior.environment.toStringList());
-    cmd2.arg("processargs", toHex(QtcProcess::splitArgs(rp.inferior.commandLineArguments).join(QChar(0))));
+    cmd2.arg("processargs", toHex(ProcessArgs::splitArgs(rp.inferior.commandLineArguments).join(QChar(0))));
     cmd2.arg("platform", rp.platform);
     cmd2.arg("symbolfile", rp.symbolFile);
 

src/plugins/debugger/pdb/pdbengine.cpp

@@ -134,7 +134,7 @@ void PdbEngine::setupEngine()
     }
 
     QStringList args = {bridge, scriptFile.fileName()};
-    args.append(Utils::QtcProcess::splitArgs(runParameters().inferior.workingDirectory));
+    args.append(Utils::ProcessArgs::splitArgs(runParameters().inferior.workingDirectory));
     showMessage("STARTING " + m_interpreter + ' ' + args.join(' '));
     m_proc.setEnvironment(runParameters().debugger.environment.toStringList());
     m_proc.start(m_interpreter, args);

src/plugins/genericprojectmanager/genericproject.cpp

@@ -413,7 +413,7 @@ static QStringList readFlags(const QString &filePath)
         return QStringList();
     QStringList flags;
     for (const auto &line : lines)
-        flags.append(QtcProcess::splitArgs(line));
+        flags.append(ProcessArgs::splitArgs(line));
     return flags;
 }
 

src/plugins/git/gitclient.cpp

@@ -2574,7 +2574,7 @@ bool GitClient::tryLauchingGitK(const Environment &env,
     }
     const QString gitkOpts = settings().gitkOptions.value();
     if (!gitkOpts.isEmpty())
-        arguments.append(QtcProcess::splitArgs(gitkOpts, HostOsInfo::hostOs()));
+        arguments.append(ProcessArgs::splitArgs(gitkOpts, HostOsInfo::hostOs()));
     if (!fileName.isEmpty())
         arguments << "--" << fileName;
     VcsOutputWindow::appendCommand(workingDirectory, {binary, arguments});

src/plugins/incredibuild/cmakecommandbuilder.cpp

@@ -63,7 +63,7 @@ QString CMakeCommandBuilder::defaultArguments() const
     if (buildDir.isEmpty())
         buildDir = ".";
 
-    return Utils::QtcProcess::joinArgs({"--build", buildDir, "--target", "all"});
+    return Utils::ProcessArgs::joinArgs({"--build", buildDir, "--target", "all"});
 }
 
 QString CMakeCommandBuilder::setMultiProcessArg(QString args)

src/plugins/ios/iosbuildstep.cpp

@@ -95,7 +95,7 @@ QWidget *IosBuildStep::createConfigWidget()
     auto buildArgumentsLabel = new QLabel(tr("Base arguments:"), widget);
 
     auto buildArgumentsTextEdit = new QPlainTextEdit(widget);
-    buildArgumentsTextEdit->setPlainText(QtcProcess::joinArgs(baseArguments()));
+    buildArgumentsTextEdit->setPlainText(ProcessArgs::joinArgs(baseArguments()));
 
     auto resetDefaultsButton = new QPushButton(widget);
     resetDefaultsButton->setLayoutDirection(Qt::RightToLeft);
@@ -105,7 +105,7 @@ QWidget *IosBuildStep::createConfigWidget()
     auto extraArgumentsLabel = new QLabel(tr("Extra arguments:"), widget);
 
     auto extraArgumentsLineEdit = new QLineEdit(widget);
-    extraArgumentsLineEdit->setText(QtcProcess::joinArgs(m_extraArguments));
+    extraArgumentsLineEdit->setText(ProcessArgs::joinArgs(m_extraArguments));
 
     auto gridLayout = new QGridLayout(widget);
     gridLayout->addWidget(buildArgumentsLabel, 0, 0, 1, 1);
@@ -125,19 +125,19 @@ QWidget *IosBuildStep::createConfigWidget()
     updateDetails();
 
     connect(buildArgumentsTextEdit, &QPlainTextEdit::textChanged, this, [=] {
-        setBaseArguments(QtcProcess::splitArgs(buildArgumentsTextEdit->toPlainText()));
+        setBaseArguments(ProcessArgs::splitArgs(buildArgumentsTextEdit->toPlainText()));
         resetDefaultsButton->setEnabled(!m_useDefaultArguments);
         updateDetails();
     });
 
     connect(resetDefaultsButton, &QAbstractButton::clicked, this, [=] {
         setBaseArguments(defaultArguments());
-        buildArgumentsTextEdit->setPlainText(QtcProcess::joinArgs(baseArguments()));
+        buildArgumentsTextEdit->setPlainText(ProcessArgs::joinArgs(baseArguments()));
         resetDefaultsButton->setEnabled(!m_useDefaultArguments);
     });
 
     connect(extraArgumentsLineEdit, &QLineEdit::editingFinished, [=] {
-        setExtraArguments(QtcProcess::splitArgs(extraArgumentsLineEdit->text()));
+        setExtraArguments(ProcessArgs::splitArgs(extraArgumentsLineEdit->text()));
     });
 
     connect(ProjectExplorerPlugin::instance(), &ProjectExplorerPlugin::settingsChanged,

src/plugins/ios/iosdsymbuildstep.cpp

@@ -213,7 +213,7 @@ QWidget *IosDsymBuildStep::createConfigWidget()
     commandLineEdit->setText(command().toString());
 
     auto argumentsTextEdit = new QPlainTextEdit(widget);
-    argumentsTextEdit->setPlainText(Utils::QtcProcess::joinArgs(arguments()));
+    argumentsTextEdit->setPlainText(Utils::ProcessArgs::joinArgs(arguments()));
 
     auto argumentsLabel = new QLabel(tr("Arguments:"), widget);
 
@@ -238,7 +238,7 @@ QWidget *IosDsymBuildStep::createConfigWidget()
 
     connect(argumentsTextEdit, &QPlainTextEdit::textChanged, this,
             [this, argumentsTextEdit, resetDefaultsButton, updateDetails] {
-        setArguments(Utils::QtcProcess::splitArgs(argumentsTextEdit->toPlainText()));
+        setArguments(Utils::ProcessArgs::splitArgs(argumentsTextEdit->toPlainText()));
         resetDefaultsButton->setEnabled(!isDefault());
         updateDetails();
     });
@@ -255,7 +255,7 @@ QWidget *IosDsymBuildStep::createConfigWidget()
         setCommand(defaultCommand());
         setArguments(defaultArguments());
         commandLineEdit->setText(command().toString());
-        argumentsTextEdit->setPlainText(Utils::QtcProcess::joinArgs(arguments()));
+        argumentsTextEdit->setPlainText(Utils::ProcessArgs::joinArgs(arguments()));
         resetDefaultsButton->setEnabled(!isDefault());
         updateDetails();
     });

src/plugins/ios/iosrunner.cpp

@@ -197,7 +197,7 @@ void IosRunner::start()
             this, &IosRunner::handleFinished);
 
     const Runnable runnable = runControl()->runnable();
-    QStringList args = QtcProcess::splitArgs(runnable.commandLineArguments, OsTypeMac);
+    QStringList args = ProcessArgs::splitArgs(runnable.commandLineArguments, OsTypeMac);
     if (m_qmlServerPort.isValid()) {
         QUrl qmlServer;
         qmlServer.setPort(m_qmlServerPort.number());

src/plugins/mesonprojectmanager/project/mesonbuildconfiguration.cpp

@@ -120,7 +120,7 @@ void MesonBuildConfiguration::build(const QString &target)
 
 QStringList MesonBuildConfiguration::mesonConfigArgs()
 {
-    return Utils::QtcProcess::splitArgs(m_parameters) + QStringList{QString("-Dbuildtype=%1").arg(mesonBuildTypeName(m_buildType))};
+    return Utils::ProcessArgs::splitArgs(m_parameters) + QStringList{QString("-Dbuildtype=%1").arg(mesonBuildTypeName(m_buildType))};
 }
 
 const QString &MesonBuildConfiguration::parameters() const

src/plugins/nim/project/nimcompilerbuildstep.cpp

@@ -97,7 +97,7 @@ QWidget *NimCompilerBuildStep::createConfigWidget()
 
     auto updateUi = [=] {
         const CommandLine cmd = commandLine();
-        const QStringList parts = QtcProcess::splitArgs(cmd.toUserOutput());
+        const QStringList parts = ProcessArgs::splitArgs(cmd.toUserOutput());
 
         commandTextEdit->setText(parts.join(QChar::LineFeed));
 

src/plugins/perfprofiler/perfprofilerruncontrol.cpp

@@ -151,11 +151,11 @@ public:
         arguments << "record";
         arguments += m_perfRecordArguments;
         arguments << "-o" << "-" << "--" << perfRunnable.executable.toString()
-                  << Utils::QtcProcess::splitArgs(perfRunnable.commandLineArguments,
+                  << Utils::ProcessArgs::splitArgs(perfRunnable.commandLineArguments,
                                                   Utils::OsTypeLinux);
 
         perfRunnable.executable = FilePath::fromString("perf");
-        perfRunnable.commandLineArguments = Utils::QtcProcess::joinArgs(arguments,
+        perfRunnable.commandLineArguments = Utils::ProcessArgs::joinArgs(arguments,
                                                                         Utils::OsTypeLinux);
         m_process->start(perfRunnable);
     }

src/plugins/perfprofiler/perfsettings.cpp

@@ -143,7 +143,7 @@ QStringList PerfSettings::perfRecordArguments() const
                         "--call-graph", callgraphArg,
                         sampleMode.itemValue().toString(),
                         QString::number(period.value())})
-         + QtcProcess::splitArgs(extraArguments.value());
+         + ProcessArgs::splitArgs(extraArguments.value());
 }
 
 void PerfSettings::resetToDefault()

src/plugins/projectexplorer/devicesupport/desktopdeviceprocess.cpp

@@ -55,7 +55,7 @@ void DesktopDeviceProcess::start(const Runnable &runnable)
     m_process.setProcessEnvironment(runnable.environment.toProcessEnvironment());
     m_process.setWorkingDirectory(runnable.workingDirectory);
     m_process.start(runnable.executable.toString(),
-                    Utils::QtcProcess::splitArgs(runnable.commandLineArguments));
+                    Utils::ProcessArgs::splitArgs(runnable.commandLineArguments));
 }
 
 void DesktopDeviceProcess::interrupt()

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -1198,10 +1198,10 @@ GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
     m_compilerCommand->setHistoryCompleter("PE.Gcc.Command.History");
     m_mainLayout->addRow(tr("&Compiler path:"), m_compilerCommand);
     m_platformCodeGenFlagsLineEdit = new QLineEdit(this);
-    m_platformCodeGenFlagsLineEdit->setText(QtcProcess::joinArgs(tc->platformCodeGenFlags()));
+    m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags()));
     m_mainLayout->addRow(tr("Platform codegen flags:"), m_platformCodeGenFlagsLineEdit);
     m_platformLinkerFlagsLineEdit = new QLineEdit(this);
-    m_platformLinkerFlagsLineEdit->setText(QtcProcess::joinArgs(tc->platformLinkerFlags()));
+    m_platformLinkerFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformLinkerFlags()));
     m_mainLayout->addRow(tr("Platform linker flags:"), m_platformLinkerFlagsLineEdit);
     m_mainLayout->addRow(tr("&ABI:"), m_abiWidget);
 
@@ -1254,8 +1254,8 @@ void GccToolChainConfigWidget::setFromToolchain()
     QSignalBlocker blocker(this);
     auto tc = static_cast<GccToolChain *>(toolChain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
-    m_platformCodeGenFlagsLineEdit->setText(QtcProcess::joinArgs(tc->platformCodeGenFlags()));
-    m_platformLinkerFlagsLineEdit->setText(QtcProcess::joinArgs(tc->platformLinkerFlags()));
+    m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags()));
+    m_platformLinkerFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformLinkerFlags()));
     if (m_abiWidget) {
         m_abiWidget->setAbis(tc->supportedAbis(), tc->targetAbi());
         if (!m_isReadOnly && !m_compilerCommand->filePath().toString().isEmpty())
@@ -1269,9 +1269,9 @@ bool GccToolChainConfigWidget::isDirtyImpl() const
     Q_ASSERT(tc);
     return m_compilerCommand->filePath() != tc->compilerCommand()
            || m_platformCodeGenFlagsLineEdit->text()
-                  != QtcProcess::joinArgs(tc->platformCodeGenFlags())
+                  != ProcessArgs::joinArgs(tc->platformCodeGenFlags())
            || m_platformLinkerFlagsLineEdit->text()
-                  != QtcProcess::joinArgs(tc->platformLinkerFlags())
+                  != ProcessArgs::joinArgs(tc->platformLinkerFlags())
            || (m_abiWidget && m_abiWidget->currentAbi() != tc->targetAbi());
 }
 
@@ -1324,7 +1324,7 @@ void GccToolChainConfigWidget::handleCompilerCommandChange()
 void GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
 {
     QString str1 = m_platformCodeGenFlagsLineEdit->text();
-    QString str2 = QtcProcess::joinArgs(splitString(str1));
+    QString str2 = ProcessArgs::joinArgs(splitString(str1));
     if (str1 != str2)
         m_platformCodeGenFlagsLineEdit->setText(str2);
     else
@@ -1334,7 +1334,7 @@ void GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
 void GccToolChainConfigWidget::handlePlatformLinkerFlagsChange()
 {
     QString str1 = m_platformLinkerFlagsLineEdit->text();
-    QString str2 = QtcProcess::joinArgs(splitString(str1));
+    QString str2 = ProcessArgs::joinArgs(splitString(str1));
     if (str1 != str2)
         m_platformLinkerFlagsLineEdit->setText(str2);
     else

src/plugins/projectexplorer/makestep.cpp

@@ -221,7 +221,7 @@ bool MakeStep::jobCountOverridesMakeflags() const
 
 static Utils::optional<int> argsJobCount(const QString &str)
 {
-    const QStringList args = Utils::QtcProcess::splitArgs(str, Utils::HostOsInfo::hostOs());
+    const QStringList args = ProcessArgs::splitArgs(str, HostOsInfo::hostOs());
     const int argIndex = Utils::indexOf(args, [](const QString &arg) { return arg.startsWith("-j"); });
     if (argIndex == -1)
         return Utils::nullopt;

src/plugins/projectexplorer/msvctoolchain.cpp

@@ -1986,7 +1986,7 @@ Utils::optional<QString> MsvcToolChain::generateEnvironmentSettings(const Utils:
     Utils::TempFileSaver saver(Utils::TemporaryDirectory::masterDirectoryPath() + "/XXXXXX.bat");
 
     QByteArray call = "call ";
-    call += Utils::QtcProcess::quoteArg(batchFile).toLocal8Bit();
+    call += ProcessArgs::quoteArg(batchFile).toLocal8Bit();
     if (!batchArgs.isEmpty()) {
         call += ' ';
         call += batchArgs.toLocal8Bit();

src/plugins/projectexplorer/processparameters.cpp

@@ -161,10 +161,10 @@ QString ProcessParameters::prettyArguments() const
 {
     QString margs = effectiveArguments();
     QString workDir = effectiveWorkingDirectory().toString();
-    QtcProcess::SplitError err;
-    QtcProcess::Arguments args =
-            QtcProcess::prepareArgs(margs, &err, HostOsInfo::hostOs(), &m_environment, &workDir);
-    if (err != QtcProcess::SplitOk)
+    ProcessArgs::SplitError err;
+    ProcessArgs args =
+            ProcessArgs::prepareArgs(margs, &err, HostOsInfo::hostOs(), &m_environment, &workDir);
+    if (err != ProcessArgs::SplitOk)
         return margs; // Sorry, too complex - just fall back.
     return args.toString();
 }
@@ -184,7 +184,7 @@ QString ProcessParameters::summary(const QString &displayName) const
 
     return QString::fromLatin1("<b>%1:</b> %2 %3")
             .arg(displayName,
-                 QtcProcess::quoteArg(prettyCommand()),
+                 ProcessArgs::quoteArg(prettyCommand()),
                  prettyArguments());
 }
 
@@ -195,7 +195,7 @@ QString ProcessParameters::summaryInWorkdir(const QString &displayName) const
 
     return QString::fromLatin1("<b>%1:</b> %2 %3 in %4")
             .arg(displayName,
-                 QtcProcess::quoteArg(prettyCommand()),
+                 ProcessArgs::quoteArg(prettyCommand()),
                  prettyArguments(),
                  QDir::toNativeSeparators(effectiveWorkingDirectory().toString()));
 }

src/plugins/projectexplorer/runconfigurationaspects.cpp

@@ -392,7 +392,7 @@ void ArgumentsAspect::fromMap(const QVariantMap &map)
     QVariant args = map.value(settingsKey());
     // Until 3.7 a QStringList was stored for Remote Linux
     if (args.type() == QVariant::StringList)
-        m_arguments = QtcProcess::joinArgs(args.toStringList(), OsTypeLinux);
+        m_arguments = ProcessArgs::joinArgs(args.toStringList(), OsTypeLinux);
     else
         m_arguments = args.toString();
 

src/plugins/projectexplorer/toolchainconfigwidget.cpp

@@ -38,6 +38,8 @@
 #include <QScrollArea>
 #include <QPainter>
 
+using namespace Utils;
+
 namespace ProjectExplorer {
 
 ToolChainConfigWidget::ToolChainConfigWidget(ToolChain *tc) :
@@ -128,15 +130,15 @@ void ToolChainConfigWidget::clearErrorMessage()
 
 QStringList ToolChainConfigWidget::splitString(const QString &s)
 {
-    Utils::QtcProcess::SplitError splitError;
-    const Utils::OsType osType = Utils::HostOsInfo::hostOs();
-    QStringList res = Utils::QtcProcess::splitArgs(s, osType, false, &splitError);
-    if (splitError != Utils::QtcProcess::SplitOk){
-        res = Utils::QtcProcess::splitArgs(s + '\\', osType, false, &splitError);
-        if (splitError != Utils::QtcProcess::SplitOk){
-            res = Utils::QtcProcess::splitArgs(s + '"', osType, false, &splitError);
-            if (splitError != Utils::QtcProcess::SplitOk)
-                res = Utils::QtcProcess::splitArgs(s + '\'', osType, false, &splitError);
+    ProcessArgs::SplitError splitError;
+    const OsType osType = HostOsInfo::hostOs();
+    QStringList res = ProcessArgs::splitArgs(s, osType, false, &splitError);
+    if (splitError != ProcessArgs::SplitOk) {
+        res = ProcessArgs::splitArgs(s + '\\', osType, false, &splitError);
+        if (splitError != ProcessArgs::SplitOk) {
+            res = ProcessArgs::splitArgs(s + '"', osType, false, &splitError);
+            if (splitError != ProcessArgs::SplitOk)
+                res = ProcessArgs::splitArgs(s + '\'', osType, false, &splitError);
         }
     }
     return res;

src/plugins/qbsprojectmanager/qbsbuildstep.cpp

@@ -497,7 +497,7 @@ void QbsBuildStep::handleProcessResult(
     if (success && !hasOutput)
         return;
 
-    emit addOutput(executable.toUserOutput() + ' '  + QtcProcess::joinArgs(arguments),
+    emit addOutput(executable.toUserOutput() + ' '  + ProcessArgs::joinArgs(arguments),
                    OutputFormat::Stdout);
     for (const QString &line : stdErr)
         emit addOutput(line, OutputFormat::Stderr);
@@ -774,7 +774,7 @@ void QbsBuildStepConfigWidget::updatePropertyEdit(const QVariantMap &data)
     for (QVariantMap::const_iterator i = editable.constBegin(); i != editable.constEnd(); ++i)
         propertyList.append(i.key() + ':' + i.value().toString());
 
-    propertyEdit->setText(QtcProcess::joinArgs(propertyList));
+    propertyEdit->setText(ProcessArgs::joinArgs(propertyList));
 }
 
 void QbsBuildStep::changeBuildVariant()
@@ -851,10 +851,9 @@ QbsBuildStep *QbsBuildStepConfigWidget::qbsStep() const
 
 bool QbsBuildStepConfigWidget::validateProperties(Utils::FancyLineEdit *edit, QString *errorMessage)
 {
-    Utils::QtcProcess::SplitError err;
-    QStringList argList = Utils::QtcProcess::splitArgs(edit->text(), Utils::HostOsInfo::hostOs(),
-                                                       false, &err);
-    if (err != Utils::QtcProcess::SplitOk) {
+    ProcessArgs::SplitError err;
+    QStringList argList = ProcessArgs::splitArgs(edit->text(), HostOsInfo::hostOs(), false, &err);
+    if (err != ProcessArgs::SplitOk) {
         if (errorMessage)
             *errorMessage = tr("Could not split properties.");
         return false;

src/plugins/qmakeprojectmanager/librarydetailscontroller.cpp

@@ -397,7 +397,7 @@ static QString smartQuote(const QString &aString)
 {
     // The OS type is not important in that case, but use always the same
     // in order not to generate different quoting depending on host platform
-    return Utils::QtcProcess::quoteArg(aString, Utils::OsTypeLinux);
+    return Utils::ProcessArgs::quoteArg(aString, Utils::OsTypeLinux);
 }
 
 static QString appendSeparator(const QString &aString)

src/plugins/qmakeprojectmanager/makefileparse.cpp

@@ -76,7 +76,7 @@ void MakeFileParse::parseArgs(const QString &args, const QString &project,
     bool after = false;
     bool ignoreNext = false;
     m_unparsedArguments = args;
-    QtcProcess::ArgIterator ait(&m_unparsedArguments);
+    ProcessArgs::ArgIterator ait(&m_unparsedArguments);
     while (ait.next()) {
         if (ignoreNext) {
             // Ignoring
@@ -391,11 +391,11 @@ void MakeFileParse::parseCommandLine(const QString &command, const QString &proj
     const QList<QMakeAssignment> &assignmentsToUse = m_mode == Mode::FilterKnownConfigValues
             ? filteredAssignments : assignments;
     foreach (const QMakeAssignment &qa, assignmentsToUse)
-        QtcProcess::addArg(&m_unparsedArguments, qa.variable + qa.op + qa.value);
+        ProcessArgs::addArg(&m_unparsedArguments, qa.variable + qa.op + qa.value);
     if (!afterAssignments.isEmpty()) {
-        QtcProcess::addArg(&m_unparsedArguments, QLatin1String("-after"));
+        ProcessArgs::addArg(&m_unparsedArguments, QLatin1String("-after"));
         foreach (const QMakeAssignment &qa, afterAssignments)
-            QtcProcess::addArg(&m_unparsedArguments, qa.variable + qa.op + qa.value);
+            ProcessArgs::addArg(&m_unparsedArguments, qa.variable + qa.op + qa.value);
     }
 }
 
@@ -527,8 +527,8 @@ void QmakeProjectManagerPlugin::testMakefileParser()
     MakeFileParse parser("/tmp/something", MakeFileParse::Mode::FilterKnownConfigValues);
     parser.parseCommandLine(command, project);
 
-    QCOMPARE(Utils::QtcProcess::splitArgs(parser.unparsedArguments()),
-             Utils::QtcProcess::splitArgs(unparsedArguments));
+    QCOMPARE(Utils::ProcessArgs::splitArgs(parser.unparsedArguments()),
+             Utils::ProcessArgs::splitArgs(unparsedArguments));
     QCOMPARE(parser.effectiveBuildConfig({}), effectiveBuildConfig);
 
     const QMakeStepConfig qmsc = parser.config();

src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp

@@ -646,7 +646,7 @@ QString QmakeBuildConfiguration::extractSpecFromArguments(QString *args,
 
     bool ignoreNext = false;
     bool nextIsSpec = false;
-    for (QtcProcess::ArgIterator ait(args); ait.next(); ) {
+    for (ProcessArgs::ArgIterator ait(args); ait.next(); ) {
         if (ignoreNext) {
             ignoreNext = false;
             ait.deleteArg();

src/plugins/qmakeprojectmanager/qmakeparsernodes.cpp

@@ -1140,9 +1140,9 @@ QByteArray QmakeProFile::cxxDefines() const
     QByteArray result;
     foreach (const QString &def, variableValue(Variable::Defines)) {
         // 'def' is shell input, so interpret it.
-        QtcProcess::SplitError error = QtcProcess::SplitOk;
-        const QStringList args = QtcProcess::splitArgs(def, HostOsInfo::hostOs(), false, &error);
-        if (error != QtcProcess::SplitOk || args.size() == 0)
+        ProcessArgs::SplitError error = ProcessArgs::SplitOk;
+        const QStringList args = ProcessArgs::splitArgs(def, HostOsInfo::hostOs(), false, &error);
+        if (error != ProcessArgs::SplitOk || args.size() == 0)
             continue;
 
         result += "#define ";

src/plugins/qmakeprojectmanager/qmakestep.cpp

@@ -142,7 +142,7 @@ QString QMakeStep::allArguments(const BaseQtVersion *v, ArgumentFlags flags) con
     if (v->qtVersion() < QtVersionNumber(5, 0, 0))
         arguments << "-r";
     bool userProvidedMkspec = false;
-    for (QtcProcess::ConstArgIterator ait(userArguments()); ait.next(); ) {
+    for (ProcessArgs::ConstArgIterator ait(userArguments()); ait.next(); ) {
         if (ait.value() == "-spec") {
             if (ait.next()) {
                 userProvidedMkspec = true;
@@ -159,11 +159,11 @@ QString QMakeStep::allArguments(const BaseQtVersion *v, ArgumentFlags flags) con
 
     arguments << deducedArguments().toArguments();
 
-    QString args = QtcProcess::joinArgs(arguments);
+    QString args = ProcessArgs::joinArgs(arguments);
     // User arguments
-    QtcProcess::addArgs(&args, userArguments());
+    ProcessArgs::addArgs(&args, userArguments());
     for (QString arg : qAsConst(m_extraArgs))
-        QtcProcess::addArgs(&args, arg);
+        ProcessArgs::addArgs(&args, arg);
     return (flags & ArgumentFlag::Expand) ? bc->macroExpander()->expand(args) : args;
 }
 
@@ -419,10 +419,10 @@ QString QMakeStep::makeArguments(const QString &makefile) const
 {
     QString args;
     if (!makefile.isEmpty()) {
-        QtcProcess::addArg(&args, "-f");
-        QtcProcess::addArg(&args, makefile);
+        ProcessArgs::addArg(&args, "-f");
+        ProcessArgs::addArg(&args, makefile);
     }
-    QtcProcess::addArg(&args, "qmake_all");
+    ProcessArgs::addArg(&args, "qmake_all");
     return args;
 }
 
@@ -453,7 +453,7 @@ QStringList QMakeStep::parserArguments()
     QStringList result = m_extraParserArgs;
     BaseQtVersion *qt = QtKitAspect::qtVersion(kit());
     QTC_ASSERT(qt, return QStringList());
-    for (QtcProcess::ConstArgIterator ait(allArguments(qt, ArgumentFlag::Expand)); ait.next(); ) {
+    for (ProcessArgs::ConstArgIterator ait(allArguments(qt, ArgumentFlag::Expand)); ait.next(); ) {
         if (ait.isSimple())
             result << ait.value();
     }
@@ -468,8 +468,8 @@ QString QMakeStep::userArguments() const
 QString QMakeStep::mkspec() const
 {
     QString additionalArguments = userArguments();
-    QtcProcess::addArgs(&additionalArguments, m_extraArgs);
-    for (QtcProcess::ArgIterator ait(&additionalArguments); ait.next(); ) {
+    ProcessArgs::addArgs(&additionalArguments, m_extraArgs);
+    for (ProcessArgs::ArgIterator ait(&additionalArguments); ait.next(); ) {
         if (ait.value() == "-spec") {
             if (ait.next())
                 return FilePath::fromUserInput(ait.value()).toString();

src/plugins/qmlpreview/qmlpreviewruncontrol.cpp

@@ -148,7 +148,7 @@ LocalQmlPreviewSupport::LocalQmlPreviewSupport(ProjectExplorer::RunControl *runC
             }
         }
 
-        Utils::QtcProcess::addArg(&runnable.commandLineArguments,
+        Utils::ProcessArgs::addArg(&runnable.commandLineArguments,
                                   QmlDebug::qmlDebugLocalArguments(QmlDebug::QmlPreviewServices,
                                                                    serverUrl.path()));
         doStart(runnable, {});

src/plugins/qmlprofiler/qmlprofilerruncontrol.cpp

@@ -51,7 +51,6 @@
 
 using namespace Core;
 using namespace ProjectExplorer;
-using namespace QmlProfiler::Internal;
 
 namespace QmlProfiler {
 namespace Internal {
@@ -249,7 +248,7 @@ LocalQmlProfilerSupport::LocalQmlProfilerSupport(RunControl *runControl, const Q
         else
             QTC_CHECK(false);
 
-        QString arguments = Utils::QtcProcess::quoteArg(
+        QString arguments = Utils::ProcessArgs::quoteArg(
                                 QmlDebug::qmlDebugCommandLineArguments(QmlDebug::QmlProfilerServices, code, true));
 
         if (!debuggee.commandLineArguments.isEmpty())

src/plugins/qmlprojectmanager/qmlprojectrunconfiguration.cpp

@@ -199,26 +199,26 @@ QString QmlProjectRunConfiguration::commandLineArguments() const
     const QmlBuildSystem *bs = qobject_cast<QmlBuildSystem *>(target()->buildSystem());
     foreach (const QString &importPath,
              QmlBuildSystem::makeAbsolute(bs->targetDirectory(), bs->customImportPaths())) {
-        QtcProcess::addArg(&args, "-I", osType);
-        QtcProcess::addArg(&args, importPath, osType);
+        ProcessArgs::addArg(&args, "-I", osType);
+        ProcessArgs::addArg(&args, importPath, osType);
     }
 
     for (const QString &fileSelector : bs->customFileSelectors()) {
-        QtcProcess::addArg(&args, "-S", osType);
-        QtcProcess::addArg(&args, fileSelector, osType);
+        ProcessArgs::addArg(&args, "-S", osType);
+        ProcessArgs::addArg(&args, fileSelector, osType);
     }
 
-    if (Utils::HostOsInfo::isWindowsHost() && bs->forceFreeType()) {
-        Utils::QtcProcess::addArg(&args, "-platform", osType);
-        Utils::QtcProcess::addArg(&args, "windows:fontengine=freetype", osType);
+    if (HostOsInfo::isWindowsHost() && bs->forceFreeType()) {
+        ProcessArgs::addArg(&args, "-platform", osType);
+        ProcessArgs::addArg(&args, "windows:fontengine=freetype", osType);
     }
 
     const QString main = bs->targetFile(FilePath::fromString(mainScript())).toString();
     if (!main.isEmpty())
-        QtcProcess::addArg(&args, main, osType);
+        ProcessArgs::addArg(&args, main, osType);
 
     if (m_multiLanguageAspect && m_multiLanguageAspect->value())
-        QtcProcess::addArg(&args, "-qmljsdebugger=file:unused_if_debugger_arguments_added,services:DebugTranslation", osType);
+        ProcessArgs::addArg(&args, "-qmljsdebugger=file:unused_if_debugger_arguments_added,services:DebugTranslation", osType);
 
     return args;
 }

src/plugins/qnx/qnxanalyzesupport.cpp

@@ -61,7 +61,7 @@ QnxQmlProfilerSupport::QnxQmlProfilerSupport(RunControl *runControl)
         profiler->recordData("QmlServerUrl", serverUrl);
 
         Runnable r = runControl->runnable();
-        QtcProcess::addArg(&r.commandLineArguments,
+        ProcessArgs::addArg(&r.commandLineArguments,
                            QmlDebug::qmlDebugTcpArguments(QmlDebug::QmlProfilerServices, serverUrl),
                            Utils::OsTypeOtherUnix);
 

src/plugins/qnx/qnxdebugsupport.cpp

@@ -116,8 +116,8 @@ public:
                 arguments.append(QmlDebug::qmlDebugTcpArguments(QmlDebug::QmlDebuggerServices,
                                                                 portsGatherer->qmlServer()));
             }
-            arguments.append(QtcProcess::splitArgs(r.commandLineArguments));
-            r.commandLineArguments = QtcProcess::joinArgs(arguments);
+            arguments.append(ProcessArgs::splitArgs(r.commandLineArguments));
+            r.commandLineArguments = ProcessArgs::joinArgs(arguments);
 
             doStart(r, runControl->device());
         });

src/plugins/qnx/qnxdeviceprocess.cpp

@@ -46,17 +46,16 @@ QnxDeviceProcess::QnxDeviceProcess(const QSharedPointer<const IDevice> &device,
 
 QString QnxDeviceProcess::fullCommandLine(const Runnable &runnable) const
 {
-    QStringList args = QtcProcess::splitArgs(runnable.commandLineArguments);
+    QStringList args = ProcessArgs::splitArgs(runnable.commandLineArguments);
     args.prepend(runnable.executable.toString());
-    QString cmd = QtcProcess::Arguments::createUnixArgs(args).toString();
+    QString cmd = ProcessArgs::createUnixArgs(args).toString();
 
-    QString fullCommandLine = QLatin1String(
+    QString fullCommandLine =
         "test -f /etc/profile && . /etc/profile ; "
-        "test -f $HOME/profile && . $HOME/profile ; "
-    );
+        "test -f $HOME/profile && . $HOME/profile ; ";
 
     if (!runnable.workingDirectory.isEmpty())
-        fullCommandLine += QString::fromLatin1("cd %1 ; ").arg(QtcProcess::quoteArg(runnable.workingDirectory));
+        fullCommandLine += QString::fromLatin1("cd %1 ; ").arg(ProcessArgs::quoteArg(runnable.workingDirectory));
 
     const Environment env = runnable.environment;
     for (auto it = env.constBegin(); it != env.constEnd(); ++it) {

src/plugins/remotelinux/genericdirectuploadservice.cpp

@@ -198,7 +198,7 @@ void GenericDirectUploadService::stopDeployment()
 void GenericDirectUploadService::runStat(const DeployableFile &file)
 {
     // We'd like to use --format=%Y, but it's not supported by busybox.
-    const QString statCmd = "stat -t " + Utils::QtcProcess::quoteArgUnix(file.remoteFilePath());
+    const QString statCmd = "stat -t " + Utils::ProcessArgs::quoteArgUnix(file.remoteFilePath());
     SshRemoteProcess * const statProc = connection()->createRemoteProcess(statCmd).release();
     statProc->setParent(this);
     connect(statProc, &SshRemoteProcess::done, this,
@@ -344,7 +344,7 @@ void GenericDirectUploadService::chmod()
         if (!f.isExecutable())
             continue;
         const QString command = QLatin1String("chmod a+x ")
-                + Utils::QtcProcess::quoteArgUnix(f.remoteFilePath());
+                + Utils::ProcessArgs::quoteArgUnix(f.remoteFilePath());
         SshRemoteProcess * const chmodProc
                 = connection()->createRemoteProcess(command).release();
         chmodProc->setParent(this);

src/plugins/remotelinux/makeinstallstep.cpp

@@ -241,7 +241,7 @@ void MakeInstallStep::updateArgsFromAspect()
 {
     if (customCommandLineAspect()->isChecked())
         return;
-    setUserArguments(QtcProcess::joinArgs(target()->makeInstallCommand(
+    setUserArguments(ProcessArgs::joinArgs(target()->makeInstallCommand(
         static_cast<StringAspect *>(aspect(InstallRootAspectId))->filePath().toString())
                                           .arguments));
     updateFullCommandLine();
@@ -252,7 +252,7 @@ void MakeInstallStep::updateFullCommandLine()
     // FIXME: Only executable?
     static_cast<StringAspect *>(aspect(FullCommandLineAspectId))->setValue(
                 QDir::toNativeSeparators(
-                    QtcProcess::quoteArg(makeExecutable().toString()))
+                    ProcessArgs::quoteArg(makeExecutable().toString()))
                 + ' '  + userArguments());
 }
 
@@ -261,9 +261,9 @@ void MakeInstallStep::updateFromCustomCommandLineAspect()
     const StringAspect * const aspect = customCommandLineAspect();
     if (!aspect->isChecked())
         return;
-    const QStringList tokens = QtcProcess::splitArgs(aspect->value());
+    const QStringList tokens = ProcessArgs::splitArgs(aspect->value());
     setMakeCommand(tokens.isEmpty() ? FilePath() : FilePath::fromString(tokens.first()));
-    setUserArguments(QtcProcess::joinArgs(tokens.mid(1)));
+    setUserArguments(ProcessArgs::joinArgs(tokens.mid(1)));
 }
 
 StringAspect *MakeInstallStep::customCommandLineAspect() const

src/plugins/remotelinux/remotelinuxqmltoolingsupport.cpp

@@ -58,7 +58,7 @@ RemoteLinuxQmlToolingSupport::RemoteLinuxQmlToolingSupport(RunControl *runContro
         QmlDebug::QmlDebugServicesPreset services = QmlDebug::servicesForRunMode(runControl->runMode());
 
         Runnable r = runControl->runnable();
-        QtcProcess::addArg(&r.commandLineArguments,
+        ProcessArgs::addArg(&r.commandLineArguments,
                            QmlDebug::qmlDebugTcpArguments(services, serverUrl),
                            OsTypeLinux);
 

src/plugins/remotelinux/rsyncdeploystep.cpp

@@ -103,8 +103,8 @@ void RsyncDeployService::createRemoteDirectories()
         remoteDirs << f.remoteDirectory();
     remoteDirs.sort();
     remoteDirs.removeDuplicates();
-    m_mkdir = connection()->createRemoteProcess("mkdir -p " + QtcProcess::Arguments
-                                                ::createUnixArgs(remoteDirs).toString());
+    m_mkdir = connection()->createRemoteProcess("mkdir -p " +
+                                                ProcessArgs::createUnixArgs(remoteDirs).toString());
     connect(m_mkdir.get(), &SshRemoteProcess::done, this, [this](const QString &error) {
         QString userError;
         if (!error.isEmpty())
@@ -237,7 +237,7 @@ QString RsyncDeployStep::defaultFlags()
 RsyncCommandLine RsyncDeployStep::rsyncCommand(const SshConnection &sshConnection,
                                                const QString &flags)
 {
-    const QString sshCmdLine = QtcProcess::joinArgs(
+    const QString sshCmdLine = ProcessArgs::joinArgs(
                 QStringList{SshSettings::sshFilePath().toUserOutput()}
                 << sshConnection.connectionOptions(SshSettings::sshFilePath()), OsTypeLinux);
     const SshConnectionParameters sshParams = sshConnection.connectionParameters();

src/plugins/valgrind/callgrindengine.cpp

@@ -97,7 +97,7 @@ QStringList CallgrindToolRunner::toolArguments() const
     if (!m_argumentForToggleCollect.isEmpty())
         arguments << m_argumentForToggleCollect;
 
-    arguments << Utils::QtcProcess::splitArgs(m_settings.callgrindArguments.value());
+    arguments << Utils::ProcessArgs::splitArgs(m_settings.callgrindArguments.value());
 
     return arguments;
 }

src/plugins/valgrind/memchecktool.cpp

@@ -220,7 +220,7 @@ QStringList MemcheckToolRunner::toolArguments() const
     if (m_withGdb)
         arguments << "--vgdb=yes" << "--vgdb-error=0";
 
-    arguments << Utils::QtcProcess::splitArgs(m_settings.memcheckArguments.value());
+    arguments << Utils::ProcessArgs::splitArgs(m_settings.memcheckArguments.value());
 
     return arguments;
 }

src/plugins/vcsbase/vcsoutputwindow.cpp

@@ -448,12 +448,12 @@ static inline QString formatArguments(const QStringList &args)
         if (i)
             str << ' ';
         if (arg.startsWith(QString::fromLatin1(passwordOptionC) + '=')) {
-            str << QtcProcess::quoteArg("--password=********");
+            str << ProcessArgs::quoteArg("--password=********");
             continue;
         }
-        str << QtcProcess::quoteArg(arg);
+        str << ProcessArgs::quoteArg(arg);
         if (arg == passwordOptionC) {
-            str << ' ' << QtcProcess::quoteArg("********");
+            str << ' ' << ProcessArgs::quoteArg("********");
             i++;
         }
     }
@@ -463,7 +463,7 @@ static inline QString formatArguments(const QStringList &args)
 QString VcsOutputWindow::msgExecutionLogEntry(const QString &workingDir, const CommandLine &command)
 {
     const QString args = formatArguments(command.splitArguments());
-    const QString nativeExecutable = QtcProcess::quoteArg(command.executable().toUserOutput());
+    const QString nativeExecutable = ProcessArgs::quoteArg(command.executable().toUserOutput());
     if (workingDir.isEmpty())
         return tr("Running: %1 %2").arg(nativeExecutable, args) + '\n';
     return tr("Running in %1: %2 %3").

src/plugins/winrt/winrtpackagedeploymentstep.cpp

@@ -346,8 +346,8 @@ void WinRtPackageDeploymentStep::stdOutput(const QString &line)
 QString WinRtPackageDeploymentStep::defaultWinDeployQtArguments() const
 {
     QString args;
-    QtcProcess::addArg(&args, QStringLiteral("--qmldir"));
-    QtcProcess::addArg(&args, project()->projectDirectory().toUserOutput());
+    ProcessArgs::addArg(&args, QStringLiteral("--qmldir"));
+    ProcessArgs::addArg(&args, project()->projectDirectory().toUserOutput());
     return args;
 }
 

src/tools/clangbackend/source/commandlinearguments.cpp

@@ -37,7 +37,7 @@
 static QList<QByteArray> splitArgs(QString &argsString)
 {
     QList<QByteArray> result;
-    Utils::QtcProcess::ArgIterator it(&argsString);
+    Utils::ProcessArgs::ArgIterator it(&argsString);
     while (it.next())
         result.append(it.value().toUtf8());
     return result;
@@ -112,7 +112,7 @@ const char *CommandLineArguments::at(int position) const
 static Utf8String maybeQuoted(const char *argumentAsCString)
 {
     const QString argumentAsQString = QString::fromUtf8(argumentAsCString);
-    const QString quotedArgument = Utils::QtcProcess::quoteArg(argumentAsQString);
+    const QString quotedArgument = Utils::ProcessArgs::quoteArg(argumentAsQString);
 
     return Utf8String::fromString(quotedArgument);
 }

tests/auto/debugger/tst_dumpers.cpp

@@ -82,14 +82,14 @@ static bool generateEnvironmentSettings(Utils::Environment &env,
     Utils::TempFileSaver saver(QDir::tempPath() + "/XXXXXX.bat");
 
     QByteArray call = "call ";
-    call += Utils::QtcProcess::quoteArg(batchFile).toLocal8Bit();
+    call += Utils::ProcessArgs::quoteArg(batchFile).toLocal8Bit();
     if (!batchArgs.isEmpty()) {
         call += ' ';
         call += batchArgs.toLocal8Bit();
     }
     saver.write(call + "\r\n");
 
-    const QByteArray redirect = "set > " + Utils::QtcProcess::quoteArg(
+    const QByteArray redirect = "set > " + Utils::ProcessArgs::quoteArg(
                                     QDir::toNativeSeparators(tempOutFile)).toLocal8Bit() + "\r\n";
     saver.write(redirect);
     if (!saver.finalize()) {

tests/auto/qtcprocess/tst_qtcprocess.cpp

@@ -130,55 +130,55 @@ void tst_QtcProcess::initTestCase()
 }
 
 
-Q_DECLARE_METATYPE(QtcProcess::SplitError)
+Q_DECLARE_METATYPE(ProcessArgs::SplitError)
 Q_DECLARE_METATYPE(Utils::OsType)
 
 void tst_QtcProcess::splitArgs_data()
 {
     QTest::addColumn<QString>("in");
     QTest::addColumn<QString>("out");
-    QTest::addColumn<QtcProcess::SplitError>("err");
+    QTest::addColumn<ProcessArgs::SplitError>("err");
     QTest::addColumn<Utils::OsType>("os");
 
     static const struct {
         const char * const in;
         const char * const out;
-        const QtcProcess::SplitError err;
+        const ProcessArgs::SplitError err;
         const OsType os;
     } vals[] = {
-        {"", "", QtcProcess::SplitOk, OsTypeWindows},
-        {" ", "", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi", "hi", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi ho", "hi ho", QtcProcess::SplitOk, OsTypeWindows},
-        {" hi ho ", "hi ho", QtcProcess::SplitOk, OsTypeWindows},
-        {"\"hi ho\" \"hi\" ho  ", "\"hi ho\" hi ho", QtcProcess::SplitOk, OsTypeWindows},
-        {"\\", "\\", QtcProcess::SplitOk, OsTypeWindows},
-        {"\\\"", "\"\"\\^\"\"\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"\"hi\"\"\"ho\"", "\"hi\"\\^\"\"ho\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"\\\\\\\"", "\"\"\\\\\\^\"\"\"", QtcProcess::SplitOk, OsTypeWindows},
-        {" ^^ ", "\"^^\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi\"", "", QtcProcess::BadQuoting, OsTypeWindows},
-        {"hi\"dood", "", QtcProcess::BadQuoting, OsTypeWindows},
-        {"%var%", "%var%", QtcProcess::SplitOk, OsTypeWindows},
+        {"", "", ProcessArgs::SplitOk, OsTypeWindows},
+        {" ", "", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi", "hi", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
+        {" hi ho ", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\"hi ho\" \"hi\" ho  ", "\"hi ho\" hi ho", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\\", "\\", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\\\"", "\"\"\\^\"\"\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\"hi\"\"\"ho\"", "\"hi\"\\^\"\"ho\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\\\\\\\"", "\"\"\\\\\\^\"\"\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {" ^^ ", "\"^^\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi\"", "", ProcessArgs::BadQuoting, OsTypeWindows},
+        {"hi\"dood", "", ProcessArgs::BadQuoting, OsTypeWindows},
+        {"%var%", "%var%", ProcessArgs::SplitOk, OsTypeWindows},
 
-        {"", "", QtcProcess::SplitOk, OsTypeLinux},
-        {" ", "", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi", "hi", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi ho", "hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {" hi ho ", "hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {"'hi ho' \"hi\" ho  ", "'hi ho' hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {" \\ ", "' '", QtcProcess::SplitOk, OsTypeLinux},
-        {" \\\" ", "'\"'", QtcProcess::SplitOk, OsTypeLinux},
-        {" '\"' ", "'\"'", QtcProcess::SplitOk, OsTypeLinux},
-        {" \"\\\"\" ", "'\"'", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi'", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"hi\"dood", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"$var", "'$var'", QtcProcess::SplitOk, OsTypeLinux},
-        {"~", "@HOME@", QtcProcess::SplitOk, OsTypeLinux},
-        {"~ foo", "@HOME@ foo", QtcProcess::SplitOk, OsTypeLinux},
-        {"foo ~", "foo @HOME@", QtcProcess::SplitOk, OsTypeLinux},
-        {"~/foo", "@HOME@/foo", QtcProcess::SplitOk, OsTypeLinux},
-        {"~foo", "'~foo'", QtcProcess::SplitOk, OsTypeLinux}
+        {"", "", ProcessArgs::SplitOk, OsTypeLinux},
+        {" ", "", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi", "hi", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {" hi ho ", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {"'hi ho' \"hi\" ho  ", "'hi ho' hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {" \\ ", "' '", ProcessArgs::SplitOk, OsTypeLinux},
+        {" \\\" ", "'\"'", ProcessArgs::SplitOk, OsTypeLinux},
+        {" '\"' ", "'\"'", ProcessArgs::SplitOk, OsTypeLinux},
+        {" \"\\\"\" ", "'\"'", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi'", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"hi\"dood", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"$var", "'$var'", ProcessArgs::SplitOk, OsTypeLinux},
+        {"~", "@HOME@", ProcessArgs::SplitOk, OsTypeLinux},
+        {"~ foo", "@HOME@ foo", ProcessArgs::SplitOk, OsTypeLinux},
+        {"foo ~", "foo @HOME@", ProcessArgs::SplitOk, OsTypeLinux},
+        {"~/foo", "@HOME@/foo", ProcessArgs::SplitOk, OsTypeLinux},
+        {"~foo", "'~foo'", ProcessArgs::SplitOk, OsTypeLinux}
     };
 
     for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++) {
@@ -194,13 +194,13 @@ void tst_QtcProcess::splitArgs()
 {
     QFETCH(QString, in);
     QFETCH(QString, out);
-    QFETCH(QtcProcess::SplitError, err);
+    QFETCH(ProcessArgs::SplitError, err);
     QFETCH(Utils::OsType, os);
 
-    QtcProcess::SplitError outerr;
-    QString outstr = QtcProcess::joinArgs(QtcProcess::splitArgs(in, os, false, &outerr), os);
+    ProcessArgs::SplitError outerr;
+    QString outstr = ProcessArgs::joinArgs(ProcessArgs::splitArgs(in, os, false, &outerr), os);
     QCOMPARE(outerr, err);
-    if (err == QtcProcess::SplitOk)
+    if (err == ProcessArgs::SplitOk)
         QCOMPARE(outstr, out);
 }
 
@@ -208,45 +208,45 @@ void tst_QtcProcess::prepareArgs_data()
 {
     QTest::addColumn<QString>("in");
     QTest::addColumn<QString>("out");
-    QTest::addColumn<QtcProcess::SplitError>("err");
+    QTest::addColumn<ProcessArgs::SplitError>("err");
     QTest::addColumn<OsType>("os");
 
     static const struct {
         const char * const in;
         const char * const out;
-        const QtcProcess::SplitError err;
+        const ProcessArgs::SplitError err;
         const OsType os;
     } vals[] = {
-        {" ", " ", QtcProcess::SplitOk, OsTypeWindows},
-        {"", "", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi", "hi", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi ho", "hi ho", QtcProcess::SplitOk, OsTypeWindows},
-        {" hi ho ", " hi ho ", QtcProcess::SplitOk, OsTypeWindows},
-        {"\"hi ho\" \"hi\" ho  ", "\"hi ho\" \"hi\" ho  ", QtcProcess::SplitOk, OsTypeWindows},
-        {"\\", "\\", QtcProcess::SplitOk, OsTypeWindows},
-        {"\\\"", "\\\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"\"hi\"\"ho\"", "\"hi\"\"ho\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"\\\\\\\"", "\\\\\\\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"^^", "^", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi\"", "hi\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi\"dood", "hi\"dood", QtcProcess::SplitOk, OsTypeWindows},
-        {"%var%", "", QtcProcess::FoundMeta, OsTypeWindows},
-        {"echo hi > file", "", QtcProcess::FoundMeta, OsTypeWindows},
+        {" ", " ", ProcessArgs::SplitOk, OsTypeWindows},
+        {"", "", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi", "hi", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
+        {" hi ho ", " hi ho ", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\"hi ho\" \"hi\" ho  ", "\"hi ho\" \"hi\" ho  ", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\\", "\\", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\\\"", "\\\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\"hi\"\"ho\"", "\"hi\"\"ho\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\\\\\\\"", "\\\\\\\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"^^", "^", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi\"", "hi\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi\"dood", "hi\"dood", ProcessArgs::SplitOk, OsTypeWindows},
+        {"%var%", "", ProcessArgs::FoundMeta, OsTypeWindows},
+        {"echo hi > file", "", ProcessArgs::FoundMeta, OsTypeWindows},
 
-        {"", "", QtcProcess::SplitOk, OsTypeLinux},
-        {" ", "", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi", "hi", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi ho", "hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {" hi ho ", "hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {"'hi ho' \"hi\" ho  ", "'hi ho' hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {" \\ ", "' '", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi'", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"hi\"dood", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"$var", "", QtcProcess::FoundMeta, OsTypeLinux},
-        {"~", "@HOME@", QtcProcess::SplitOk, OsTypeLinux},
-        {"~ foo", "@HOME@ foo", QtcProcess::SplitOk, OsTypeLinux},
-        {"~/foo", "@HOME@/foo", QtcProcess::SplitOk, OsTypeLinux},
-        {"~foo", "", QtcProcess::FoundMeta, OsTypeLinux}
+        {"", "", ProcessArgs::SplitOk, OsTypeLinux},
+        {" ", "", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi", "hi", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {" hi ho ", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {"'hi ho' \"hi\" ho  ", "'hi ho' hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {" \\ ", "' '", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi'", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"hi\"dood", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"$var", "", ProcessArgs::FoundMeta, OsTypeLinux},
+        {"~", "@HOME@", ProcessArgs::SplitOk, OsTypeLinux},
+        {"~ foo", "@HOME@ foo", ProcessArgs::SplitOk, OsTypeLinux},
+        {"~/foo", "@HOME@/foo", ProcessArgs::SplitOk, OsTypeLinux},
+        {"~foo", "", ProcessArgs::FoundMeta, OsTypeLinux}
     };
 
     for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++) {
@@ -262,15 +262,15 @@ void tst_QtcProcess::prepareArgs()
 {
     QFETCH(QString, in);
     QFETCH(QString, out);
-    QFETCH(QtcProcess::SplitError, err);
+    QFETCH(ProcessArgs::SplitError, err);
     QFETCH(OsType, os);
 
-    QtcProcess::SplitError outerr;
-    QtcProcess::Arguments args = QtcProcess::prepareArgs(in, &outerr, os);
+    ProcessArgs::SplitError outerr;
+    ProcessArgs args = ProcessArgs::prepareArgs(in, &outerr, os);
     QString outstr = args.toString();
 
     QCOMPARE(outerr, err);
-    if (err == QtcProcess::SplitOk)
+    if (err == ProcessArgs::SplitOk)
         QCOMPARE(outstr, out);
 }
 
@@ -278,65 +278,65 @@ void tst_QtcProcess::prepareArgsEnv_data()
 {
     QTest::addColumn<QString>("in");
     QTest::addColumn<QString>("out");
-    QTest::addColumn<QtcProcess::SplitError>("err");
+    QTest::addColumn<ProcessArgs::SplitError>("err");
     QTest::addColumn<OsType>("os");
 
     static const struct {
         const char * const in;
         const char * const out;
-        const QtcProcess::SplitError err;
+        const ProcessArgs::SplitError err;
         const OsType os;
     } vals[] = {
-        {" ", " ", QtcProcess::SplitOk, OsTypeWindows},
-        {"", "", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi", "hi", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi ho", "hi ho", QtcProcess::SplitOk, OsTypeWindows},
-        {" hi ho ", " hi ho ", QtcProcess::SplitOk, OsTypeWindows},
-        {"\"hi ho\" \"hi\" ho  ", "\"hi ho\" \"hi\" ho  ", QtcProcess::SplitOk, OsTypeWindows},
-        {"\\", "\\", QtcProcess::SplitOk, OsTypeWindows},
-        {"\\\"", "\\\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"\"hi\"\"ho\"", "\"hi\"\"ho\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"\\\\\\\"", "\\\\\\\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"^^", "^", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi\"", "hi\"", QtcProcess::SplitOk, OsTypeWindows},
-        {"hi\"dood", "hi\"dood", QtcProcess::SplitOk, OsTypeWindows},
-        {"%empty%", "%empty%", QtcProcess::SplitOk, OsTypeWindows}, // Yep, no empty variables on Windows.
-        {"%word%", "hi", QtcProcess::SplitOk, OsTypeWindows},
-        {" %word% ", " hi ", QtcProcess::SplitOk, OsTypeWindows},
-        {"%words%", "hi ho", QtcProcess::SplitOk, OsTypeWindows},
-        {"%nonsense%words%", "%nonsensehi ho", QtcProcess::SplitOk, OsTypeWindows},
-        {"fail%nonsense%words%", "fail%nonsensehi ho", QtcProcess::SplitOk, OsTypeWindows},
-        {"%words%words%", "hi howords%", QtcProcess::SplitOk, OsTypeWindows},
-        {"%words%%words%", "hi hohi ho", QtcProcess::SplitOk, OsTypeWindows},
-        {"echo hi > file", "", QtcProcess::FoundMeta, OsTypeWindows},
+        {" ", " ", ProcessArgs::SplitOk, OsTypeWindows},
+        {"", "", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi", "hi", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
+        {" hi ho ", " hi ho ", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\"hi ho\" \"hi\" ho  ", "\"hi ho\" \"hi\" ho  ", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\\", "\\", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\\\"", "\\\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\"hi\"\"ho\"", "\"hi\"\"ho\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"\\\\\\\"", "\\\\\\\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"^^", "^", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi\"", "hi\"", ProcessArgs::SplitOk, OsTypeWindows},
+        {"hi\"dood", "hi\"dood", ProcessArgs::SplitOk, OsTypeWindows},
+        {"%empty%", "%empty%", ProcessArgs::SplitOk, OsTypeWindows}, // Yep, no empty variables on Windows.
+        {"%word%", "hi", ProcessArgs::SplitOk, OsTypeWindows},
+        {" %word% ", " hi ", ProcessArgs::SplitOk, OsTypeWindows},
+        {"%words%", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
+        {"%nonsense%words%", "%nonsensehi ho", ProcessArgs::SplitOk, OsTypeWindows},
+        {"fail%nonsense%words%", "fail%nonsensehi ho", ProcessArgs::SplitOk, OsTypeWindows},
+        {"%words%words%", "hi howords%", ProcessArgs::SplitOk, OsTypeWindows},
+        {"%words%%words%", "hi hohi ho", ProcessArgs::SplitOk, OsTypeWindows},
+        {"echo hi > file", "", ProcessArgs::FoundMeta, OsTypeWindows},
 
-        {"", "", QtcProcess::SplitOk, OsTypeLinux},
-        {" ", "", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi", "hi", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi ho", "hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {" hi ho ", "hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {"'hi ho' \"hi\" ho  ", "'hi ho' hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {" \\ ", "' '", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi'", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"hi\"dood", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"$empty", "", QtcProcess::SplitOk, OsTypeLinux},
-        {"$word", "hi", QtcProcess::SplitOk, OsTypeLinux},
-        {" $word ", "hi", QtcProcess::SplitOk, OsTypeLinux},
-        {"${word}", "hi", QtcProcess::SplitOk, OsTypeLinux},
-        {" ${word} ", "hi", QtcProcess::SplitOk, OsTypeLinux},
-        {"$words", "hi ho", QtcProcess::SplitOk, OsTypeLinux},
-        {"$spacedwords", "hi ho sucker", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi${empty}ho", "hiho", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi${words}ho", "hihi hoho", QtcProcess::SplitOk, OsTypeLinux},
-        {"hi${spacedwords}ho", "hi hi ho sucker ho", QtcProcess::SplitOk, OsTypeLinux},
-        {"${", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"${var", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"${var ", "", QtcProcess::FoundMeta, OsTypeLinux},
-        {"\"hi${words}ho\"", "'hihi hoho'", QtcProcess::SplitOk, OsTypeLinux},
-        {"\"hi${spacedwords}ho\"", "'hi hi   ho sucker ho'", QtcProcess::SplitOk, OsTypeLinux},
-        {"\"${", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"\"${var", "", QtcProcess::BadQuoting, OsTypeLinux},
-        {"\"${var ", "", QtcProcess::FoundMeta, OsTypeLinux},
+        {"", "", ProcessArgs::SplitOk, OsTypeLinux},
+        {" ", "", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi", "hi", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {" hi ho ", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {"'hi ho' \"hi\" ho  ", "'hi ho' hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {" \\ ", "' '", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi'", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"hi\"dood", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"$empty", "", ProcessArgs::SplitOk, OsTypeLinux},
+        {"$word", "hi", ProcessArgs::SplitOk, OsTypeLinux},
+        {" $word ", "hi", ProcessArgs::SplitOk, OsTypeLinux},
+        {"${word}", "hi", ProcessArgs::SplitOk, OsTypeLinux},
+        {" ${word} ", "hi", ProcessArgs::SplitOk, OsTypeLinux},
+        {"$words", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {"$spacedwords", "hi ho sucker", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi${empty}ho", "hiho", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi${words}ho", "hihi hoho", ProcessArgs::SplitOk, OsTypeLinux},
+        {"hi${spacedwords}ho", "hi hi ho sucker ho", ProcessArgs::SplitOk, OsTypeLinux},
+        {"${", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"${var", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"${var ", "", ProcessArgs::FoundMeta, OsTypeLinux},
+        {"\"hi${words}ho\"", "'hihi hoho'", ProcessArgs::SplitOk, OsTypeLinux},
+        {"\"hi${spacedwords}ho\"", "'hi hi   ho sucker ho'", ProcessArgs::SplitOk, OsTypeLinux},
+        {"\"${", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"\"${var", "", ProcessArgs::BadQuoting, OsTypeLinux},
+        {"\"${var ", "", ProcessArgs::FoundMeta, OsTypeLinux},
     };
 
     for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++) {
@@ -352,15 +352,15 @@ void tst_QtcProcess::prepareArgsEnv()
 {
     QFETCH(QString, in);
     QFETCH(QString, out);
-    QFETCH(QtcProcess::SplitError, err);
+    QFETCH(ProcessArgs::SplitError, err);
     QFETCH(OsType, os);
 
-    QtcProcess::SplitError outerr;
-    QtcProcess::Arguments args = QtcProcess::prepareArgs(in, &outerr, os, os == OsTypeLinux ? &envLinux : &envWindows);
+    ProcessArgs::SplitError outerr;
+    ProcessArgs args = ProcessArgs::prepareArgs(in, &outerr, os, os == OsTypeLinux ? &envLinux : &envWindows);
     QString outstr = args.toString();
 
     QCOMPARE(outerr, err);
-    if (err == QtcProcess::SplitOk)
+    if (err == ProcessArgs::SplitOk)
         QCOMPARE(outstr, out);
 }
 
@@ -605,9 +605,9 @@ void tst_QtcProcess::expandMacros()
     QFETCH(OsType, os);
 
     if (os == OsTypeWindows)
-        QtcProcess::expandMacros(&in, &mxWin, os);
+        ProcessArgs::expandMacros(&in, &mxWin, os);
     else
-        QtcProcess::expandMacros(&in, &mxUnix, os);
+        ProcessArgs::expandMacros(&in, &mxUnix, os);
     QCOMPARE(in, out);
 }
 
@@ -673,11 +673,11 @@ void tst_QtcProcess::iterations()
     QFETCH(OsType, os);
 
     QString outstr;
-    for (QtcProcess::ArgIterator ait(&in, os); ait.next(); ) {
+    for (ProcessArgs::ArgIterator ait(&in, os); ait.next(); ) {
         if (ait.isSimple())
-            QtcProcess::addArg(&outstr, ait.value(), os);
+            ProcessArgs::addArg(&outstr, ait.value(), os);
         else
-            QtcProcess::addArgs(&outstr, "{}");
+            ProcessArgs::addArgs(&outstr, "{}");
     }
     QCOMPARE(outstr, out);
 }
@@ -686,7 +686,7 @@ void tst_QtcProcess::iteratorEditsHelper(OsType osType)
 {
     QString in1 = "one two three", in2 = in1, in3 = in1, in4 = in1, in5 = in1;
 
-    QtcProcess::ArgIterator ait1(&in1, osType);
+    ProcessArgs::ArgIterator ait1(&in1, osType);
     QVERIFY(ait1.next());
     ait1.deleteArg();
     QVERIFY(ait1.next());
@@ -696,7 +696,7 @@ void tst_QtcProcess::iteratorEditsHelper(OsType osType)
     ait1.appendArg("four");
     QCOMPARE(in1, QString::fromLatin1("two three four"));
 
-    QtcProcess::ArgIterator ait2(&in2, osType);
+    ProcessArgs::ArgIterator ait2(&in2, osType);
     QVERIFY(ait2.next());
     QVERIFY(ait2.next());
     ait2.deleteArg();
@@ -705,7 +705,7 @@ void tst_QtcProcess::iteratorEditsHelper(OsType osType)
     QVERIFY(!ait2.next());
     QCOMPARE(in2, QString::fromLatin1("one three four"));
 
-    QtcProcess::ArgIterator ait3(&in3, osType);
+    ProcessArgs::ArgIterator ait3(&in3, osType);
     QVERIFY(ait3.next());
     ait3.appendArg("one-b");
     QVERIFY(ait3.next());
@@ -714,7 +714,7 @@ void tst_QtcProcess::iteratorEditsHelper(OsType osType)
     QVERIFY(!ait3.next());
     QCOMPARE(in3, QString::fromLatin1("one one-b two"));
 
-    QtcProcess::ArgIterator ait4(&in4, osType);
+    ProcessArgs::ArgIterator ait4(&in4, osType);
     ait4.appendArg("pre-one");
     QVERIFY(ait4.next());
     QVERIFY(ait4.next());
@@ -723,7 +723,7 @@ void tst_QtcProcess::iteratorEditsHelper(OsType osType)
     QVERIFY(!ait4.next());
     QCOMPARE(in4, QString::fromLatin1("pre-one one two"));
 
-    QtcProcess::ArgIterator ait5(&in5, osType);
+    ProcessArgs::ArgIterator ait5(&in5, osType);
     QVERIFY(ait5.next());
     QVERIFY(ait5.next());
     QVERIFY(ait5.next());