CppTools: findMatchingDefinition handles const and volatile

Strict set to true, SymbolFinder::findMatchingDefinition will now also
check, if const and volatile matches.

Changed return type from 'Symbol *' to 'Function *' since only functions
are returned.

Change-Id: Ib55cb12b6c404e94fcefd0613b964e8caa425690
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@digia.com>

src/plugins/cpptools/insertionpointlocator.cpp

@@ -516,56 +516,44 @@ static InsertionLocation nextToSurroundingDefinitions(Declaration *declaration,
 
     // find the declaration's definition
     CppTools::SymbolFinder symbolFinder;
-    Symbol *definition = symbolFinder.findMatchingDefinition(surroundingFunctionDecl,
-                                                             changes.snapshot());
-    if (!definition)
+    Function *definitionFunction = symbolFinder.findMatchingDefinition(surroundingFunctionDecl,
+                                                                       changes.snapshot());
+    if (!definitionFunction)
         return noResult;
 
     unsigned line, column;
     if (suffix.isEmpty()) {
-        Function *definitionFunction = definition->asFunction();
-        if (!definitionFunction)
-            return noResult;
-
-        Document::Ptr targetDoc = changes.snapshot().document(QString::fromUtf8(definition->fileName()));
+        Document::Ptr targetDoc = changes.snapshot().document(QString::fromUtf8(definitionFunction->fileName()));
         if (!targetDoc)
             return noResult;
 
         targetDoc->translationUnit()->getPosition(definitionFunction->endOffset(), &line, &column);
     } else {
         // we don't have an offset to the start of the function definition, so we need to manually find it...
-        CppRefactoringFilePtr targetFile = changes.file(QString::fromUtf8(definition->fileName()));
+        CppRefactoringFilePtr targetFile = changes.file(QString::fromUtf8(definitionFunction->fileName()));
         if (!targetFile->isValid())
             return noResult;
 
         FindFunctionDefinition finder(targetFile->cppDocument()->translationUnit());
-        FunctionDefinitionAST *functionDefinition = finder(definition->line(), definition->column());
+        FunctionDefinitionAST *functionDefinition = finder(definitionFunction->line(), definitionFunction->column());
         if (!functionDefinition)
             return noResult;
 
         targetFile->cppDocument()->translationUnit()->getTokenStartPosition(functionDefinition->firstToken(), &line, &column);
     }
 
-    return InsertionLocation(QString::fromUtf8(definition->fileName()), prefix, suffix, line, column);
+    return InsertionLocation(QString::fromUtf8(definitionFunction->fileName()), prefix, suffix, line, column);
 }
 
-QList<InsertionLocation> InsertionPointLocator::methodDefinition(
-    Declaration *declaration) const
+QList<InsertionLocation> InsertionPointLocator::methodDefinition(Declaration *declaration) const
 {
     QList<InsertionLocation> result;
     if (!declaration)
         return result;
 
     CppTools::SymbolFinder symbolFinder;
-    if (Symbol *s = symbolFinder.findMatchingDefinition(declaration,
-                                                        m_refactoringChanges.snapshot(),
-                                                        true)) {
-        if (Function *f = s->asFunction()) {
-            if (f->isConst() == declaration->type().isConst()
-                    && f->isVolatile() == declaration->type().isVolatile())
-                return result;
-        }
-    }
+    if (symbolFinder.findMatchingDefinition(declaration, m_refactoringChanges.snapshot(), true))
+        return result;
 
     const InsertionLocation location = nextToSurroundingDefinitions(declaration, m_refactoringChanges);
     if (location.isValid()) {

src/plugins/cpptools/symbolfinder.cpp

@@ -95,8 +95,8 @@ SymbolFinder::SymbolFinder()
 {}
 
 // strict means the returned symbol has to match exactly,
-// including argument count and argument types
-Symbol *SymbolFinder::findMatchingDefinition(Symbol *declaration,
+// including argument count, argument types, constness and volatileness.
+Function *SymbolFinder::findMatchingDefinition(Symbol *declaration,
                                              const Snapshot &snapshot,
                                              bool strict)
 {
@@ -189,8 +189,11 @@ Symbol *SymbolFinder::findMatchingDefinition(Symbol *declaration,
                             break;
                     }
 
-                    if (argIt == argc)
+                    if (argIt == argc
+                            && fun->isConst() == declaration->type().isConst()
+                            && fun->isVolatile() == declaration->type().isVolatile()) {
                         best = fun;
+                    }
                 }
             }
 

src/plugins/cpptools/symbolfinder.h

@@ -46,9 +46,9 @@ class CPPTOOLS_EXPORT SymbolFinder
 public:
     SymbolFinder();
 
-    CPlusPlus::Symbol *findMatchingDefinition(CPlusPlus::Symbol *symbol,
-                                              const CPlusPlus::Snapshot &snapshot,
-                                              bool strict = false);
+    CPlusPlus::Function *findMatchingDefinition(CPlusPlus::Symbol *symbol,
+                                                const CPlusPlus::Snapshot &snapshot,
+                                                bool strict = false);
 
     CPlusPlus::Class *findMatchingClassDeclaration(CPlusPlus::Symbol *declaration,
                                                    const CPlusPlus::Snapshot &snapshot);

src/plugins/designer/qtcreatorintegration.cpp

@@ -257,11 +257,11 @@ static Document::Ptr findDefinition(Function *functionDeclaration, int *line)
     if (CppTools::CppModelManagerInterface *cppModelManager = CppTools::CppModelManagerInterface::instance()) {
         const Snapshot snapshot = cppModelManager->snapshot();
         CppTools::SymbolFinder symbolFinder;
-        if (Symbol *def = symbolFinder.findMatchingDefinition(functionDeclaration, snapshot)) {
+        if (Function *fun = symbolFinder.findMatchingDefinition(functionDeclaration, snapshot)) {
             if (line)
-                *line = def->line();
+                *line = fun->line();
 
-            return snapshot.document(QString::fromUtf8(def->fileName(), def->fileNameLength()));
+            return snapshot.document(QString::fromUtf8(fun->fileName(), fun->fileNameLength()));
         }
     }