qmllsmain.cpp - mozsearch

// Copyright (C) 2025 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:significant reason:default

#include "qmllsmain_p.h"

#include <private/qhttpmessagestreamparser_p.h>

#include <private/qqmlglobal_p.h>

#include <private/qqmljscompiler_p.h>

#include <private/qqmljsimporter_p.h>

#include <private/qqmljslogger_p.h>

#include <private/qqmljsresourcefilemapper_p.h>

#include <private/qqmljsscope_p.h>

#include <private/qqmllanguageserver_p.h>

#include <private/qqmltoolingsettings_p.h>

#include <private/qqmltoolingutils_p.h>

#include <QtCore/qdebug.h>

#include <QtCore/qfile.h>

#include <QtCore/qdir.h>

#include <QtCore/qfileinfo.h>

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdiriterator.h>

#include <QtCore/qjsonobject.h>

#include <QtCore/qjsonarray.h>

#include <QtCore/qjsondocument.h>

#include <QtCore/qmutex.h>

#include <QtCore/QMutexLocker>

#include <QtCore/qscopedpointer.h>

#include <QtCore/qrunnable.h>

#include <QtCore/qthreadpool.h>

#include <QtCore/qtimer.h>

#if QT_CONFIG(commandlineparser)

#  include <QtCore/qcommandlineparser.h>

#endif

#ifndef QT_BOOTSTRAPPED

#  include <QtCore/qlibraryinfo.h>

#endif

#include <iostream>

#ifdef Q_OS_WIN32

#  include <fcntl.h>

#  include <io.h>

#endif

QT_BEGIN_NAMESPACE

namespace QmlLsp {

QFile *logFile = nullptr;

QBasicMutex *logFileLock = nullptr;

class AbstractReader : public QObject

    Q_OBJECT

public:

    virtual ~AbstractReader() { }

protected:

    virtual void readNextMessageImpl() = 0;

signals:

    void receivedData(const QByteArray &data, bool canRequestMoreData);

    void eof();

public slots:

    void readNextMessage() { readNextMessageImpl(); }

};

class StdinReader final : public AbstractReader

    Q_OBJECT

public:

    StdinReader()

        : m_streamReader(

                  [](const QByteArray &, const QByteArray &) { /* just a header, do nothing */ },

                  [this](const QByteArray &) {

                      // stop reading until we are sure that the server is not shutting down

                      m_isReading = false;

                      // message body

                      m_shouldSendData = true;

},

                  [this](QtMsgType, const QString &) {

                      // there was an error

                      m_shouldSendData = true;

},

                  QHttpMessageStreamParser::UNBUFFERED)

    void sendData()

        const bool isEndOfMessage = !m_isReading && !m_hasEof;

        const qsizetype toSend = m_bytesInBuf;

        m_bytesInBuf = 0;

        const QByteArray dataToSend(m_buffer, toSend);

        emit receivedData(dataToSend, isEndOfMessage);

private:

    const static constexpr qsizetype s_bufSize = 1024;

    qsizetype m_bytesInBuf = 0;

    char m_buffer[2 * s_bufSize] = {};

    QHttpMessageStreamParser m_streamReader;

/*!

    \internal

    Indicates if the current message is not read out entirely.

*/

    bool m_isReading = true;

/*!

    \internal

    Indicates if an EOF was encountered. No more data can be read after an EOF.

*/

    bool m_hasEof = false;

/*!

    \internal

    Indicates whether sendData() should be called or not.

*/

    bool m_shouldSendData = false;

protected:

    void readNextMessageImpl() override

        if (m_hasEof)

            return;

        m_isReading = true;

        // Try to fill up the buffer as much as possible before calling the queued signal:

        // each loop iteration might read only one character from std::in in the worstcase, this

        // happens for example on macos.

        while (m_isReading) {

            // block while waiting for some data

            if (!std::cin.get(m_buffer[m_bytesInBuf])) {

                qInfo() << "Received EOF, stopping...";

                m_hasEof = true;

                emit eof();

                return;

            // see if more data is available and fill the buffer with it

            qsizetype readNow = std::cin.readsome(m_buffer + m_bytesInBuf + 1, s_bufSize) + 1;

            QByteArray toAdd(m_buffer + m_bytesInBuf, readNow);

            m_bytesInBuf += readNow;

            m_streamReader.receiveData(std::move(toAdd));

            m_shouldSendData |= m_bytesInBuf >= s_bufSize;

            if (std::exchange(m_shouldSendData, false))

                sendData();

};

/*!

   \internal

   FileReader allows to read JsonRPC commands from a file. This is useful when the JsonRPC

   commands can't be read from stdin, for example when running qmlls in the macos profiler.

*/

class FileReader final : public AbstractReader

    Q_OBJECT

public:

    FileReader(const QString &fileName) : m_file(fileName)

        bool isOpen = m_file.open(QFile::ReadOnly);

        Q_ASSERT(isOpen);

private:

    QFile m_file;

protected:

    void readNextMessageImpl() override

        if (!m_file.isOpen())

            return;

        emit receivedData(m_file.readAll(), false);

        // emit eof will shutdown qmlls before it manages to complete the preceding requests, so

        // don't emit eof when reading from a file.

        // also, just read the content of the file once, so close it now

        m_file.close();

};

static QStringList collectImportPaths(const QCommandLineParser &parser,

                                      const QCommandLineOption &qmlImportPathOption,

                                      const QCommandLineOption &environmentOption,

                                      const QCommandLineOption &qmlImportNoDefault)

    QStringList importPaths;

    if (parser.isSet(qmlImportPathOption)) {

        const QStringList pathsFromOption =

                QQmlToolingUtils::getAndWarnForInvalidDirsFromOption(parser, qmlImportPathOption);

        qInfo().nospace().noquote() << "Using import directories passed by -I: \""

                                    << pathsFromOption.join(u"\", \""_s) << "\".";

        importPaths << pathsFromOption;

    if (parser.isSet(environmentOption)) {

        if (const QStringList dirsFromEnv =

                    QQmlToolingUtils::getAndWarnForInvalidDirsFromEnv(u"QML_IMPORT_PATH"_s);

            !dirsFromEnv.isEmpty()) {

            qInfo().nospace().noquote()

                    << "Using import directories passed from environment variable "

                       "\"QML_IMPORT_PATH\": \""

                    << dirsFromEnv.join(u"\", \""_s) << "\".";

            importPaths << dirsFromEnv;

        if (const QStringList dirsFromEnv2 =

                    QQmlToolingUtils::getAndWarnForInvalidDirsFromEnv(u"QML2_IMPORT_PATH"_s);

            !dirsFromEnv2.isEmpty()) {

            qInfo().nospace().noquote()

                    << "Using import directories passed from the deprecated environment variable "

                       "\"QML2_IMPORT_PATH\": \""

                    << dirsFromEnv2.join(u"\", \""_s) << "\".";

            importPaths << dirsFromEnv2;

    // add as default fallback at the end

    if (!parser.isSet(qmlImportNoDefault))

        importPaths << QLibraryInfo::paths(QLibraryInfo::QmlImportsPath);

    return importPaths;

static int cmakeJobs(const QCommandLineParser &parser, const QCommandLineOption &cmakeJobsOption)

    auto parseAndWarn = [](const QString &valueString, const QString &infoMessage,

                           const QString &warningMessage) {

        bool ok = false;

        if (valueString == QQmlCodeModel::s_maxCMakeJobs) {

            const int value = QThread::idealThreadCount();

            qInfo().noquote() << infoMessage.arg("max (%1)"_L1.arg(QString::number(value)));

            return value;

        const int value = valueString.toInt(&ok);

        if (!ok || value < 1) {

            qInfo().noquote() << warningMessage.arg(valueString);

            return QQmlCodeModel::s_defaultCMakeJobs;

        qInfo().noquote() << infoMessage.arg(QString::number(value));

        return value;

};

    if (parser.isSet(cmakeJobsOption)) {

        return parseAndWarn(

                parser.value(cmakeJobsOption), "Using %1 jobs for CMake, set via --cmake-jobs."_L1,

                "Value \"%1\" passed to --cmake-jobs is not a number greater than 0 and not "

                "\"max\", using default value of 1 instead."_L1);

    if (!qEnvironmentVariableIsSet("QMLLS_CMAKE_JOBS")) {

        qInfo() << "Using 1 job for CMake, you can increase that value with the QMLLS_CMAKE_JOBS "

                   "environment variable or the --cmake-jobs option.";

        return QQmlCodeModel::s_defaultCMakeJobs;

    return parseAndWarn(

            qEnvironmentVariable("QMLLS_CMAKE_JOBS"),

            "Using %1 jobs for CMake, set via QMLLS_CMAKE_JOBS environment variable."_L1,

            "Value \"%1\" passed to QMLLS_CMAKE_JOBS is not a number greater than 0 and not "

            "\"max\", using default value of 1 instead."_L1);

static bool prepareCMakeFeature(const QCommandLineParser &parser,

                                const QCommandLineOption &noCMakeCallsOption)

    if (qmlGetConfigOption<bool, qmlConvertBoolConfigOption>("QMLLS_NO_CMAKE_CALLS")) {

        qWarning() << "Disabling CMake calls via QMLLS_NO_CMAKE_CALLS environment variable.";

        return false;

    if (parser.isSet(noCMakeCallsOption)) {

        qWarning() << "Disabling CMake calls via command line switch.";

        return false;

    return true;

// To debug:

//

// * simple logging can be redirected to a file

//   passing -l <file> to the qmlls command

//

// * more complex debugging can use named pipes:

//

//     mkfifo qmllsIn

//     mkfifo qmllsOut

//

// this together with a qmllsEcho script that can be defined as

//

//     #!/bin/sh

//     cat -u < ~/qmllsOut &

//     cat -u > ~/qmllsIn

//

// allows to use qmllsEcho as lsp server, and still easily start

// it in a terminal

//

//     qmlls < ~/qmllsIn > ~/qmllsOut

//

// * statup can be slowed down to have the time to attach via the

//   -w <nSeconds> flag.

int qmllsMain(int argv, char *argc[])

#ifdef Q_OS_WIN32

    // windows does not open stdin/stdout in binary mode by default

    int err = _setmode(_fileno(stdout), _O_BINARY);

    if (err == -1)

        perror("Cannot set mode for stdout");

    err = _setmode(_fileno(stdin), _O_BINARY);

    if (err == -1)

        perror("Cannot set mode for stdin");

#endif

    QHashSeed::setDeterministicGlobalSeed();

    QCoreApplication app(argv, argc);

    QCommandLineParser parser;

    QQmlToolingSharedSettings settings("qmlls"_L1);

    parser.setApplicationDescription("QML languageserver"_L1);

    parser.addHelpOption();

    QCommandLineOption waitOption(QStringList() << "w"_L1

                                                << "wait"_L1,

                                  "Waits the given number of seconds before startup"_L1,

                                  "waitSeconds"_L1);

    parser.addOption(waitOption);

    QCommandLineOption verboseOption(

            QStringList() << "v"_L1

                          << "verbose"_L1,

            "Outputs extra information on the operations being performed"_L1);

    parser.addOption(verboseOption);

    QCommandLineOption logFileOption(QStringList() << "l"_L1

                                                   << "log-file"_L1,

                                     "Writes logging to the given file"_L1, "logFile"_L1);

    parser.addOption(logFileOption);

    QString buildDir = QStringLiteral(u"buildDir");

    QCommandLineOption buildDirOption(QStringList() << "b"_L1

                                                    << "build-dir"_L1,

                                      "Adds a build dir to look up for qml information"_L1,

                                      buildDir);

    parser.addOption(buildDirOption);

    settings.addOption(buildDir);

    QString qmlImportPath = QStringLiteral(u"importPaths");

    QCommandLineOption qmlImportPathOption(QStringList() << "I"_L1,

                                           "Look for QML modules in the specified directory"_L1,

                                           qmlImportPath);

    parser.addOption(qmlImportPathOption);

    settings.addOption(qmlImportPath);

    QCommandLineOption environmentOption(

            QStringList() << "E"_L1,

            "Use the QML_IMPORT_PATH environment variable to look for QML Modules"_L1);

    parser.addOption(environmentOption);

    QCommandLineOption writeDefaultsOption(

            QStringList() << "write-defaults"_L1,

            "Writes defaults settings to .qmlls.ini and exits (Warning: This "

            "will overwrite any existing settings and comments!)"_L1);

    parser.addOption(writeDefaultsOption);

    QCommandLineOption ignoreSettings(QStringList() << "ignore-settings"_L1,

                                      "Ignores all settings files and only takes "

                                      "command line options into consideration"_L1);

    parser.addOption(ignoreSettings);

    QCommandLineOption noCMakeCallsOption(

            QStringList() << "no-cmake-calls"_L1,

            "Disables automatic CMake rebuilds and C++ file watching."_L1);

    parser.addOption(noCMakeCallsOption);

    settings.addOption("no-cmake-calls"_L1, "false"_L1);

    QCommandLineOption cmakeJobsOption(QStringList() << "cmake-jobs"_L1 << "j"_L1,

                                       "Number of CMake jobs for automatic CMake rebuilds. "_L1,

                                       "jobs"_L1, "1"_L1);

    parser.addOption(cmakeJobsOption);

    settings.addOption("CMakeJobs"_L1, "1"_L1);

    QCommandLineOption docDir({ { "d"_L1, "p"_L1, "doc-dir"_L1 },

                                "Documentation path to use for the documentation hints feature"_L1,

                                "path"_L1,

                                QString() });

    parser.addOption(docDir);

    settings.addOption("docDir"_L1);

    QCommandLineOption qmlImportNoDefault(QStringList() << "bare"_L1,

                                          "Do not include default import directories. "

                                          "This may be used to run qmlls on a Boot2Qt project."_L1);

    parser.addOption(qmlImportNoDefault);

    const QString qmlImportNoDefaultSetting = "DisableDefaultImports"_L1;

    settings.addOption(qmlImportNoDefaultSetting, false);

    QCommandLineOption inputFile(QStringList() << "inputFile"_L1,

                                 "Read from file instead of stdin"_L1, "fileName"_L1);

    inputFile.setFlags(QCommandLineOption::HiddenFromHelp);

    parser.addOption(inputFile);

    // we can't use parser.addVersionOption() because we already have one '-v' option for verbose...

    QCommandLineOption versionOption("version"_L1, "Displays version information."_L1);

    parser.addOption(versionOption);

    parser.process(app);

    if (parser.isSet(versionOption)) {

        parser.showVersion();

        return EXIT_SUCCESS;

    if (parser.isSet(writeDefaultsOption)) {

        return settings.writeDefaults() ? 0 : 1;

    if (parser.isSet(logFileOption)) {

        QString fileName = parser.value(logFileOption);

        qInfo() << "will log to" << fileName;

        logFile = new QFile(fileName);

        logFileLock = new QMutex;

        if (!logFile->open(QFile::WriteOnly | QFile::Truncate | QFile::Text)) {

            qWarning("Failed to open file %s: %s", qPrintable(logFile->fileName()),

                     qPrintable(logFile->errorString()));

        qInstallMessageHandler([](QtMsgType t, const QMessageLogContext &, const QString &msg) {

            QMutexLocker l(logFileLock);

            logFile->write(QString::number(int(t)).toUtf8());

            logFile->write(" ");

            logFile->write(msg.toUtf8());

            logFile->write("\n");

            logFile->flush();

});

    if (parser.isSet(waitOption)) {

        int waitSeconds = parser.value(waitOption).toInt();

        if (waitSeconds > 0)

            qDebug() << "waiting";

        QThread::sleep(waitSeconds);

        qDebug() << "starting";

    QMutex writeMutex;

    QQmlLanguageServer qmlServer(

            [&writeMutex](const QByteArray &data) {

                QMutexLocker l(&writeMutex);

                std::cout.write(data.constData(), data.size());

                std::cout.flush();

},

            (parser.isSet(ignoreSettings) ? nullptr : &settings));

    if (parser.isSet(verboseOption)) {

        QLoggingCategory::setFilterRules("qt.languageserver*.debug=true\n"_L1);

        qmlServer.codeModelManager()->setVerbose(true);

    if (parser.isSet(docDir))

        qmlServer.codeModelManager()->setDocumentationRootPath(

                QString::fromUtf8(parser.value(docDir).toUtf8()));

    if (parser.isSet(buildDirOption)) {

        const QStringList dirs =

                QQmlToolingUtils::getAndWarnForInvalidDirsFromOption(parser, buildDirOption);

        qInfo().nospace().noquote()

                << "Using build directories passed by -b: \"" << dirs.join(u"\", \""_s) << "\".";

        qmlServer.codeModelManager()->setBuildPathsForRootUrl(QByteArray(), dirs);

    } else if (QStringList dirsFromEnv =

                       QQmlToolingUtils::getAndWarnForInvalidDirsFromEnv(u"QMLLS_BUILD_DIRS"_s);

               !dirsFromEnv.isEmpty()) {

        // warn now at qmlls startup that those directories will be used later in qqmlcodemodel when

        // searching for build folders.

        qInfo().nospace().noquote() << "Using build directories passed from environment variable "

                                       "\"QMLLS_BUILD_DIRS\": \""

                                    << dirsFromEnv.join(u"\", \""_s) << "\".";

        qmlServer.codeModelManager()->setBuildPathsForRootUrl(QByteArray(), dirsFromEnv);

    } else {

        qInfo() << "Using the build directories found in the .qmlls.ini file. Your build folder "

                   "might not be found if no .qmlls.ini files are present in the root source "

                   "folder.";

    qmlServer.codeModelManager()->setImportPaths(

            collectImportPaths(parser, qmlImportPathOption, environmentOption, qmlImportNoDefault));

    if (prepareCMakeFeature(parser, noCMakeCallsOption)) {

        qmlServer.codeModelManager()->setCMakeJobs(cmakeJobs(parser, cmakeJobsOption));

        qmlServer.codeModelManager()->tryEnableCMakeCalls();

    } else {

        qmlServer.codeModelManager()->disableCMakeCalls();

    auto r = parser.isSet(inputFile) && parser.value(inputFile) != "-"_L1

            ? std::unique_ptr<AbstractReader>(std::make_unique<FileReader>(parser.value(inputFile)))

            : std::unique_ptr<AbstractReader>(std::make_unique<StdinReader>());

    QThread workerThread;

    r->moveToThread(&workerThread);

    QObject::connect(r.get(), &AbstractReader::receivedData, &qmlServer,

                     &QLanguageServer::receiveData);

    QObject::connect(&qmlServer, &QLanguageServer::readNextMessage, r.get(),

                     &AbstractReader::readNextMessage);

    auto exit = [&app, &workerThread]() {

        workerThread.quit();

        workerThread.wait();

        QTimer::singleShot(100, &app, []() {

            QCoreApplication::processEvents();

            QCoreApplication::exit();

});

};

    QObject::connect(r.get(), &StdinReader::eof, &app, exit);

    QObject::connect(&qmlServer, &QLanguageServer::exit, &workerThread, exit);

    emit r->readNextMessage();

    workerThread.start();

    app.exec();

    workerThread.quit();

    workerThread.wait();

    return qmlServer.returnValue();

} // namespace QmlLsp

QT_END_NAMESPACE

#include <qmllsmain.moc>

Revision control

Copy as Markdown