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; }