Fix compile warnings about missing override

Task-number: QTCREATORBUG-24098
Change-Id: I9c50d070d34a198b39176f6db13bc2f95521a6a8
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/libs/3rdparty/cplusplus/Bind.h

@@ -106,180 +106,180 @@ protected:
     FullySpecifiedType trailingReturnType(TrailingReturnTypeAST *ast, const FullySpecifiedType &init);
     const StringLiteral *asStringLiteral(const AST *ast);
 
-    virtual bool preVisit(AST *);
+    bool preVisit(AST *) override;
-    virtual void postVisit(AST *);
+    void postVisit(AST *) override;
 
     // AST
-    virtual bool visit(ObjCSelectorArgumentAST *ast);
+    bool visit(ObjCSelectorArgumentAST *ast) override;
-    virtual bool visit(GnuAttributeAST *ast);
+    bool visit(GnuAttributeAST *ast) override;
-    virtual bool visit(DeclaratorAST *ast);
+    bool visit(DeclaratorAST *ast) override;
-    virtual bool visit(QtPropertyDeclarationItemAST *ast);
+    bool visit(QtPropertyDeclarationItemAST *ast) override;
-    virtual bool visit(QtInterfaceNameAST *ast);
+    bool visit(QtInterfaceNameAST *ast) override;
-    virtual bool visit(BaseSpecifierAST *ast);
+    bool visit(BaseSpecifierAST *ast) override;
-    virtual bool visit(CtorInitializerAST *ast);
+    bool visit(CtorInitializerAST *ast) override;
-    virtual bool visit(EnumeratorAST *ast);
+    bool visit(EnumeratorAST *ast) override;
-    virtual bool visit(DynamicExceptionSpecificationAST *ast);
+    bool visit(DynamicExceptionSpecificationAST *ast) override;
-    virtual bool visit(MemInitializerAST *ast);
+    bool visit(MemInitializerAST *ast) override;
-    virtual bool visit(NestedNameSpecifierAST *ast);
+    bool visit(NestedNameSpecifierAST *ast) override;
-    virtual bool visit(NoExceptSpecificationAST *) { return true; }
+    bool visit(NoExceptSpecificationAST *) override { return true; }
-    virtual bool visit(NewArrayDeclaratorAST *ast);
+    bool visit(NewArrayDeclaratorAST *ast) override;
-    virtual bool visit(NewTypeIdAST *ast);
+    bool visit(NewTypeIdAST *ast) override;
-    virtual bool visit(OperatorAST *ast);
+    bool visit(OperatorAST *ast) override;
-    virtual bool visit(ParameterDeclarationClauseAST *ast);
+    bool visit(ParameterDeclarationClauseAST *ast) override;
-    virtual bool visit(TranslationUnitAST *ast);
+    bool visit(TranslationUnitAST *ast) override;
-    virtual bool visit(ObjCProtocolRefsAST *ast);
+    bool visit(ObjCProtocolRefsAST *ast) override;
-    virtual bool visit(ObjCMessageArgumentAST *ast);
+    bool visit(ObjCMessageArgumentAST *ast) override;
-    virtual bool visit(ObjCTypeNameAST *ast);
+    bool visit(ObjCTypeNameAST *ast) override;
-    virtual bool visit(ObjCInstanceVariablesDeclarationAST *ast);
+    bool visit(ObjCInstanceVariablesDeclarationAST *ast) override;
-    virtual bool visit(ObjCPropertyAttributeAST *ast);
+    bool visit(ObjCPropertyAttributeAST *ast) override;
-    virtual bool visit(ObjCMessageArgumentDeclarationAST *ast);
+    bool visit(ObjCMessageArgumentDeclarationAST *ast) override;
-    virtual bool visit(ObjCMethodPrototypeAST *ast);
+    bool visit(ObjCMethodPrototypeAST *ast) override;
-    virtual bool visit(ObjCSynthesizedPropertyAST *ast);
+    bool visit(ObjCSynthesizedPropertyAST *ast) override;
-    virtual bool visit(LambdaIntroducerAST *ast);
+    bool visit(LambdaIntroducerAST *ast) override;
-    virtual bool visit(LambdaCaptureAST *ast);
+    bool visit(LambdaCaptureAST *ast) override;
-    virtual bool visit(CaptureAST *ast);
+    bool visit(CaptureAST *ast) override;
-    virtual bool visit(LambdaDeclaratorAST *ast);
+    bool visit(LambdaDeclaratorAST *ast) override;
-    virtual bool visit(TrailingReturnTypeAST *ast);
+    bool visit(TrailingReturnTypeAST *ast) override;
-    virtual bool visit(DotDesignatorAST *) { return true; }
+    bool visit(DotDesignatorAST *) override { return true; }
-    virtual bool visit(BracketDesignatorAST *) { return true; }
+    bool visit(BracketDesignatorAST *) override { return true; }
 
     // StatementAST
-    virtual bool visit(QtMemberDeclarationAST *ast);
+    bool visit(QtMemberDeclarationAST *ast) override;
-    virtual bool visit(CaseStatementAST *ast);
+    bool visit(CaseStatementAST *ast) override;
-    virtual bool visit(CompoundStatementAST *ast);
+    bool visit(CompoundStatementAST *ast) override;
-    virtual bool visit(DeclarationStatementAST *ast);
+    bool visit(DeclarationStatementAST *ast) override;
-    virtual bool visit(DoStatementAST *ast);
+    bool visit(DoStatementAST *ast) override;
-    virtual bool visit(ExpressionOrDeclarationStatementAST *ast);
+    bool visit(ExpressionOrDeclarationStatementAST *ast) override;
-    virtual bool visit(ExpressionStatementAST *ast);
+    bool visit(ExpressionStatementAST *ast) override;
-    virtual bool visit(ForeachStatementAST *ast);
+    bool visit(ForeachStatementAST *ast) override;
-    virtual bool visit(RangeBasedForStatementAST *ast);
+    bool visit(RangeBasedForStatementAST *ast) override;
-    virtual bool visit(ForStatementAST *ast);
+    bool visit(ForStatementAST *ast) override;
-    virtual bool visit(IfStatementAST *ast);
+    bool visit(IfStatementAST *ast) override;
-    virtual bool visit(LabeledStatementAST *ast);
+    bool visit(LabeledStatementAST *ast) override;
-    virtual bool visit(BreakStatementAST *ast);
+    bool visit(BreakStatementAST *ast) override;
-    virtual bool visit(ContinueStatementAST *ast);
+    bool visit(ContinueStatementAST *ast) override;
-    virtual bool visit(GotoStatementAST *ast);
+    bool visit(GotoStatementAST *ast) override;
-    virtual bool visit(ReturnStatementAST *ast);
+    bool visit(ReturnStatementAST *ast) override;
-    virtual bool visit(SwitchStatementAST *ast);
+    bool visit(SwitchStatementAST *ast) override;
-    virtual bool visit(TryBlockStatementAST *ast);
+    bool visit(TryBlockStatementAST *ast) override;
-    virtual bool visit(CatchClauseAST *ast);
+    bool visit(CatchClauseAST *ast) override;
-    virtual bool visit(WhileStatementAST *ast);
+    bool visit(WhileStatementAST *ast) override;
-    virtual bool visit(ObjCFastEnumerationAST *ast);
+    bool visit(ObjCFastEnumerationAST *ast) override;
-    virtual bool visit(ObjCSynchronizedStatementAST *ast);
+    bool visit(ObjCSynchronizedStatementAST *ast) override;
 
     // ExpressionAST
-    virtual bool visit(AlignofExpressionAST *) { return true; }
+    bool visit(AlignofExpressionAST *) override { return true; }
-    virtual bool visit(IdExpressionAST *ast);
+    bool visit(IdExpressionAST *ast) override;
-    virtual bool visit(CompoundExpressionAST *ast);
+    bool visit(CompoundExpressionAST *ast) override;
-    virtual bool visit(CompoundLiteralAST *ast);
+    bool visit(CompoundLiteralAST *ast) override;
-    virtual bool visit(QtMethodAST *ast);
+    bool visit(QtMethodAST *ast) override;
-    virtual bool visit(BinaryExpressionAST *ast);
+    bool visit(BinaryExpressionAST *ast) override;
-    virtual bool visit(CastExpressionAST *ast);
+    bool visit(CastExpressionAST *ast) override;
-    virtual bool visit(ConditionAST *ast);
+    bool visit(ConditionAST *ast) override;
-    virtual bool visit(ConditionalExpressionAST *ast);
+    bool visit(ConditionalExpressionAST *ast) override;
-    virtual bool visit(CppCastExpressionAST *ast);
+    bool visit(CppCastExpressionAST *ast) override;
-    virtual bool visit(DeleteExpressionAST *ast);
+    bool visit(DeleteExpressionAST *ast) override;
-    virtual bool visit(DesignatedInitializerAST *) { return true; }
+    bool visit(DesignatedInitializerAST *) override { return true; }
-    virtual bool visit(ArrayInitializerAST *ast);
+    bool visit(ArrayInitializerAST *ast) override;
-    virtual bool visit(NewExpressionAST *ast);
+    bool visit(NewExpressionAST *ast) override;
-    virtual bool visit(NoExceptOperatorExpressionAST *) { return true; }
+    bool visit(NoExceptOperatorExpressionAST *) override { return true; }
-    virtual bool visit(TypeidExpressionAST *ast);
+    bool visit(TypeidExpressionAST *ast) override;
-    virtual bool visit(TypenameCallExpressionAST *ast);
+    bool visit(TypenameCallExpressionAST *ast) override;
-    virtual bool visit(TypeConstructorCallAST *ast);
+    bool visit(TypeConstructorCallAST *ast) override;
-    virtual bool visit(SizeofExpressionAST *ast);
+    bool visit(SizeofExpressionAST *ast) override;
-    virtual bool visit(StaticAssertDeclarationAST *) { return true; }
+    bool visit(StaticAssertDeclarationAST *) override { return true; }
-    virtual bool visit(PointerLiteralAST *ast);
+    bool visit(PointerLiteralAST *ast) override;
-    virtual bool visit(NumericLiteralAST *ast);
+    bool visit(NumericLiteralAST *ast) override;
-    virtual bool visit(BoolLiteralAST *ast);
+    bool visit(BoolLiteralAST *ast) override;
-    virtual bool visit(ThisExpressionAST *ast);
+    bool visit(ThisExpressionAST *ast) override;
-    virtual bool visit(NestedExpressionAST *ast);
+    bool visit(NestedExpressionAST *ast) override;
-    virtual bool visit(StringLiteralAST *ast);
+    bool visit(StringLiteralAST *ast) override;
-    virtual bool visit(ThrowExpressionAST *ast);
+    bool visit(ThrowExpressionAST *ast) override;
-    virtual bool visit(TypeIdAST *ast);
+    bool visit(TypeIdAST *ast) override;
-    virtual bool visit(UnaryExpressionAST *ast);
+    bool visit(UnaryExpressionAST *ast) override;
-    virtual bool visit(ObjCMessageExpressionAST *ast);
+    bool visit(ObjCMessageExpressionAST *ast) override;
-    virtual bool visit(ObjCProtocolExpressionAST *ast);
+    bool visit(ObjCProtocolExpressionAST *ast) override;
-    virtual bool visit(ObjCEncodeExpressionAST *ast);
+    bool visit(ObjCEncodeExpressionAST *ast) override;
-    virtual bool visit(ObjCSelectorExpressionAST *ast);
+    bool visit(ObjCSelectorExpressionAST *ast) override;
-    virtual bool visit(LambdaExpressionAST *ast);
+    bool visit(LambdaExpressionAST *ast) override;
-    virtual bool visit(BracedInitializerAST *ast);
+    bool visit(BracedInitializerAST *ast) override;
-    virtual bool visit(ExpressionListParenAST *ast);
+    bool visit(ExpressionListParenAST *ast) override;
 
     // DeclarationAST
-    virtual bool visit(SimpleDeclarationAST *ast);
+    bool visit(SimpleDeclarationAST *ast) override;
-    virtual bool visit(EmptyDeclarationAST *ast);
+    bool visit(EmptyDeclarationAST *ast) override;
-    virtual bool visit(AccessDeclarationAST *ast);
+    bool visit(AccessDeclarationAST *ast) override;
-    virtual bool visit(QtObjectTagAST *ast);
+    bool visit(QtObjectTagAST *ast) override;
-    virtual bool visit(QtPrivateSlotAST *ast);
+    bool visit(QtPrivateSlotAST *ast) override;
-    virtual bool visit(QtPropertyDeclarationAST *ast);
+    bool visit(QtPropertyDeclarationAST *ast) override;
-    virtual bool visit(QtEnumDeclarationAST *ast);
+    bool visit(QtEnumDeclarationAST *ast) override;
-    virtual bool visit(QtFlagsDeclarationAST *ast);
+    bool visit(QtFlagsDeclarationAST *ast) override;
-    virtual bool visit(QtInterfacesDeclarationAST *ast);
+    bool visit(QtInterfacesDeclarationAST *ast) override;
-    virtual bool visit(AliasDeclarationAST *ast);
+    bool visit(AliasDeclarationAST *ast) override;
-    virtual bool visit(AsmDefinitionAST *ast);
+    bool visit(AsmDefinitionAST *ast) override;
-    virtual bool visit(ExceptionDeclarationAST *ast);
+    bool visit(ExceptionDeclarationAST *ast) override;
-    virtual bool visit(FunctionDefinitionAST *ast);
+    bool visit(FunctionDefinitionAST *ast) override;
-    virtual bool visit(LinkageBodyAST *ast);
+    bool visit(LinkageBodyAST *ast) override;
-    virtual bool visit(LinkageSpecificationAST *ast);
+    bool visit(LinkageSpecificationAST *ast) override;
-    virtual bool visit(NamespaceAST *ast);
+    bool visit(NamespaceAST *ast) override;
-    virtual bool visit(NamespaceAliasDefinitionAST *ast);
+    bool visit(NamespaceAliasDefinitionAST *ast) override;
-    virtual bool visit(ParameterDeclarationAST *ast);
+    bool visit(ParameterDeclarationAST *ast) override;
-    virtual bool visit(TemplateDeclarationAST *ast);
+    bool visit(TemplateDeclarationAST *ast) override;
-    virtual bool visit(TypenameTypeParameterAST *ast);
+    bool visit(TypenameTypeParameterAST *ast) override;
-    virtual bool visit(TemplateTypeParameterAST *ast);
+    bool visit(TemplateTypeParameterAST *ast) override;
-    virtual bool visit(UsingAST *ast);
+    bool visit(UsingAST *ast) override;
-    virtual bool visit(UsingDirectiveAST *ast);
+    bool visit(UsingDirectiveAST *ast) override;
-    virtual bool visit(ObjCClassForwardDeclarationAST *ast);
+    bool visit(ObjCClassForwardDeclarationAST *ast) override;
-    virtual bool visit(ObjCClassDeclarationAST *ast);
+    bool visit(ObjCClassDeclarationAST *ast) override;
-    virtual bool visit(ObjCProtocolForwardDeclarationAST *ast);
+    bool visit(ObjCProtocolForwardDeclarationAST *ast) override;
-    virtual bool visit(ObjCProtocolDeclarationAST *ast);
+    bool visit(ObjCProtocolDeclarationAST *ast) override;
-    virtual bool visit(ObjCVisibilityDeclarationAST *ast);
+    bool visit(ObjCVisibilityDeclarationAST *ast) override;
-    virtual bool visit(ObjCPropertyDeclarationAST *ast);
+    bool visit(ObjCPropertyDeclarationAST *ast) override;
-    virtual bool visit(ObjCMethodDeclarationAST *ast);
+    bool visit(ObjCMethodDeclarationAST *ast) override;
-    virtual bool visit(ObjCSynthesizedPropertiesDeclarationAST *ast);
+    bool visit(ObjCSynthesizedPropertiesDeclarationAST *ast) override;
-    virtual bool visit(ObjCDynamicPropertiesDeclarationAST *ast);
+    bool visit(ObjCDynamicPropertiesDeclarationAST *ast) override;
 
     // NameAST
-    virtual bool visit(ObjCSelectorAST *ast);
+    bool visit(ObjCSelectorAST *ast) override;
-    virtual bool visit(QualifiedNameAST *ast);
+    bool visit(QualifiedNameAST *ast) override;
-    virtual bool visit(OperatorFunctionIdAST *ast);
+    bool visit(OperatorFunctionIdAST *ast) override;
-    virtual bool visit(ConversionFunctionIdAST *ast);
+    bool visit(ConversionFunctionIdAST *ast) override;
-    virtual bool visit(AnonymousNameAST *ast);
+    bool visit(AnonymousNameAST *ast) override;
-    virtual bool visit(SimpleNameAST *ast);
+    bool visit(SimpleNameAST *ast) override;
-    virtual bool visit(DestructorNameAST *ast);
+    bool visit(DestructorNameAST *ast) override;
-    virtual bool visit(TemplateIdAST *ast);
+    bool visit(TemplateIdAST *ast) override;
 
     // SpecifierAST
-    virtual bool visit(SimpleSpecifierAST *ast);
+    bool visit(SimpleSpecifierAST *ast) override;
-    virtual bool visit(AlignmentSpecifierAST *ast);
+    bool visit(AlignmentSpecifierAST *ast) override;
-    virtual bool visit(GnuAttributeSpecifierAST *ast);
+    bool visit(GnuAttributeSpecifierAST *ast) override;
-    virtual bool visit(MsvcDeclspecSpecifierAST *ast);
+    bool visit(MsvcDeclspecSpecifierAST *ast) override;
-    virtual bool visit(StdAttributeSpecifierAST *ast);
+    bool visit(StdAttributeSpecifierAST *ast) override;
-    virtual bool visit(TypeofSpecifierAST *ast);
+    bool visit(TypeofSpecifierAST *ast) override;
-    virtual bool visit(DecltypeSpecifierAST *ast);
+    bool visit(DecltypeSpecifierAST *ast) override;
-    virtual bool visit(ClassSpecifierAST *ast);
+    bool visit(ClassSpecifierAST *ast) override;
-    virtual bool visit(NamedTypeSpecifierAST *ast);
+    bool visit(NamedTypeSpecifierAST *ast) override;
-    virtual bool visit(ElaboratedTypeSpecifierAST *ast);
+    bool visit(ElaboratedTypeSpecifierAST *ast) override;
-    virtual bool visit(EnumSpecifierAST *ast);
+    bool visit(EnumSpecifierAST *ast) override;
 
     // PtrOperatorAST
-    virtual bool visit(PointerToMemberAST *ast);
+    bool visit(PointerToMemberAST *ast) override;
-    virtual bool visit(PointerAST *ast);
+    bool visit(PointerAST *ast) override;
-    virtual bool visit(ReferenceAST *ast);
+    bool visit(ReferenceAST *ast) override;
 
     // PostfixAST
-    virtual bool visit(CallAST *ast);
+    bool visit(CallAST *ast) override;
-    virtual bool visit(ArrayAccessAST *ast);
+    bool visit(ArrayAccessAST *ast) override;
-    virtual bool visit(PostIncrDecrAST *ast);
+    bool visit(PostIncrDecrAST *ast) override;
-    virtual bool visit(MemberAccessAST *ast);
+    bool visit(MemberAccessAST *ast) override;
 
     // CoreDeclaratorAST
-    virtual bool visit(DeclaratorIdAST *ast);
+    bool visit(DeclaratorIdAST *ast) override;
-    virtual bool visit(NestedDeclaratorAST *ast);
+    bool visit(NestedDeclaratorAST *ast) override;
 
     // PostfixDeclaratorAST
-    virtual bool visit(FunctionDeclaratorAST *ast);
+    bool visit(FunctionDeclaratorAST *ast) override;
-    virtual bool visit(ArrayDeclaratorAST *ast);
+    bool visit(ArrayDeclaratorAST *ast) override;
 
 private:
     static const int kMaxDepth;

src/libs/3rdparty/cplusplus/CoreTypes.h

@@ -35,29 +35,29 @@ public:
         return &t;
     }
 
-    virtual const UndefinedType *asUndefinedType() const
+    const UndefinedType *asUndefinedType() const override
     { return this; }
 
-    virtual UndefinedType *asUndefinedType()
+    UndefinedType *asUndefinedType() override
     { return this; }
 
 protected:
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 };
 
 class CPLUSPLUS_EXPORT VoidType: public Type
 {
 public:
-    virtual const VoidType *asVoidType() const
+    const VoidType *asVoidType() const override
     { return this; }
 
-    virtual VoidType *asVoidType()
+    VoidType *asVoidType() override
     { return this; }
 
 protected:
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 };
 
 class CPLUSPLUS_EXPORT IntegerType: public Type
@@ -81,15 +81,15 @@ public:
 
     int kind() const;
 
-    virtual IntegerType *asIntegerType()
+    IntegerType *asIntegerType() override
     { return this; }
 
-    virtual const IntegerType *asIntegerType() const
+    const IntegerType *asIntegerType() const override
     { return this; }
 
 protected:
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     int _kind;
@@ -110,15 +110,15 @@ public:
 
     int kind() const;
 
-    virtual const FloatType *asFloatType() const
+    const FloatType *asFloatType() const override
     { return this; }
 
-    virtual FloatType *asFloatType()
+    FloatType *asFloatType() override
     { return this; }
 
 protected:
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     int _kind;
@@ -132,15 +132,15 @@ public:
 
     FullySpecifiedType elementType() const;
 
-    virtual const PointerType *asPointerType() const
+    const PointerType *asPointerType() const override
     { return this; }
 
-    virtual PointerType *asPointerType()
+    PointerType *asPointerType() override
     { return this; }
 
 protected:
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     FullySpecifiedType _elementType;
@@ -155,15 +155,15 @@ public:
     const Name *memberName() const;
     FullySpecifiedType elementType() const;
 
-    virtual const PointerToMemberType *asPointerToMemberType() const
+    const PointerToMemberType *asPointerToMemberType() const override
     { return this; }
 
-    virtual PointerToMemberType *asPointerToMemberType()
+    PointerToMemberType *asPointerToMemberType() override
     { return this; }
 
 protected:
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     const Name *_memberName;
@@ -179,15 +179,15 @@ public:
     FullySpecifiedType elementType() const;
     bool isRvalueReference() const;
 
-    virtual const ReferenceType *asReferenceType() const
+    const ReferenceType *asReferenceType() const override
     { return this; }
 
-    virtual ReferenceType *asReferenceType()
+    ReferenceType *asReferenceType() override
     { return this; }
 
 protected:
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     FullySpecifiedType _elementType;
@@ -203,15 +203,15 @@ public:
     FullySpecifiedType elementType() const;
     unsigned size() const;
 
-    virtual const ArrayType *asArrayType() const
+    const ArrayType *asArrayType() const override
     { return this; }
 
-    virtual ArrayType *asArrayType()
+    ArrayType *asArrayType() override
     { return this; }
 
 protected:
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     FullySpecifiedType _elementType;
@@ -226,15 +226,15 @@ public:
 
     const Name *name() const;
 
-    virtual const NamedType *asNamedType() const
+    const NamedType *asNamedType() const override
     { return this; }
 
-    virtual NamedType *asNamedType()
+    NamedType *asNamedType() override
     { return this; }
 
 protected:
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     const Name *_name;

src/libs/3rdparty/cplusplus/Literals.h

@@ -112,14 +112,14 @@ public:
         : Literal(chars, size)
     { }
 
-    virtual const Identifier *identifier() const { return this; }
+    const Identifier *identifier() const override { return this; }
 
-    virtual const Identifier *asNameId() const
+    const Identifier *asNameId() const override
     { return this; }
 
 protected:
-    virtual void accept0(NameVisitor *visitor) const;
+    void accept0(NameVisitor *visitor) const override;
-    virtual bool match0(const Name *otherName, Matcher *matcher) const;
+    bool match0(const Name *otherName, Matcher *matcher) const override;
 };
 
 } // namespace CPlusPlus

src/libs/3rdparty/cplusplus/Names.h

@@ -35,17 +35,17 @@ public:
 
     virtual ~QualifiedNameId();
 
-    virtual const Identifier *identifier() const;
+    const Identifier *identifier() const override;
 
     const Name *base() const;
     const Name *name() const;
 
-    virtual const QualifiedNameId *asQualifiedNameId() const
+    const QualifiedNameId *asQualifiedNameId() const override
     { return this; }
 
 protected:
-    virtual void accept0(NameVisitor *visitor) const;
+    void accept0(NameVisitor *visitor) const override;
-    virtual bool match0(const Name *otherName, Matcher *matcher) const;
+    bool match0(const Name *otherName, Matcher *matcher) const override;
 
 private:
     const Name *_base;
@@ -58,16 +58,16 @@ public:
     DestructorNameId(const Name *name);
     virtual ~DestructorNameId();
 
-    virtual const Name *name() const;
+    const Name *name() const;
 
-    virtual const Identifier *identifier() const;
+    const Identifier *identifier() const override;
 
-    virtual const DestructorNameId *asDestructorNameId() const
+    const DestructorNameId *asDestructorNameId() const override
     { return this; }
 
 protected:
-    virtual void accept0(NameVisitor *visitor) const;
+    void accept0(NameVisitor *visitor) const override;
-    virtual bool match0(const Name *otherName, Matcher *matcher) const;
+    bool match0(const Name *otherName, Matcher *matcher) const override;
 
 private:
     const Name *_name;
@@ -130,13 +130,13 @@ public:
 
     virtual ~TemplateNameId();
 
-    virtual const Identifier *identifier() const;
+    const Identifier *identifier() const override;
 
     // ### find a better name
     int templateArgumentCount() const;
     const TemplateArgument &templateArgumentAt(int index) const;
 
-    virtual const TemplateNameId *asTemplateNameId() const
+    const TemplateNameId *asTemplateNameId() const override
     { return this; }
 
     typedef std::vector<TemplateArgument>::const_iterator TemplateArgumentIterator;
@@ -151,8 +151,8 @@ public:
     };
 
 protected:
-    virtual void accept0(NameVisitor *visitor) const;
+    void accept0(NameVisitor *visitor) const override;
-    virtual bool match0(const Name *otherName, Matcher *matcher) const;
+    bool match0(const Name *otherName, Matcher *matcher) const override;
 
 private:
     const Identifier *_identifier;
@@ -224,14 +224,14 @@ public:
 
     Kind kind() const;
 
-    virtual const Identifier *identifier() const;
+    const Identifier *identifier() const override;
 
-    virtual const OperatorNameId *asOperatorNameId() const
+    const OperatorNameId *asOperatorNameId() const override
     { return this; }
 
 protected:
-    virtual void accept0(NameVisitor *visitor) const;
+    void accept0(NameVisitor *visitor) const override;
-    virtual bool match0(const Name *otherName, Matcher *matcher) const;
+    bool match0(const Name *otherName, Matcher *matcher) const override;
 
 private:
     Kind _kind;
@@ -245,14 +245,14 @@ public:
 
     FullySpecifiedType type() const;
 
-    virtual const Identifier *identifier() const;
+    const Identifier *identifier() const override;
 
-    virtual const ConversionNameId *asConversionNameId() const
+    const ConversionNameId *asConversionNameId() const override
     { return this; }
 
 protected:
-    virtual void accept0(NameVisitor *visitor) const;
+    void accept0(NameVisitor *visitor) const override;
-    virtual bool match0(const Name *otherName, Matcher *matcher) const;
+    bool match0(const Name *otherName, Matcher *matcher) const override;
 
 private:
     FullySpecifiedType _type;
@@ -267,13 +267,13 @@ public:
 
     virtual ~SelectorNameId();
 
-    virtual const Identifier *identifier() const;
+    const Identifier *identifier() const override;
 
     int nameCount() const;
     const Name *nameAt(int index) const;
     bool hasArguments() const;
 
-    virtual const SelectorNameId *asSelectorNameId() const
+    const SelectorNameId *asSelectorNameId() const override
     { return this; }
 
     typedef std::vector<const Name *>::const_iterator NameIterator;
@@ -282,8 +282,8 @@ public:
     NameIterator lastName() const { return _names.end(); }
 
 protected:
-    virtual void accept0(NameVisitor *visitor) const;
+    void accept0(NameVisitor *visitor) const override;
-    virtual bool match0(const Name *otherName, Matcher *matcher) const;
+    bool match0(const Name *otherName, Matcher *matcher) const override;
 
 private:
     std::vector<const Name *> _names;
@@ -298,14 +298,14 @@ public:
 
     int classTokenIndex() const;
 
-    virtual const Identifier *identifier() const;
+    const Identifier *identifier() const override;
 
-    virtual const AnonymousNameId *asAnonymousNameId() const
+    const AnonymousNameId *asAnonymousNameId() const override
     { return this; }
 
 protected:
-    virtual void accept0(NameVisitor *visitor) const;
+    void accept0(NameVisitor *visitor) const override;
-    virtual bool match0(const Name *otherName, Matcher *matcher) const;
+    bool match0(const Name *otherName, Matcher *matcher) const override;
 
 private:
     int _classTokenIndex;

src/libs/3rdparty/cplusplus/SafeMatcher.h

@@ -37,17 +37,17 @@ public:
     SafeMatcher();
     ~SafeMatcher();
 
-    bool match(const PointerToMemberType *type, const PointerToMemberType *otherType);
+    bool match(const PointerToMemberType *type, const PointerToMemberType *otherType) override;
-    bool match(const PointerType *type, const PointerType *otherType);
+    bool match(const PointerType *type, const PointerType *otherType) override;
-    bool match(const ReferenceType *type, const ReferenceType *otherType);
+    bool match(const ReferenceType *type, const ReferenceType *otherType) override;
-    bool match(const ArrayType *type, const ArrayType *otherType);
+    bool match(const ArrayType *type, const ArrayType *otherType) override;
-    bool match(const NamedType *type, const NamedType *otherType);
+    bool match(const NamedType *type, const NamedType *otherType) override;
 
-    bool match(const TemplateNameId *name, const TemplateNameId *otherName);
+    bool match(const TemplateNameId *name, const TemplateNameId *otherName) override;
-    bool match(const DestructorNameId *name, const DestructorNameId *otherName);
+    bool match(const DestructorNameId *name, const DestructorNameId *otherName) override;
-    bool match(const ConversionNameId *name, const ConversionNameId *otherName);
+    bool match(const ConversionNameId *name, const ConversionNameId *otherName) override;
-    bool match(const QualifiedNameId *name, const QualifiedNameId *otherName);
+    bool match(const QualifiedNameId *name, const QualifiedNameId *otherName) override;
-    bool match(const SelectorNameId *name, const SelectorNameId *otherName);
+    bool match(const SelectorNameId *name, const SelectorNameId *otherName) override;
 
 private:
     std::vector<const Type *> _blockedTypes;

src/libs/3rdparty/cplusplus/Scope.h

@@ -65,10 +65,10 @@ public:
     int endOffset() const;
     void setEndOffset(int offset);
 
-    virtual const Scope *asScope() const
+    const Scope *asScope() const override
     { return this; }
 
-    virtual Scope *asScope()
+    Scope *asScope() override
     { return this; }
 
 private:

src/libs/3rdparty/cplusplus/Symbols.h

@@ -39,16 +39,16 @@ public:
     virtual ~UsingNamespaceDirective();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const UsingNamespaceDirective *asUsingNamespaceDirective() const
+    const UsingNamespaceDirective *asUsingNamespaceDirective() const override
     { return this; }
 
-    virtual UsingNamespaceDirective *asUsingNamespaceDirective()
+    UsingNamespaceDirective *asUsingNamespaceDirective() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
 class CPLUSPLUS_EXPORT UsingDeclaration: public Symbol
@@ -59,16 +59,16 @@ public:
     virtual ~UsingDeclaration();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const UsingDeclaration *asUsingDeclaration() const
+    const UsingDeclaration *asUsingDeclaration() const override
     { return this; }
 
-    virtual UsingDeclaration *asUsingDeclaration()
+    UsingDeclaration *asUsingDeclaration() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
 class CPLUSPLUS_EXPORT NamespaceAlias: public Symbol
@@ -82,16 +82,16 @@ public:
     void setNamespaceName(const Name *namespaceName);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const NamespaceAlias *asNamespaceAlias() const
+    const NamespaceAlias *asNamespaceAlias() const override
     { return this; }
 
-    virtual NamespaceAlias *asNamespaceAlias()
+    NamespaceAlias *asNamespaceAlias() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 
 private:
     const Name *_namespaceName;
@@ -108,13 +108,13 @@ public:
     void setInitializer(StringLiteral const* initializer);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
     const StringLiteral *getInitializer() const;
 
-    virtual const Declaration *asDeclaration() const
+    const Declaration *asDeclaration() const override
     { return this; }
 
-    virtual Declaration *asDeclaration()
+    Declaration *asDeclaration() override
     { return this; }
 
     virtual EnumeratorDeclaration *asEnumeratorDeclarator()
@@ -124,7 +124,7 @@ public:
     { return nullptr; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 
 private:
     FullySpecifiedType _type;
@@ -140,10 +140,10 @@ public:
     const StringLiteral *constantValue() const;
     void setConstantValue(const StringLiteral *constantValue);
 
-    virtual EnumeratorDeclaration *asEnumeratorDeclarator()
+    EnumeratorDeclaration *asEnumeratorDeclarator() override
     { return this; }
 
-    virtual const EnumeratorDeclaration *asEnumeratorDeclarator() const
+    const EnumeratorDeclaration *asEnumeratorDeclarator() const override
     { return this; }
 
 private:
@@ -165,16 +165,16 @@ public:
     void setInitializer(const StringLiteral *initializer);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const Argument *asArgument() const
+    const Argument *asArgument() const override
     { return this; }
 
-    virtual Argument *asArgument()
+    Argument *asArgument() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 
 private:
     const StringLiteral *_initializer;
@@ -193,16 +193,16 @@ public:
     bool isClassDeclarator() const { return _isClassDeclarator; }
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const TypenameArgument *asTypenameArgument() const
+    const TypenameArgument *asTypenameArgument() const override
     { return this; }
 
-    virtual TypenameArgument *asTypenameArgument()
+    TypenameArgument *asTypenameArgument() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 
 private:
     FullySpecifiedType _type;
@@ -217,16 +217,16 @@ public:
     virtual ~Block();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const Block *asBlock() const
+    const Block *asBlock() const override
     { return this; }
 
-    virtual Block *asBlock()
+    Block *asBlock() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
 class CPLUSPLUS_EXPORT ForwardClassDeclaration: public Symbol, public Type
@@ -237,25 +237,25 @@ public:
     virtual ~ForwardClassDeclaration();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const ForwardClassDeclaration *asForwardClassDeclaration() const
+    const ForwardClassDeclaration *asForwardClassDeclaration() const override
     { return this; }
 
-    virtual ForwardClassDeclaration *asForwardClassDeclaration()
+    ForwardClassDeclaration *asForwardClassDeclaration() override
     { return this; }
 
     // Type's interface
-    virtual const ForwardClassDeclaration *asForwardClassDeclarationType() const
+    const ForwardClassDeclaration *asForwardClassDeclarationType() const override
     { return this; }
 
-    virtual ForwardClassDeclaration *asForwardClassDeclarationType()
+    ForwardClassDeclaration *asForwardClassDeclarationType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 };
 
 class CPLUSPLUS_EXPORT Enum: public Scope, public Type
@@ -269,25 +269,25 @@ public:
     void setScoped(bool scoped);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const Enum *asEnum() const
+    const Enum *asEnum() const override
     { return this; }
 
-    virtual Enum *asEnum()
+    Enum *asEnum() override
     { return this; }
 
     // Type's interface
-    virtual const Enum *asEnumType() const
+    const Enum *asEnumType() const override
     { return this; }
 
-    virtual Enum *asEnumType()
+    Enum *asEnumType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     bool _isScoped;
@@ -375,25 +375,25 @@ public:
     void setExceptionSpecification(const StringLiteral *spec);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const Function *asFunction() const
+    const Function *asFunction() const override
     { return this; }
 
-    virtual Function *asFunction()
+    Function *asFunction() override
     { return this; }
 
     // Type's interface
-    virtual const Function *asFunctionType() const
+    const Function *asFunctionType() const override
     { return this; }
 
-    virtual Function *asFunctionType()
+    Function *asFunctionType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     FullySpecifiedType _returnType;
@@ -430,25 +430,25 @@ public:
     Symbol *declaration() const;
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const Template *asTemplate() const
+    const Template *asTemplate() const override
     { return this; }
 
-    virtual Template *asTemplate()
+    Template *asTemplate() override
     { return this; }
 
     // Type's interface
-    virtual const Template *asTemplateType() const
+    const Template *asTemplateType() const override
     { return this; }
 
-    virtual Template *asTemplateType()
+    Template *asTemplateType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 };
 
 
@@ -460,19 +460,19 @@ public:
     virtual ~Namespace();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const Namespace *asNamespace() const
+    const Namespace *asNamespace() const override
     { return this; }
 
-    virtual Namespace *asNamespace()
+    Namespace *asNamespace() override
     { return this; }
 
     // Type's interface
-    virtual const Namespace *asNamespaceType() const
+    const Namespace *asNamespaceType() const override
     { return this; }
 
-    virtual Namespace *asNamespaceType()
+    Namespace *asNamespaceType() override
     { return this; }
 
     bool isInline() const
@@ -482,9 +482,9 @@ public:
     { _isInline = onoff; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     bool _isInline;
@@ -504,17 +504,17 @@ public:
     void setVariadic(bool isVariadic);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
     void setType(const FullySpecifiedType &type);
 
-    virtual const BaseClass *asBaseClass() const
+    const BaseClass *asBaseClass() const override
     { return this; }
 
-    virtual BaseClass *asBaseClass()
+    BaseClass *asBaseClass() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 
 private:
     bool _isVariadic = false;
@@ -546,25 +546,25 @@ public:
     void addBaseClass(BaseClass *baseClass);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const Class *asClass() const
+    const Class *asClass() const override
     { return this; }
 
-    virtual Class *asClass()
+    Class *asClass() override
     { return this; }
 
     // Type's interface
-    virtual const Class *asClassType() const
+    const Class *asClassType() const override
     { return this; }
 
-    virtual Class *asClassType()
+    Class *asClassType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     Key _key;
@@ -604,16 +604,16 @@ public:
     int flags() const;
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const QtPropertyDeclaration *asQtPropertyDeclaration() const
+    const QtPropertyDeclaration *asQtPropertyDeclaration() const override
     { return this; }
 
-    virtual QtPropertyDeclaration *asQtPropertyDeclaration()
+    QtPropertyDeclaration *asQtPropertyDeclaration() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 
 private:
     FullySpecifiedType _type;
@@ -628,16 +628,16 @@ public:
     virtual ~QtEnum();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const QtEnum *asQtEnum() const
+    const QtEnum *asQtEnum() const override
     { return this; }
 
-    virtual QtEnum *asQtEnum()
+    QtEnum *asQtEnum() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
 class CPLUSPLUS_EXPORT ObjCBaseClass: public Symbol
@@ -648,16 +648,16 @@ public:
     virtual ~ObjCBaseClass();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const ObjCBaseClass *asObjCBaseClass() const
+    const ObjCBaseClass *asObjCBaseClass() const override
     { return this; }
 
-    virtual ObjCBaseClass *asObjCBaseClass()
+    ObjCBaseClass *asObjCBaseClass() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
 class CPLUSPLUS_EXPORT ObjCBaseProtocol: public Symbol
@@ -668,16 +668,16 @@ public:
     virtual ~ObjCBaseProtocol();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const ObjCBaseProtocol *asObjCBaseProtocol() const
+    const ObjCBaseProtocol *asObjCBaseProtocol() const override
     { return this; }
 
-    virtual ObjCBaseProtocol *asObjCBaseProtocol()
+    ObjCBaseProtocol *asObjCBaseProtocol() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
 class CPLUSPLUS_EXPORT ObjCForwardProtocolDeclaration: public Symbol, public Type
@@ -688,25 +688,25 @@ public:
     virtual ~ObjCForwardProtocolDeclaration();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclaration() const
+    const ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclaration() const override
     { return this; }
 
-    virtual ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclaration()
+    ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclaration() override
     { return this; }
 
     // Type's interface
-    virtual const ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclarationType() const
+    const ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclarationType() const override
     { return this; }
 
-    virtual ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclarationType()
+    ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclarationType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 };
 
 class CPLUSPLUS_EXPORT ObjCProtocol: public Scope, public Type
@@ -721,25 +721,25 @@ public:
     void addProtocol(ObjCBaseProtocol *protocol);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const ObjCProtocol *asObjCProtocol() const
+    const ObjCProtocol *asObjCProtocol() const override
     { return this; }
 
-    virtual ObjCProtocol *asObjCProtocol()
+    ObjCProtocol *asObjCProtocol() override
     { return this; }
 
     // Type's interface
-    virtual const ObjCProtocol *asObjCProtocolType() const
+    const ObjCProtocol *asObjCProtocolType() const override
     { return this; }
 
-    virtual ObjCProtocol *asObjCProtocolType()
+    ObjCProtocol *asObjCProtocolType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     std::vector<ObjCBaseProtocol *> _protocols;
@@ -753,25 +753,25 @@ public:
     virtual ~ObjCForwardClassDeclaration();
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const ObjCForwardClassDeclaration *asObjCForwardClassDeclaration() const
+    const ObjCForwardClassDeclaration *asObjCForwardClassDeclaration() const override
     { return this; }
 
-    virtual ObjCForwardClassDeclaration *asObjCForwardClassDeclaration()
+    ObjCForwardClassDeclaration *asObjCForwardClassDeclaration() override
     { return this; }
 
     // Type's interface
-    virtual const ObjCForwardClassDeclaration *asObjCForwardClassDeclarationType() const
+    const ObjCForwardClassDeclaration *asObjCForwardClassDeclarationType() const override
     { return this; }
 
-    virtual ObjCForwardClassDeclaration *asObjCForwardClassDeclarationType()
+    ObjCForwardClassDeclaration *asObjCForwardClassDeclarationType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 };
 
 class CPLUSPLUS_EXPORT ObjCClass: public Scope, public Type
@@ -796,25 +796,25 @@ public:
     void addProtocol(ObjCBaseProtocol *protocol);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const ObjCClass *asObjCClass() const
+    const ObjCClass *asObjCClass() const override
     { return this; }
 
-    virtual ObjCClass *asObjCClass()
+    ObjCClass *asObjCClass() override
     { return this; }
 
     // Type's interface
-    virtual const ObjCClass *asObjCClassType() const
+    const ObjCClass *asObjCClassType() const override
     { return this; }
 
-    virtual ObjCClass *asObjCClassType()
+    ObjCClass *asObjCClassType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     const Name *_categoryName;
@@ -846,25 +846,25 @@ public:
     void setVariadic(bool isVariadic);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const ObjCMethod *asObjCMethod() const
+    const ObjCMethod *asObjCMethod() const override
     { return this; }
 
-    virtual ObjCMethod *asObjCMethod()
+    ObjCMethod *asObjCMethod() override
     { return this; }
 
     // Type's interface
-    virtual const ObjCMethod *asObjCMethodType() const
+    const ObjCMethod *asObjCMethodType() const override
     { return this; }
 
-    virtual ObjCMethod *asObjCMethodType()
+    ObjCMethod *asObjCMethodType() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
-    virtual void accept0(TypeVisitor *visitor);
+    void accept0(TypeVisitor *visitor) override;
-    virtual bool match0(const Type *otherType, Matcher *matcher) const;
+    bool match0(const Type *otherType, Matcher *matcher) const override;
 
 private:
     FullySpecifiedType _returnType;
@@ -918,16 +918,16 @@ public:
     void setType(const FullySpecifiedType &type);
 
     // Symbol's interface
-    virtual FullySpecifiedType type() const;
+    FullySpecifiedType type() const override;
 
-    virtual const ObjCPropertyDeclaration *asObjCPropertyDeclaration() const
+    const ObjCPropertyDeclaration *asObjCPropertyDeclaration() const override
     { return this; }
 
-    virtual ObjCPropertyDeclaration *asObjCPropertyDeclaration()
+    ObjCPropertyDeclaration *asObjCPropertyDeclaration() override
     { return this; }
 
 protected:
-    virtual void visitSymbol0(SymbolVisitor *visitor);
+    void visitSymbol0(SymbolVisitor *visitor) override;
 
 private:
     const Name *_getterName;

src/libs/3rdparty/cplusplus/Templates.h

@@ -72,26 +72,26 @@ public:
     FullySpecifiedType cloneType(const FullySpecifiedType &type, Subst *subst);
 
 protected:
-    virtual void visit(UndefinedType *type);
+    void visit(UndefinedType *type) override;
-    virtual void visit(VoidType *type);
+    void visit(VoidType *type) override;
-    virtual void visit(IntegerType *type);
+    void visit(IntegerType *type) override;
-    virtual void visit(FloatType *type);
+    void visit(FloatType *type) override;
-    virtual void visit(PointerToMemberType *type);
+    void visit(PointerToMemberType *type) override;
-    virtual void visit(PointerType *type);
+    void visit(PointerType *type) override;
-    virtual void visit(ReferenceType *type);
+    void visit(ReferenceType *type) override;
-    virtual void visit(ArrayType *type);
+    void visit(ArrayType *type) override;
-    virtual void visit(NamedType *type);
+    void visit(NamedType *type) override;
-    virtual void visit(Function *type);
+    void visit(Function *type) override;
-    virtual void visit(Namespace *type);
+    void visit(Namespace *type) override;
-    virtual void visit(Template *type);
+    void visit(Template *type) override;
-    virtual void visit(Class *type);
+    void visit(Class *type) override;
-    virtual void visit(Enum *type);
+    void visit(Enum *type) override;
-    virtual void visit(ForwardClassDeclaration *type);
+    void visit(ForwardClassDeclaration *type) override;
-    virtual void visit(ObjCClass *type);
+    void visit(ObjCClass *type) override;
-    virtual void visit(ObjCProtocol *type);
+    void visit(ObjCProtocol *type) override;
-    virtual void visit(ObjCMethod *type);
+    void visit(ObjCMethod *type) override;
-    virtual void visit(ObjCForwardClassDeclaration *type);
+    void visit(ObjCForwardClassDeclaration *type) override;
-    virtual void visit(ObjCForwardProtocolDeclaration *type);
+    void visit(ObjCForwardProtocolDeclaration *type) override;
 
 protected:
     typedef std::pair <const FullySpecifiedType, Subst *> TypeSubstPair;
@@ -112,14 +112,14 @@ public:
     const Name *cloneName(const Name *name, Subst *subst);
 
 protected:
-    virtual void visit(const Identifier *name);
+    void visit(const Identifier *name) override;
-    virtual void visit(const AnonymousNameId *name);
+    void visit(const AnonymousNameId *name) override;
-    virtual void visit(const TemplateNameId *name);
+    void visit(const TemplateNameId *name) override;
-    virtual void visit(const DestructorNameId *name);
+    void visit(const DestructorNameId *name) override;
-    virtual void visit(const OperatorNameId *name);
+    void visit(const OperatorNameId *name) override;
-    virtual void visit(const ConversionNameId *name);
+    void visit(const ConversionNameId *name) override;
-    virtual void visit(const QualifiedNameId *name);
+    void visit(const QualifiedNameId *name) override;
-    virtual void visit(const SelectorNameId *name);
+    void visit(const SelectorNameId *name) override;
 
 protected:
     typedef std::pair <const Name *, Subst *> NameSubstPair;
@@ -140,34 +140,34 @@ public:
     Symbol *cloneSymbol(Symbol *symbol, Subst *subst);
 
 protected:
-    virtual bool visit(UsingNamespaceDirective *symbol);
+    bool visit(UsingNamespaceDirective *symbol) override;
-    virtual bool visit(UsingDeclaration *symbol);
+    bool visit(UsingDeclaration *symbol) override;
-    virtual bool visit(NamespaceAlias *symbol);
+    bool visit(NamespaceAlias *symbol) override;
-    virtual bool visit(Declaration *symbol);
+    bool visit(Declaration *symbol) override;
-    virtual bool visit(Argument *symbol);
+    bool visit(Argument *symbol) override;
-    virtual bool visit(TypenameArgument *symbol);
+    bool visit(TypenameArgument *symbol) override;
-    virtual bool visit(BaseClass *symbol);
+    bool visit(BaseClass *symbol) override;
-    virtual bool visit(Enum *symbol);
+    bool visit(Enum *symbol) override;
-    virtual bool visit(Function *symbol);
+    bool visit(Function *symbol) override;
-    virtual bool visit(Namespace *symbol);
+    bool visit(Namespace *symbol) override;
-    virtual bool visit(Template *symbol);
+    bool visit(Template *symbol) override;
-    virtual bool visit(Class *symbol);
+    bool visit(Class *symbol) override;
-    virtual bool visit(Block *symbol);
+    bool visit(Block *symbol) override;
-    virtual bool visit(ForwardClassDeclaration *symbol);
+    bool visit(ForwardClassDeclaration *symbol) override;
 
     // Qt
-    virtual bool visit(QtPropertyDeclaration *symbol);
+    bool visit(QtPropertyDeclaration *symbol) override;
-    virtual bool visit(QtEnum *symbol);
+    bool visit(QtEnum *symbol) override;
 
     // Objective-C
-    virtual bool visit(ObjCBaseClass *symbol);
+    bool visit(ObjCBaseClass *symbol) override;
-    virtual bool visit(ObjCBaseProtocol *symbol);
+    bool visit(ObjCBaseProtocol *symbol) override;
-    virtual bool visit(ObjCClass *symbol);
+    bool visit(ObjCClass *symbol) override;
-    virtual bool visit(ObjCForwardClassDeclaration *symbol);
+    bool visit(ObjCForwardClassDeclaration *symbol) override;
-    virtual bool visit(ObjCProtocol *symbol);
+    bool visit(ObjCProtocol *symbol) override;
-    virtual bool visit(ObjCForwardProtocolDeclaration *symbol);
+    bool visit(ObjCForwardProtocolDeclaration *symbol) override;
-    virtual bool visit(ObjCMethod *symbol);
+    bool visit(ObjCMethod *symbol) override;
-    virtual bool visit(ObjCPropertyDeclaration *symbol);
+    bool visit(ObjCPropertyDeclaration *symbol) override;
 
 protected:
     typedef std::pair <Symbol *, Subst *> SymbolSubstPair;

src/libs/cplusplus/LookupContext.h

@@ -243,27 +243,27 @@ protected:
     /// Creates bindings for the symbols reachable from the \a root symbol.
     void process(Symbol *root);
 
-    virtual bool visit(Template *templ);
+    bool visit(Template *templ) override;
-    virtual bool visit(Namespace *ns);
+    bool visit(Namespace *ns) override;
-    virtual bool visit(Class *klass);
+    bool visit(Class *klass) override;
-    virtual bool visit(ForwardClassDeclaration *klass);
+    bool visit(ForwardClassDeclaration *klass) override;
-    virtual bool visit(Enum *e);
+    bool visit(Enum *e) override;
-    virtual bool visit(Declaration *decl);
+    bool visit(Declaration *decl) override;
-    virtual bool visit(Function *function);
+    bool visit(Function *function) override;
-    virtual bool visit(Block *block);
+    bool visit(Block *block) override;
 
-    virtual bool visit(BaseClass *b);
+    bool visit(BaseClass *b) override;
-    virtual bool visit(UsingNamespaceDirective *u);
+    bool visit(UsingNamespaceDirective *u) override;
-    virtual bool visit(UsingDeclaration *u);
+    bool visit(UsingDeclaration *u) override;
-    virtual bool visit(NamespaceAlias *a);
+    bool visit(NamespaceAlias *a) override;
 
-    virtual bool visit(ObjCClass *klass);
+    bool visit(ObjCClass *klass) override;
-    virtual bool visit(ObjCBaseClass *b);
+    bool visit(ObjCBaseClass *b) override;
-    virtual bool visit(ObjCForwardClassDeclaration *klass);
+    bool visit(ObjCForwardClassDeclaration *klass) override;
-    virtual bool visit(ObjCProtocol *proto);
+    bool visit(ObjCProtocol *proto) override;
-    virtual bool visit(ObjCBaseProtocol *b);
+    bool visit(ObjCBaseProtocol *b) override;
-    virtual bool visit(ObjCForwardProtocolDeclaration *proto);
+    bool visit(ObjCForwardProtocolDeclaration *proto) override;
-    virtual bool visit(ObjCMethod *);
+    bool visit(ObjCMethod *) override;
 
 private:
     Symbol *instantiateTemplateFunction(const Name *instantiationName,