src/shared/lsp/jsonrpcmessages.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

#include "jsonrpcmessages.h"

#include "initializemessages.h"
#include "languageserverprotocoltr.h"
#include "lsputils.h"

#include <QCoreApplication>
#include <QObject>
#include <QJsonDocument>
#include <QTextCodec>

namespace lsp {
Q_LOGGING_CATEGORY(timingLog, "qtc.languageserverprotocol.timing", QtWarningMsg)

constexpr const char CancelRequest::methodName[];

QByteArray JsonRpcMessage::toRawData() const
{
    return QJsonDocument(m_jsonObject).toJson(QJsonDocument::Compact);
}

bool JsonRpcMessage::isValid(QString *errorMessage) const
{
    if (!m_parseError.isEmpty()) {
        if (errorMessage)
            *errorMessage = m_parseError;
        return false;
    }
    return m_jsonObject[jsonRpcVersionKey] == "2.0";
}

const QJsonObject &JsonRpcMessage::toJsonObject() const
{
    return m_jsonObject;
}

JsonRpcMessage::JsonRpcMessage()
{
    // The language server protocol always uses “2.0” as the jsonrpc version
    m_jsonObject[jsonRpcVersionKey] = "2.0";
}

constexpr int utf8mib = 106;

static QString docType(const QJsonDocument &doc)
{
    if (doc.isArray())
        return QString("array");
    if (doc.isEmpty())
        return QString("empty");
    if (doc.isNull())
        return QString("null");
    if (doc.isObject())
        return QString("object");
    return {};
}

JsonRpcMessage::JsonRpcMessage(const BaseMessage &message)
{
    if (message.content.isEmpty())
        return;
    QByteArray content;
    if (message.codec && message.codec->mibEnum() != utf8mib) {
        QTextCodec *utf8 = QTextCodec::codecForMib(utf8mib);
        if (utf8)
            content = utf8->fromUnicode(message.codec->toUnicode(message.content));
    }
    if (content.isEmpty())
        content = message.content;
    QJsonParseError error = {0, QJsonParseError::NoError};
    const QJsonDocument doc = QJsonDocument::fromJson(content, &error);
    if (doc.isObject())
        m_jsonObject = doc.object();
    else if (doc.isNull())
        m_parseError = Tr::tr("Could not parse JSON message: \"%1\".").arg(error.errorString());
    else
        m_parseError =
            Tr::tr("Expected a JSON object, but got a JSON \"%1\" value.").arg(docType(doc));
}

JsonRpcMessage::JsonRpcMessage(const QJsonObject &jsonObject)
    : m_jsonObject(jsonObject)
{ }

JsonRpcMessage::JsonRpcMessage(QJsonObject &&jsonObject)
    : m_jsonObject(std::move(jsonObject))
{ }

QByteArray JsonRpcMessage::jsonRpcMimeType()
{
    return "application/vscode-jsonrpc";
}

CancelRequest::CancelRequest(const CancelParameter &params)
    : Notification(methodName, params)
{ }

void logElapsedTime(const QString &method, const QElapsedTimer &t)
{
    qCDebug(timingLog) << "received server reply to" << method
                       << "after" << t.elapsed() << "ms";
}

} // namespace lsp