void SimpleRefactoring::doContextMenu(KDevelop::ContextMenuExtension& extension, KDevelop::Context* context) {
if(DeclarationContext* declContext = dynamic_cast<DeclarationContext*>(context)){
//Actions on declarations
qRegisterMetaType<KDevelop::IndexedDeclaration>("KDevelop::IndexedDeclaration");
DUChainReadLocker lock(DUChain::lock());
Declaration* declaration = declContext->declaration().data();
if(declaration) {
QFileInfo finfo(declaration->topContext()->url().str());
if (finfo.isWritable()) {
QAction* action = new QAction(i18n("Rename %1", declaration->qualifiedIdentifier().toString()), this);
action->setData(QVariant::fromValue(IndexedDeclaration(declaration)));
action->setIcon(KIcon("edit-rename"));
connect(action, SIGNAL(triggered(bool)), this, SLOT(executeRenameAction()));
extension.addAction(ContextMenuExtension::RefactorGroup, action);
if(declContext->use().isEmpty() && declaration->isFunctionDeclaration() && declaration->internalContext() && declaration->internalContext()->type() == DUContext::Other &&
!dynamic_cast<Cpp::TemplateDeclaration*>(declaration)) {
AbstractFunctionDeclaration* funDecl = dynamic_cast<AbstractFunctionDeclaration*>(declaration);
if(funDecl && !funDecl->isInline() && !dynamic_cast<FunctionDefinition*>(funDecl)) {
//Is a candidate for moving into source
QAction* action = new QAction(i18n("Create separate definition for %1", declaration->qualifiedIdentifier().toString()), this);
action->setData(QVariant::fromValue(IndexedDeclaration(declaration)));
// action->setIcon(KIcon("arrow-right"));
connect(action, SIGNAL(triggered(bool)), this, SLOT(executeMoveIntoSourceAction()));
extension.addAction(ContextMenuExtension::RefactorGroup, action);
}
}
//Returns only the name, no template-parameters or scope
QString cursorItemText() {
KDevelop::DUChainReadLocker lock( DUChain::lock() );
Declaration* decl = cursorDeclaration();
if(!decl)
return QString();
IDocument* doc = ICore::self()->documentController()->activeDocument();
if(!doc)
return QString();
TopDUContext* context = DUChainUtils::standardContextForUrl( doc->url() );
if( !context ) {
qCDebug(PLUGIN_QUICKOPEN) << "Got no standard context";
return QString();
}
AbstractType::Ptr t = decl->abstractType();
IdentifiedType* idType = dynamic_cast<IdentifiedType*>(t.data());
if( idType && idType->declaration(context) )
decl = idType->declaration(context);
if(!decl->qualifiedIdentifier().isEmpty())
return decl->qualifiedIdentifier().last().identifier().str();
return QString();
}
QString DUChainItemData::text() const
{
DUChainReadLocker lock;;
Declaration* decl = m_item.m_item.data();
if(!decl)
return i18n("Not available any more: %1", m_item.m_text);
if(FunctionDefinition* def = dynamic_cast<FunctionDefinition*>(decl)) {
if(def->declaration()) {
decl = def->declaration();
}
}
QString text = decl->qualifiedIdentifier().toString();
if(!decl->abstractType()) {
//With simplified representation, still mark functions as such by adding parens
if(dynamic_cast<AbstractFunctionDeclaration*>(decl)) {
text += QLatin1String("(...)");
}
}else if(TypePtr<FunctionType> function = decl->type<FunctionType>()) {
text += function->partToString( FunctionType::SignatureArguments );
}
return text;
}
QList<QVariant> DUChainItemData::highlighting() const
{
DUChainReadLocker lock;;
Declaration* decl = m_item.m_item.data();
if(!decl) {
return QList<QVariant>();
}
if(FunctionDefinition* def = dynamic_cast<FunctionDefinition*>(decl)) {
if(def->declaration()) {
decl = def->declaration();
}
}
QTextCharFormat boldFormat;
boldFormat.setFontWeight(QFont::Bold);
QTextCharFormat normalFormat;
int prefixLength = 0;
QString signature;
TypePtr<FunctionType> function = decl->type<FunctionType>();
if(function) {
signature = function->partToString( FunctionType::SignatureArguments );
}
//Only highlight the last part of the qualified identifier, so the scope doesn't distract too much
QualifiedIdentifier id = decl->qualifiedIdentifier();
QString fullId = id.toString();
QString lastId;
if(!id.isEmpty()) {
lastId = id.last().toString();
}
prefixLength += fullId.length() - lastId.length();
QList<QVariant> ret;
ret << 0;
ret << prefixLength;
ret << QVariant(normalFormat);
ret << prefixLength;
ret << lastId.length();
ret << QVariant(boldFormat);
if(!signature.isEmpty()) {
ret << prefixLength + lastId.length();
ret << signature.length();
ret << QVariant(normalFormat);
}
return ret;
}
void ADLTypeVisitor::endVisit(const FunctionType * /*type*/)
{
// return type and argument types are handled by FunctionType::accept0
// here we process the namespace of the function name (or containing class), if any
/* at the bottom of 3.4.2.2 we find the following:
In addition, if the argument is the name or address of a set of overloaded functions and/or function tem-
plates, its associated classes and namespaces are the union of those associated with each of the members of
the set: the namespace in which the function or function template is defined and the classes and namespaces
associated with its (non-dependent) parameter types and return type.
*/
if (m_helper.m_possibleFunctionName.data() && m_helper.m_possibleFunctionName.data()->isFunctionDeclaration())
{
Declaration * declaration = m_helper.m_possibleFunctionName.data();
#ifdef DEBUG_ADL
qCDebug(CPPDUCHAIN) << " function name = " << declaration->toString() << " ; identifier = " << declaration->qualifiedIdentifier().toString();
#endif
// start going towards the global scope until we match an interesting name
// note that calling addDeclarationScopeIdentifier does not work because for some reason
// for function names DUContext::scopeIdentifier returns the function name instead of the
// name of the function's scope
DUContext* context = declaration->context();
while (context) {
if (Declaration* decl = context->owner())
{
if (context->type() == DUContext::Namespace)
{
m_helper.addAssociatedNamespace(decl->qualifiedIdentifier());
break;
} else if (context->type() == DUContext::Class) {
m_helper.addAssociatedClass(decl);
break;
}
}
context = context->parentContext();
}
}
}