static QList<QByteArray> fullIdForSymbol(Symbol *symbol)
{
QList<QByteArray> uid;
Symbol *current = symbol;
do {
uid.prepend(idForSymbol(current));
current = current->enclosingScope();
} while (current);
return uid;
}
QModelIndex OverviewModel::parent(const QModelIndex &child) const
{
Symbol *symbol = static_cast<Symbol *>(child.internalPointer());
if (!symbol) // account for no symbol item
return QModelIndex();
if (Scope *scope = symbol->enclosingScope()) {
if (scope->enclosingScope()) {
QModelIndex index;
if (scope->enclosingScope() && scope->enclosingScope()->enclosingScope()) // the parent doesn't have a parent
index = createIndex(scope->index(), 0, scope);
else //+1 to account for no symbol item
index = createIndex(scope->index() + 1, 0, scope);
return index;
}
}
return QModelIndex();
}
/*!
* Extract the function name including scope at the given position.
*
* Note that a function (scope) starts at the name of that function, not at the return type. The
* implication is that this function will return an empty string when the line/column is on the
* return type.
*
* \param line the line number, starting with line 1
* \param column the column number, starting with column 1
* \param lineOpeningDeclaratorParenthesis optional output parameter, the line of the opening
parenthesis of the declarator starting with 1
* \param lineClosingBrace optional output parameter, the line of the closing brace starting with 1
*/
QString Document::functionAt(int line, int column, int *lineOpeningDeclaratorParenthesis,
int *lineClosingBrace) const
{
if (line < 1 || column < 1)
return QString();
Symbol *symbol = lastVisibleSymbolAt(line, column);
if (!symbol)
return QString();
// Find the enclosing function scope (which might be several levels up, or we might be standing
// on it)
Scope *scope = symbol->asScope();
if (!scope)
scope = symbol->enclosingScope();
while (scope && !scope->isFunction() )
scope = scope->enclosingScope();
if (!scope)
return QString();
// We found the function scope
if (lineOpeningDeclaratorParenthesis) {
unsigned line;
translationUnit()->getPosition(scope->startOffset(), &line);
*lineOpeningDeclaratorParenthesis = static_cast<int>(line);
}
if (lineClosingBrace) {
unsigned line;
translationUnit()->getPosition(scope->endOffset(), &line);
*lineClosingBrace = static_cast<int>(line);
}
const QList<const Name *> fullyQualifiedName = LookupContext::fullyQualifiedName(scope);
return Overview().prettyName(fullyQualifiedName);
}
Symbol *CloneSymbol::cloneSymbol(Symbol *symbol, Subst *subst)
{
if (! symbol)
return 0;
SymbolSubstPair symbolSubstPair = std::make_pair(symbol, subst);
if (_cache.find(symbolSubstPair) != _cache.end()) {
Symbol *cachedSymbol = _cache[symbolSubstPair];
if (cachedSymbol->enclosingScope() == symbol->enclosingScope())
return cachedSymbol;
}
Symbol *r = 0;
std::swap(_subst, subst);
std::swap(_symbol, r);
accept(symbol);
std::swap(_symbol, r);
std::swap(_subst, subst);
CPP_CHECK(r != 0);
_cache[symbolSubstPair] = r;
return r;
}
Symbol *CanonicalSymbol::canonicalSymbol(Scope *scope, const QString &code,
TypeOfExpression &typeOfExpression)
{
const QList<LookupItem> results =
typeOfExpression(code.toUtf8(), scope, TypeOfExpression::Preprocess);
for (int i = results.size() - 1; i != -1; --i) {
const LookupItem &r = results.at(i);
Symbol *decl = r.declaration();
if (!(decl && decl->enclosingScope()))
break;
if (Class *classScope = r.declaration()->enclosingScope()->asClass()) {
const Identifier *declId = decl->identifier();
const Identifier *classId = classScope->identifier();
if (classId && classId->match(declId))
continue; // skip it, it's a ctor or a dtor.
if (Function *funTy = r.declaration()->type()->asFunctionType()) {
if (funTy->isVirtual())
return r.declaration();
}
}
}
for (int i = 0; i < results.size(); ++i) {
const LookupItem &r = results.at(i);
if (r.declaration())
return r.declaration();
}
return 0;
}