feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Renamed SymbolsForDotAccess to ResolveClass.

Browse Source
This commit is contained in:
Roberto Raggi
2008-12-30 12:03:49 +01:00
parent 7c3d1a0158
commit c7b023c0e1
3 changed files with 34 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/libs/cplusplus/ResolveExpression.cpp
View File

@@ -427,7 +427,7 @@ bool ResolveExpression::visit(UnaryExpressionAST *ast)
bool ResolveExpression::visit(QualifiedNameAST *ast) bool ResolveExpression::visit(QualifiedNameAST *ast)
{ {
SymbolsForDotAccess symbolsForDotAcces; ResolveClass symbolsForDotAcces;
Scope dummy; Scope dummy;
Name *name = sem.check(ast, &dummy); Name *name = sem.check(ast, &dummy);
@@ -537,7 +537,7 @@ bool ResolveExpression::visit(ArrayAccessAST *ast)
_results.clear(); _results.clear();
const QList<Result> indexResults = operator()(ast->expression); const QList<Result> indexResults = operator()(ast->expression);
SymbolsForDotAccess symbolsForDotAcccess; ResolveClass symbolsForDotAcccess;
foreach (Result p, baseResults) { foreach (Result p, baseResults) {
FullySpecifiedType ty = p.first; FullySpecifiedType ty = p.first;
@@ -595,7 +595,7 @@ ResolveExpression::resolveMemberExpression(const QList<Result> &baseResults,
unsigned accessOp, unsigned accessOp,
Name *memberName) const Name *memberName) const
{ {
SymbolsForDotAccess symbolsForDotAccess; ResolveClass resolveClass;
QList<Result> results; QList<Result> results;
if (accessOp == T_ARROW) { if (accessOp == T_ARROW) {
@@ -607,7 +607,7 @@ ResolveExpression::resolveMemberExpression(const QList<Result> &baseResults,
if (NamedType *namedTy = ty->asNamedType()) { if (NamedType *namedTy = ty->asNamedType()) {
const QList<Symbol *> classObjectCandidates = const QList<Symbol *> classObjectCandidates =
symbolsForDotAccess(namedTy, p, _context); resolveClass(namedTy, p, _context);
foreach (Symbol *classObject, classObjectCandidates) { foreach (Symbol *classObject, classObjectCandidates) {
const QList<Result> overloads = resolveArrowOperator(p, namedTy, const QList<Result> overloads = resolveArrowOperator(p, namedTy,
@@ -667,10 +667,10 @@ ResolveExpression::resolveMember(const Result &p,
Name *memberName, Name *memberName,
NamedType *namedTy) const NamedType *namedTy) const
{ {
SymbolsForDotAccess symbolsForDotAccess; ResolveClass resolveClass;
const QList<Symbol *> classObjectCandidates = const QList<Symbol *> classObjectCandidates =
symbolsForDotAccess(namedTy, p, _context); resolveClass(namedTy, p, _context);
QList<Result> results; QList<Result> results;
foreach (Symbol *classObject, classObjectCandidates) { foreach (Symbol *classObject, classObjectCandidates) {
@@ -799,29 +799,29 @@ bool ResolveExpression::visit(PostIncrDecrAST *)
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
SymbolsForDotAccess::SymbolsForDotAccess() ResolveClass::ResolveClass()
{ } { }
QList<Symbol *> SymbolsForDotAccess::operator()(NamedType *namedTy, QList<Symbol *> ResolveClass::operator()(NamedType *namedTy,
ResolveExpression::Result p, ResolveExpression::Result p,
const LookupContext &context) const LookupContext &context)
{ {
const QList<ResolveExpression::Result> previousBlackList = _blackList; const QList<ResolveExpression::Result> previousBlackList = _blackList;
const QList<Symbol *> symbols = symbolsForDotAccess(namedTy, p, context); const QList<Symbol *> symbols = resolveClass(namedTy, p, context);
_blackList = previousBlackList; _blackList = previousBlackList;
return symbols; return symbols;
} }
QList<Symbol *> SymbolsForDotAccess::operator()(ResolveExpression::Result p, QList<Symbol *> ResolveClass::operator()(ResolveExpression::Result p,
const LookupContext &context) const LookupContext &context)
{ {
const QList<ResolveExpression::Result> previousBlackList = _blackList; const QList<ResolveExpression::Result> previousBlackList = _blackList;
const QList<Symbol *> symbols = symbolsForDotAccess(p, context); const QList<Symbol *> symbols = resolveClass(p, context);
_blackList = previousBlackList; _blackList = previousBlackList;
return symbols; return symbols;
} }
QList<Symbol *> SymbolsForDotAccess::symbolsForDotAccess(NamedType *namedTy, QList<Symbol *> ResolveClass::resolveClass(NamedType *namedTy,
ResolveExpression::Result p, ResolveExpression::Result p,
const LookupContext &context) const LookupContext &context)
{ {
@@ -852,7 +852,7 @@ QList<Symbol *> SymbolsForDotAccess::symbolsForDotAccess(NamedType *namedTy,
// Boh b; // Boh b;
// b. // b.
const ResolveExpression::Result r(decl->type(), decl); const ResolveExpression::Result r(decl->type(), decl);
resolvedSymbols += symbolsForDotAccess(r, context); resolvedSymbols += resolveClass(r, context);
} }
} }
} else if (Declaration *decl = candidate->asDeclaration()) { } else if (Declaration *decl = candidate->asDeclaration()) {
@@ -861,7 +861,7 @@ QList<Symbol *> SymbolsForDotAccess::symbolsForDotAccess(NamedType *namedTy,
// foo. // foo.
if (funTy->scope()->isBlockScope() || funTy->scope()->isNamespaceScope()) { if (funTy->scope()->isBlockScope() || funTy->scope()->isNamespaceScope()) {
const ResolveExpression::Result r(funTy->returnType(), decl); const ResolveExpression::Result r(funTy->returnType(), decl);
resolvedSymbols += symbolsForDotAccess(r, context); resolvedSymbols += resolveClass(r, context);
} }
} }
} }
@@ -870,16 +870,16 @@ QList<Symbol *> SymbolsForDotAccess::symbolsForDotAccess(NamedType *namedTy,
return resolvedSymbols; return resolvedSymbols;
} }
QList<Symbol *> SymbolsForDotAccess::symbolsForDotAccess(ResolveExpression::Result p, QList<Symbol *> ResolveClass::resolveClass(ResolveExpression::Result p,
const LookupContext &context) const LookupContext &context)
{ {
FullySpecifiedType ty = p.first; FullySpecifiedType ty = p.first;
if (NamedType *namedTy = ty->asNamedType()) { if (NamedType *namedTy = ty->asNamedType()) {
return symbolsForDotAccess(namedTy, p, context); return resolveClass(namedTy, p, context);
} else if (ReferenceType *refTy = ty->asReferenceType()) { } else if (ReferenceType *refTy = ty->asReferenceType()) {
const ResolveExpression::Result e(refTy->elementType(), p.second); const ResolveExpression::Result e(refTy->elementType(), p.second);
return symbolsForDotAccess(e, context); return resolveClass(e, context);
} }
return QList<Symbol *>(); return QList<Symbol *>();

8
src/libs/cplusplus/ResolveExpression.h
View File

@@ -128,10 +128,10 @@ private:
QList<Result> _results; QList<Result> _results;
}; };
class CPLUSPLUS_EXPORT SymbolsForDotAccess class CPLUSPLUS_EXPORT ResolveClass
{ {
public: public:
SymbolsForDotAccess(); ResolveClass();
QList<Symbol *> operator()(NamedType *namedTy, QList<Symbol *> operator()(NamedType *namedTy,
ResolveExpression::Result p, ResolveExpression::Result p,
@@ -141,11 +141,11 @@ public:
const LookupContext &context); const LookupContext &context);
private: private:
QList<Symbol *> symbolsForDotAccess(NamedType *namedTy, QList<Symbol *> resolveClass(NamedType *namedTy,
ResolveExpression::Result p, ResolveExpression::Result p,
const LookupContext &context); const LookupContext &context);
QList<Symbol *> symbolsForDotAccess(ResolveExpression::Result p, QList<Symbol *> resolveClass(ResolveExpression::Result p,
const LookupContext &context); const LookupContext &context);
private: private:

26
src/plugins/cpptools/cppcodecompletion.cpp
View File

@@ -592,10 +592,9 @@ bool CppCodeCompletion::completeMember(const QList<TypeOfExpression::Result> &re
if (NamedType *namedTy = ty->asNamedType()) { if (NamedType *namedTy = ty->asNamedType()) {
ResolveExpression resolveExpression(context); ResolveExpression resolveExpression(context);
SymbolsForDotAccess symbolsForDotAccess; ResolveClass resolveClass;
const QList<Symbol *> candidates = symbolsForDotAccess(namedTy, p, const QList<Symbol *> candidates = resolveClass(namedTy, p, context);
context);
foreach (Symbol *classObject, candidates) { foreach (Symbol *classObject, candidates) {
const QList<TypeOfExpression::Result> overloads = const QList<TypeOfExpression::Result> overloads =
@@ -616,7 +615,7 @@ bool CppCodeCompletion::completeMember(const QList<TypeOfExpression::Result> &re
if (PointerType *ptrTy = ty->asPointerType()) { if (PointerType *ptrTy = ty->asPointerType()) {
if (NamedType *namedTy = ptrTy->elementType()->asNamedType()) { if (NamedType *namedTy = ptrTy->elementType()->asNamedType()) {
const QList<Symbol *> classes = const QList<Symbol *> classes =
symbolsForDotAccess(namedTy, p, context); resolveClass(namedTy, p, context);
foreach (Symbol *c, classes) { foreach (Symbol *c, classes) {
if (! classObjectCandidates.contains(c)) if (! classObjectCandidates.contains(c))
@@ -628,9 +627,9 @@ bool CppCodeCompletion::completeMember(const QList<TypeOfExpression::Result> &re
} }
} else if (PointerType *ptrTy = ty->asPointerType()) { } else if (PointerType *ptrTy = ty->asPointerType()) {
if (NamedType *namedTy = ptrTy->elementType()->asNamedType()) { if (NamedType *namedTy = ptrTy->elementType()->asNamedType()) {
SymbolsForDotAccess symbolsForDotAccess; ResolveClass resolveClass;
const QList<Symbol *> classes = symbolsForDotAccess(namedTy, p, const QList<Symbol *> classes = resolveClass(namedTy, p,
context); context);
foreach (Symbol *c, classes) { foreach (Symbol *c, classes) {
@@ -663,8 +662,8 @@ bool CppCodeCompletion::completeMember(const QList<TypeOfExpression::Result> &re
} }
if (namedTy) { if (namedTy) {
SymbolsForDotAccess symbolsForDotAccess; ResolveClass resolveClass;
const QList<Symbol *> symbols = symbolsForDotAccess(namedTy, p, context); const QList<Symbol *> symbols = resolveClass(namedTy, p, context);
foreach (Symbol *symbol, symbols) { foreach (Symbol *symbol, symbols) {
if (classObjectCandidates.contains(symbol)) if (classObjectCandidates.contains(symbol))
continue; continue;
@@ -715,8 +714,8 @@ bool CppCodeCompletion::completeScope(const QList<TypeOfExpression::Result> &res
completeClass(candidates, context); completeClass(candidates, context);
} else if (Symbol *symbol = result.second) { } else if (Symbol *symbol = result.second) {
if (symbol->isTypedef()) { if (symbol->isTypedef()) {
SymbolsForDotAccess symbolsForDotAccess; ResolveClass resolveClass;
const QList<Symbol *> candidates = symbolsForDotAccess(result, const QList<Symbol *> candidates = resolveClass(result,
context); context);
completeClass(candidates, context); completeClass(candidates, context);
} }
@@ -829,6 +828,8 @@ bool CppCodeCompletion::completeQtMethod(CPlusPlus::FullySpecifiedType,
if (results.isEmpty()) if (results.isEmpty())
return false; return false;
ResolveClass resolveClass;
ConvertToCompletionItem toCompletionItem(this); ConvertToCompletionItem toCompletionItem(this);
Overview o; Overview o;
o.setShowReturnTypes(false); o.setShowReturnTypes(false);
@@ -849,10 +850,8 @@ bool CppCodeCompletion::completeQtMethod(CPlusPlus::FullySpecifiedType,
if (! namedTy) // not a class name. if (! namedTy) // not a class name.
continue; continue;
const QList<Scope *> visibleScopes = context.visibleScopes(p);
const QList<Symbol *> classObjects = const QList<Symbol *> classObjects =
context.resolveClass(namedTy->name(), visibleScopes); resolveClass(namedTy, p, context);
if (classObjects.isEmpty()) if (classObjects.isEmpty())
continue; continue;
@@ -860,6 +859,7 @@ bool CppCodeCompletion::completeQtMethod(CPlusPlus::FullySpecifiedType,
Class *klass = classObjects.first()->asClass(); Class *klass = classObjects.first()->asClass();
QList<Scope *> todo; QList<Scope *> todo;
const QList<Scope *> visibleScopes = context.visibleScopes(p);
context.expand(klass->members(), visibleScopes, &todo); context.expand(klass->members(), visibleScopes, &todo);
foreach (Scope *scope, todo) { foreach (Scope *scope, todo) {