Differential D1005 Diff 2483 languages/clang/codegen/simplerefactoring.cpp

Changeset View

Standalone View

View Options

languages/clang/codegen/simplerefactoring.cpp

  • This file was added.
1​/*
2​ * This file is part of KDevelop
3​ *
4​ * Copyright 2015 Sergey Kalinichev <kalinichev.so.0@gmail.com>
5​ *
6​ * This program is free software; you can redistribute it and/or
7​ * modify it under the terms of the GNU General Public License as
8​ * published by the Free Software Foundation; either version 2 of
9​ * the License or (at your option) version 3 or any later version
10​ * accepted by the membership of KDE e.V. (or its successor approved
11​ * by the membership of KDE e.V.), which shall act as a proxy
12​ * defined in Section 14 of version 3 of the license.
13​ *
14​ * This program is distributed in the hope that it will be useful,
15​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
16​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17​ * GNU General Public License for more details.
18​ *
19​ * You should have received a copy of the GNU General Public License
20​ * along with this program. If not, see <http://www.gnu.org/licenses/>.
21​ *
22​ */
23​
24​#include "simplerefactoring.h"
25​
26​#include <QAction>
27​#include <QIcon>
28​
29​#include <interfaces/context.h>
30​#include <interfaces/contextmenuextension.h>
31​#include <language/duchain/duchain.h>
32​#include <language/duchain/duchainlock.h>
33​#include <language/duchain/functiondeclaration.h>
34​#include <language/duchain/functiondefinition.h>
35​#include <language/duchain/types/functiontype.h>
36​#include <language/interfaces/codecontext.h>
37​
38​#include <interfaces/icore.h>
39​#include <interfaces/ilanguagecontroller.h>
40​#include <language/backgroundparser/backgroundparser.h>
41​
42​#include "duchain/clanghelpers.h"
43​#include "duchain/documentfinderhelpers.h"
44​#include "duchain/duchainutils.h"
45​#include "sourcemanipulation.h"
46​#include "util/clangdebug.h"
47​
48​using namespace KDevelop;
49​
50​SimpleRefactoring::SimpleRefactoring(QObject* parent)
51​ : BasicRefactoring(parent)
52​{
53​ qRegisterMetaType<IndexedDeclaration>();
54​}
55​
56​void SimpleRefactoring::fillContextMenu(ContextMenuExtension& extension, Context* context)
57​{
58​ if (auto declContext = dynamic_cast<DeclarationContext*>(context)) {
59​ DUChainReadLocker lock;
60​
kfunkUnsubmitted
Done

Early return?

kfunk: Early return?
61​ if (auto declaration = declContext->declaration().data()) {
62​ QFileInfo fileInfo(declaration->topContext()->url().str());
63​ if (!fileInfo.isWritable()) {
kfunkUnsubmitted
Done

Ditto

kfunk: Ditto
64​ return;
65​ }
66​
67​ auto action = new QAction(i18n("Rename %1", declaration->qualifiedIdentifier().toString()), this);
68​ action->setData(QVariant::fromValue(IndexedDeclaration(declaration)));
69​ action->setIcon(QIcon::fromTheme(QStringLiteral("edit-rename")));
70​ connect(action, &QAction::triggered, this, &SimpleRefactoring::executeRenameAction);
71​
72​ extension.addAction(ContextMenuExtension::RefactorGroup, action);
73​
74​ if (!validCandidateToMoveIntoSource(declaration)) {
75​ return;
76​ }
77​
78​ action = new QAction(
79​ i18n("Create separate definition for %1", declaration->qualifiedIdentifier().toString()), this);
80​ action->setData(QVariant::fromValue(IndexedDeclaration(declaration)));
81​ connect(action, &QAction::triggered, this, &SimpleRefactoring::executeMoveIntoSourceAction);
82​ extension.addAction(ContextMenuExtension::RefactorGroup, action);
83​ }
84​ }
85​}
86​
87​bool SimpleRefactoring::validCandidateToMoveIntoSource(Declaration* decl)
88​{
89​ if (!decl || !decl->isFunctionDeclaration() || !decl->type<FunctionType>()) {
90​ return false;
91​ }
92​
93​ if (!decl->internalContext() || decl->internalContext()->type() != DUContext::Function) {
94​ return false;
95​ }
96​
97​ auto childCtx = decl->internalContext()->childContexts();
98​ if (childCtx.isEmpty()) {
99​ return false;
100​ }
101​
102​ auto ctx = childCtx.first();
103​ if (!ctx || ctx->type() != DUContext::Other) {
104​ return false;
105​ }
106​
107​ auto functionDecl = dynamic_cast<AbstractFunctionDeclaration*>(decl);
108​
109​ if (!functionDecl || functionDecl->isInline()) {
110​ return false;
kfunkUnsubmitted
Done

Nitpick: Remove newline

kfunk: Nitpick: Remove newline
111​ }
112​
113​ return true;
114​}
115​
116​QString SimpleRefactoring::moveIntoSource(const IndexedDeclaration& iDecl)
117​{
118​ DUChainReadLocker lock;
119​ auto decl = iDecl.data();
120​ if (!decl) {
121​ return i18n("No declaration under cursor");
122​ }
123​
124​ const auto headerUrl = decl->url();
125​ auto targetUrl = headerUrl.str();
126​
127​ if (ClangHelpers::headerExtensions().contains(QFileInfo(targetUrl).suffix())) {
128​ auto buddies = DocumentFinderHelpers::getPotentialBuddies(headerUrl.toUrl());
129​ for (const auto& buddy : buddies) {
130​ const auto local = buddy.toLocalFile();
131​ if (QFileInfo::exists(local)) {
132​ targetUrl = local;
133​ break;
134​ }
mwolffUnsubmitted
Done

afaik we have a "isHeader" check, no? If not, introduce it please

mwolff: afaik we have a "isHeader" check, no? If not, introduce it please
135​ }
mwolffUnsubmitted
Done

the below should be moved into a helper function, "documentFinderHelpers::sourceForHeader(headerPath)"

mwolff: the below should be moved into a helper function, "documentFinderHelpers::sourceForHeader…
136​ }
137​
138​ if (targetUrl.isEmpty() || targetUrl == headerUrl.str()) {
139​ // TODO: Create source file if it doesn't exist
140​ return i18n("No source file available for %1.", headerUrl.str());
141​ }
142​
143​ lock.unlock();
144​ const IndexedString indexedTargetUrl(targetUrl);
145​ auto top
146​ = DUChain::self()->waitForUpdate(headerUrl, KDevelop::TopDUContext::AllDeclarationsAndContexts);
147​ auto targetTopContext
148​ = DUChain::self()->waitForUpdate(indexedTargetUrl, KDevelop::TopDUContext::AllDeclarationsAndContexts);
149​ lock.lock();
150​
151​ if (!targetTopContext) {
152​ return i18n("Failed to update DUChain for %1.", targetUrl);
153​ }
154​
155​ if (!top || !iDecl.data() || iDecl.data() != decl) {
156​ return i18n("Declaration lost while updating.");
157​ }
158​
159​ clangDebug() << "moving" << decl->qualifiedIdentifier();
160​
161​ if (!validCandidateToMoveIntoSource(decl)) {
162​ return i18n("Cannot create definition for this declaration.");
163​ }
164​
165​ auto otherCtx = decl->internalContext()->childContexts().first();
166​ auto funcCtx = decl->internalContext();
167​
168​ auto code = createCodeRepresentation(headerUrl);
169​ if (!code) {
170​ return i18n("No document for %1", headerUrl.str());
171​ }
172​
173​ auto bodyRange = otherCtx->rangeInCurrentRevision();
174​
175​ auto prefixRange(ClangIntegration::DUChainUtils::functionSignatureRange(decl));
176​ const auto prefixText = code->rangeText(prefixRange);
177​ for (int i = prefixText.length() - 1; i >= 0 && prefixText.at(i).isSpace(); --i) {
178​ if (bodyRange.start().column() == 0) {
179​ bodyRange.setStart(bodyRange.start() - KTextEditor::Cursor(1, 0));
180​ if (bodyRange.start().line() == prefixRange.start().line()) {
181​ bodyRange.setStart(KTextEditor::Cursor(bodyRange.start().line(), prefixRange.start().column() + i));
182​ } else {
183​ int lastNewline = prefixText.lastIndexOf(QLatin1Char('\n'), i - 1);
184​ bodyRange.setStart(KTextEditor::Cursor(bodyRange.start().line(), i - lastNewline - 1));
185​ }
186​ } else {
187​ bodyRange.setStart(bodyRange.start() - KTextEditor::Cursor(0, 1));
188​ }
189​ }
190​
191​ const QString body = code->rangeText(bodyRange);
192​ SourceCodeInsertion ins(targetTopContext);
193​ auto parentId = decl->internalContext()->parentContext()->scopeIdentifier(false);
194​
195​ ins.setSubScope(parentId);
196​
197​ QList<SourceCodeInsertion::SignatureItem> signature;
198​
199​ foreach (auto argument, funcCtx->localDeclarations()) {
kfunkUnsubmitted
Done

QVector?

kfunk: QVector?
200​ SourceCodeInsertion::SignatureItem item;
201​ item.name = argument->identifier().toString();
202​ item.type = argument->abstractType();
203​ signature.append(item);
204​ }
205​
mwolffUnsubmitted
Done
auto localDeclarations = funcCtx->localDeclarations();
signature.reserve(localDeclarations.size());

or even better, use std::transform with a back_inserter and a lambda for the conversion.

mwolff: auto localDeclarations = funcCtx->localDeclarations(); signature.reserve…
206​ Identifier id(IndexedString(decl->qualifiedIdentifier().mid(parentId.count()).toString()));
207​ clangDebug() << "id:" << id;
208​
209​ auto funcType = decl->type<FunctionType>();
210​ if (!ins.insertFunctionDeclaration(id, funcType->returnType(), signature,
211​ funcType->modifiers() & AbstractType::ConstModifier, body)) {
212​ return i18n("Insertion failed");
213​ }
214​ lock.unlock();
215​
216​ auto applied = ins.changes().applyAllChanges();
217​ if (!applied) {
218​ return i18n("Applying changes failed: %1", applied.m_failureReason);
219​ }
220​
221​ // replace function body with a semicolon
222​ DocumentChangeSet changeHeader;
223​ changeHeader.addChange(DocumentChange(headerUrl, bodyRange, body, QStringLiteral(";")));
224​ applied = changeHeader.applyAllChanges();
225​ if (!applied) {
226​ return i18n("Applying changes failed: %1", applied.m_failureReason);
227​ }
228​
229​ ICore::self()->languageController()->backgroundParser()->addDocument(headerUrl);
230​ ICore::self()->languageController()->backgroundParser()->addDocument(indexedTargetUrl);
231​
232​ return {};
233​}
234​
235​void SimpleRefactoring::executeMoveIntoSourceAction()
236​{
237​ auto action = qobject_cast<QAction*>(sender());
238​ Q_ASSERT(action);
239​
240​ auto iDecl = action->data().value<IndexedDeclaration>();
241​ if (!iDecl.isValid()) {
242​ iDecl = declarationUnderCursor(false);
243​ }
244​
245​ const auto error = moveIntoSource(iDecl);
246​ if (!error.isEmpty()) {
247​ KMessageBox::error(nullptr, error);
248​ }
249​}
250​
251​#include "moc_simplerefactoring.cpp"
mwolffUnsubmitted
Done

shouldn't be required anymore afaik

mwolff: shouldn't be required anymore afaik