diff --git a/src/libs/cplusplus/FindUsages.cpp b/src/libs/cplusplus/FindUsages.cpp
index 7374e034fb6..396e9c8a5e7 100644
--- a/src/libs/cplusplus/FindUsages.cpp
+++ b/src/libs/cplusplus/FindUsages.cpp
@@ -269,16 +269,13 @@ void FindUsages::checkExpression(unsigned startToken, unsigned endToken)
     getTokenStartPosition(startToken, &line, &column);
     Symbol *lastVisibleSymbol = _doc->findSymbolAt(line, column);
 
-    const QList<TypeOfExpression::Result> results =
-            typeofExpression(expression, _doc, lastVisibleSymbol,
-                             TypeOfExpression::Preprocess);
+    const QList<LookupItem> results = typeofExpression(expression, _doc, lastVisibleSymbol,
+                                                   TypeOfExpression::Preprocess);
 
     QList<Symbol *> candidates;
 
-    foreach (TypeOfExpression::Result r, results) {
-        FullySpecifiedType ty = r.first;
-        Symbol *lastVisibleSymbol = r.second;
-
+    foreach (const LookupItem &r, results) {
+        Symbol *lastVisibleSymbol = r.lastVisibleSymbol();
         candidates.append(lastVisibleSymbol);
     }
 
diff --git a/src/libs/cplusplus/LookupContext.cpp b/src/libs/cplusplus/LookupContext.cpp
index 653d86b0d00..3c60dda6410 100644
--- a/src/libs/cplusplus/LookupContext.cpp
+++ b/src/libs/cplusplus/LookupContext.cpp
@@ -43,6 +43,13 @@
 
 using namespace CPlusPlus;
 
+uint qHash(const CPlusPlus::LookupItem &key)
+{
+    const uint h1 = qHash(key.type().type());
+    const uint h2 = qHash(key.lastVisibleSymbol());
+    return ((h1 << 16) | (h1 >> 16)) ^ h2;
+}
+
 /////////////////////////////////////////////////////////////////////
 // LookupContext
 /////////////////////////////////////////////////////////////////////
@@ -348,8 +355,8 @@ QList<Scope *> LookupContext::buildVisibleScopes()
     return scopes;
 }
 
-QList<Scope *> LookupContext::visibleScopes(const QPair<FullySpecifiedType, Symbol *> &result) const
-{ return visibleScopes(result.second); }
+QList<Scope *> LookupContext::visibleScopes(const LookupItem &result) const
+{ return visibleScopes(result.lastVisibleSymbol()); }
 
 QList<Scope *> LookupContext::visibleScopes(Symbol *symbol) const
 {
@@ -696,14 +703,13 @@ Symbol *LookupContext::canonicalSymbol(const QList<Symbol *> &candidates,
     return canonicalSymbol(candidates.first(), globalNamespaceBinding);
 }
 
-Symbol *LookupContext::canonicalSymbol(const QList<QPair<FullySpecifiedType, Symbol *> > &results,
+Symbol *LookupContext::canonicalSymbol(const QList<LookupItem> &results,
                                        NamespaceBinding *globalNamespaceBinding)
 {
     QList<Symbol *> candidates;
-    QPair<FullySpecifiedType, Symbol *> result;
 
-    foreach (result, results)
-        candidates.append(result.second); // ### not exacly.
+    foreach (const LookupItem &result, results)
+        candidates.append(result.lastVisibleSymbol()); // ### not exacly.
 
     return canonicalSymbol(candidates, globalNamespaceBinding);
 }
diff --git a/src/libs/cplusplus/LookupContext.h b/src/libs/cplusplus/LookupContext.h
index 6a69b3330bb..a5aeb69b174 100644
--- a/src/libs/cplusplus/LookupContext.h
+++ b/src/libs/cplusplus/LookupContext.h
@@ -31,10 +31,41 @@
 #define CPLUSPLUS_LOOKUPCONTEXT_H
 
 #include "CppDocument.h"
-#include <QPair>
+#include <FullySpecifiedType.h>
 
 namespace CPlusPlus {
 
+class CPLUSPLUS_EXPORT LookupItem
+{
+public:
+    LookupItem()
+        : _lastVisibleSymbol(0) {}
+
+    LookupItem(const FullySpecifiedType &type, Symbol *lastVisibleSymbol)
+        : _type(type), _lastVisibleSymbol(lastVisibleSymbol) {}
+
+    FullySpecifiedType type() const { return _type; }
+    void setType(const FullySpecifiedType &type) { _type = type; }
+
+    Symbol *lastVisibleSymbol() const { return _lastVisibleSymbol; }
+    void setLastVisibleSymbol(Symbol *symbol) { _lastVisibleSymbol = symbol; }
+
+    bool operator == (const LookupItem &other) const
+    {
+        if (_type == other._type)
+            return _lastVisibleSymbol == other._lastVisibleSymbol;
+
+        return false;
+    }
+
+    bool operator != (const LookupItem &result) const
+    { return ! operator == (result); }
+
+private:
+    FullySpecifiedType _type;
+    Symbol *_lastVisibleSymbol;
+};
+
 class CPLUSPLUS_EXPORT LookupContext
 {
 public:
@@ -60,7 +91,7 @@ public:
     static Symbol *canonicalSymbol(Symbol *symbol,
                                    NamespaceBinding *globalNamespaceBinding);
 
-    static Symbol *canonicalSymbol(const QList<QPair<FullySpecifiedType, Symbol *> > &candidates,
+    static Symbol *canonicalSymbol(const QList<LookupItem> &candidates,
                                    NamespaceBinding *globalNamespaceBinding);
 
     QList<Symbol *> resolve(Name *name) const
@@ -113,7 +144,7 @@ public:
     { return _visibleScopes; }
 
     QList<Scope *> visibleScopes(Symbol *symbol) const;
-    QList<Scope *> visibleScopes(const QPair<FullySpecifiedType, Symbol *> &result) const;
+    QList<Scope *> visibleScopes(const LookupItem &result) const;
 
     QList<Scope *> expand(const QList<Scope *> &scopes) const;
 
@@ -199,4 +230,8 @@ private:
 
 } // end of namespace CPlusPlus
 
+
+uint qHash(const CPlusPlus::LookupItem &result);
+
+
 #endif // CPLUSPLUS_LOOKUPCONTEXT_H
diff --git a/src/libs/cplusplus/ResolveExpression.cpp b/src/libs/cplusplus/ResolveExpression.cpp
index de26ea9c5d3..2d2b3defa1a 100644
--- a/src/libs/cplusplus/ResolveExpression.cpp
+++ b/src/libs/cplusplus/ResolveExpression.cpp
@@ -80,42 +80,42 @@ ResolveExpression::ResolveExpression(const LookupContext &context)
 ResolveExpression::~ResolveExpression()
 { }
 
-QList<ResolveExpression::Result> ResolveExpression::operator()(ExpressionAST *ast)
+QList<LookupItem> ResolveExpression::operator()(ExpressionAST *ast)
 {
-    const QList<Result> previousResults = switchResults(QList<Result>());
+    const QList<LookupItem> previousResults = switchResults(QList<LookupItem>());
     accept(ast);
     return removeDuplicates(switchResults(previousResults));
 }
 
-QList<ResolveExpression::Result>
-ResolveExpression::switchResults(const QList<ResolveExpression::Result> &results)
+QList<LookupItem>
+ResolveExpression::switchResults(const QList<LookupItem> &results)
 {
-    const QList<Result> previousResults = _results;
+    const QList<LookupItem> previousResults = _results;
     _results = results;
     return previousResults;
 }
 
-void ResolveExpression::addResults(const QList<Result> &results)
+void ResolveExpression::addResults(const QList<LookupItem> &results)
 {
-    foreach (const Result r, results)
+    foreach (const LookupItem r, results)
         addResult(r);
 }
 
 void ResolveExpression::addResult(const FullySpecifiedType &ty, Symbol *symbol)
-{ return addResult(Result(ty, symbol)); }
+{ return addResult(LookupItem(ty, symbol)); }
 
-void ResolveExpression::addResult(const Result &r)
+void ResolveExpression::addResult(const LookupItem &r)
 {
-    Result p = r;
+    LookupItem p = r;
 
-    if (! p.second)
-        p.second = _context.symbol();
+    if (! p.lastVisibleSymbol())
+        p.setLastVisibleSymbol(_context.symbol());
 
     if (! _results.contains(p))
         _results.append(p);
 }
 
-QList<Scope *> ResolveExpression::visibleScopes(const Result &result) const
+QList<Scope *> ResolveExpression::visibleScopes(const LookupItem &result) const
 { return _context.visibleScopes(result); }
 
 bool ResolveExpression::visit(BinaryExpressionAST *ast)
@@ -323,18 +323,20 @@ bool ResolveExpression::visit(UnaryExpressionAST *ast)
     accept(ast->expression);
     unsigned unaryOp = tokenKind(ast->unary_op_token);
     if (unaryOp == T_AMPER) {
-        QMutableListIterator<Result > it(_results);
+        QMutableListIterator<LookupItem > it(_results);
         while (it.hasNext()) {
-            Result p = it.next();
-            p.first.setType(control()->pointerType(p.first));
+            LookupItem p = it.next();
+            FullySpecifiedType ty = p.type();
+            ty.setType(control()->pointerType(ty));
+            p.setType(ty);
             it.setValue(p);
         }
     } else if (unaryOp == T_STAR) {
-        QMutableListIterator<Result > it(_results);
+        QMutableListIterator<LookupItem > it(_results);
         while (it.hasNext()) {
-            Result p = it.next();
-            if (PointerType *ptrTy = p.first->asPointerType()) {
-                p.first = ptrTy->elementType();
+            LookupItem p = it.next();
+            if (PointerType *ptrTy = p.type()->asPointerType()) {
+                p.setType(ptrTy->elementType());
                 it.setValue(p);
             } else {
                 it.remove();
@@ -359,7 +361,7 @@ bool ResolveExpression::visit(QualifiedNameAST *ast)
     foreach (Symbol *symbol, symbols) {
         if (symbol->isTypedef()) {
             if (NamedType *namedTy = symbol->type()->asNamedType()) {
-                const Result r(namedTy, symbol);
+                const LookupItem r(namedTy, symbol);
                 const QList<Symbol *> resolvedClasses =
                         resolveClass(namedTy->name(), r, _context);
                 if (resolvedClasses.count()) {
@@ -437,7 +439,7 @@ bool ResolveExpression::visit(CallAST *ast)
 {
     ResolveClass resolveClass;
 
-    const QList<Result> baseResults = _results;
+    const QList<LookupItem> baseResults = _results;
     _results.clear();
 
     // Compute the types of the actual arguments.
@@ -451,18 +453,18 @@ bool ResolveExpression::visit(CallAST *ast)
 
     Name *functionCallOp = control()->operatorNameId(OperatorNameId::FunctionCallOp);
 
-    foreach (const Result &result, baseResults) {
-        FullySpecifiedType ty = result.first.simplified();
-        Symbol *lastVisibleSymbol = result.second;
+    foreach (const LookupItem &result, baseResults) {
+        FullySpecifiedType ty = result.type().simplified();
+        Symbol *lastVisibleSymbol = result.lastVisibleSymbol();
 
         if (NamedType *namedTy = ty->asNamedType()) {
             const QList<Symbol *> classObjectCandidates = resolveClass(namedTy->name(), result, _context);
 
             foreach (Symbol *classObject, classObjectCandidates) {
-                const QList<Result> overloads = resolveMember(functionCallOp, classObject->asClass(), namedTy->name());
+                const QList<LookupItem> overloads = resolveMember(functionCallOp, classObject->asClass(), namedTy->name());
 
-                foreach (const Result &o, overloads) {
-                    FullySpecifiedType overloadTy = o.first.simplified();
+                foreach (const LookupItem &o, overloads) {
+                    FullySpecifiedType overloadTy = o.type().simplified();
 
                     if (Function *funTy = overloadTy->asFunctionType()) {
                         if (maybeValidPrototype(funTy, actualArgumentCount))
@@ -487,17 +489,17 @@ bool ResolveExpression::visit(CallAST *ast)
 
 bool ResolveExpression::visit(ArrayAccessAST *ast)
 {
-    const QList<Result> baseResults = _results;
+    const QList<LookupItem> baseResults = _results;
     _results.clear();
 
-    const QList<Result> indexResults = operator()(ast->expression);
+    const QList<LookupItem> indexResults = operator()(ast->expression);
     ResolveClass resolveClass;
 
     Name *arrayAccessOp = control()->operatorNameId(OperatorNameId::ArrayAccessOp);
 
-    foreach (const Result &result, baseResults) {
-        FullySpecifiedType ty = result.first.simplified();
-        Symbol *contextSymbol = result.second;
+    foreach (const LookupItem &result, baseResults) {
+        FullySpecifiedType ty = result.type().simplified();
+        Symbol *contextSymbol = result.lastVisibleSymbol();
 
         if (PointerType *ptrTy = ty->asPointerType()) {
             addResult(ptrTy->elementType().simplified(), contextSymbol);
@@ -512,11 +514,11 @@ bool ResolveExpression::visit(ArrayAccessAST *ast)
             foreach (Symbol *classObject, classObjectCandidates) {
                 Q_ASSERT(classObject->isClass());
 
-                const QList<Result> overloads =
+                const QList<LookupItem> overloads =
                         resolveMember(arrayAccessOp, classObject->asClass(), namedTy->name());
 
-                foreach (Result r, overloads) {
-                    FullySpecifiedType ty = r.first.simplified();
+                foreach (LookupItem r, overloads) {
+                    FullySpecifiedType ty = r.type().simplified();
                     if (Function *funTy = ty->asFunctionType()) {
                         ty = funTy->returnType().simplified();
                         addResult(ty, funTy);
@@ -532,7 +534,7 @@ bool ResolveExpression::visit(MemberAccessAST *ast)
 {
     // The candidate types for the base expression are stored in
     // _results.
-    QList<Result> baseResults = _results;
+    QList<LookupItem> baseResults = _results;
 
     // Evaluate the expression-id that follows the access operator.
     Name *memberName = 0;
@@ -547,18 +549,18 @@ bool ResolveExpression::visit(MemberAccessAST *ast)
     return false;
 }
 
-QList<ResolveExpression::Result>
-ResolveExpression::resolveBaseExpression(const QList<Result> &baseResults, int accessOp,
+QList<LookupItem>
+ResolveExpression::resolveBaseExpression(const QList<LookupItem> &baseResults, int accessOp,
                                          bool *replacedDotOperator) const
 {
-    QList<Result> results;
+    QList<LookupItem> results;
 
     if (baseResults.isEmpty())
         return results;
 
-    Result result = baseResults.first();
-    FullySpecifiedType ty = result.first.simplified();
-    Symbol *lastVisibleSymbol = result.second;
+    LookupItem result = baseResults.first();
+    FullySpecifiedType ty = result.type().simplified();
+    Symbol *lastVisibleSymbol = result.lastVisibleSymbol();
 
     if (Function *funTy = ty->asFunctionType()) {
         if (funTy->isAmbiguous())
@@ -568,7 +570,7 @@ ResolveExpression::resolveBaseExpression(const QList<Result> &baseResults, int a
     if (accessOp == T_ARROW)  {
         if (lastVisibleSymbol && ty->isClassType() && ! lastVisibleSymbol->isClass()) {
             // ### remove ! lastVisibleSymbol->isClass() from the condition.
-            results.append(Result(ty, lastVisibleSymbol));
+            results.append(LookupItem(ty, lastVisibleSymbol));
 
         } else if (NamedType *namedTy = ty->asNamedType()) {
             // ### This code is pretty slow.
@@ -577,14 +579,14 @@ ResolveExpression::resolveBaseExpression(const QList<Result> &baseResults, int a
             foreach (Symbol *candidate, candidates) {
                 if (candidate->isTypedef()) {
                     FullySpecifiedType declTy = candidate->type().simplified();
-                    const ResolveExpression::Result r(declTy, candidate);
+                    const LookupItem r(declTy, candidate);
 
                     // update the result
                     result = r;
 
                     // refresh the cached ty and lastVisibileSymbol.
-                    ty = result.first.simplified();
-                    lastVisibleSymbol = result.second;
+                    ty = result.type().simplified();
+                    lastVisibleSymbol = result.lastVisibleSymbol();
                     break;
                 }
             }
@@ -596,12 +598,12 @@ ResolveExpression::resolveBaseExpression(const QList<Result> &baseResults, int a
             const QList<Symbol *> candidates = resolveClass(namedTy->name(), result, _context);
 
             foreach (Symbol *classObject, candidates) {                
-                const QList<Result> overloads = resolveMember(arrowAccessOp, classObject->asClass(),
+                const QList<LookupItem> overloads = resolveMember(arrowAccessOp, classObject->asClass(),
                                                               namedTy->name());
 
-                foreach (const Result &r, overloads) {
-                    FullySpecifiedType typeOfOverloadFunction = r.first.simplified();
-                    Symbol *lastVisibleSymbol = r.second;
+                foreach (const LookupItem &r, overloads) {
+                    FullySpecifiedType typeOfOverloadFunction = r.type().simplified();
+                    Symbol *lastVisibleSymbol = r.lastVisibleSymbol();
                     Function *funTy = typeOfOverloadFunction->asFunctionType();
                     if (! funTy)
                         continue;
@@ -612,7 +614,7 @@ ResolveExpression::resolveBaseExpression(const QList<Result> &baseResults, int a
                         FullySpecifiedType elementTy = ptrTy->elementType().simplified();
 
                         if (elementTy->isNamedType())
-                            results.append(Result(elementTy, lastVisibleSymbol));
+                            results.append(LookupItem(elementTy, lastVisibleSymbol));
                     }
                 }
             }
@@ -620,7 +622,7 @@ ResolveExpression::resolveBaseExpression(const QList<Result> &baseResults, int a
             FullySpecifiedType elementTy = ptrTy->elementType().simplified();
 
             if (elementTy->isNamedType() || elementTy->isClassType())
-                results.append(Result(elementTy, lastVisibleSymbol));
+                results.append(LookupItem(elementTy, lastVisibleSymbol));
         }
     } else if (accessOp == T_DOT) {
         if (replacedDotOperator) {
@@ -643,14 +645,14 @@ ResolveExpression::resolveBaseExpression(const QList<Result> &baseResults, int a
                 }
             }
 
-            results.append(Result(ty, lastVisibleSymbol));
+            results.append(LookupItem(ty, lastVisibleSymbol));
 
         } else if (Function *fun = ty->asFunctionType()) {
             Scope *funScope = fun->scope();
 
             if (funScope && (funScope->isBlockScope() || funScope->isNamespaceScope())) {
                 FullySpecifiedType retTy = fun->returnType().simplified();
-                results.append(Result(retTy, lastVisibleSymbol));
+                results.append(LookupItem(retTy, lastVisibleSymbol));
             }
         }
     }
@@ -658,18 +660,18 @@ ResolveExpression::resolveBaseExpression(const QList<Result> &baseResults, int a
     return removeDuplicates(results);
 }
 
-QList<ResolveExpression::Result>
-ResolveExpression::resolveMemberExpression(const QList<Result> &baseResults,
+QList<LookupItem>
+ResolveExpression::resolveMemberExpression(const QList<LookupItem> &baseResults,
                                            unsigned accessOp,
                                            Name *memberName,
                                            bool *replacedDotOperator) const
 {
     ResolveClass resolveClass;
-    QList<Result> results;
+    QList<LookupItem> results;
 
-    const QList<Result> classObjectResults = resolveBaseExpression(baseResults, accessOp, replacedDotOperator);
-    foreach (const Result &r, classObjectResults) {
-        FullySpecifiedType ty = r.first;
+    const QList<LookupItem> classObjectResults = resolveBaseExpression(baseResults, accessOp, replacedDotOperator);
+    foreach (const LookupItem &r, classObjectResults) {
+        FullySpecifiedType ty = r.type();
 
         if (Class *klass = ty->asClassType())
             results += resolveMember(memberName, klass);
@@ -688,11 +690,11 @@ ResolveExpression::resolveMemberExpression(const QList<Result> &baseResults,
     return removeDuplicates(results);
 }
 
-QList<ResolveExpression::Result>
+QList<LookupItem>
 ResolveExpression::resolveMember(Name *memberName, Class *klass,
                                  Name *className) const
 {
-    QList<Result> results;
+    QList<LookupItem> results;
 
     if (! className)
         className = klass->name();
@@ -731,17 +733,17 @@ ResolveExpression::resolveMember(Name *memberName, Class *klass,
             ty = inst(candidate);
         }
         
-        results.append(Result(ty, candidate));
+        results.append(LookupItem(ty, candidate));
     }
 
     return removeDuplicates(results);
 }
 
 
-QList<ResolveExpression::Result>
+QList<LookupItem>
 ResolveExpression::resolveMember(Name *memberName, ObjCClass *klass) const
 {
-    QList<Result> results;
+    QList<LookupItem> results;
 
     if (!memberName || !klass)
         return results;
@@ -754,7 +756,7 @@ ResolveExpression::resolveMember(Name *memberName, ObjCClass *klass) const
     foreach (Symbol *candidate, candidates) {
         FullySpecifiedType ty = candidate->type();
 
-        results.append(Result(ty, candidate));
+        results.append(LookupItem(ty, candidate));
     }
 
     return removeDuplicates(results);
@@ -767,11 +769,11 @@ bool ResolveExpression::visit(PostIncrDecrAST *)
 
 bool ResolveExpression::visit(ObjCMessageExpressionAST *ast)
 {
-    QList<Result> receiverResults = operator()(ast->receiver_expression);
+    QList<LookupItem> receiverResults = operator()(ast->receiver_expression);
 
     if (!receiverResults.isEmpty()) {
-        Result result = receiverResults.first();
-        FullySpecifiedType ty = result.first.simplified();
+        LookupItem result = receiverResults.first();
+        FullySpecifiedType ty = result.type().simplified();
         Name *klassName = 0;
 
         if (const ObjCClass *classTy = ty->asObjCClassType()) {
@@ -804,17 +806,17 @@ ResolveClass::ResolveClass()
 { }
 
 QList<Symbol *> ResolveClass::operator()(Name *name,
-                                         const ResolveExpression::Result &p,
+                                         const LookupItem &p,
                                          const LookupContext &context)
 {
-    const QList<ResolveExpression::Result> previousBlackList = _blackList;
+    const QList<LookupItem> previousBlackList = _blackList;
     const QList<Symbol *> symbols = resolveClass(name, p, context);
     _blackList = previousBlackList;
     return symbols;
 }
 
 QList<Symbol *> ResolveClass::resolveClass(Name *name,
-                                           const ResolveExpression::Result &p,
+                                           const LookupItem &p,
                                            const LookupContext &context)
 {
     QList<Symbol *> resolvedSymbols;
@@ -845,7 +847,7 @@ QList<Symbol *> ResolveClass::resolveClass(Name *name,
                     // b.
                     FullySpecifiedType declType = decl->type().simplified();
                     if (NamedType *namedTy = declType->asNamedType()) {
-                        const ResolveExpression::Result r(declType, decl);
+                        const LookupItem r(declType, decl);
                         resolvedSymbols += resolveClass(namedTy->name(), r, context);
                     }
                 }
@@ -857,7 +859,7 @@ QList<Symbol *> ResolveClass::resolveClass(Name *name,
                 if (funTy->scope() && (funTy->scope()->isBlockScope() || funTy->scope()->isNamespaceScope())) {
                     FullySpecifiedType retTy = funTy->returnType().simplified();
                     if (NamedType *namedTy = retTy->asNamedType()) {
-                        const ResolveExpression::Result r(retTy, decl);
+                        const LookupItem r(retTy, decl);
                         resolvedSymbols += resolveClass(namedTy->name(), r, context);
                     }
                 }
@@ -872,7 +874,7 @@ ResolveObjCClass::ResolveObjCClass()
 {}
 
 QList<Symbol *> ResolveObjCClass::operator ()(Name *name,
-                                              const ResolveExpression::Result &p,
+                                              const LookupItem &p,
                                               const LookupContext &context)
 {
     QList<Symbol *> resolvedSymbols;
diff --git a/src/libs/cplusplus/ResolveExpression.h b/src/libs/cplusplus/ResolveExpression.h
index adda2716c36..f4c00352daa 100644
--- a/src/libs/cplusplus/ResolveExpression.h
+++ b/src/libs/cplusplus/ResolveExpression.h
@@ -40,35 +40,32 @@ namespace CPlusPlus {
 
 class CPLUSPLUS_EXPORT ResolveExpression: protected ASTVisitor
 {
-public:
-    typedef QPair<FullySpecifiedType, Symbol *> Result;
-
 public:
     ResolveExpression(const LookupContext &context);
     virtual ~ResolveExpression();
 
-    QList<Result> operator()(ExpressionAST *ast);
+    QList<LookupItem> operator()(ExpressionAST *ast);
 
-    QList<Result> resolveMemberExpression(const QList<Result> &baseResults,
+    QList<LookupItem> resolveMemberExpression(const QList<LookupItem> &baseResults,
                                           unsigned accessOp,
                                           Name *memberName,
                                           bool *replacedDotOperator = 0) const;
 
-    QList<Result> resolveBaseExpression(const QList<Result> &baseResults,
+    QList<LookupItem> resolveBaseExpression(const QList<LookupItem> &baseResults,
                                         int accessOp,
                                         bool *replacedDotOperator = 0) const;
 
-    QList<Result> resolveMember(Name *memberName, Class *klass,
+    QList<LookupItem> resolveMember(Name *memberName, Class *klass,
                                 Name *className = 0) const;
 
-    QList<Result> resolveMember(Name *memberName, ObjCClass *klass) const;
+    QList<LookupItem> resolveMember(Name *memberName, ObjCClass *klass) const;
 
 protected:
-    QList<Result> switchResults(const QList<Result> &symbols);
+    QList<LookupItem> switchResults(const QList<LookupItem> &symbols);
 
     void addResult(const FullySpecifiedType &ty, Symbol *symbol = 0);
-    void addResult(const Result &result);
-    void addResults(const QList<Result> &results);
+    void addResult(const LookupItem &result);
+    void addResults(const QList<LookupItem> &results);
 
     bool maybeValidPrototype(Function *funTy, unsigned actualArgumentCount) const;
 
@@ -114,12 +111,12 @@ protected:
     // Objective-C expressions
     virtual bool visit(ObjCMessageExpressionAST *ast);
 
-    QList<Scope *> visibleScopes(const Result &result) const;
+    QList<Scope *> visibleScopes(const LookupItem &result) const;
 
 private:
     LookupContext _context;
     Semantic sem;
-    QList<Result> _results;
+    QList<LookupItem> _results;
     Symbol *_declSymbol;
 };
 
@@ -129,16 +126,16 @@ public:
     ResolveClass();
 
     QList<Symbol *> operator()(Name *name,
-                               const ResolveExpression::Result &p,
+                               const LookupItem &p,
                                const LookupContext &context);
 
 private:
     QList<Symbol *> resolveClass(Name *name,
-                                 const ResolveExpression::Result &p,
+                                 const LookupItem &p,
                                  const LookupContext &context);
 
 private:
-    QList<ResolveExpression::Result> _blackList;
+    QList<LookupItem> _blackList;
 };
 
 class CPLUSPLUS_EXPORT ResolveObjCClass
@@ -147,7 +144,7 @@ public:
     ResolveObjCClass();
 
     QList<Symbol *> operator()(Name *name,
-                               const ResolveExpression::Result &p,
+                               const LookupItem &p,
                                const LookupContext &context);
 };
 
diff --git a/src/libs/cplusplus/TypeOfExpression.cpp b/src/libs/cplusplus/TypeOfExpression.cpp
index c76e6b5f240..8450bac236c 100644
--- a/src/libs/cplusplus/TypeOfExpression.cpp
+++ b/src/libs/cplusplus/TypeOfExpression.cpp
@@ -54,10 +54,10 @@ void TypeOfExpression::setSnapshot(const Snapshot &documents)
     m_lookupContext = LookupContext();
 }
 
-QList<TypeOfExpression::Result> TypeOfExpression::operator()(const QString &expression,
-                                                             Document::Ptr document,
-                                                             Symbol *lastVisibleSymbol,
-                                                             PreprocessMode mode)
+QList<LookupItem> TypeOfExpression::operator()(const QString &expression,
+                                           Document::Ptr document,
+                                           Symbol *lastVisibleSymbol,
+                                           PreprocessMode mode)
 {
     QString code = expression;
     if (mode == Preprocess)
diff --git a/src/libs/cplusplus/TypeOfExpression.h b/src/libs/cplusplus/TypeOfExpression.h
index b3572cf5761..6e7ad456cc3 100644
--- a/src/libs/cplusplus/TypeOfExpression.h
+++ b/src/libs/cplusplus/TypeOfExpression.h
@@ -44,9 +44,6 @@ class Macro;
 
 class CPLUSPLUS_EXPORT TypeOfExpression
 {
-public:
-    typedef QPair<FullySpecifiedType, Symbol *> Result;
-
 public:
     TypeOfExpression();
 
@@ -78,7 +75,7 @@ public:
      * @param document          The document the expression is part of.
      * @param lastVisibleSymbol The last visible symbol in the document.
      */
-    QList<Result> operator()(const QString &expression, Document::Ptr document,
+    QList<LookupItem> operator()(const QString &expression, Document::Ptr document,
                              Symbol *lastVisibleSymbol,
                              PreprocessMode mode = NoPreprocess);
 
diff --git a/src/plugins/cppeditor/cppeditor.cpp b/src/plugins/cppeditor/cppeditor.cpp
index 59d06a90392..4bba1e21a5b 100644
--- a/src/plugins/cppeditor/cppeditor.cpp
+++ b/src/plugins/cppeditor/cppeditor.cpp
@@ -745,12 +745,13 @@ CPlusPlus::Symbol *CPPEditor::findCanonicalSymbol(const QTextCursor &cursor,
 
     Symbol *lastVisibleSymbol = doc->findSymbolAt(line, col);
 
-    const QList<TypeOfExpression::Result> results = typeOfExpression(code, doc,
-                                                                     lastVisibleSymbol,
-                                                                     TypeOfExpression::Preprocess);
+    const QList<LookupItem> results = typeOfExpression(code, doc,
+                                                   lastVisibleSymbol,
+                                                   TypeOfExpression::Preprocess);
 
     NamespaceBindingPtr glo = bind(doc, snapshot);
     Symbol *canonicalSymbol = LookupContext::canonicalSymbol(results, glo.data());
+
     return canonicalSymbol;
 }
 
@@ -1079,7 +1080,7 @@ void CPPEditor::switchDeclarationDefinition()
     if (f) {
         TypeOfExpression typeOfExpression;
         typeOfExpression.setSnapshot(m_modelManager->snapshot());
-        QList<TypeOfExpression::Result> resolvedSymbols = typeOfExpression(QString(), doc, lastSymbol);
+        QList<LookupItem> resolvedSymbols = typeOfExpression(QString(), doc, lastSymbol);
         const LookupContext &context = typeOfExpression.lookupContext();
 
         QualifiedNameId *q = qualifiedNameIdForSymbol(f, context);
@@ -1164,46 +1165,47 @@ CPPEditor::Link CPPEditor::findLinkAt(const QTextCursor &cursor,
     const QString expression = expressionUnderCursor(tc);
     TypeOfExpression typeOfExpression;
     typeOfExpression.setSnapshot(snapshot);
-    QList<TypeOfExpression::Result> resolvedSymbols =
+    QList<LookupItem> resolvedSymbols =
             typeOfExpression(expression, doc, lastSymbol);
 
     if (!resolvedSymbols.isEmpty()) {
-        TypeOfExpression::Result result = resolvedSymbols.first();
+        LookupItem result = resolvedSymbols.first();
+        const FullySpecifiedType ty = result.type().simplified();
 
-        if (result.first->isForwardClassDeclarationType()) {
+        if (ty->isForwardClassDeclarationType()) {
             while (! resolvedSymbols.isEmpty()) {
-                TypeOfExpression::Result r = resolvedSymbols.takeFirst();
+                LookupItem r = resolvedSymbols.takeFirst();
 
-                if (! r.first->isForwardClassDeclarationType()) {
+                if (! r.type()->isForwardClassDeclarationType()) {
                     result = r;
                     break;
                 }
             }
         }
 
-        if (result.first->isObjCForwardClassDeclarationType()) {
+        if (ty->isObjCForwardClassDeclarationType()) {
             while (! resolvedSymbols.isEmpty()) {
-                TypeOfExpression::Result r = resolvedSymbols.takeFirst();
+                LookupItem r = resolvedSymbols.takeFirst();
 
-                if (! r.first->isObjCForwardClassDeclarationType()) {
+                if (! r.type()->isObjCForwardClassDeclarationType()) {
                     result = r;
                     break;
                 }
             }
         }
 
-        if (result.first->isObjCForwardProtocolDeclarationType()) {
+        if (ty->isObjCForwardProtocolDeclarationType()) {
             while (! resolvedSymbols.isEmpty()) {
-                TypeOfExpression::Result r = resolvedSymbols.takeFirst();
+                LookupItem r = resolvedSymbols.takeFirst();
 
-                if (! r.first->isObjCForwardProtocolDeclarationType()) {
+                if (! r.type()->isObjCForwardProtocolDeclarationType()) {
                     result = r;
                     break;
                 }
             }
         }
 
-        if (Symbol *symbol = result.second) {
+        if (Symbol *symbol = result.lastVisibleSymbol()) {
             Symbol *def = 0;
             if (resolveTarget && !lastSymbol->isFunction())
                 def = findDefinition(symbol);
diff --git a/src/plugins/cppeditor/cpphoverhandler.cpp b/src/plugins/cppeditor/cpphoverhandler.cpp
index ff671da25af..6c93ca8ffa5 100644
--- a/src/plugins/cppeditor/cpphoverhandler.cpp
+++ b/src/plugins/cppeditor/cpphoverhandler.cpp
@@ -323,14 +323,13 @@ void CppHoverHandler::updateHelpIdAndTooltip(TextEditor::ITextEditor *editor, in
         ExpressionUnderCursor expressionUnderCursor;
         const QString expression = expressionUnderCursor(tc);
 
-        const QList<TypeOfExpression::Result> types =
-                typeOfExpression(expression, doc, lastSymbol);
+        const QList<LookupItem> types = typeOfExpression(expression, doc, lastSymbol);
 
         if (!types.isEmpty()) {
-            const TypeOfExpression::Result result = types.first();
+            const LookupItem result = types.first();
 
-            FullySpecifiedType firstType = result.first; // result of `type of expression'.
-            Symbol *lookupSymbol = result.second;        // lookup symbol
+            FullySpecifiedType firstType = result.type(); // result of `type of expression'.
+            Symbol *lookupSymbol = result.lastVisibleSymbol(); // lookup symbol
 
             Symbol *resolvedSymbol = lookupSymbol;
             Name *resolvedName = lookupSymbol ? lookupSymbol->name() : 0;
@@ -349,7 +348,7 @@ void CppHoverHandler::updateHelpIdAndTooltip(TextEditor::ITextEditor *editor, in
             m_helpId = buildHelpId(resolvedSymbol, resolvedName);
 
             if (m_toolTip.isEmpty()) {
-                Symbol *symbol = result.second;
+                Symbol *symbol = result.lastVisibleSymbol();
                 if (resolvedSymbol)
                     symbol = resolvedSymbol;
 
diff --git a/src/plugins/cpptools/cppcodecompletion.cpp b/src/plugins/cpptools/cppcodecompletion.cpp
index 5502e285440..0fb216a475e 100644
--- a/src/plugins/cpptools/cppcodecompletion.cpp
+++ b/src/plugins/cpptools/cppcodecompletion.cpp
@@ -789,8 +789,8 @@ int CppCodeCompletion::startCompletion(TextEditor::ITextEditable *editor)
         Symbol *lastVisibleSymbol = thisDocument->findSymbolAt(line, column);
         typeOfExpression.setSnapshot(m_manager->snapshot());
 
-        QList<TypeOfExpression::Result> resolvedTypes = typeOfExpression(expression, thisDocument, lastVisibleSymbol,
-                                                                         TypeOfExpression::Preprocess);
+        QList<LookupItem> resolvedTypes = typeOfExpression(expression, thisDocument, lastVisibleSymbol,
+                                                       TypeOfExpression::Preprocess);
         LookupContext context = typeOfExpression.lookupContext();
 
         if (!typeOfExpression.expressionAST() && (! m_completionOperator ||
@@ -852,14 +852,14 @@ int CppCodeCompletion::startCompletion(TextEditor::ITextEditable *editor)
             const QString baseExpression = expressionUnderCursor(tc);
 
             // Resolve the type of this expression
-            const QList<TypeOfExpression::Result> results =
+            const QList<LookupItem> results =
                     typeOfExpression(baseExpression, thisDocument,
                                      lastVisibleSymbol,
                                      TypeOfExpression::Preprocess);
 
             // If it's a class, add completions for the constructors
-            foreach (const TypeOfExpression::Result &result, results) {
-                if (result.first->isClassType()) {
+            foreach (const LookupItem &result, results) {
+                if (result.type()->isClassType()) {
                     if (completeConstructorOrFunction(results, context, endOfExpression, true))
                         return m_startPosition;
                     break;
@@ -872,14 +872,14 @@ int CppCodeCompletion::startCompletion(TextEditor::ITextEditable *editor)
     return -1;
 }
 
-bool CppCodeCompletion::completeConstructorOrFunction(const QList<TypeOfExpression::Result> &results,
+bool CppCodeCompletion::completeConstructorOrFunction(const QList<LookupItem> &results,
                                                       const LookupContext &context,
                                                       int endOfExpression, bool toolTipOnly)
 {
     QList<Function *> functions;
 
-    foreach (const TypeOfExpression::Result &result, results) {
-        FullySpecifiedType exprTy = result.first.simplified();
+    foreach (const LookupItem &result, results) {
+        FullySpecifiedType exprTy = result.type().simplified();
 
         if (Class *klass = exprTy->asClassType()) {
             Name *className = klass->name();
@@ -909,8 +909,8 @@ bool CppCodeCompletion::completeConstructorOrFunction(const QList<TypeOfExpressi
     }
 
     if (functions.isEmpty()) {
-        foreach (const TypeOfExpression::Result &result, results) {
-            FullySpecifiedType ty = result.first.simplified();
+        foreach (const LookupItem &result, results) {
+            FullySpecifiedType ty = result.type().simplified();
 
             if (Function *fun = ty->asFunctionType()) {
 
@@ -939,20 +939,20 @@ bool CppCodeCompletion::completeConstructorOrFunction(const QList<TypeOfExpressi
         ResolveClass resolveClass;
         Name *functionCallOp = context.control()->operatorNameId(OperatorNameId::FunctionCallOp);
 
-        foreach (const TypeOfExpression::Result &result, results) {
-            FullySpecifiedType ty = result.first.simplified();
+        foreach (const LookupItem &result, results) {
+            FullySpecifiedType ty = result.type().simplified();
 
             if (NamedType *namedTy = ty->asNamedType()) {
                 const QList<Symbol *> classObjectCandidates = resolveClass(namedTy->name(), result, context);
 
                 foreach (Symbol *classObjectCandidate, classObjectCandidates) {
                     if (Class *klass = classObjectCandidate->asClass()) {
-                        const QList<TypeOfExpression::Result> overloads =
+                        const QList<LookupItem> overloads =
                                 resolveExpression.resolveMember(functionCallOp, klass,
                                                                 namedTy->name());
 
-                        foreach (const TypeOfExpression::Result &overloadResult, overloads) {
-                            FullySpecifiedType overloadTy = overloadResult.first.simplified();
+                        foreach (const LookupItem &overloadResult, overloads) {
+                            FullySpecifiedType overloadTy = overloadResult.type().simplified();
 
                             if (Function *funTy = overloadTy->asFunctionType())
                                 functions.append(funTy);
@@ -1060,7 +1060,7 @@ bool CppCodeCompletion::completeConstructorOrFunction(const QList<TypeOfExpressi
     return false;
 }
 
-bool CppCodeCompletion::completeMember(const QList<TypeOfExpression::Result> &baseResults,
+bool CppCodeCompletion::completeMember(const QList<LookupItem> &baseResults,
                                        const LookupContext &context)
 {
     if (baseResults.isEmpty())
@@ -1070,14 +1070,14 @@ bool CppCodeCompletion::completeMember(const QList<TypeOfExpression::Result> &ba
     ResolveClass resolveClass;
 
     bool replacedDotOperator = false;
-    const QList<TypeOfExpression::Result> classObjectResults =
+    const QList<LookupItem> classObjectResults =
             resolveExpression.resolveBaseExpression(baseResults,
                                                     m_completionOperator,
                                                     &replacedDotOperator);
 
     QList<Symbol *> classObjectCandidates;
-    foreach (const TypeOfExpression::Result &r, classObjectResults) {
-        FullySpecifiedType ty = r.first.simplified();
+    foreach (const LookupItem &r, classObjectResults) {
+        FullySpecifiedType ty = r.type().simplified();
 
         if (Class *klass = ty->asClassType())
             classObjectCandidates.append(klass);
@@ -1108,13 +1108,13 @@ bool CppCodeCompletion::completeMember(const QList<TypeOfExpression::Result> &ba
     return false;
 }
 
-bool CppCodeCompletion::completeScope(const QList<TypeOfExpression::Result> &results,
+bool CppCodeCompletion::completeScope(const QList<LookupItem> &results,
                                       const LookupContext &context)
 {
     QList<Symbol *> classes, namespaces;
 
-    foreach (TypeOfExpression::Result result, results) {
-        FullySpecifiedType ty = result.first;
+    foreach (LookupItem result, results) {
+        FullySpecifiedType ty = result.type();
 
         if (Class *classTy = ty->asClassType())
             classes.append(classTy);
@@ -1305,7 +1305,7 @@ void CppCodeCompletion::completeClass(const QList<Symbol *> &candidates,
     }
 }
 
-bool CppCodeCompletion::completeQtMethod(const QList<TypeOfExpression::Result> &results,
+bool CppCodeCompletion::completeQtMethod(const QList<LookupItem> &results,
                                          const LookupContext &context,
                                          bool wantSignals)
 {
@@ -1321,8 +1321,8 @@ bool CppCodeCompletion::completeQtMethod(const QList<TypeOfExpression::Result> &
     o.setShowFunctionSignatures(true);
 
     QSet<QString> signatures;
-    foreach (const TypeOfExpression::Result &p, results) {
-        FullySpecifiedType ty = p.first.simplified();
+    foreach (const LookupItem &p, results) {
+        FullySpecifiedType ty = p.type().simplified();
 
         if (PointerType *ptrTy = ty->asPointerType())
             ty = ptrTy->elementType().simplified();
diff --git a/src/plugins/cpptools/cppcodecompletion.h b/src/plugins/cpptools/cppcodecompletion.h
index 8e93c6adc29..8d908e0b3e8 100644
--- a/src/plugins/cpptools/cppcodecompletion.h
+++ b/src/plugins/cpptools/cppcodecompletion.h
@@ -95,14 +95,14 @@ private:
 
     bool completeInclude(const QTextCursor &cursor);
 
-    bool completeConstructorOrFunction(const QList<CPlusPlus::TypeOfExpression::Result> &,
+    bool completeConstructorOrFunction(const QList<CPlusPlus::LookupItem> &,
                                        const CPlusPlus::LookupContext &,
                                        int endOfExpression, bool toolTipOnly);
 
-    bool completeMember(const QList<CPlusPlus::TypeOfExpression::Result> &,
+    bool completeMember(const QList<CPlusPlus::LookupItem> &,
                         const CPlusPlus::LookupContext &context);
 
-    bool completeScope(const QList<CPlusPlus::TypeOfExpression::Result> &,
+    bool completeScope(const QList<CPlusPlus::LookupItem> &,
                        const CPlusPlus::LookupContext &context);
 
     void completeNamespace(const QList<CPlusPlus::Symbol *> &candidates,
@@ -114,15 +114,15 @@ private:
 
     bool completeConstructors(CPlusPlus::Class *klass);
 
-    bool completeQtMethod(const QList<CPlusPlus::TypeOfExpression::Result> &,
+    bool completeQtMethod(const QList<CPlusPlus::LookupItem> &,
                           const CPlusPlus::LookupContext &context,
                           bool wantSignals);
 
-    bool completeSignal(const QList<CPlusPlus::TypeOfExpression::Result> &results,
+    bool completeSignal(const QList<CPlusPlus::LookupItem> &results,
                         const CPlusPlus::LookupContext &context)
     { return completeQtMethod(results, context, true); }
 
-    bool completeSlot(const QList<CPlusPlus::TypeOfExpression::Result> &results,
+    bool completeSlot(const QList<CPlusPlus::LookupItem> &results,
                       const CPlusPlus::LookupContext &context)
     { return completeQtMethod(results, context, false); }