[clang][NFC] Add 'override' keyword to virtual function overrides

[logan-5]

Summary

This patch adds override to several overriding virtual functions that were missing the keyword within the clang/ directory. NFC.

These were found by a Clang build equipped with -Wsuggest-override, as implemented in this patch (D82728).

[dblaikie]

Looks good - thanks!

(I can't actually find where the instructions are on how to request commit access these days - but should you find them, I thin it'd be fine for you to have commit access for committing changes like this)

[logan-5]

Committed as rG2c2a297bb6d1

[dblaikie]

In D83611#2151208, @logan-5 wrote:

Committed as rG2c2a297bb6d1

If you add/leave the "Differential Revision: https://reviews.llvm.org/DXXXX" line in the commit message (arc will add this line automatically) Phabricator will close the review for you automatically

[logan-5]

In D83611#2151278, @dblaikie wrote:

If you add/leave the "Differential Revision: https://reviews.llvm.org/DXXXX" line in the commit message (arc will add this line automatically) Phabricator will close the review for you automatically

Thanks--figured that out shortly after I did this one. :)

clang/include/clang/AST/DeclOpenMP.h

private:
   /// Orig parameter of the initializer.
   Expr *Orig = nullptr;
 
   /// Reference to the previous declare reduction construct in the same
   /// scope with the same name. Required for proper templates instantiation if
   /// the declare reduction construct is declared inside compound statement.
   LazyDeclPtr PrevDeclInScope;
 
-  virtual void anchor();
+  void anchor() override;
 
   OMPDeclareReductionDecl(Kind DK, DeclContext *DC, SourceLocation L,
                           DeclarationName Name, QualType Ty,
                           OMPDeclareReductionDecl *PrevDeclInScope);
 
   void setPrevDeclInScope(OMPDeclareReductionDecl *Prev) {
     PrevDeclInScope = Prev;
   }
class OMPDeclareMapperDecl final : public ValueDecl, public DeclContext {
   /// Mapper variable, which is 'v' in the example above
   Expr *MapperVarRef = nullptr;
 
   /// Name of the mapper variable
   DeclarationName VarName;
 
   LazyDeclPtr PrevDeclInScope;
 
-  virtual void anchor();
+  void anchor() override;
 
   OMPDeclareMapperDecl(Kind DK, DeclContext *DC, SourceLocation L,
                        DeclarationName Name, QualType Ty,
                        DeclarationName VarName,
                        OMPDeclareMapperDecl *PrevDeclInScope)
       : ValueDecl(DK, DC, L, Name, Ty), DeclContext(DK), VarName(VarName),
         PrevDeclInScope(PrevDeclInScope) {}
 

clang/lib/AST/Interp/InterpFrame.h

public:
 
   /// Invokes the destructors for a scope.
   void destroy(unsigned Idx);
 
   /// Pops the arguments off the stack.
   void popArgs();
 
   /// Describes the frame with arguments for diagnostic purposes.
-  void describe(llvm::raw_ostream &OS);
+  void describe(llvm::raw_ostream &OS) override;
 
   /// Returns the parent frame object.
-  Frame *getCaller() const;
+  Frame *getCaller() const override;
 
   /// Returns the location of the call to the frame.
-  SourceLocation getCallLocation() const;
+  SourceLocation getCallLocation() const override;
 
   /// Returns the caller.
-  const FunctionDecl *getCallee() const;
+  const FunctionDecl *getCallee() const override;
 
   /// Returns the current function.
   Function *getFunction() const { return Func; }
 
   /// Returns the offset on the stack at which the frame starts.
   size_t getFrameOffset() const { return FrameOffset; }
 
   /// Returns the value of a local variable.

clang/lib/AST/OSLog.cpp

getKind(analyze_format_string::ConversionSpecifier::Kind K) {
     }
   }
 
 public:
   OSLogFormatStringHandler(ArrayRef<const Expr *> Args) : Args(Args) {
     ArgsData.reserve(Args.size());
   }
 
-  virtual bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS,
-                                     const char *StartSpecifier,
-                                     unsigned SpecifierLen) {
+  bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS,
+                             unsigned SpecifierLen) override {
     if (!FS.consumesDataArgument() &&
         FS.getConversionSpecifier().getKind() !=
             clang::analyze_format_string::ConversionSpecifier::PrintErrno)
       return true;
 
     ArgsData.emplace_back();
     unsigned ArgIndex = FS.getArgIndex();
     if (ArgIndex < Args.size())

clang/lib/Basic/Targets/OSTargets.h

 };
 
 // WebAssembly target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo
     : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                    MacroBuilder &Builder) const {
+                    MacroBuilder &Builder) const override {
     // A common platform macro.
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     // Follow g++ convention and predefine _GNU_SOURCE for C++.
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
     // Indicate that we have __float128.
     Builder.defineMacro("__FLOAT128__");

clang/lib/Sema/SemaDeclCXX.cpp

static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T,
   // If we get this far, we've committed to the tuple interpretation, but
   // we can still fail if there actually isn't a usable ::value.
 
   struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
     LookupResult &R;
     TemplateArgumentListInfo &Args;
     ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
         : R(R), Args(Args) {}
-    void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) {
+    void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override {
       S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
           << printTemplateArgs(S.Context.getPrintingPolicy(), Args);
     }
   } Diagnoser(R, Args);
 
   ExprResult E =
       S.BuildDeclarationNameExpr(CXXScopeSpec(), R, /*NeedsADL*/false);
   if (E.isInvalid())

clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp

public:
   void checkPostStmt(const CallExpr *S, CheckerContext &C) const;
   void checkDeadSymbols(SymbolReaper &SR, CheckerContext &C) const;
   ProgramStateRef checkPointerEscape(ProgramStateRef State,
                                      const InvalidatedSymbols &Escaped,
                                      const CallEvent *Call,
                                      PointerEscapeKind Kind) const;
   ProgramStateRef evalAssume(ProgramStateRef state, SVal Cond,
                              bool Assumption) const;
   void printState(raw_ostream &Out, ProgramStateRef State,
-                  const char *NL, const char *Sep) const;
+                  const char *NL, const char *Sep) const override;
 
 private:
   typedef std::pair<SymbolRef, const AllocationState*> AllocationPair;
   typedef SmallVector<AllocationPair, 2> AllocationPairVec;
 
   enum APIKind {
     /// Denotes functions tracked by this checker.
     ValidAPI = 0,

clang/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp

class Callback : public MatchFinder::MatchCallback {
   const NumberObjectConversionChecker *C;
   BugReporter &BR;
   AnalysisDeclContext *ADC;
 
 public:
   Callback(const NumberObjectConversionChecker *C,
            BugReporter &BR, AnalysisDeclContext *ADC)
       : C(C), BR(BR), ADC(ADC) {}
-  virtual void run(const MatchFinder::MatchResult &Result);
+  void run(const MatchFinder::MatchResult &Result) override;
 };
 } // end of anonymous namespace
 
 void Callback::run(const MatchFinder::MatchResult &Result) {
   bool IsPedanticMatch =
       (Result.Nodes.getNodeAs<Stmt>("pedantic") != nullptr);
   if (IsPedanticMatch && !C->Pedantic)
     return;

clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp

public:
 
   void checkPostStmt(const CallExpr *CE, CheckerContext &C) const;
   void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
   ProgramStateRef checkPointerEscape(ProgramStateRef State,
                                      const InvalidatedSymbols &Escaped,
                                      const CallEvent *Call,
                                      PointerEscapeKind Kind) const;
 
   void printState(raw_ostream &OS, ProgramStateRef State,
-                  const char *NL, const char *Sep) const;
+                  const char *NL, const char *Sep) const override;
 };
 } // end anonymous namespace
 
 // ProgramState trait - a map from array symbol to its state.
 REGISTER_MAP_WITH_PROGRAMSTATE(ArraySizeMap, SymbolRef, DefinedSVal)
 
 void ObjCContainersChecker::addSizeInfo(const Expr *Array, const Expr *Size,
                                         CheckerContext &C) const {