feat: [completion] Optimize intelligent completion

src/base/abstractinlinecompletionprovider.cpp

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: 2024 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "abstractinlinecompletionprovider.h"
+
+AbstractInlineCompletionProvider::AbstractInlineCompletionProvider(QObject *parent)
+    : QObject(parent)
+{
+}

src/base/abstractinlinecompletionprovider.h

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: 2024 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef ABSTRACTINLINECOMPLETIONPROVIDER_H
+#define ABSTRACTINLINECOMPLETIONPROVIDER_H
+
+#include <QObject>
+
+class AbstractInlineCompletionProvider : public QObject
+{
+    Q_OBJECT
+public:
+    struct Position
+    {
+        int line = -1;
+        int column = -1;
+
+        bool operator==(const Position &pos) const
+        {
+            return line == pos.line && column == pos.column;
+        }
+
+        bool operator!=(const Position &pos) const
+        {
+            return !(operator==(pos));
+        }
+    };
+
+    struct InlineCompletionContext
+    {
+        QString prefix;
+        QString suffix;
+    };
+
+    struct InlineCompletionItem
+    {
+        QString completion;
+        Position pos;
+    };
+
+    explicit AbstractInlineCompletionProvider(QObject *parent = nullptr);
+
+    virtual QString providerName() const = 0;
+    virtual void provideInlineCompletionItems(const Position &pos, const InlineCompletionContext &contex) = 0;
+    virtual QList<InlineCompletionItem> inlineCompletionItems() const = 0;
+    virtual bool inlineCompletionEnabled() const { return false; }
+
+Q_SIGNALS:
+    void finished();
+};
+
+Q_DECLARE_METATYPE(AbstractInlineCompletionProvider::InlineCompletionItem)
+#endif   // ABSTRACTINLINECOMPLETIONPROVIDER_H

src/plugins/codeeditor/codeeditor.cpp

@@ -10,6 +10,7 @@
 #include "gui/settings/editorsettingswidget.h"
 #include "lexer/lexermanager.h"
 #include "utils/editorutils.h"
+#include "utils/resourcemanager.h"
 #include "status/statusinfomanager.h"
 #include "symbol/symbollocator.h"
 #include "symbol/symbolwidget.h"
@@ -171,7 +172,6 @@ void CodeEditor::initEditorService()
     editorService->undo = std::bind(&WorkspaceWidget::undo, workspaceWidget);
     editorService->modifiedFiles = std::bind(&WorkspaceWidget::modifiedFiles, workspaceWidget);
     editorService->saveAll = std::bind(&WorkspaceWidget::saveAll, workspaceWidget);
-    editorService->setCompletion = std::bind(&WorkspaceWidget::setCompletion, workspaceWidget, _1);
     editorService->currentFile = std::bind(&WorkspaceWidget::currentFile, workspaceWidget);
     editorService->setText = std::bind(&WorkspaceWidget::setText, workspaceWidget, _1);
     editorService->registerWidget = std::bind(&WorkspaceWidget::registerWidget, workspaceWidget, _1, _2);
@@ -201,6 +201,7 @@ void CodeEditor::initEditorService()
     editorService->rangeText = std::bind(&WorkspaceWidget::rangeText, workspaceWidget, _1, _2);
     editorService->selectionRange = std::bind(&WorkspaceWidget::selectionRange, workspaceWidget, _1);
     editorService->codeRange = std::bind(&WorkspaceWidget::codeRange, workspaceWidget, _1, _2);
+    editorService->registerInlineCompletionProvider = std::bind(&ResourceManager::registerInlineCompletionProvider, ResourceManager::instance(), _1);
 
     LexerManager::instance()->init(editorService);
 }

src/plugins/codeeditor/gui/completion/codecompletionwidget.cpp

@@ -356,27 +356,43 @@ void CodeCompletionWidget::updateHeight()
     }
 
     geom.setHeight(baseHeight);
-    if (geometry() != geom)
+    if (geometry() != geom) {
         setGeometry(geom);
+        if (completionOrigin == Top)
+            updatePosition();
+    }
 
     QSize entryListSize = QSize(completionView->width(), baseHeight - 2 * frameWidth());
     if (completionView->size() != entryListSize)
         completionView->resize(entryListSize);
 }
 
-void CodeCompletionWidget::updatePosition(bool force)
+void CodeCompletionWidget::updatePosition(bool force, CompletionOrigin origin)
 {
     if (!force && !isCompletionActive())
         return;
 
-    auto cursorPosition = editor()->pointFromPosition(editor()->cursorPosition());
-    if (cursorPosition == QPoint(-1, -1)) {
-        abortCompletion();
-        return;
+    if (origin != completionOrigin)
+        completionOrigin = origin;
+
+    if (showPosition == QPoint(-1, -1)) {
+        showPosition = editor()->pointFromPosition(editor()->cursorPosition());
+        if (showPosition == QPoint(-1, -1)) {
+            abortCompletion();
+            return;
+        }
+    }
+
+    QPoint p = editor()->mapToGlobal(showPosition);
+    switch (origin) {
+    case Bottom:
+        p.setY(p.y() + editor()->fontMetrics().height() + 2);
+        break;
+    case Top:
+        p.setY(p.y() - height());
+        break;
     }
 
-    QPoint p = editor()->mapToGlobal(cursorPosition);
-    p.setY(p.y() + editor()->fontMetrics().height() + 2);
     move(p);
 }
 
@@ -478,6 +494,13 @@ void CodeCompletionWidget::focusOutEvent(QFocusEvent *event)
     abortCompletion();
 }
 
+void CodeCompletionWidget::hideEvent(QHideEvent *event)
+{
+    showPosition = QPoint(-1, -1);
+    completionOrigin = Bottom;
+    QFrame::hideEvent(event);
+}
+
 void CodeCompletionWidget::onTextAdded(int pos, int len, int added, const QString &text, int line)
 {
     Q_UNUSED(line)

src/plugins/codeeditor/gui/completion/codecompletionwidget.h

@@ -21,6 +21,11 @@ class CodeCompletionWidget : public QFrame
 {
     Q_OBJECT
 public:
+    enum CompletionOrigin {
+        Bottom = 0,
+        Top
+    };
+
     explicit CodeCompletionWidget(TextEditor *parent);
 
     TextEditor *editor() const;
@@ -29,7 +34,7 @@ class CodeCompletionWidget : public QFrame
     void startCompletion();
 
     void updateHeight();
-    void updatePosition(bool force = false);
+    void updatePosition(bool force = false, CompletionOrigin origin = Bottom);
     void setCompletion(const QString &info, const QIcon &icon, const QKeySequence &key);
 
 public slots:
@@ -40,7 +45,8 @@ public slots:
     void automaticInvocation();
 
 protected:
-    virtual void focusOutEvent(QFocusEvent *event) override;
+    void focusOutEvent(QFocusEvent *event) override;
+    void hideEvent(QHideEvent *event) override;
 
 private:
     void initUI();
@@ -68,14 +74,14 @@ private slots:
     CodeCompletionModel *completionModel { nullptr };
     CompletionSortFilterProxyModel *proxyModel { nullptr };
     CodeCompletionExtendWidget *completionExtWidget { nullptr };
-
     QTimer *automaticInvocationTimer { nullptr };
 
     QString automaticInvocationLine;
     int automaticInvocationAt;
-
     bool needShow { false };
     bool isCompletionInput { false };
+    QPoint showPosition { -1, -1 };
+    CompletionOrigin completionOrigin { Bottom };
 };
 
 #endif   // CODECOMPLETIONWIDGET_H

src/plugins/codeeditor/gui/private/texteditor_p.cpp

@@ -5,6 +5,7 @@
 #include "texteditor_p.h"
 #include "utils/editorutils.h"
 #include "utils/colordefine.h"
+#include "utils/resourcemanager.h"
 #include "lexer/lexermanager.h"
 #include "transceiver/codeeditorreceiver.h"
 #include "common/common.h"
@@ -56,6 +57,7 @@ void TextEditorPrivate::init()
                      TextEditor::SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE);
     selectionChangeTimer.setSingleShot(true);
     selectionChangeTimer.setInterval(50);
+    completionWidget->installEventFilter(q);
 
     initWidgetContainer();
     initMargins();
@@ -229,6 +231,30 @@ void TextEditorPrivate::onSelectionChanged()
     editor.selectionChanged(fileName, lineFrom, indexFrom, lineTo, indexTo);
 }
 
+void TextEditorPrivate::setInlineCompletion()
+{
+    auto provider = dynamic_cast<AbstractInlineCompletionProvider *>(sender());
+    if (!provider)
+        return;
+
+    // Take only one completion for now
+    const auto &items = provider->inlineCompletionItems();
+    for (const auto &item : items) {
+        if (item.completion.isEmpty())
+            continue;
+
+        AbstractInlineCompletionProvider::Position pos;
+        q->getCursorPosition(&pos.line, &pos.column);
+        if (item.pos != pos)
+            continue;
+
+        cancelInlineCompletion();
+        inlineCompletionCache = qMakePair(pos.line, item.completion);
+        updateInlineCompletion();
+        return;
+    }
+}
+
 void TextEditorPrivate::loadLexer()
 {
     if (fileName.isEmpty())
@@ -551,10 +577,10 @@ void TextEditorPrivate::updateCacheInfo(int pos, int added)
         }
     }
 
-    if (cpCache.first != -1 && cpCache.first >= line) {
-        const auto &eolStr = q->eolAnnotation(cpCache.first);
-        if (eolStr.isEmpty() || !cpCache.second.contains(eolStr))
-            cpCache.first += added;
+    if (inlineCompletionCache.first != -1 && inlineCompletionCache.first >= line) {
+        const auto &eolStr = q->eolAnnotation(inlineCompletionCache.first);
+        if (eolStr.isEmpty() || !inlineCompletionCache.second.contains(eolStr))
+            inlineCompletionCache.first += added;
     }
 
     // update eolannotation line
@@ -577,6 +603,81 @@ void TextEditorPrivate::updateCacheInfo(int pos, int added)
     }
 }
 
+void TextEditorPrivate::provideInlineCompletion(int pos, int added)
+{
+    auto providerList = ResourceManager::instance()->inlineCompletionProviders();
+    for (auto provider : providerList) {
+        if (!provider || !provider->inlineCompletionEnabled())
+            continue;
+
+        int cursorPos = pos + added;
+        AbstractInlineCompletionProvider::Position position;
+        q->lineIndexFromPosition(cursorPos, &position.line, &position.column);
+        int lineEndPos = q->SendScintilla(TextEditor::SCI_GETLINEENDPOSITION, position.line);
+        if (lineEndPos != cursorPos)
+            return;
+
+        connect(provider, &AbstractInlineCompletionProvider::finished,
+                this, &TextEditorPrivate::setInlineCompletion, Qt::UniqueConnection);
+        AbstractInlineCompletionProvider::InlineCompletionContext context;
+        context.prefix = q->text(0, cursorPos);
+        context.suffix = q->text(cursorPos, q->length());
+        provider->provideInlineCompletionItems(position, context);
+    }
+}
+
+void TextEditorPrivate::applyInlineCompletion()
+{
+    if (inlineCompletionCache.first == -1)
+        return;
+
+    const auto cpStr = inlineCompletionCache.second;
+    cancelInlineCompletion();
+    q->insertText(cpStr);
+}
+
+void TextEditorPrivate::cancelInlineCompletion()
+{
+    if (inlineCompletionCache.first == -1)
+        return;
+
+    q->clearEOLAnnotations(inlineCompletionCache.first);
+    q->clearAnnotations(inlineCompletionCache.first);
+
+    inlineCompletionCache = qMakePair(-1, QString());
+}
+
+void TextEditorPrivate::updateInlineCompletion()
+{
+    int line = inlineCompletionCache.first;
+    QString completion = inlineCompletionCache.second;
+    if (line == -1)
+        return;
+
+    const auto &part1 = completion.mid(0, completion.indexOf('\n'));
+    QString part2 = completion.mid(completion.indexOf('\n') + 1);
+    QsciStyle cpStyle(1, "", Qt::gray, q->lexer() ? q->lexer()->defaultPaper(-1) : q->paper(),
+                      q->lexer() ? q->lexer()->defaultFont() : q->font());
+    q->eOLAnnotate(line, part1, cpStyle);
+    if (part1 != part2) {
+        if (!completionWidget->isCompletionActive()) {
+            q->annotate(line, part2, cpStyle);
+            return;
+        }
+
+        auto point = q->pointFromPosition(q->cursorPosition());
+        if (point.y() >= completionWidget->height()) {
+            completionWidget->updatePosition(true, CodeCompletionWidget::Top);
+        } else {
+            auto lineHeight = q->textHeight(line);
+            auto padding = completionWidget->height() / lineHeight;
+            part2.prepend(QString(padding, '\n'));
+        }
+
+        q->annotate(line, part2, cpStyle);
+    }
+}
+
 void TextEditorPrivate::resetThemeColor()
 {
     if (q->lexer()) {
@@ -628,6 +729,8 @@ void TextEditorPrivate::onModified(int pos, int mtype, const QString &text, int
         updateCacheInfo(pos, added);
 
     if (mtype & TextEditor::SC_MOD_INSERTTEXT) {
+        if (!(mtype & (TextEditor::SC_PERFORMED_UNDO | TextEditor::SC_PERFORMED_REDO)))
+            provideInlineCompletion(pos, len);
         emit q->textAdded(pos, len, added, text, line);
     } else if (mtype & TextEditor::SC_MOD_DELETETEXT) {
         emit q->textRemoved(pos, len, -added, text, line);

src/plugins/codeeditor/gui/private/texteditor_p.h

@@ -10,6 +10,8 @@
 #include "lsp/languageclienthandler.h"
 #include "gui/completion/codecompletionwidget.h"
 
+#include "base/abstractinlinecompletionprovider.h"
+
 #include <Qsci/qscistyle.h>
 
 #include <DFloatingWidget>
@@ -68,6 +70,10 @@ class TextEditorPrivate : public QObject
     void setContainerWidget(QWidget *widget);
     void updateLineWidgetPosition();
     void updateCacheInfo(int pos, int added);
+    void provideInlineCompletion(int pos, int added);
+    void applyInlineCompletion();
+    void cancelInlineCompletion();
+    void updateInlineCompletion();
 
 public slots:
     void resetThemeColor();
@@ -77,6 +83,7 @@ public slots:
                     int line, int foldNow, int foldPrev, int token, int annotationLinesAdded);
     void updateSettings();
     void onSelectionChanged();
+    void setInlineCompletion();
 
 public:
     TextEditor *q { nullptr };
@@ -98,7 +105,7 @@ public slots:
     int fontSize { 10 };
 
     using CompletionCache = QPair<int, QString>;
-    CompletionCache cpCache { -1, "" };
+    CompletionCache inlineCompletionCache { -1, "" };
     CodeCompletionWidget *completionWidget { nullptr };
     QMap<QString, QVariant> commentSettings;