void AdaptSignatureAssistant::textChanged(KTextEditor::View* view, const KTextEditor::Range& invocationRange, const QString& removedText)
{
reset();
m_view = view;
//FIXME: update signature assistant to play well with the rename assistant
KTextEditor::Range sigAssistRange = invocationRange;
if (!removedText.isEmpty()) {
sigAssistRange.setRange(sigAssistRange.start(), sigAssistRange.start());
}
m_document = view->document()->url();
DUChainReadLocker lock(DUChain::lock(), 300);
if(!lock.locked()) {
qCDebug(CPP) << "failed to lock duchain in time";
return;
}
KTextEditor::Range simpleInvocationRange = KTextEditor::Range(sigAssistRange);
Declaration* funDecl = getDeclarationAtCursor(simpleInvocationRange.start(), m_document);
if(!funDecl || !funDecl->type<FunctionType>())
return;
if(QtFunctionDeclaration* classFun = dynamic_cast<QtFunctionDeclaration*>(funDecl)) {
if (classFun->isSignal()) {
// do not offer to change signature of a signal, as the implementation will be generated by moc
return;
}
}
Declaration* otherSide = 0;
FunctionDefinition* definition = dynamic_cast<FunctionDefinition*>(funDecl);
if (definition)
{
m_editingDefinition = true;
otherSide = definition->declaration();
}
else if ((definition = FunctionDefinition::definition(funDecl)))
{
m_editingDefinition = false;
otherSide = definition;
}
if (!otherSide)
return;
m_otherSideContext = DUContextPointer(DUChainUtils::getFunctionContext(otherSide));
if (!m_otherSideContext)
return;
m_declarationName = funDecl->identifier();
m_otherSideId = otherSide->id();
m_otherSideTopContext = ReferencedTopDUContext(otherSide->topContext());
m_oldSignature = getDeclarationSignature(otherSide, m_otherSideContext.data(), true);
//Schedule an update, to make sure the ranges match
DUChain::self()->updateContextForUrl(m_otherSideTopContext->url(), TopDUContext::AllDeclarationsAndContexts);
}
void AdaptSignatureAssistant::parseJobFinished(KDevelop::ParseJob* job)
{
if (job->document().toUrl() != m_document || !m_view) {
return;
}
clearActions();
DUChainReadLocker lock;
Declaration *functionDecl = getDeclarationAtCursor(KTextEditor::Cursor(m_view.data()->cursorPosition()), m_document);
if (!functionDecl || functionDecl->identifier() != m_declarationName) {
clangDebug() << "No function found at" << m_document << m_view.data()->cursorPosition();
return;
}
DUContext *functionCtxt = DUChainUtils::getFunctionContext(functionDecl);
if (!functionCtxt) {
clangDebug() << "No function context found for" << functionDecl->toString();
return;
}
#if 0 // TODO: Port
if (QtFunctionDeclaration * classFun = dynamic_cast<QtFunctionDeclaration*>(functionDecl)) {
if (classFun->isSignal()) {
// do not offer to change signature of a signal, as the implementation will be generated by moc
return;
}
}
#endif
//ParseJob having finished, get the signature that was modified
Signature newSignature = getDeclarationSignature(functionDecl, functionCtxt, false);
//Check for changes between m_oldSignature and newSignature, use oldPositions to store old<->new param index mapping
QList<int> oldPositions;
if (!getSignatureChanges(newSignature, oldPositions)) {
reset();
return; //No changes to signature
}
QList<RenameAction*> renameActions;
if (m_editingDefinition) {
setDefaultParams(newSignature, oldPositions); //restore default parameters before updating the declarations
} else {
renameActions = getRenameActions(newSignature, oldPositions); //rename as needed when updating the definition
}
IAssistantAction::Ptr action(new AdaptSignatureAction(m_otherSideId, m_otherSideTopContext,
m_oldSignature, newSignature,
m_editingDefinition, renameActions));
connect(action.data(), &IAssistantAction::executed,
this, &AdaptSignatureAssistant::reset);
addAction(action);
emit actionsChanged();
}
void TestDUChain::testTypeDeductionInTemplateInstantiation()
{
// see: http://clang-developers.42468.n3.nabble.com/RFC-missing-libclang-query-functions-features-td2504253.html
TestFile file("template<typename T> struct foo { T member; } foo<int> f; auto i = f.member;", "cpp");
QVERIFY(file.parseAndWait());
DUChainReadLocker lock;
DUContext* ctx = file.topContext().data();
QVERIFY(ctx);
QCOMPARE(ctx->localDeclarations().size(), 3);
Declaration* decl = 0;
// check 'foo' declaration
decl = ctx->localDeclarations()[0];
QVERIFY(decl);
QCOMPARE(decl->identifier(), Identifier("foo"));
// check type of 'member' inside declaration-scope
QCOMPARE(ctx->childContexts().size(), 1);
DUContext* fooCtx = ctx->childContexts().first();
QVERIFY(fooCtx);
// Should there really be two declarations?
QCOMPARE(fooCtx->localDeclarations().size(), 2);
decl = fooCtx->localDeclarations()[1];
QCOMPARE(decl->identifier(), Identifier("member"));
// check type of 'member' in definition of 'f'
decl = ctx->localDeclarations()[1];
QCOMPARE(decl->identifier(), Identifier("f"));
decl = ctx->localDeclarations()[2];
QCOMPARE(decl->identifier(), Identifier("i"));
#if CINDEX_VERSION_MINOR < 31
QEXPECT_FAIL("", "No type deduction here unfortunately, missing API in Clang", Continue);
#endif
QVERIFY(decl->type<IntegralType>());
}
void TestDUChain::testVirtualMemberFunction()
{
//Forward-declarations with "struct" or "class" are considered equal, so make sure the override is detected correctly.
TestFile file("struct S {}; struct A { virtual S* ret(); }; struct B : public A { virtual S* ret(); };", "cpp");
QVERIFY(file.parseAndWait());
DUChainReadLocker lock;
DUContext* top = file.topContext().data();
QVERIFY(top);
QCOMPARE(top->childContexts().count(), 3);
QCOMPARE(top->localDeclarations().count(), 3);
QCOMPARE(top->childContexts()[2]->localDeclarations().count(), 1);
Declaration* decl = top->childContexts()[2]->localDeclarations()[0];
QCOMPARE(decl->identifier(), Identifier("ret"));
QVERIFY(DUChainUtils::getOverridden(decl));
}
QList<RenameAction*> AdaptSignatureAssistant::getRenameActions(const Signature &newSignature, const QList<int> &oldPositions) const
{
Q_ASSERT(DUChain::lock()->currentThreadHasReadLock());
QList<RenameAction*> renameActions;
if (!m_otherSideContext) {
return renameActions;
}
for (int i = newSignature.parameters.size() - 1; i >= 0; --i) {
if (oldPositions[i] == -1) {
continue; //new parameter
}
Declaration *renamedDecl = m_otherSideContext->localDeclarations()[oldPositions[i]];
if (newSignature.parameters[i].second != m_oldSignature.parameters[oldPositions[i]].second) {
QMap<IndexedString, QList<RangeInRevision> > uses = renamedDecl->uses();
if (!uses.isEmpty()) {
renameActions << new RenameAction(renamedDecl->identifier(), newSignature.parameters[i].second,
RevisionedFileRanges::convert(uses));
}
}
}
return renameActions;
}
void TestDUChain::testBaseClasses()
{
TestFile file("class Base {}; class Inherited : public Base {};", "cpp");
QVERIFY(file.parseAndWait());
DUChainReadLocker lock;
DUContext* top = file.topContext().data();
QVERIFY(top);
QCOMPARE(top->localDeclarations().count(), 2);
Declaration* baseDecl = top->localDeclarations().first();
QCOMPARE(baseDecl->identifier(), Identifier("Base"));
ClassDeclaration* inheritedDecl = dynamic_cast<ClassDeclaration*>(top->localDeclarations()[1]);
QCOMPARE(inheritedDecl->identifier(), Identifier("Inherited"));
QVERIFY(inheritedDecl);
QCOMPARE(inheritedDecl->baseClassesSize(), 1u);
QCOMPARE(baseDecl->uses().count(), 1);
QCOMPARE(baseDecl->uses().first().count(), 1);
QCOMPARE(baseDecl->uses().first().first(), RangeInRevision(0, 40, 0, 44));
}
void TestDUChain::testAutoTypeDeduction()
{
TestFile file("const volatile auto foo = 5;\n", "cpp");
QVERIFY(file.parseAndWait());
DUChainReadLocker lock;
DUContext* ctx = file.topContext().data();
QVERIFY(ctx);
QCOMPARE(ctx->localDeclarations().size(), 1);
QCOMPARE(ctx->findDeclarations(QualifiedIdentifier("foo")).size(), 1);
Declaration* decl = ctx->findDeclarations(QualifiedIdentifier("foo"))[0];
QCOMPARE(decl->identifier(), Identifier("foo"));
#if CINDEX_VERSION_MINOR < 31
QEXPECT_FAIL("", "No type deduction here unfortunately, missing API in Clang", Continue);
#endif
QVERIFY(decl->type<IntegralType>());
#if CINDEX_VERSION_MINOR < 31
QCOMPARE(decl->toString(), QStringLiteral("const volatile auto foo"));
#else
QCOMPARE(decl->toString(), QStringLiteral("const volatile int foo"));
#endif
}
QString DeclarationNavigationContext::html(bool shorten)
{
clear();
m_shorten = shorten;
modifyHtml() += "<html><body><p>" + fontSizePrefix(shorten);
addExternalHtml(m_prefix);
if(!m_declaration.data()) {
modifyHtml() += i18n("<br /> lost declaration <br />");
return currentHtml();
}
if( m_previousContext ) {
QString link = createLink( m_previousContext->name(), m_previousContext->name(), NavigationAction(m_previousContext) );
modifyHtml() += navigationHighlight(i18n("Back to %1<br />", link));
}
QExplicitlySharedDataPointer<IDocumentation> doc;
if( !shorten ) {
doc = ICore::self()->documentationController()->documentationForDeclaration(m_declaration.data());
const AbstractFunctionDeclaration* function = dynamic_cast<const AbstractFunctionDeclaration*>(m_declaration.data());
if( function ) {
htmlFunction();
} else if( m_declaration->isTypeAlias() || m_declaration->kind() == Declaration::Instance ) {
if( m_declaration->isTypeAlias() )
modifyHtml() += importantHighlight("type ");
if(m_declaration->type<EnumeratorType>())
modifyHtml() += i18n("enumerator ");
if( !m_declaration->isTypeAlias())
modifyHtml() += ' ' + identifierHighlight(declarationName(m_declaration).toHtmlEscaped(), m_declaration) + " ";
AbstractType::Ptr useType = m_declaration->abstractType();
if(m_declaration->isTypeAlias()) {
//Do not show the own name as type of typedefs
if(useType.cast<TypeAliasType>())
useType = useType.cast<TypeAliasType>()->type();
}
eventuallyMakeTypeLinks( useType );
modifyHtml() += "<br>";
}else{
if( m_declaration->kind() == Declaration::Type && m_declaration->abstractType().cast<StructureType>()) {
htmlClass();
}
if ( m_declaration->kind() == Declaration::Namespace ) {
modifyHtml() += i18n("namespace %1 ", identifierHighlight(m_declaration->qualifiedIdentifier().toString().toHtmlEscaped(), m_declaration));
}
if(m_declaration->type<EnumerationType>()) {
EnumerationType::Ptr enumeration = m_declaration->type<EnumerationType>();
modifyHtml() += i18n("enumeration %1 ", identifierHighlight(m_declaration->identifier().toString().toHtmlEscaped(), m_declaration));
}
if(m_declaration->isForwardDeclaration()) {
ForwardDeclaration* forwardDec = static_cast<ForwardDeclaration*>(m_declaration.data());
Declaration* resolved = forwardDec->resolve(m_topContext.data());
if(resolved) {
modifyHtml() += i18n("( resolved forward-declaration: ");
makeLink(resolved->identifier().toString(), KDevelop::DeclarationPointer(resolved), NavigationAction::NavigateDeclaration );
modifyHtml() += i18n(") ");
}else{
modifyHtml() += i18n("(unresolved forward-declaration) ");
QualifiedIdentifier id = forwardDec->qualifiedIdentifier();
uint count;
const IndexedDeclaration* decls;
PersistentSymbolTable::self().declarations(id, count, decls);
for(uint a = 0; a < count; ++a) {
if(decls[a].isValid() && !decls[a].data()->isForwardDeclaration()) {
modifyHtml() += "<br />";
makeLink(i18n("possible resolution from"), KDevelop::DeclarationPointer(decls[a].data()), NavigationAction::NavigateDeclaration);
modifyHtml() += ' ' + decls[a].data()->url().str();
}
}
}
}
modifyHtml() += "<br />";
}
}else{
AbstractType::Ptr showType = m_declaration->abstractType();
if(showType && showType.cast<FunctionType>()) {
showType = showType.cast<FunctionType>()->returnType();
if(showType)
modifyHtml() += labelHighlight(i18n("Returns: "));
}else if(showType) {
modifyHtml() += labelHighlight(i18n("Type: "));
}
if(showType) {
eventuallyMakeTypeLinks(showType);
modifyHtml() += " ";
}
}
QualifiedIdentifier identifier = m_declaration->qualifiedIdentifier();
if( identifier.count() > 1 ) {
if( m_declaration->context() && m_declaration->context()->owner() )
{
Declaration* decl = m_declaration->context()->owner();
FunctionDefinition* definition = dynamic_cast<FunctionDefinition*>(decl);
if(definition && definition->declaration())
decl = definition->declaration();
if(decl->abstractType().cast<EnumerationType>())
modifyHtml() += labelHighlight(i18n("Enum: "));
else
modifyHtml() += labelHighlight(i18n("Container: "));
makeLink( declarationName(DeclarationPointer(decl)), DeclarationPointer(decl), NavigationAction::NavigateDeclaration );
modifyHtml() += " ";
} else {
QualifiedIdentifier parent = identifier;
parent.pop();
modifyHtml() += labelHighlight(i18n("Scope: %1 ", typeHighlight(parent.toString().toHtmlEscaped())));
}
}
if( shorten && !m_declaration->comment().isEmpty() ) {
QString comment = QString::fromUtf8(m_declaration->comment());
if( comment.length() > 60 ) {
comment.truncate(60);
comment += "...";
}
comment.replace('\n', " ");
comment.replace("<br />", " ");
comment.replace("<br/>", " ");
modifyHtml() += commentHighlight(comment.toHtmlEscaped()) + " ";
}
QString access = stringFromAccess(m_declaration);
if( !access.isEmpty() )
modifyHtml() += labelHighlight(i18n("Access: %1 ", propertyHighlight(access.toHtmlEscaped())));
///@todo Enumerations
QString detailsHtml;
QStringList details = declarationDetails(m_declaration);
if( !details.isEmpty() ) {
bool first = true;
foreach( const QString &str, details ) {
if( !first )
detailsHtml += ", ";
first = false;
detailsHtml += propertyHighlight(str);
}
}
void CorrectionFileGenerator::addHint(const QString &typeCode, const QStringList &modules, Declaration *forDeclaration,
CorrectionFileGenerator::HintType hintType)
{
if ( ! forDeclaration || ! forDeclaration->context() ) {
qCWarning(KDEV_PYTHON_CODEGEN) << "Declaration does not have context!" << (forDeclaration ? forDeclaration->toString() : "");
return;
}
DUContext* context = forDeclaration->context();
if ( context->type() == DUContext::Function ) {
auto otherImporters = context->importers();
if ( otherImporters.isEmpty() ) {
return;
}
context = otherImporters.first();
}
// We're in a class if the context of the declaration is a Class or if its
// parent context is a class. This is because a function body has a context
// of type Other.
bool inClass = context->type() == DUContext::Class
|| (context->parentContext() && context->parentContext()->type() == DUContext::Class);
// If the declaration is part of the function's arguments or it's parent
// context is one of a function.
bool inFunction = context->type() == DUContext::Function
|| (context->owner() && context->owner()->abstractType()->whichType() == AbstractType::TypeFunction);
qCDebug(KDEV_PYTHON_CODEGEN) << "Are we in a class: " << inClass;
qCDebug(KDEV_PYTHON_CODEGEN) << "Are we in a function: " << inFunction;
QString enclosingClassIdentifier, enclosingFunctionIdentifier;
if ( context->owner() ) {
if ( inClass && inFunction ) {
Declaration *functionDeclaration = context->owner();
enclosingClassIdentifier = functionDeclaration->context()->owner()->identifier().identifier().str();
enclosingFunctionIdentifier = functionDeclaration->identifier().identifier().str();
}
else if ( inClass ) {
enclosingClassIdentifier = context->owner()->identifier().identifier().str();
}
else if ( inFunction ) {
enclosingFunctionIdentifier = context->owner()->identifier().identifier().str();
}
}
qCDebug(KDEV_PYTHON_CODEGEN) << "Enclosing class: " << enclosingClassIdentifier;
qCDebug(KDEV_PYTHON_CODEGEN) << "Enclosing function: " << enclosingFunctionIdentifier;
QString declarationIdentifier = forDeclaration->identifier().identifier().str();
bool foundClassDeclaration = false;
bool foundFunctionDeclaration = false;
QString functionIdentifier;
if ( hintType == FunctionReturnHint ) {
functionIdentifier = declarationIdentifier;
}
else if ( hintType == LocalVariableHint ) {
functionIdentifier = enclosingFunctionIdentifier;
}
int line = findStructureFor(enclosingClassIdentifier, functionIdentifier);
if ( line == -1 ) {
line = findStructureFor(enclosingClassIdentifier, QString());
}
else if ( inFunction || hintType == FunctionReturnHint ) {
foundFunctionDeclaration = true;
}
if ( line == -1 ) {
line = findStructureFor(QString(), QString());
}
else if ( inClass ) {
foundClassDeclaration = true;
}
qCDebug(KDEV_PYTHON_CODEGEN) << "Found class declaration: " << foundClassDeclaration << enclosingClassIdentifier;
qCDebug(KDEV_PYTHON_CODEGEN) << "Found function declaration: " << foundFunctionDeclaration << functionIdentifier;
qCDebug(KDEV_PYTHON_CODEGEN) << "Line: " << line;
int indentsForNextStatement = m_fileIndents->indentForLine(line);
if ( foundClassDeclaration ) {
indentsForNextStatement += DEFAULT_INDENT_LEVEL;
}
QStringList newCode;
if ( inClass ) {
if ( ! foundClassDeclaration ) {
QString classDeclaration = createStructurePart(enclosingClassIdentifier, ClassType);
classDeclaration.prepend(QString(indentsForNextStatement, ' '));
newCode.append(classDeclaration);
indentsForNextStatement += DEFAULT_INDENT_LEVEL;
}
else {
line++;
}
}
if ( inFunction || hintType == FunctionReturnHint ) {
if ( ! foundFunctionDeclaration ) {
QString functionDeclaration;
if ( inClass ) {
functionDeclaration = createStructurePart(functionIdentifier, MemberFunctionType);
}
else {
functionDeclaration = createStructurePart(functionIdentifier, FunctionType);
}
functionDeclaration.prepend(QString(indentsForNextStatement, ' '));
newCode.append(functionDeclaration);
indentsForNextStatement += DEFAULT_INDENT_LEVEL;
}
else {
line++;
}
}
if ( foundFunctionDeclaration && ! foundClassDeclaration ) {
indentsForNextStatement += DEFAULT_INDENT_LEVEL;
}
QString hintCode;
if ( hintType == FunctionReturnHint ) {
hintCode = "returns = " + typeCode;
}
else if ( hintType == LocalVariableHint ) {
hintCode = "l_" + declarationIdentifier + " = " + typeCode;
}
qCDebug(KDEV_PYTHON_CODEGEN) << "Hint code: " << hintCode;
hintCode.prepend(QString(indentsForNextStatement, ' '));
newCode.append(hintCode);
for ( int i = 0; i < newCode.length(); i++ ) {
m_code.insert(line + i, newCode.at(i));
}
// We safely insert any import declaration at the top
foreach ( const QString &moduleName, modules ) {
bool importExists = false;
foreach (const QString &line, m_code) {
if ( ! line.startsWith("import") && ! line.startsWith("from") && ! line.isEmpty() ) {
break;
}
// In both import ... and from ... import ..., the second part is what we want
if ( line.section(' ', 1, 1, QString::SectionSkipEmpty) == moduleName.trimmed() ) {
importExists = true;
}
}
if ( ! importExists ) {
m_code.prepend("import " + moduleName.trimmed());
}
}