Prefer using 'override' instead of 'virtual'

warning: prefer using 'override' or (rarely) 'final' instead of
'virtual' [modernize-use-override]

Change-Id: I6dac7a62b627fa1353b4455e1af92f869c2571cc
Reviewed-by: Marco Benelli <marco.benelli@qt.io>

4 files changed, 81 insertions, 81 deletions

diff --git a/src/libs/cplusplus/CppDocument.cpp b/src/libs/cplusplus/CppDocument.cpp
index 93f3654e4f..d892948468 100644
--- a/src/libs/cplusplus/CppDocument.cpp
+++ b/src/libs/cplusplus/CppDocument.cpp
@@ -142,34 +142,34 @@ protected:
 
     using SymbolVisitor::visit;
 
-    virtual bool preVisit(Symbol *)
+    bool preVisit(Symbol *) override
     { return ! _scope; }
 
-    virtual bool visit(UsingNamespaceDirective *) { return false; }
-    virtual bool visit(UsingDeclaration *) { return false; }
-    virtual bool visit(NamespaceAlias *) { return false; }
-    virtual bool visit(Declaration *) { return false; }
-    virtual bool visit(Argument *) { return false; }
-    virtual bool visit(TypenameArgument *) { return false; }
-    virtual bool visit(BaseClass *) { return false; }
-    virtual bool visit(ForwardClassDeclaration *) { return false; }
+    bool visit(UsingNamespaceDirective *) override { return false; }
+    bool visit(UsingDeclaration *) override { return false; }
+    bool visit(NamespaceAlias *) override { return false; }
+    bool visit(Declaration *) override { return false; }
+    bool visit(Argument *) override { return false; }
+    bool visit(TypenameArgument *) override { return false; }
+    bool visit(BaseClass *) override { return false; }
+    bool visit(ForwardClassDeclaration *) override { return false; }
 
-    virtual bool visit(Enum *symbol)
+    bool visit(Enum *symbol) override
     { return process(symbol); }
 
-    virtual bool visit(Function *symbol)
+    bool visit(Function *symbol) override
     { return process(symbol); }
 
-    virtual bool visit(Namespace *symbol)
+    bool visit(Namespace *symbol) override
     { return process(symbol); }
 
-    virtual bool visit(Class *symbol)
+    bool visit(Class *symbol) override
     { return process(symbol); }
 
-    virtual bool visit(Block *symbol)
+    bool visit(Block *symbol) override
     { return process(symbol); }
 
-    virtual bool visit(Template *symbol)
+    bool visit(Template *symbol) override
     {
         if (Symbol *decl = symbol->declaration()) {
             if (decl->isFunction() || decl->isClass() || decl->isDeclaration())
@@ -179,19 +179,19 @@ protected:
     }
 
     // Objective-C
-    virtual bool visit(ObjCBaseClass *) { return false; }
-    virtual bool visit(ObjCBaseProtocol *) { return false; }
-    virtual bool visit(ObjCForwardClassDeclaration *) { return false; }
-    virtual bool visit(ObjCForwardProtocolDeclaration *) { return false; }
-    virtual bool visit(ObjCPropertyDeclaration *) { return false; }
+    bool visit(ObjCBaseClass *) override { return false; }
+    bool visit(ObjCBaseProtocol *) override { return false; }
+    bool visit(ObjCForwardClassDeclaration *) override { return false; }
+    bool visit(ObjCForwardProtocolDeclaration *) override { return false; }
+    bool visit(ObjCPropertyDeclaration *) override { return false; }
 
-    virtual bool visit(ObjCClass *symbol)
+    bool visit(ObjCClass *symbol) override
     { return process(symbol); }
 
-    virtual bool visit(ObjCProtocol *symbol)
+    bool visit(ObjCProtocol *symbol) override
     { return process(symbol); }
 
-    virtual bool visit(ObjCMethod *symbol)
+    bool visit(ObjCMethod *symbol) override
     { return process(symbol); }
 };
 
@@ -209,10 +209,10 @@ public:
           errorCount(0)
     { }
 
-    virtual void report(int level,
-                        const StringLiteral *fileId,
-                        unsigned line, unsigned column,
-                        const char *format, va_list ap)
+    void report(int level,
+                const StringLiteral *fileId,
+                unsigned line, unsigned column,
+                const char *format, va_list ap) override
     {
         if (level == Error) {
             ++errorCount;
diff --git a/src/libs/cplusplus/CppRewriter.cpp b/src/libs/cplusplus/CppRewriter.cpp
index 1ce9cc2dfa..aec22d8248 100644
--- a/src/libs/cplusplus/CppRewriter.cpp
+++ b/src/libs/cplusplus/CppRewriter.cpp
@@ -73,52 +73,52 @@ public:
             return (!temps.isEmpty()) ? temps.takeLast() : ty;
         }
 
-        virtual void visit(UndefinedType *)
+        void visit(UndefinedType *) override
         {
             temps.append(FullySpecifiedType());
         }
 
-        virtual void visit(VoidType *)
+        void visit(VoidType *) override
         {
             temps.append(control()->voidType());
         }
 
-        virtual void visit(IntegerType *type)
+        void visit(IntegerType *type) override
         {
             temps.append(control()->integerType(type->kind()));
         }
 
-        virtual void visit(FloatType *type)
+        void visit(FloatType *type) override
         {
             temps.append(control()->floatType(type->kind()));
         }
 
-        virtual void visit(PointerToMemberType *type)
+        void visit(PointerToMemberType *type) override
         {
             const Name *memberName = rewrite->rewriteName(type->memberName());
             const FullySpecifiedType elementType = rewrite->rewriteType(type->elementType());
             temps.append(control()->pointerToMemberType(memberName, elementType));
         }
 
-        virtual void visit(PointerType *type)
+        void visit(PointerType *type) override
         {
             const FullySpecifiedType elementType = rewrite->rewriteType(type->elementType());
             temps.append(control()->pointerType(elementType));
         }
 
-        virtual void visit(ReferenceType *type)
+        void visit(ReferenceType *type) override
         {
             const FullySpecifiedType elementType = rewrite->rewriteType(type->elementType());
             temps.append(control()->referenceType(elementType, type->isRvalueReference()));
         }
 
-        virtual void visit(ArrayType *type)
+        void visit(ArrayType *type) override
         {
             const FullySpecifiedType elementType = rewrite->rewriteType(type->elementType());
             temps.append(control()->arrayType(elementType, type->size()));
         }
 
-        virtual void visit(NamedType *type)
+        void visit(NamedType *type) override
         {
             FullySpecifiedType ty = rewrite->env->apply(type->name(), rewrite);
             if (! ty->isUndefinedType()) {
@@ -129,7 +129,7 @@ public:
             }
         }
 
-        virtual void visit(Function *type)
+        void visit(Function *type) override
         {
             Function *funTy = control()->newFunction(0, 0);
             funTy->copy(type);
@@ -158,55 +158,55 @@ public:
             temps.append(funTy);
         }
 
-        virtual void visit(Namespace *type)
+        void visit(Namespace *type) override
         {
             qWarning() << Q_FUNC_INFO;
             temps.append(type);
         }
 
-        virtual void visit(Class *type)
+        void visit(Class *type) override
         {
             qWarning() << Q_FUNC_INFO;
             temps.append(type);
         }
 
-        virtual void visit(Enum *type)
+        void visit(Enum *type) override
         {
             qWarning() << Q_FUNC_INFO;
             temps.append(type);
         }
 
-        virtual void visit(ForwardClassDeclaration *type)
+        void visit(ForwardClassDeclaration *type) override
         {
             qWarning() << Q_FUNC_INFO;
             temps.append(type);
         }
 
-        virtual void visit(ObjCClass *type)
+        void visit(ObjCClass *type) override
         {
             qWarning() << Q_FUNC_INFO;
             temps.append(type);
         }
 
-        virtual void visit(ObjCProtocol *type)
+        void visit(ObjCProtocol *type) override
         {
             qWarning() << Q_FUNC_INFO;
             temps.append(type);
         }
 
-        virtual void visit(ObjCMethod *type)
+        void visit(ObjCMethod *type) override
         {
             qWarning() << Q_FUNC_INFO;
             temps.append(type);
         }
 
-        virtual void visit(ObjCForwardClassDeclaration *type)
+        void visit(ObjCForwardClassDeclaration *type) override
         {
             qWarning() << Q_FUNC_INFO;
             temps.append(type);
         }
 
-        virtual void visit(ObjCForwardProtocolDeclaration *type)
+        void visit(ObjCForwardProtocolDeclaration *type) override
         {
             qWarning() << Q_FUNC_INFO;
             temps.append(type);
@@ -242,19 +242,19 @@ public:
             return (!temps.isEmpty()) ? temps.takeLast() : name;
         }
 
-        virtual void visit(const QualifiedNameId *name)
+        void visit(const QualifiedNameId *name) override
         {
             const Name *base = rewrite->rewriteName(name->base());
             const Name *n = rewrite->rewriteName(name->name());
             temps.append(control()->qualifiedNameId(base, n));
         }
 
-        virtual void visit(const Identifier *name)
+        void visit(const Identifier *name) override
         {
             temps.append(control()->identifier(name->chars(), name->size()));
         }
 
-        virtual void visit(const TemplateNameId *name)
+        void visit(const TemplateNameId *name) override
         {
             QVarLengthArray<FullySpecifiedType, 8> args(name->templateArgumentCount());
             for (unsigned i = 0; i < name->templateArgumentCount(); ++i)
@@ -263,23 +263,23 @@ public:
                                                    args.data(), args.size()));
         }
 
-        virtual void visit(const DestructorNameId *name)
+        void visit(const DestructorNameId *name) override
         {
             temps.append(control()->destructorNameId(identifier(name->identifier())));
         }
 
-        virtual void visit(const OperatorNameId *name)
+        void visit(const OperatorNameId *name) override
         {
             temps.append(control()->operatorNameId(name->kind()));
         }
 
-        virtual void visit(const ConversionNameId *name)
+        void visit(const ConversionNameId *name) override
         {
             FullySpecifiedType ty = rewrite->rewriteType(name->type());
             temps.append(control()->conversionNameId(ty));
         }
 
-        virtual void visit(const SelectorNameId *name)
+        void visit(const SelectorNameId *name) override
         {
             QVarLengthArray<const Name *, 8> names(name->nameCount());
             for (unsigned i = 0; i < name->nameCount(); ++i)
diff --git a/src/libs/cplusplus/DeprecatedGenTemplateInstance.cpp b/src/libs/cplusplus/DeprecatedGenTemplateInstance.cpp
index 90cd52ef6b..db39d0b20d 100644
--- a/src/libs/cplusplus/DeprecatedGenTemplateInstance.cpp
+++ b/src/libs/cplusplus/DeprecatedGenTemplateInstance.cpp
@@ -81,48 +81,48 @@ private:
             return previousType;
         }
 
-        virtual void visit(VoidType *)
+        void visit(VoidType *) override
         {
             // nothing to do
         }
 
-        virtual void visit(IntegerType *)
+        void visit(IntegerType *) override
         {
             // nothing to do
         }
 
-        virtual void visit(FloatType *)
+        void visit(FloatType *) override
         {
             // nothing to do
         }
 
-        virtual void visit(PointerToMemberType *)
+        void visit(PointerToMemberType *) override
         {
             qDebug() << Q_FUNC_INFO; // ### TODO
         }
 
-        virtual void visit(PointerType *ptrTy)
+        void visit(PointerType *ptrTy) override
         {
             _type.setType(control()->pointerType(q->apply(ptrTy->elementType())));
         }
 
-        virtual void visit(ReferenceType *refTy)
+        void visit(ReferenceType *refTy) override
         {
             _type.setType(control()->referenceType(q->apply(refTy->elementType()), refTy->isRvalueReference()));
         }
 
-        virtual void visit(ArrayType *arrayTy)
+        void visit(ArrayType *arrayTy) override
         {
             _type.setType(control()->arrayType(q->apply(arrayTy->elementType()), arrayTy->size()));
         }
 
-        virtual void visit(NamedType *ty)
+        void visit(NamedType *ty) override
         {
             FullySpecifiedType n = q->apply(ty->name());
             _type.setType(n.type());
         }
 
-        virtual void visit(Function *funTy)
+        void visit(Function *funTy) override
         {
             Function *fun = control()->newFunction(/*sourceLocation=*/ 0, funTy->name());
             fun->setEnclosingScope(funTy->enclosingScope());
@@ -149,47 +149,47 @@ private:
             _type.setType(fun);
         }
 
-        virtual void visit(Namespace *)
+        void visit(Namespace *) override
         {
             qDebug() << Q_FUNC_INFO;
         }
 
-        virtual void visit(Class *)
+        void visit(Class *) override
         {
             qDebug() << Q_FUNC_INFO;
         }
 
-        virtual void visit(Enum *)
+        void visit(Enum *) override
         {
             qDebug() << Q_FUNC_INFO;
         }
 
-        virtual void visit(ForwardClassDeclaration *)
+        void visit(ForwardClassDeclaration *) override
         {
             qDebug() << Q_FUNC_INFO;
         }
 
-        virtual void visit(ObjCClass *)
+        void visit(ObjCClass *) override
         {
             qDebug() << Q_FUNC_INFO;
         }
 
-        virtual void visit(ObjCProtocol *)
+        void visit(ObjCProtocol *) override
         {
             qDebug() << Q_FUNC_INFO;
         }
 
-        virtual void visit(ObjCMethod *)
+        void visit(ObjCMethod *) override
         {
             qDebug() << Q_FUNC_INFO;
         }
 
-        virtual void visit(ObjCForwardClassDeclaration *)
+        void visit(ObjCForwardClassDeclaration *) override
         {
             qDebug() << Q_FUNC_INFO;
         }
 
-        virtual void visit(ObjCForwardProtocolDeclaration *)
+        void visit(ObjCForwardProtocolDeclaration *) override
         {
             qDebug() << Q_FUNC_INFO;
         }
@@ -229,7 +229,7 @@ private:
             return previousType;
         }
 
-        virtual void visit(const Identifier *name)
+        void visit(const Identifier *name) override
         {
             int index = findSubstitution(name->identifier());
 
@@ -240,7 +240,7 @@ private:
                 _type = control()->namedType(name);
         }
 
-        virtual void visit(const TemplateNameId *name)
+        void visit(const TemplateNameId *name) override
         {
             QVarLengthArray<FullySpecifiedType, 8> arguments(name->templateArgumentCount());
             for (unsigned i = 0; i < name->templateArgumentCount(); ++i) {
@@ -294,31 +294,31 @@ private:
             return 0;
         }
 
-        virtual void visit(const QualifiedNameId *name)
+        void visit(const QualifiedNameId *name) override
         {
             if (const Name *n = instantiate(name))
                 _type = control()->namedType(n);
         }
 
-        virtual void visit(const DestructorNameId *name)
+        void visit(const DestructorNameId *name) override
         {
             Overview oo;
             qWarning() << "ignored name:" << oo.prettyName(name);
         }
 
-        virtual void visit(const OperatorNameId *name)
+        void visit(const OperatorNameId *name) override
         {
             Overview oo;
             qWarning() << "ignored name:" << oo.prettyName(name);
         }
 
-        virtual void visit(const ConversionNameId *name)
+        void visit(const ConversionNameId *name) override
         {
             Overview oo;
             qWarning() << "ignored name:" << oo.prettyName(name);
         }
 
-        virtual void visit(const SelectorNameId *name)
+        void visit(const SelectorNameId *name) override
         {
             Overview oo;
             qWarning() << "ignored name:" << oo.prettyName(name);
diff --git a/src/libs/cplusplus/ResolveExpression.cpp b/src/libs/cplusplus/ResolveExpression.cpp
index 37b9ce8b30..034ea6fcc1 100644
--- a/src/libs/cplusplus/ResolveExpression.cpp
+++ b/src/libs/cplusplus/ResolveExpression.cpp
@@ -659,7 +659,7 @@ public:
         accept(tu->ast());
     }
 
-    virtual bool preVisit(AST *)
+    bool preVisit(AST *) override
     {
         if (_block)
             return false;
@@ -667,7 +667,7 @@ public:
         return true;
     }
 
-    virtual bool visit(SimpleNameAST *ast)
+    bool visit(SimpleNameAST *ast) override
     {
         if (ast->name
                 && ast->name->identifier()
@@ -678,7 +678,7 @@ public:
         return false;
     }
 
-    virtual bool visit(MemberAccessAST *ast)
+    bool visit(MemberAccessAST *ast) override
     {
         accept(ast->base_expression);
         return false;