File: codecompletionhelper.cpp

package info (click to toggle)
kdevelop 4%3A22.12.2-1
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 70,096 kB
  • sloc: cpp: 284,635; javascript: 3,558; python: 3,422; sh: 1,319; ansic: 685; xml: 331; php: 95; lisp: 66; makefile: 39; sed: 12
file content (91 lines) | stat: -rw-r--r-- 3,289 bytes parent folder | download
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
/*
    SPDX-FileCopyrightText: 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>

    SPDX-License-Identifier: LGPL-2.0-only
*/

#include "codecompletionhelper.h"

#include "../duchain/duchain.h"
#include "../duchain/declaration.h"
#include "../duchain/duchainlock.h"
#include "../duchain/types/functiontype.h"
#include "../duchain/types/integraltype.h"

#include <KTextEditor/Document>
#include <KTextEditor/View>

namespace KDevelop {
void insertFunctionParenText(KTextEditor::View* view, const KTextEditor::Cursor& pos,
                             const DeclarationPointer& declaration, bool jumpForbidden)
{
    bool spaceBeforeParen = false; ///@todo Take this from some astyle config or something
    bool spaceBetweenParens = false;
    bool spaceBetweenEmptyParens = false;

    KDevelop::DUChainReadLocker lock(KDevelop::DUChain::lock());

    bool haveArguments = false;

    if (!declaration)
        return;

    TypePtr<FunctionType> funcType = declaration->type<FunctionType>();

    if (declaration->kind() == Declaration::Type || (funcType && funcType->indexedArgumentsSize()))
        haveArguments = true;

    if (declaration->kind() == Declaration::Instance && !declaration->isFunctionDeclaration())
        haveArguments = true; //probably a constructor initializer

    //Need to have a paren behind
    QString suffix = view->document()->text(KTextEditor::Range(pos, pos + KTextEditor::Cursor(1, 0)));
    if (suffix.trimmed().startsWith(QLatin1Char('('))) {
        //Move the cursor behind the opening paren
        if (view)
            view->setCursorPosition(pos + KTextEditor::Cursor(0, suffix.indexOf(QLatin1Char('(')) + 1));
    } else {
        //We need to insert an opening paren
        QString openingParen;
        if (spaceBeforeParen)
            openingParen = QStringLiteral(" (");
        else
            openingParen = QStringLiteral("(");

        if (spaceBetweenParens && (haveArguments || spaceBetweenEmptyParens))
            openingParen += QLatin1Char(' ');

        QString closingParen;
        if (spaceBetweenParens && (haveArguments)) {
            closingParen = QStringLiteral(" )");
        } else
            closingParen = QStringLiteral(")");

        KTextEditor::Cursor jumpPos = pos + KTextEditor::Cursor(0, openingParen.length());

        // when function returns void, also add a semicolon
        if (funcType) {
            if (IntegralType::Ptr type = funcType->returnType().cast<IntegralType>()) {
                if (type->dataType() == IntegralType::TypeVoid) {
                    const QChar nextChar = view->document()->characterAt(pos);
                    if (nextChar != QLatin1Char(';') && nextChar != QLatin1Char(')') && nextChar != QLatin1Char(',')) {
                        closingParen += QLatin1Char(';');
                    }
                }
            }
        }

        //If no arguments, move the cursor behind the closing paren (or semicolon)
        if (!haveArguments)
            jumpPos += KTextEditor::Cursor(0, closingParen.length());

        lock.unlock();
        if (view) {
            view->document()->insertText(pos, openingParen + closingParen);
            if (!jumpForbidden) {
                view->setCursorPosition(jumpPos);
            }
        }
    }
}
}