Use override in all the places where it is possible

src/compiler/preprocessor/DirectiveParser.cpp

@@ -154,7 +154,7 @@ class DefinedParser : public Lexer
     }
 
   protected:
-    virtual void lex(Token *token)
+    void lex(Token *token) override
     {
         const char kDefined[] = "defined";
 

src/compiler/preprocessor/DirectiveParser.h

@@ -27,7 +27,7 @@ class DirectiveParser : public Lexer
                     Diagnostics *diagnostics,
                     DirectiveHandler *directiveHandler);
 
-    virtual void lex(Token *token);
+    void lex(Token *token) override;
 
   private:
     PP_DISALLOW_COPY_AND_ASSIGN(DirectiveParser);

src/compiler/preprocessor/MacroExpander.cpp

@@ -26,7 +26,7 @@ class TokenLexer : public Lexer
         mIter = mTokens.begin();
     }
 
-    virtual void lex(Token *token)
+    void lex(Token *token) override
     {
         if (mIter == mTokens.end())
         {

src/compiler/preprocessor/MacroExpander.h

@@ -24,9 +24,9 @@ class MacroExpander : public Lexer
 {
   public:
     MacroExpander(Lexer *lexer, MacroSet *macroSet, Diagnostics *diagnostics);
-    virtual ~MacroExpander();
+    ~MacroExpander() override;
 
-    virtual void lex(Token *token);
+    void lex(Token *token) override;
 
   private:
     PP_DISALLOW_COPY_AND_ASSIGN(MacroExpander);

src/compiler/preprocessor/Tokenizer.h

@@ -42,7 +42,7 @@ class Tokenizer : public Lexer
     void setLineNumber(int line);
     void setMaxTokenSize(size_t maxTokenSize);
 
-    virtual void lex(Token *token);
+    void lex(Token *token) override;
 
   private:
     PP_DISALLOW_COPY_AND_ASSIGN(Tokenizer);

src/compiler/translator/BuiltInFunctionEmulator.cpp

@@ -17,7 +17,7 @@ class BuiltInFunctionEmulator::BuiltInFunctionEmulationMarker : public TIntermTr
     {
     }
 
-    virtual bool visitUnary(Visit visit, TIntermUnary *node)
+    bool visitUnary(Visit visit, TIntermUnary *node) override
     {
         if (visit == PreVisit)
         {
@@ -28,7 +28,7 @@ class BuiltInFunctionEmulator::BuiltInFunctionEmulationMarker : public TIntermTr
         return true;
     }
 
-    virtual bool visitAggregate(Visit visit, TIntermAggregate *node)
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override
     {
         if (visit == PreVisit)
         {

src/compiler/translator/Compiler.h

@@ -67,8 +67,8 @@ class TCompiler : public TShHandleBase
 {
   public:
     TCompiler(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output);
-    virtual ~TCompiler();
-    virtual TCompiler* getAsCompiler() { return this; }
+    ~TCompiler() override;
+    TCompiler *getAsCompiler() override { return this; }
 
     bool Init(const ShBuiltInResources& resources);
 

src/compiler/translator/Diagnostics.h

@@ -16,7 +16,7 @@ class TDiagnostics : public pp::Diagnostics, angle::NonCopyable
 {
   public:
     TDiagnostics(TInfoSink& infoSink);
-    virtual ~TDiagnostics();
+    ~TDiagnostics() override;
 
     TInfoSink& infoSink() { return mInfoSink; }
 
@@ -30,9 +30,7 @@ class TDiagnostics : public pp::Diagnostics, angle::NonCopyable
                    const std::string& extra);
 
   protected:
-    virtual void print(ID id,
-                       const pp::SourceLocation& loc,
-                       const std::string& text);
+    void print(ID id, const pp::SourceLocation &loc, const std::string &text) override;
 
   private:
     TInfoSink& mInfoSink;

src/compiler/translator/DirectiveHandler.h

@@ -21,25 +21,23 @@ class TDirectiveHandler : public pp::DirectiveHandler, angle::NonCopyable
                       TDiagnostics& diagnostics,
                       int& shaderVersion,
                       bool debugShaderPrecisionSupported);
-    virtual ~TDirectiveHandler();
+    ~TDirectiveHandler() override;
 
     const TPragma& pragma() const { return mPragma; }
     const TExtensionBehavior& extensionBehavior() const { return mExtensionBehavior; }
 
-    virtual void handleError(const pp::SourceLocation& loc,
-                             const std::string& msg);
+    void handleError(const pp::SourceLocation &loc, const std::string &msg) override;
 
-    virtual void handlePragma(const pp::SourceLocation& loc,
-                              const std::string& name,
-                              const std::string& value,
-                              bool stdgl);
+    void handlePragma(const pp::SourceLocation &loc,
+                      const std::string &name,
+                      const std::string &value,
+                      bool stdgl) override;
 
-    virtual void handleExtension(const pp::SourceLocation& loc,
-                                 const std::string& name,
-                                 const std::string& behavior);
+    void handleExtension(const pp::SourceLocation &loc,
+                         const std::string &name,
+                         const std::string &behavior) override;
 
-    virtual void handleVersion(const pp::SourceLocation& loc,
-                               int version);
+    void handleVersion(const pp::SourceLocation &loc, int version) override;
 
   private:
     TPragma mPragma;

src/compiler/translator/EmulatePrecision.h

@@ -23,10 +23,10 @@ class EmulatePrecision : public TLValueTrackingTraverser
   public:
     EmulatePrecision(const TSymbolTable &symbolTable, int shaderVersion);
 
-    virtual void visitSymbol(TIntermSymbol *node);
-    virtual bool visitBinary(Visit visit, TIntermBinary *node);
-    virtual bool visitUnary(Visit visit, TIntermUnary *node);
-    virtual bool visitAggregate(Visit visit, TIntermAggregate *node);
+    void visitSymbol(TIntermSymbol *node) override;
+    bool visitBinary(Visit visit, TIntermBinary *node) override;
+    bool visitUnary(Visit visit, TIntermUnary *node) override;
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override;
 
     void writeEmulationHelpers(TInfoSinkBase& sink, ShShaderOutput outputLanguage);
 

src/compiler/translator/FlagStd140Structs.h

@@ -27,8 +27,8 @@ class FlagStd140Structs : public TIntermTraverser
     const std::vector<TIntermTyped *> getFlaggedNodes() const { return mFlaggedNodes; }
 
   protected:
-    virtual bool visitBinary(Visit visit, TIntermBinary *binaryNode);
-    virtual void visitSymbol(TIntermSymbol *symbol);
+    bool visitBinary(Visit visit, TIntermBinary *binaryNode) override;
+    void visitSymbol(TIntermSymbol *symbol) override;
 
   private:
     bool isInStd140InterfaceBlock(TIntermTyped *node) const;

src/compiler/translator/ForLoopUnroll.h

@@ -32,9 +32,9 @@ class ForLoopUnrollMarker : public TIntermTraverser
     {
     }
 
-    virtual bool visitBinary(Visit, TIntermBinary *node);
-    virtual bool visitLoop(Visit, TIntermLoop *node);
-    virtual void visitSymbol(TIntermSymbol *node);
+    bool visitBinary(Visit, TIntermBinary *node) override;
+    bool visitLoop(Visit, TIntermLoop *node) override;
+    void visitSymbol(TIntermSymbol *node) override;
 
     bool samplerArrayIndexIsFloatLoopIndex() const
     {

src/compiler/translator/InitializeVariables.h

@@ -33,13 +33,13 @@ class InitializeVariables : public TIntermTraverser
     }
 
   protected:
-    virtual bool visitBinary(Visit, TIntermBinary *node) { return false; }
-    virtual bool visitUnary(Visit, TIntermUnary *node) { return false; }
-    virtual bool visitSelection(Visit, TIntermSelection *node) { return false; }
-    virtual bool visitLoop(Visit, TIntermLoop *node) { return false; }
-    virtual bool visitBranch(Visit, TIntermBranch *node) { return false; }
+    bool visitBinary(Visit, TIntermBinary *node) override { return false; }
+    bool visitUnary(Visit, TIntermUnary *node) override { return false; }
+    bool visitSelection(Visit, TIntermSelection *node) override { return false; }
+    bool visitLoop(Visit, TIntermLoop *node) override { return false; }
+    bool visitBranch(Visit, TIntermBranch *node) override { return false; }
 
-    virtual bool visitAggregate(Visit visit, TIntermAggregate* node);
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override;
 
   private:
     void insertInitCode(TIntermSequence *sequence);

src/compiler/translator/OutputESSL.h

@@ -21,7 +21,8 @@ public:
                 bool forceHighp);
 
 protected:
-    virtual bool writeVariablePrecision(TPrecision precision);
+  bool writeVariablePrecision(TPrecision precision) override;
+
 private:
     bool mForceHighp;
 };

src/compiler/translator/OutputGLSL.h

@@ -21,9 +21,9 @@ class TOutputGLSL : public TOutputGLSLBase
                 ShShaderOutput output);
 
   protected:
-    virtual bool writeVariablePrecision(TPrecision);
-    virtual void visitSymbol(TIntermSymbol* node);
-    virtual TString translateTextureFunction(TString& name);
+    bool writeVariablePrecision(TPrecision) override;
+    void visitSymbol(TIntermSymbol *node) override;
+    TString translateTextureFunction(TString &name) override;
 };
 
 #endif  // COMPILER_TRANSLATOR_OUTPUTGLSL_H_

src/compiler/translator/OutputGLSLBase.h

@@ -39,16 +39,16 @@ class TOutputGLSLBase : public TIntermTraverser
     void writeConstructorTriplet(Visit visit, const TType &type, const char *constructorBaseType);
     TString getTypeName(const TType &type);
 
-    virtual void visitSymbol(TIntermSymbol *node);
-    virtual void visitConstantUnion(TIntermConstantUnion *node);
-    virtual bool visitBinary(Visit visit, TIntermBinary *node);
-    virtual bool visitUnary(Visit visit, TIntermUnary *node);
-    virtual bool visitSelection(Visit visit, TIntermSelection *node);
-    virtual bool visitSwitch(Visit visit, TIntermSwitch *node);
-    virtual bool visitCase(Visit visit, TIntermCase *node);
-    virtual bool visitAggregate(Visit visit, TIntermAggregate *node);
-    virtual bool visitLoop(Visit visit, TIntermLoop *node);
-    virtual bool visitBranch(Visit visit, TIntermBranch *node);
+    void visitSymbol(TIntermSymbol *node) override;
+    void visitConstantUnion(TIntermConstantUnion *node) override;
+    bool visitBinary(Visit visit, TIntermBinary *node) override;
+    bool visitUnary(Visit visit, TIntermUnary *node) override;
+    bool visitSelection(Visit visit, TIntermSelection *node) override;
+    bool visitSwitch(Visit visit, TIntermSwitch *node) override;
+    bool visitCase(Visit visit, TIntermCase *node) override;
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override;
+    bool visitLoop(Visit visit, TIntermLoop *node) override;
+    bool visitBranch(Visit visit, TIntermBranch *node) override;
 
     void visitCodeBlock(TIntermNode *node);
 

src/compiler/translator/RegenerateStructNames.h

@@ -23,8 +23,8 @@ class RegenerateStructNames : public TIntermTraverser
           mScopeDepth(0) {}
 
   protected:
-    virtual void visitSymbol(TIntermSymbol *);
-    virtual bool visitAggregate(Visit, TIntermAggregate *);
+    void visitSymbol(TIntermSymbol *) override;
+    bool visitAggregate(Visit, TIntermAggregate *) override;
 
   private:
     const TSymbolTable &mSymbolTable;

src/compiler/translator/RenameFunction.h

@@ -20,7 +20,7 @@ public:
     , mOldFunctionName(oldFunctionName)
     , mNewFunctionName(newFunctionName) {}
 
-    virtual bool visitAggregate(Visit visit, TIntermAggregate* node)
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override
     {
         TOperator op = node->getOp();
         if ((op == EOpFunction || op == EOpFunctionCall) && node->getName() == mOldFunctionName)

src/compiler/translator/ScalarizeVecAndMatConstructorArgs.h

@@ -20,7 +20,7 @@ class ScalarizeVecAndMatConstructorArgs : public TIntermTraverser
           mFragmentPrecisionHigh(fragmentPrecisionHigh) {}
 
   protected:
-    virtual bool visitAggregate(Visit visit, TIntermAggregate *node);
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override;
 
   private:
     void scalarizeArgs(TIntermAggregate *aggregate,

src/compiler/translator/SearchSymbol.h

@@ -20,7 +20,7 @@ class SearchSymbol : public TIntermTraverser
     SearchSymbol(const TString &symbol);
 
     void traverse(TIntermNode *node);
-    void visitSymbol(TIntermSymbol *symbolNode);
+    void visitSymbol(TIntermSymbol *symbolNode) override;
 
     bool foundMatch() const;
 

src/compiler/translator/SymbolTable.h

@@ -109,13 +109,8 @@ class TVariable : public TSymbol
           unionArray(0)
     {
     }
-    virtual ~TVariable()
-    {
-    }
-    virtual bool isVariable() const
-    {
-        return true;
-    }
+    ~TVariable() override {}
+    bool isVariable() const override { return true; }
     TType &getType()
     {
         return type;
@@ -229,11 +224,8 @@ class TFunction : public TSymbol
     {
         relateToExtension(ext);
     }
-    virtual ~TFunction();
-    virtual bool isFunction() const
-    {
-        return true;
-    }
+    ~TFunction() override;
+    bool isFunction() const override { return true; }
 
     static TString mangleName(const TString &name)
     {
@@ -250,7 +242,7 @@ class TFunction : public TSymbol
         mangledName = nullptr;
     }
 
-    const TString &getMangledName() const
+    const TString &getMangledName() const override
     {
         if (mangledName == nullptr)
         {

src/compiler/translator/Types.h

@@ -161,10 +161,7 @@ class TStructure : public TFieldListCollection
         *mutableName = name;
     }
 
-    virtual TString mangledNamePrefix() const
-    {
-        return "struct-";
-    }
+    TString mangledNamePrefix() const override { return "struct-"; }
     int calculateDeepestNesting() const;
 
     mutable int mDeepestNesting;
@@ -212,10 +209,7 @@ class TInterfaceBlock : public TFieldListCollection
     }
 
   private:
-    virtual TString mangledNamePrefix() const
-    {
-        return "iblock-";
-    }
+    TString mangledNamePrefix() const override { return "iblock-"; }
 
     const TString *mInstanceName; // for interface block instance names
     int mArraySize; // 0 if not an array

src/compiler/translator/UnfoldShortCircuitAST.h

@@ -25,7 +25,7 @@ class UnfoldShortCircuitAST : public TIntermTraverser
     {
     }
 
-    virtual bool visitBinary(Visit visit, TIntermBinary *);
+    bool visitBinary(Visit visit, TIntermBinary *) override;
 };
 
 #endif  // COMPILER_TRANSLATOR_UNFOLDSHORTCIRCUITAST_H_

src/compiler/translator/ValidateLimitations.cpp

@@ -35,7 +35,7 @@ class ValidateConstIndexExpr : public TIntermTraverser
     // Returns true if the parsed node represents a constant index expression.
     bool isValid() const { return mValid; }
 
-    virtual void visitSymbol(TIntermSymbol *symbol)
+    void visitSymbol(TIntermSymbol *symbol) override
     {
         // Only constants and loop indices are allowed in a
         // constant index expression.

src/compiler/translator/ValidateLimitations.h

@@ -21,10 +21,10 @@ class ValidateLimitations : public TIntermTraverser
 
     int numErrors() const { return mNumErrors; }
 
-    virtual bool visitBinary(Visit, TIntermBinary *);
-    virtual bool visitUnary(Visit, TIntermUnary *);
-    virtual bool visitAggregate(Visit, TIntermAggregate *);
-    virtual bool visitLoop(Visit, TIntermLoop *);
+    bool visitBinary(Visit, TIntermBinary *) override;
+    bool visitUnary(Visit, TIntermUnary *) override;
+    bool visitAggregate(Visit, TIntermAggregate *) override;
+    bool visitLoop(Visit, TIntermLoop *) override;
 
   private:
     void error(TSourceLoc loc, const char *reason, const char *token);

src/compiler/translator/ValidateOutputs.h

@@ -21,7 +21,7 @@ class ValidateOutputs : public TIntermTraverser
 
     int validateAndCountErrors(TInfoSinkBase &sink) const;
 
-    virtual void visitSymbol(TIntermSymbol*);
+    void visitSymbol(TIntermSymbol *) override;
 
   private:
     int mMaxDrawBuffers;

src/compiler/translator/VariableInfo.cpp

@@ -476,7 +476,7 @@ class NameHashingTraverser : public GetVariableTraverser
     {}
 
   private:
-    virtual void visitVariable(ShaderVariable *variable)
+    void visitVariable(ShaderVariable *variable) override
     {
         TString stringName = TString(variable->name.c_str());
         variable->mappedName = TIntermTraverser::hash(stringName, mHashFunction).c_str();

src/compiler/translator/VariableInfo.h

@@ -28,9 +28,9 @@ class CollectVariables : public TIntermTraverser
                      ShHashFunction64 hashFunction,
                      const TSymbolTable &symbolTable);
 
-    virtual void visitSymbol(TIntermSymbol *symbol);
-    virtual bool visitAggregate(Visit, TIntermAggregate *node);
-    virtual bool visitBinary(Visit visit, TIntermBinary *binaryNode);
+    void visitSymbol(TIntermSymbol *symbol) override;
+    bool visitAggregate(Visit, TIntermAggregate *node) override;
+    bool visitBinary(Visit visit, TIntermBinary *binaryNode) override;
 
   private:
     template <typename VarT>

src/compiler/translator/VersionGLSL.h

@@ -56,8 +56,8 @@ class TVersionGLSL : public TIntermTraverser
     //   Else 110 is returned.
     int getVersion() const { return mVersion; }
 
-    virtual void visitSymbol(TIntermSymbol *);
-    virtual bool visitAggregate(Visit, TIntermAggregate *);
+    void visitSymbol(TIntermSymbol *) override;
+    bool visitAggregate(Visit, TIntermAggregate *) override;
 
   private:
     void ensureVersionIsAtLeast(int version);

src/compiler/translator/blocklayout.h

@@ -81,12 +81,20 @@ class COMPILER_EXPORT Std140BlockEncoder : public BlockLayoutEncoder
   public:
     Std140BlockEncoder();
 
-    virtual void enterAggregateType();
-    virtual void exitAggregateType();
+    void enterAggregateType() override;
+    void exitAggregateType() override;
 
   protected:
-    virtual void getBlockLayoutInfo(GLenum type, unsigned int arraySize, bool isRowMajorMatrix, int *arrayStrideOut, int *matrixStrideOut);
-    virtual void advanceOffset(GLenum type, unsigned int arraySize, bool isRowMajorMatrix, int arrayStride, int matrixStride);
+    void getBlockLayoutInfo(GLenum type,
+                            unsigned int arraySize,
+                            bool isRowMajorMatrix,
+                            int *arrayStrideOut,
+                            int *matrixStrideOut) override;
+    void advanceOffset(GLenum type,
+                       unsigned int arraySize,
+                       bool isRowMajorMatrix,
+                       int arrayStride,
+                       int matrixStride) override;
 };
 
 }

src/compiler/translator/depgraph/DependencyGraph.h

@@ -46,9 +46,10 @@ protected:
 class TGraphParentNode : public TGraphNode {
 public:
     TGraphParentNode(TIntermNode* node) : TGraphNode(node) {}
-    virtual ~TGraphParentNode() {}
+    ~TGraphParentNode() override {}
     void addDependentNode(TGraphNode* node) { if (node != this) mDependentNodes.insert(node); }
-    virtual void traverse(TDependencyGraphTraverser* graphTraverser);
+    void traverse(TDependencyGraphTraverser *graphTraverser) override;
+
 private:
     TGraphNodeSet mDependentNodes;
 };
@@ -61,10 +62,11 @@ public:
     TGraphArgument(TIntermAggregate* intermFunctionCall, int argumentNumber)
         : TGraphParentNode(intermFunctionCall)
         , mArgumentNumber(argumentNumber) {}
-    virtual ~TGraphArgument() {}
+    ~TGraphArgument() override {}
     const TIntermAggregate* getIntermFunctionCall() const { return intermNode->getAsAggregate(); }
     int getArgumentNumber() const { return mArgumentNumber; }
-    virtual void traverse(TDependencyGraphTraverser* graphTraverser);
+    void traverse(TDependencyGraphTraverser *graphTraverser) override;
+
 private:
     int mArgumentNumber;
 };
@@ -76,9 +78,9 @@ class TGraphFunctionCall : public TGraphParentNode {
 public:
     TGraphFunctionCall(TIntermAggregate* intermFunctionCall)
         : TGraphParentNode(intermFunctionCall) {}
-    virtual ~TGraphFunctionCall() {}
+    ~TGraphFunctionCall() override {}
     const TIntermAggregate* getIntermFunctionCall() const { return intermNode->getAsAggregate(); }
-    virtual void traverse(TDependencyGraphTraverser* graphTraverser);
+    void traverse(TDependencyGraphTraverser *graphTraverser) override;
 };
 
 //
@@ -87,9 +89,9 @@ public:
 class TGraphSymbol : public TGraphParentNode {
 public:
     TGraphSymbol(TIntermSymbol* intermSymbol) : TGraphParentNode(intermSymbol) {}
-    virtual ~TGraphSymbol() {}
+    ~TGraphSymbol() override {}
     const TIntermSymbol* getIntermSymbol() const { return intermNode->getAsSymbolNode(); }
-    virtual void traverse(TDependencyGraphTraverser* graphTraverser);
+    void traverse(TDependencyGraphTraverser *graphTraverser) override;
 };
 
 //
@@ -98,9 +100,9 @@ public:
 class TGraphSelection : public TGraphNode {
 public:
     TGraphSelection(TIntermSelection* intermSelection) : TGraphNode(intermSelection) {}
-    virtual ~TGraphSelection() {}
+    ~TGraphSelection() override {}
     const TIntermSelection* getIntermSelection() const { return intermNode->getAsSelectionNode(); }
-    virtual void traverse(TDependencyGraphTraverser* graphTraverser);
+    void traverse(TDependencyGraphTraverser *graphTraverser) override;
 };
 
 //
@@ -109,9 +111,9 @@ public:
 class TGraphLoop : public TGraphNode {
 public:
     TGraphLoop(TIntermLoop* intermLoop) : TGraphNode(intermLoop) {}
-    virtual ~TGraphLoop() {}
+    ~TGraphLoop() override {}
     const TIntermLoop* getIntermLoop() const { return intermNode->getAsLoopNode(); }
-    virtual void traverse(TDependencyGraphTraverser* graphTraverser);
+    void traverse(TDependencyGraphTraverser *graphTraverser) override;
 };
 
 //
@@ -120,10 +122,10 @@ public:
 class TGraphLogicalOp : public TGraphNode {
 public:
     TGraphLogicalOp(TIntermBinary* intermLogicalOp) : TGraphNode(intermLogicalOp) {}
-    virtual ~TGraphLogicalOp() {}
+    ~TGraphLogicalOp() override {}
     const TIntermBinary* getIntermLogicalOp() const { return intermNode->getAsBinaryNode(); }
     const char* getOpString() const;
-    virtual void traverse(TDependencyGraphTraverser* graphTraverser);
+    void traverse(TDependencyGraphTraverser *graphTraverser) override;
 };
 
 //

src/compiler/translator/depgraph/DependencyGraphBuilder.h

@@ -18,11 +18,11 @@ class TDependencyGraphBuilder : public TIntermTraverser
   public:
     static void build(TIntermNode *node, TDependencyGraph *graph);
 
-    virtual void visitSymbol(TIntermSymbol *);
-    virtual bool visitBinary(Visit visit, TIntermBinary *);
-    virtual bool visitSelection(Visit visit, TIntermSelection *);
-    virtual bool visitAggregate(Visit visit, TIntermAggregate *);
-    virtual bool visitLoop(Visit visit, TIntermLoop *);
+    void visitSymbol(TIntermSymbol *) override;
+    bool visitBinary(Visit visit, TIntermBinary *) override;
+    bool visitSelection(Visit visit, TIntermSelection *) override;
+    bool visitAggregate(Visit visit, TIntermAggregate *) override;
+    bool visitLoop(Visit visit, TIntermLoop *) override;
 
   private:
     typedef std::stack<TGraphSymbol *> TSymbolStack;

src/compiler/translator/intermOut.cpp

@@ -34,14 +34,14 @@ class TOutputTraverser : public TIntermTraverser
     TInfoSinkBase& sink;
 
   protected:
-    void visitSymbol(TIntermSymbol *);
-    void visitConstantUnion(TIntermConstantUnion *);
-    bool visitBinary(Visit visit, TIntermBinary *);
-    bool visitUnary(Visit visit, TIntermUnary *);
-    bool visitSelection(Visit visit, TIntermSelection *);
-    bool visitAggregate(Visit visit, TIntermAggregate *);
-    bool visitLoop(Visit visit, TIntermLoop *);
-    bool visitBranch(Visit visit, TIntermBranch *);
+    void visitSymbol(TIntermSymbol *) override;
+    void visitConstantUnion(TIntermConstantUnion *) override;
+    bool visitBinary(Visit visit, TIntermBinary *) override;
+    bool visitUnary(Visit visit, TIntermUnary *) override;
+    bool visitSelection(Visit visit, TIntermSelection *) override;
+    bool visitAggregate(Visit visit, TIntermAggregate *) override;
+    bool visitLoop(Visit visit, TIntermLoop *) override;
+    bool visitBranch(Visit visit, TIntermBranch *) override;
 };
 
 //

src/compiler/translator/parseConst.cpp

@@ -33,14 +33,14 @@ class TConstTraverser : public TIntermTraverser
     bool error;
 
   protected:
-    void visitSymbol(TIntermSymbol *);
-    void visitConstantUnion(TIntermConstantUnion *);
-    bool visitBinary(Visit visit, TIntermBinary *);
-    bool visitUnary(Visit visit, TIntermUnary *);
-    bool visitSelection(Visit visit, TIntermSelection *);
-    bool visitAggregate(Visit visit, TIntermAggregate *);
-    bool visitLoop(Visit visit, TIntermLoop *);
-    bool visitBranch(Visit visit, TIntermBranch *);
+    void visitSymbol(TIntermSymbol *) override;
+    void visitConstantUnion(TIntermConstantUnion *) override;
+    bool visitBinary(Visit visit, TIntermBinary *) override;
+    bool visitUnary(Visit visit, TIntermUnary *) override;
+    bool visitSelection(Visit visit, TIntermSelection *) override;
+    bool visitAggregate(Visit visit, TIntermAggregate *) override;
+    bool visitLoop(Visit visit, TIntermLoop *) override;
+    bool visitBranch(Visit visit, TIntermBranch *) override;
 
     size_t mIndex;
     TConstantUnion *mUnionArray;

src/compiler/translator/timing/RestrictVertexShaderTiming.h

@@ -22,7 +22,8 @@ public:
     void enforceRestrictions(TIntermNode* root) { root->traverse(this); }
     int numErrors() { return mNumErrors; }
 
-    virtual void visitSymbol(TIntermSymbol*);
+    void visitSymbol(TIntermSymbol *) override;
+
 private:
     TInfoSinkBase& mSink;
     int mNumErrors;

src/third_party/compiler/ArrayBoundsClamper.cpp

@@ -48,7 +48,7 @@ public:
    {
    }
 
-   virtual bool visitBinary(Visit visit, TIntermBinary* node)
+    bool visitBinary(Visit visit, TIntermBinary *node) override
    {
        if (node->getOp() == EOpIndexIndirect)
        {