[nfc] Mark classes final as reported by -Wsuggest-final-types

[Trass3r]

More of an RFC.
See https://github.com/llvm/llvm-project/issues/57525.
This marks some of the classes with devirtualization potential final, as reported by gcc.
It needs to be checked which of those make sense.
Also, is there a proper way to mark classes as 'explicitly designed to be subclassed' (along the lines of class F /*non-final*/ : ...?).

[Trass3r]

fix build

clang/include/clang/AST/Decl.h

public:
   void setMSAsmLabelResolved() { MSAsmNameResolved = true; }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == Label; }
 };
 
 /// Represent a C++ namespace.
-class NamespaceDecl : public NamedDecl, public DeclContext,
+class NamespaceDecl final : public NamedDecl, public DeclContext,
                             public Redeclarable<NamespaceDecl>
 {
   /// The starting location of the source range, pointing
   /// to either the namespace or the inline keyword.
   SourceLocation LocStart;
 
   /// The ending location of the source range.
   SourceLocation RBraceLoc;
 
public:
   }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == ImplicitParam; }
 };
 
 /// Represents a parameter to a function.
-class ParmVarDecl : public VarDecl {
+class ParmVarDecl final : public VarDecl {
 public:
   enum { MaxFunctionScopeDepth = 255 };
   enum { MaxFunctionScopeIndex = 255 };
 
 protected:
   ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
               SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
               TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
public:
   static TagDecl *castFromDeclContext(const DeclContext *DC) {
     return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
   }
 };
 
 /// Represents an enum.  In C++11, enums can be forward-declared
 /// with a fixed underlying type, and in C we allow them to be forward-declared
 /// with no underlying type as an extension.
-class EnumDecl : public TagDecl {
+class EnumDecl final : public TagDecl {
   // This class stores some data in DeclContext::EnumDeclBits
   // to save some space. Use the provided accessors to access it.
 
   /// This represent the integer type that the enum corresponds
   /// to for code generation purposes.  Note that the enumerator constants may
   /// have a different type than this does.
   ///
   /// If the underlying integer type was explicitly stated in the source
public:
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == FileScopeAsm; }
 };
 
 /// Represents a block literal declaration, which is like an
 /// unnamed FunctionDecl.  For example:
 /// ^{ statement-body }   or   ^(int arg1, float arg2){ statement-body }
-class BlockDecl : public Decl, public DeclContext {
+class BlockDecl final : public Decl, public DeclContext {
   // This class stores some data in DeclContext::BlockDeclBits
   // to save some space. Use the provided accessors to access it.
 public:
   /// A class which contains all the information about a particular
   /// captured value.
   class Capture {
     enum {
       flag_isByRef = 0x1,

clang/include/clang/AST/DeclCXX.h

 /// For example:
 ///
 /// \code
 /// class X {
 /// public:
 ///   operator bool();
 /// };
 /// \endcode
-class CXXConversionDecl : public CXXMethodDecl {
+class CXXConversionDecl final : public CXXMethodDecl {
   CXXConversionDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                     const DeclarationNameInfo &NameInfo, QualType T,
                     TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline,
                     ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind,
                     SourceLocation EndLocation,
                     Expr *TrailingRequiresClause = nullptr)
       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
                       SC_None, UsesFPIntrin, isInline, ConstexprKind,
public:
   static UnresolvedUsingIfExistsDecl *CreateDeserialized(ASTContext &Ctx,
                                                          unsigned ID);
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == Decl::UnresolvedUsingIfExists; }
 };
 
 /// Represents a C++11 static_assert declaration.
-class StaticAssertDecl : public Decl {
+class StaticAssertDecl final : public Decl {
   llvm::PointerIntPair<Expr *, 1, bool> AssertExprAndFailed;
   StringLiteral *Message;
   SourceLocation RParenLoc;
 
   StaticAssertDecl(DeclContext *DC, SourceLocation StaticAssertLoc,
                    Expr *AssertExpr, StringLiteral *Message,
                    SourceLocation RParenLoc, bool Failed)
       : Decl(StaticAssert, DC, StaticAssertLoc),

clang/include/clang/AST/DeclObjC.h

 /// - (void)replaceSubview:(NSView *)oldView with:(NSView *)newView;
 ///
 /// Getter class method:
 /// + (NSMenu *)defaultMenu;
 ///
 /// A selector represents a unique name for a method. The selector names for
 /// the above methods are setMenu:, menu, replaceSubview:with:, and defaultMenu.
 ///
-class ObjCMethodDecl : public NamedDecl, public DeclContext {
+class ObjCMethodDecl final : public NamedDecl, public DeclContext {
   // This class stores some data in DeclContext::ObjCMethodDeclBits
   // to save some space. Use the provided accessors to access it.
 
 public:
   enum ImplementationControl { None, Required, Optional };
 
 private:
   /// Return type of this method.

 ///   \@end                                    // to an NSEvent.
 /// \endcode
 ///
 ///   Unlike C/C++, forward class declarations are accomplished with \@class.
 ///   Unlike C/C++, \@class allows for a list of classes to be forward declared.
 ///   Unlike C++, ObjC is a single-rooted class model. In Cocoa, classes
 ///   typically inherit from NSObject (an exception is NSProxy).
 ///
-class ObjCInterfaceDecl : public ObjCContainerDecl
-                        , public Redeclarable<ObjCInterfaceDecl> {
+class ObjCInterfaceDecl final : public ObjCContainerDecl,
+                                public Redeclarable<ObjCInterfaceDecl> {
   friend class ASTContext;
 
   /// TypeForDecl - This indicates the Type object that represents this
   /// TypeDecl.  It is a cache maintained by ASTContext::getObjCInterfaceType
   mutable const Type *TypeForDecl = nullptr;
 
   struct DefinitionData {
     /// The definition of this class, for quick access from any

 ///   \@public:
 ///     id canBePublic; // same as C++.
 ///   \@protected:
 ///     id canBeProtected; // same as C++.
 ///   \@package:
 ///     id canBePackage; // framework visibility (not available in C++).
 ///   }
 ///
-class ObjCIvarDecl : public FieldDecl {
+class ObjCIvarDecl final : public FieldDecl {
   void anchor() override;
 
 public:
   enum AccessControl {
     None, Private, Protected, Public, Package
   };
 
 private:
private:
   ObjCIvarDecl *NextIvar = nullptr;
 
   // NOTE: VC++ treats enums as signed, avoid using the AccessControl enum
   unsigned DeclAccess : 3;
   unsigned Synthesized : 1;
 };
 
 /// Represents a field declaration created by an \@defs(...).
-class ObjCAtDefsFieldDecl : public FieldDecl {
+class ObjCAtDefsFieldDecl final : public FieldDecl {
   ObjCAtDefsFieldDecl(DeclContext *DC, SourceLocation StartLoc,
                       SourceLocation IdLoc, IdentifierInfo *Id,
                       QualType T, Expr *BW)
       : FieldDecl(ObjCAtDefsField, DC, StartLoc, IdLoc, Id, T,
                   /*TInfo=*/nullptr, // FIXME: Do ObjCAtDefs have declarators ?
                   BW, /*Mutable=*/false, /*HasInit=*/ICIS_NoInit) {}
 
   void anchor() override;

clang/include/clang/AST/DeclTemplate.h

SpecEntryTraits<FunctionTemplateSpecializationInfo> {
 
   static ArrayRef<TemplateArgument>
   getTemplateArgs(FunctionTemplateSpecializationInfo *I) {
     return I->TemplateArguments->asArray();
   }
 };
 
 /// Declaration of a template function.
-class FunctionTemplateDecl : public RedeclarableTemplateDecl {
+class FunctionTemplateDecl final : public RedeclarableTemplateDecl {
 protected:
   friend class FunctionDecl;
 
   /// Data that is common to all of the declarations of a given
   /// function template.
   struct Common : CommonBase {
     /// The function template specializations for this function
     /// template, including explicit specializations and instantiations.
public:
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
 
   static bool classofKind(Kind K) {
     return K == ClassTemplatePartialSpecialization;
   }
 };
 
 /// Declaration of a class template.
-class ClassTemplateDecl : public RedeclarableTemplateDecl {
+class ClassTemplateDecl final : public RedeclarableTemplateDecl {
 protected:
   /// Data that is common to all of the declarations of a given
   /// class template.
   struct Common : CommonBase {
     /// The class template specializations for this class
     /// template, including explicit specializations and instantiations.
     llvm::FoldingSetVector<ClassTemplateSpecializationDecl> Specializations;
 

clang/include/clang/Frontend/CompilerInstance.h

 /// The compiler instance generally owns the instance of all the objects that it
 /// manages. However, clients can still share objects by manually setting the
 /// object and retaking ownership prior to destroying the CompilerInstance.
 ///
 /// The compiler instance is intended to simplify clients, but not to lock them
 /// in to the compiler instance for everything. When possible, utility functions
 /// come in two forms; a short form that reuses the CompilerInstance objects,
 /// and a long form that takes explicit instances of any required objects.
-class CompilerInstance : public ModuleLoader {
+class CompilerInstance final : public ModuleLoader {
   /// The options used in this compiler instance.
   std::shared_ptr<CompilerInvocation> Invocation;
 
   /// The diagnostics engine instance.
   IntrusiveRefCntPtr<DiagnosticsEngine> Diagnostics;
 
   /// The target being compiled for.
   IntrusiveRefCntPtr<TargetInfo> Target;

clang/include/clang/Lex/Lexer.h

struct PreambleBounds {
   PreambleBounds(unsigned Size, bool PreambleEndsAtStartOfLine)
       : Size(Size), PreambleEndsAtStartOfLine(PreambleEndsAtStartOfLine) {}
 };
 
 /// Lexer - This provides a simple interface that turns a text buffer into a
 /// stream of tokens.  This provides no support for file reading or buffering,
 /// or buffering/seeking of tokens, only forward lexing is supported.  It relies
 /// on the specified Preprocessor object to handle preprocessor directives, etc.
-class Lexer : public PreprocessorLexer {
+class Lexer final : public PreprocessorLexer {
   friend class Preprocessor;
 
   void anchor() override;
 
   //===--------------------------------------------------------------------===//
   // Constant configuration values for this lexer.
 
   // Start of the buffer.

clang/include/clang/Lex/Pragma.h

public:
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &FirstToken) override;
 };
 
 /// PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas,
 /// allowing hierarchical pragmas to be defined.  Common examples of namespaces
 /// are "\#pragma GCC", "\#pragma STDC", and "\#pragma omp", but any namespaces
 /// may be (potentially recursively) defined.
-class PragmaNamespace : public PragmaHandler {
+class PragmaNamespace final : public PragmaHandler {
   /// Handlers - This is a map of the handlers in this namespace with their name
   /// as key.
   llvm::StringMap<std::unique_ptr<PragmaHandler>> Handlers;
 
 public:
   explicit PragmaNamespace(StringRef Name) : PragmaHandler(Name) {}
 
   /// FindHandler - Check to see if there is already a handler for the

clang/include/clang/Parse/Parser.h

namespace clang {
   struct OMPTraitSelector;
   struct OMPTraitSet;
   class OMPTraitInfo;
 
 /// Parser - This implements a parser for the C family of languages.  After
 /// parsing units of the grammar, productions are invoked to handle whatever has
 /// been read.
 ///
-class Parser : public CodeCompletionHandler {
+class Parser final : public CodeCompletionHandler {
   friend class ColonProtectionRAIIObject;
   friend class ParsingOpenMPDirectiveRAII;
   friend class InMessageExpressionRAIIObject;
   friend class PoisonSEHIdentifiersRAIIObject;
   friend class ObjCDeclContextSwitch;
   friend class ParenBraceBracketBalancer;
   friend class BalancedDelimiterTracker;
 

clang/include/clang/Sema/CodeCompleteConsumer.h

 /// CodeCompletionString::BriefComment for OverloadCandidate.
 const RawComment *
 getParameterComment(const ASTContext &Ctx,
                     const CodeCompleteConsumer::OverloadCandidate &Result,
                     unsigned ArgIndex);
 
 /// A simple code-completion consumer that prints the results it
 /// receives in a simple format.
-class PrintingCodeCompleteConsumer : public CodeCompleteConsumer {
+class PrintingCodeCompleteConsumer final : public CodeCompleteConsumer {
   /// The raw output stream.
   raw_ostream &OS;
 
   CodeCompletionTUInfo CCTUInfo;
 
 public:
   /// Create a new printing code-completion consumer that prints its
   /// results to the given raw output stream.

clang/include/clang/Sema/SemaInternal.h

 inline std::pair<unsigned, unsigned>
 getDepthAndIndex(UnexpandedParameterPack UPP) {
   if (const auto *TTP = UPP.first.dyn_cast<const TemplateTypeParmType *>())
     return std::make_pair(TTP->getDepth(), TTP->getIndex());
 
   return getDepthAndIndex(UPP.first.get<const NamedDecl *>());
 }
 
-class TypoCorrectionConsumer : public VisibleDeclConsumer {
+class TypoCorrectionConsumer final : public VisibleDeclConsumer {
   typedef SmallVector<TypoCorrection, 1> TypoResultList;
   typedef llvm::StringMap<TypoResultList> TypoResultsMap;
   typedef std::map<unsigned, TypoResultsMap> TypoEditDistanceMap;
 
 public:
   TypoCorrectionConsumer(Sema &SemaRef,
                          const DeclarationNameInfo &TypoName,
                          Sema::LookupNameKind LookupKind,

clang/include/clang/Serialization/ASTReader.h

 /// class) containing the serialized representation of a given
 /// abstract syntax tree and its supporting data structures. An
 /// instance of the ASTReader can be attached to an ASTContext object,
 /// which will provide access to the contents of the AST files.
 ///
 /// The AST reader provides lazy de-serialization of declarations, as
 /// required when traversing the AST. Only those AST nodes that are
 /// actually required will be de-serialized.
-class ASTReader
+class ASTReader final
   : public ExternalPreprocessorSource,
     public ExternalPreprocessingRecordSource,
     public ExternalHeaderFileInfoSource,
     public ExternalSemaSource,
     public IdentifierInfoLookup,
     public ExternalSLocEntrySource
 {
 public:

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h

 class ExpressionHandler;
 class StoreHandler;
 
 /// A generalized component for tracking expressions, values, and stores.
 ///
 /// Tracker aimes at providing a sensible set of default behaviors that can be
 /// used by any checker, while providing mechanisms to hook into any part of the
 /// tracking process and insert checker-specific logic.
-class Tracker : public llvm::RefCountedBase<Tracker> {
+class Tracker final : public llvm::RefCountedBase<Tracker> {
 private:
   using ExpressionHandlerPtr = std::unique_ptr<ExpressionHandler>;
   using StoreHandlerPtr = std::unique_ptr<StoreHandler>;
 
   PathSensitiveBugReport &Report;
   std::list<ExpressionHandlerPtr> ExpressionHandlers;
   std::list<StoreHandlerPtr> StoreHandlers;
 

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h

public:
   }
 
   /// isSuppressOnSink - Returns true if bug reports associated with this bug
   ///  type should be suppressed if the end node of the report is post-dominated
   ///  by a sink node.
   bool isSuppressOnSink() const { return SuppressOnSink; }
 };
 
-class BuiltinBug : public BugType {
+class BuiltinBug final : public BugType {
   const std::string desc;
   void anchor() override;
 public:
   BuiltinBug(class CheckerNameRef checker, const char *name,
              const char *description)
       : BugType(checker, name, categories::LogicError), desc(description) {}
 
   BuiltinBug(const CheckerBase *checker, const char *name,

clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h

 
 namespace clang {
 
 class CodeInjector;
 
 namespace ento {
   class CheckerManager;
 
-class AnalysisManager : public BugReporterData {
+class AnalysisManager final : public BugReporterData {
   virtual void anchor();
   AnalysisDeclContextManager AnaCtxMgr;
 
   ASTContext &Ctx;
   Preprocessor &PP;
   const LangOptions &LangOpts;
   PathDiagnosticConsumers PathConsumers;
 

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

static bool classof(const CallEvent *Call) {
     return Call->getKind() >= CE_BEG_CXX_CONSTRUCTOR_CALLS &&
            Call->getKind() <= CE_END_CXX_CONSTRUCTOR_CALLS;
   }
 };
 
 /// Represents a call to a C++ constructor.
 ///
 /// Example: \c T(1)
-class CXXConstructorCall : public AnyCXXConstructorCall {
+class CXXConstructorCall final : public AnyCXXConstructorCall {
   friend class CallEventManager;
 
 protected:
   /// Creates a constructor call.
   ///
   /// \param CE The constructor expression as written in the source.
   /// \param Target The region where the object should be constructed. If NULL,
   ///               a new symbolic region will be used.
enum ObjCMessageKind {
   OCM_PropertyAccess,
   OCM_Subscript,
   OCM_Message
 };
 
 /// Represents any expression that calls an Objective-C method.
 ///
 /// This includes all of the kinds listed in ObjCMessageKind.
-class ObjCMethodCall : public CallEvent {
+class ObjCMethodCall final : public CallEvent {
   friend class CallEventManager;
 
   const PseudoObjectExpr *getContainingPseudoObjectExpr() const;
 
 protected:
   ObjCMethodCall(const ObjCMessageExpr *Msg, ProgramStateRef St,
                  const LocationContext *LCtx)
       : CallEvent(Msg, St, LCtx) {

clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h

public:
   static bool classof(const MemRegion* R) {
     return R->getKind() == CXXThisRegionKind;
   }
 
 private:
   const PointerType *ThisPointerTy;
 };
 
-class FieldRegion : public DeclRegion {
+class FieldRegion final : public DeclRegion {
   friend class MemRegionManager;
 
   const FieldDecl *FD;
 
   FieldRegion(const FieldDecl *fd, const SubRegion *sReg)
       : DeclRegion(sReg, FieldRegionKind), FD(fd) {
     assert(FD);
   }

clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h

 typedef llvm::ImmutableSet<
     std::pair<clang::ento::SymbolRef, const llvm::SMTExpr *>>
     ConstraintSMTType;
 REGISTER_TRAIT_WITH_PROGRAMSTATE(ConstraintSMT, ConstraintSMTType)
 
 namespace clang {
 namespace ento {
 
-class SMTConstraintManager : public clang::ento::SimpleConstraintManager {
+class SMTConstraintManager final : public clang::ento::SimpleConstraintManager {
   mutable llvm::SMTSolverRef Solver = llvm::CreateZ3Solver();
 
 public:
   SMTConstraintManager(clang::ento::ExprEngine *EE,
                        clang::ento::SValBuilder &SB)
       : SimpleConstraintManager(EE, SB) {}
   virtual ~SMTConstraintManager() = default;
 

clang/lib/Driver/ToolChains/AIX.h

 
 namespace clang {
 namespace driver {
 namespace tools {
 
 /// aix -- Directly call system default assembler and linker.
 namespace aix {
 
-class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
+class LLVM_LIBRARY_VISIBILITY Assembler final : public Tool {
 public:
   Assembler(const ToolChain &TC) : Tool("aix::Assembler", "assembler", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("aix::Linker", "linker", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
 } // end namespace aix
 
 } // end namespace tools
 } // end namespace driver
 } // end namespace clang
 
 namespace clang {
 namespace driver {
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY AIX : public ToolChain {
+class LLVM_LIBRARY_VISIBILITY AIX final : public ToolChain {
 public:
   AIX(const Driver &D, const llvm::Triple &Triple,
       const llvm::opt::ArgList &Args);
 
   bool parseInlineAsmUsingAsmParser() const override {
     return ParseInlineAsmUsingAsmParser;
   }
   bool isPICDefault() const override { return true; }

clang/lib/Driver/ToolChains/BareMetal.h

 
 #include <string>
 
 namespace clang {
 namespace driver {
 
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY BareMetal : public ToolChain {
+class LLVM_LIBRARY_VISIBILITY BareMetal final : public ToolChain {
 public:
   BareMetal(const Driver &D, const llvm::Triple &Triple,
             const llvm::opt::ArgList &Args);
   ~BareMetal() override = default;
 
   static bool handlesTarget(const llvm::Triple &Triple);
 
   void findMultilibs(const Driver &D, const llvm::Triple &Triple,
public:
   std::string computeSysRoot() const override;
 };
 
 } // namespace toolchains
 
 namespace tools {
 namespace baremetal {
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("baremetal::Linker", "ld.lld", TC) {}
   bool isLinkJob() const override { return true; }
   bool hasIntegratedCPP() const override { return false; }
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;

clang/lib/Driver/ToolChains/CSKYToolChain.h

 
 #include "Gnu.h"
 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY CSKYToolChain : public Generic_ELF {
+class LLVM_LIBRARY_VISIBILITY CSKYToolChain final : public Generic_ELF {
 public:
   CSKYToolChain(const Driver &D, const llvm::Triple &Triple,
                 const llvm::opt::ArgList &Args);
 
   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args,
                              Action::OffloadKind) const override;
   RuntimeLibType GetDefaultRuntimeLibType() const override;

 private:
   std::string computeSysRoot() const override;
 };
 
 } // end namespace toolchains
 
 namespace tools {
 namespace CSKY {
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("CSKY::Linker", "ld", TC) {}
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 } // end namespace CSKY
 } // end namespace tools
 
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_CSKYTOOLCHAIN_H

clang/lib/Driver/ToolChains/CrossWindows.h

 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 namespace tools {
 
 namespace CrossWindows {
-class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
+class LLVM_LIBRARY_VISIBILITY Assembler final : public Tool {
 public:
   Assembler(const ToolChain &TC) : Tool("CrossWindows::Assembler", "as", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("CrossWindows::Linker", "ld", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 } // end namespace CrossWindows
 } // end namespace tools
 
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY CrossWindowsToolChain : public Generic_GCC {
+class LLVM_LIBRARY_VISIBILITY CrossWindowsToolChain final : public Generic_GCC {
 public:
   CrossWindowsToolChain(const Driver &D, const llvm::Triple &T,
                         const llvm::opt::ArgList &Args);
 
   bool IsIntegratedAssemblerDefault() const override { return true; }
   UnwindTableLevel
   getDefaultUnwindTableLevel(const llvm::opt::ArgList &Args) const override;
   bool isPICDefault() const override;

clang/lib/Driver/ToolChains/Cuda.h

public:
   }
   void WarnIfUnsupportedVersion();
 };
 
 namespace tools {
 namespace NVPTX {
 
 // Run ptxas, the NVPTX assembler.
-class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
+class LLVM_LIBRARY_VISIBILITY Assembler final : public Tool {
  public:
    Assembler(const ToolChain &TC) : Tool("NVPTX::Assembler", "ptxas", TC) {}
 
    bool hasIntegratedCPP() const override { return false; }
 
    void ConstructJob(Compilation &C, const JobAction &JA,
                      const InputInfo &Output, const InputInfoList &Inputs,
                      const llvm::opt::ArgList &TCArgs,
                      const char *LinkingOutput) const override;
 };
 
 // Runs fatbinary, which combines GPU object files ("cubin" files) and/or PTX
 // assembly into a single output file.
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
  public:
    Linker(const ToolChain &TC) : Tool("NVPTX::Linker", "fatbinary", TC) {}
 
    bool hasIntegratedCPP() const override { return false; }
 
    void ConstructJob(Compilation &C, const JobAction &JA,
                      const InputInfo &Output, const InputInfoList &Inputs,
                      const llvm::opt::ArgList &TCArgs,
                      const char *LinkingOutput) const override;
 };
 
 void getNVPTXTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                             const llvm::opt::ArgList &Args,
                             std::vector<StringRef> &Features);
 
 } // end namespace NVPTX
 } // end namespace tools
 
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY CudaToolChain : public ToolChain {
+class LLVM_LIBRARY_VISIBILITY CudaToolChain final : public ToolChain {
 public:
   CudaToolChain(const Driver &D, const llvm::Triple &Triple,
                 const ToolChain &HostTC, const llvm::opt::ArgList &Args);
 
   const llvm::Triple *getAuxTriple() const override {
     return &HostTC.getTriple();
   }
 

clang/lib/Driver/ToolChains/Darwin.h

const toolchains::MachO &getMachOToolChain() const {
     return reinterpret_cast<const toolchains::MachO &>(getToolChain());
   }
 
 public:
   MachOTool(const char *Name, const char *ShortName, const ToolChain &TC)
       : Tool(Name, ShortName, TC) {}
 };
 
-class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool {
+class LLVM_LIBRARY_VISIBILITY Assembler final : public MachOTool {
 public:
   Assembler(const ToolChain &TC)
       : MachOTool("darwin::Assembler", "assembler", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public MachOTool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public MachOTool {
   bool NeedsTempPath(const InputInfoList &Inputs) const;
   void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
                    llvm::opt::ArgStringList &CmdArgs,
                    const InputInfoList &Inputs, VersionTuple Version,
                    bool LinkerIsLLD) const;
 
 public:
   Linker(const ToolChain &TC) : MachOTool("darwin::Linker", "linker", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY StaticLibTool : public MachOTool {
+class LLVM_LIBRARY_VISIBILITY StaticLibTool final : public MachOTool {
 public:
   StaticLibTool(const ToolChain &TC)
       : MachOTool("darwin::StaticLibTool", "static-lib-linker", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool {
+class LLVM_LIBRARY_VISIBILITY Lipo final : public MachOTool {
 public:
   Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool {
+class LLVM_LIBRARY_VISIBILITY Dsymutil final : public MachOTool {
 public:
   Dsymutil(const ToolChain &TC)
       : MachOTool("darwin::Dsymutil", "dsymutil", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isDsymutilJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool {
+class LLVM_LIBRARY_VISIBILITY VerifyDebug final : public MachOTool {
 public:
   VerifyDebug(const ToolChain &TC)
       : MachOTool("darwin::VerifyDebug", "dwarfdump", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
public:
   bool SupportsEmbeddedBitcode() const override;
 
   SanitizerMask getSupportedSanitizers() const override;
 
   void printVerboseInfo(raw_ostream &OS) const override;
 };
 
 /// DarwinClang - The Darwin toolchain used by Clang.
-class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
+class LLVM_LIBRARY_VISIBILITY DarwinClang final : public Darwin {
 public:
   DarwinClang(const Driver &D, const llvm::Triple &Triple,
               const llvm::opt::ArgList &Args);
 
   /// @name Apple ToolChain Implementation
   /// {
 
   RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const override;

clang/lib/Driver/ToolChains/Fuchsia.h

 #include "clang/Basic/LangOptions.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 namespace tools {
 namespace fuchsia {
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("fuchsia::Linker", "ld.lld", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 } // end namespace fuchsia
 } // end namespace tools
 
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY Fuchsia : public ToolChain {
+class LLVM_LIBRARY_VISIBILITY Fuchsia final : public ToolChain {
 public:
   Fuchsia(const Driver &D, const llvm::Triple &Triple,
           const llvm::opt::ArgList &Args);
 
   bool HasNativeLLVMSupport() const override { return true; }
   bool IsIntegratedAssemblerDefault() const override { return true; }
   bool IsMathErrnoDefault() const override { return false; }
   bool useRelaxRelocations() const override { return true; };

clang/lib/Driver/ToolChains/Gnu.h

public:
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("GNU::Linker", "linker", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY StaticLibTool : public Tool {
+class LLVM_LIBRARY_VISIBILITY StaticLibTool final : public Tool {
 public:
   StaticLibTool(const ToolChain &TC)
       : Tool("GNU::StaticLibTool", "static-lib-linker", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
void ConstructJob(Compilation &C, const JobAction &JA,
                     const char *LinkingOutput) const override;
 
   /// RenderExtraToolArgs - Render any arguments necessary to force
   /// the particular tool mode.
   virtual void RenderExtraToolArgs(const JobAction &JA,
                                    llvm::opt::ArgStringList &CmdArgs) const = 0;
 };
 
-class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common {
+class LLVM_LIBRARY_VISIBILITY Preprocessor final : public Common {
 public:
   Preprocessor(const ToolChain &TC)
       : Common("gcc::Preprocessor", "gcc preprocessor", TC) {}
 
   bool hasGoodDiagnostics() const override { return true; }
   bool hasIntegratedCPP() const override { return false; }
 
   void RenderExtraToolArgs(const JobAction &JA,
                            llvm::opt::ArgStringList &CmdArgs) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Compiler : public Common {
+class LLVM_LIBRARY_VISIBILITY Compiler final : public Common {
 public:
   Compiler(const ToolChain &TC) : Common("gcc::Compiler", "gcc frontend", TC) {}
 
   bool hasGoodDiagnostics() const override { return true; }
   bool hasIntegratedCPP() const override { return true; }
 
   void RenderExtraToolArgs(const JobAction &JA,
                            llvm::opt::ArgStringList &CmdArgs) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Common {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Common {
 public:
   Linker(const ToolChain &TC) : Common("gcc::Linker", "linker (via gcc)", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void RenderExtraToolArgs(const JobAction &JA,
                            llvm::opt::ArgStringList &CmdArgs) const override;

clang/lib/Driver/ToolChains/Hexagon.h

 
 namespace clang {
 namespace driver {
 namespace tools {
 namespace hexagon {
 // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile
 // and Compile.
 // We simply use "clang -cc1" for those actions.
-class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
+class LLVM_LIBRARY_VISIBILITY Assembler final : public Tool {
 public:
   Assembler(const ToolChain &TC)
       : Tool("hexagon::Assembler", "hexagon-as", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
 
   void RenderExtraToolArgs(const JobAction &JA,
                            llvm::opt::ArgStringList &CmdArgs) const;
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("hexagon::Linker", "hexagon-ld", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   virtual void RenderExtraToolArgs(const JobAction &JA,
                                    llvm::opt::ArgStringList &CmdArgs) const;
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
 void getHexagonTargetFeatures(const Driver &D, const llvm::opt::ArgList &Args,
                               std::vector<StringRef> &Features);
 
 } // end namespace hexagon.
 } // end namespace tools
 
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY HexagonToolChain : public Linux {
+class LLVM_LIBRARY_VISIBILITY HexagonToolChain final : public Linux {
 protected:
   GCCVersion GCCLibAndIncVersion;
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 
   unsigned getOptimizationLevel(const llvm::opt::ArgList &DriverArgs) const;
 
 public:

clang/lib/Driver/ToolChains/Hurd.h

 
 #include "Gnu.h"
 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY Hurd : public Generic_ELF {
+class LLVM_LIBRARY_VISIBILITY Hurd final : public Generic_ELF {
 public:
   Hurd(const Driver &D, const llvm::Triple &Triple,
        const llvm::opt::ArgList &Args);
 
   bool HasNativeLLVMSupport() const override;
 
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,

clang/lib/Driver/ToolChains/Lanai.h

 
 #include "Gnu.h"
 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY LanaiToolChain : public Generic_ELF {
+class LLVM_LIBRARY_VISIBILITY LanaiToolChain final : public Generic_ELF {
 public:
   LanaiToolChain(const Driver &D, const llvm::Triple &Triple,
                  const llvm::opt::ArgList &Args)
       : Generic_ELF(D, Triple, Args) {}
 
   // No support for finding a C++ standard library yet.
   void addLibCxxIncludePaths(
       const llvm::opt::ArgList &DriverArgs,

clang/lib/Driver/ToolChains/MSP430.h

 
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace driver {
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY MSP430ToolChain : public Generic_ELF {
+class LLVM_LIBRARY_VISIBILITY MSP430ToolChain final : public Generic_ELF {
 public:
   MSP430ToolChain(const Driver &D, const llvm::Triple &Triple,
                   const llvm::opt::ArgList &Args);
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args,
private:
   std::string computeSysRoot() const override;
 };
 
 } // end namespace toolchains
 
 namespace tools {
 namespace msp430 {
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("MSP430::Linker", "msp430-elf-ld", TC) {}
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;

clang/lib/Driver/ToolChains/MSVC.h

 #include "llvm/WindowsDriver/MSVCPaths.h"
 
 namespace clang {
 namespace driver {
 namespace tools {
 
 /// Visual studio tools.
 namespace visualstudio {
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("visualstudio::Linker", "linker", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 } // end namespace visualstudio
 
 } // end namespace tools
 
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY MSVCToolChain : public ToolChain {
+class LLVM_LIBRARY_VISIBILITY MSVCToolChain final : public ToolChain {
 public:
   MSVCToolChain(const Driver &D, const llvm::Triple &Triple,
                 const llvm::opt::ArgList &Args);
 
   llvm::opt::DerivedArgList *
   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
                 Action::OffloadKind DeviceOffloadKind) const override;
 

clang/lib/Driver/ToolChains/MinGW.h

 #include "llvm/Support/ErrorOr.h"
 
 namespace clang {
 namespace driver {
 namespace tools {
 
 /// MinGW -- Directly call GNU Binutils assembler and linker
 namespace MinGW {
-class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
+class LLVM_LIBRARY_VISIBILITY Assembler final : public Tool {
 public:
   Assembler(const ToolChain &TC) : Tool("MinGW::Assemble", "assembler", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("MinGW::Linker", "linker", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 
 private:
   void AddLibGCC(const llvm::opt::ArgList &Args,
                  llvm::opt::ArgStringList &CmdArgs) const;
 };
 } // end namespace MinGW
 } // end namespace tools
 
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY MinGW : public ToolChain {
+class LLVM_LIBRARY_VISIBILITY MinGW final : public ToolChain {
 public:
   MinGW(const Driver &D, const llvm::Triple &Triple,
         const llvm::opt::ArgList &Args);
 
   static void fixTripleArch(const Driver &D, llvm::Triple &Triple,
                             const llvm::opt::ArgList &Args);
 
   bool HasNativeLLVMSupport() const override;

clang/lib/Driver/ToolChains/NaCl.h

 #include "Gnu.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 namespace tools {
 namespace nacltools {
-class LLVM_LIBRARY_VISIBILITY AssemblerARM : public gnutools::Assembler {
+class LLVM_LIBRARY_VISIBILITY AssemblerARM final : public gnutools::Assembler {
 public:
   AssemblerARM(const ToolChain &TC) : gnutools::Assembler(TC) {}
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("NaCl::Linker", "linker", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 } // end namespace nacltools
 } // end namespace tools
 
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY NaClToolChain : public Generic_ELF {
+class LLVM_LIBRARY_VISIBILITY NaClToolChain final : public Generic_ELF {
 public:
   NaClToolChain(const Driver &D, const llvm::Triple &Triple,
                 const llvm::opt::ArgList &Args);
 
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
   void addLibCxxIncludePaths(

clang/lib/Driver/ToolChains/OpenBSD.h

 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 namespace tools {
 
 /// openbsd -- Directly call GNU Binutils assembler and linker
 namespace openbsd {
-class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
+class LLVM_LIBRARY_VISIBILITY Assembler final : public Tool {
 public:
   Assembler(const ToolChain &TC)
       : Tool("openbsd::Assembler", "assembler", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("openbsd::Linker", "linker", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 } // end namespace openbsd
 } // end namespace tools
 
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
+class LLVM_LIBRARY_VISIBILITY OpenBSD final : public Generic_ELF {
 public:
   OpenBSD(const Driver &D, const llvm::Triple &Triple,
           const llvm::opt::ArgList &Args);
 
   bool HasNativeLLVMSupport() const override;
 
   bool IsMathErrnoDefault() const override { return false; }
   bool IsObjCNonFragileABIDefault() const override { return true; }

clang/lib/Driver/ToolChains/PPCFreeBSD.h

 #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_PPC_FREEBSD_H
 
 #include "FreeBSD.h"
 
 namespace clang {
 namespace driver {
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY PPCFreeBSDToolChain : public FreeBSD {
+class LLVM_LIBRARY_VISIBILITY PPCFreeBSDToolChain final : public FreeBSD {
 public:
   PPCFreeBSDToolChain(const Driver &D, const llvm::Triple &Triple,
                       const llvm::opt::ArgList &Args)
       : FreeBSD(D, Triple, Args) {}
 
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_PPC_FREEBSD_H

clang/lib/Driver/ToolChains/RISCVToolchain.h

 
 #include "Gnu.h"
 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY RISCVToolChain : public Generic_ELF {
+class LLVM_LIBRARY_VISIBILITY RISCVToolChain final : public Generic_ELF {
 public:
   RISCVToolChain(const Driver &D, const llvm::Triple &Triple,
                  const llvm::opt::ArgList &Args);
 
   static bool hasGCCToolchain(const Driver &D, const llvm::opt::ArgList &Args);
   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args,
                              Action::OffloadKind) const override;

 private:
   std::string computeSysRoot() const override;
 };
 
 } // end namespace toolchains
 
 namespace tools {
 namespace RISCV {
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("RISCV::Linker", "ld", TC) {}
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 } // end namespace RISCV
 } // end namespace tools
 
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_RISCVTOOLCHAIN_H

clang/lib/Driver/ToolChains/SPIRV.h

 void addTranslatorArgs(const llvm::opt::ArgList &InArgs,
                        llvm::opt::ArgStringList &OutArgs);
 
 void constructTranslateCommand(Compilation &C, const Tool &T,
                                const JobAction &JA, const InputInfo &Output,
                                const InputInfo &Input,
                                const llvm::opt::ArgStringList &Args);
 
-class LLVM_LIBRARY_VISIBILITY Translator : public Tool {
+class LLVM_LIBRARY_VISIBILITY Translator final : public Tool {
 public:
   Translator(const ToolChain &TC)
       : Tool("SPIR-V::Translator", "llvm-spirv", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
   bool hasIntegratedAssembler() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
-class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
 public:
   Linker(const ToolChain &TC) : Tool("SPIRV::Linker", "spirv-link", TC) {}
   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;

clang/lib/Driver/ToolChains/VEToolchain.h

 
 #include "Linux.h"
 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 namespace toolchains {
 
-class LLVM_LIBRARY_VISIBILITY VEToolChain : public Linux {
+class LLVM_LIBRARY_VISIBILITY VEToolChain final : public Linux {
 public:
   VEToolChain(const Driver &D, const llvm::Triple &Triple,
               const llvm::opt::ArgList &Args);
 
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 

clang/lib/Frontend/MultiplexConsumer.cpp

 void MultiplexASTDeserializationListener::ModuleImportRead(
     serialization::SubmoduleID ID, SourceLocation ImportLoc) {
   for (auto &Listener : Listeners)
     Listener->ModuleImportRead(ID, ImportLoc);
 }
 
 // This ASTMutationListener forwards its notifications to a set of
 // child listeners.
-class MultiplexASTMutationListener : public ASTMutationListener {
+class MultiplexASTMutationListener final : public ASTMutationListener {
 public:
   // Does NOT take ownership of the elements in L.
   MultiplexASTMutationListener(ArrayRef<ASTMutationListener*> L);
   void CompletedTagDefinition(const TagDecl *D) override;
   void AddedVisibleDecl(const DeclContext *DC, const Decl *D) override;
   void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) override;
   void AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
                             const ClassTemplateSpecializationDecl *D) override;

clang/lib/Sema/Sema.cpp

 void Sema::ActOnTranslationUnitScope(Scope *S) {
   TUScope = S;
   PushDeclContext(S, Context.getTranslationUnitDecl());
 }
 
 namespace clang {
 namespace sema {
 
-class SemaPPCallbacks : public PPCallbacks {
+class SemaPPCallbacks final : public PPCallbacks {
   Sema *S = nullptr;
   llvm::SmallVector<SourceLocation, 8> IncludeStack;
 
 public:
   void set(Sema &S) { this->S = &S; }
 
   void reset() { S = nullptr; }
 

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h

 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 
 namespace clang {
 namespace ento {
 namespace retaincountchecker {
 
-class RefCountBug : public BugType {
+class RefCountBug final : public BugType {
 public:
   enum RefCountBugKind {
     UseAfterRelease,
     ReleaseNotOwned,
     DeallocNotOwned,
     FreeNotOwned,
     OverAutorelease,
     ReturnNotOwnedForOwned,

llvm/include/llvm/CodeGen/GlobalISel/GISelKnownBits.h

 #include "llvm/InitializePasses.h"
 #include "llvm/Support/KnownBits.h"
 
 namespace llvm {
 
 class TargetLowering;
 class DataLayout;
 
-class GISelKnownBits : public GISelChangeObserver {
+class GISelKnownBits final : public GISelChangeObserver {
   MachineFunction &MF;
   MachineRegisterInfo &MRI;
   const TargetLowering &TL;
   const DataLayout &DL;
   unsigned MaxDepth;
   /// Cache maintained during a computeKnownBits request.
   SmallDenseMap<Register, KnownBits, 16> ComputeKnownBitsCache;
 

llvm/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

public:
   virtual void dump(raw_ostream &OS) const = 0;
 
   DWARFAcceleratorTable(const DWARFAcceleratorTable &) = delete;
   void operator=(const DWARFAcceleratorTable &) = delete;
 };
 
 /// This implements the Apple accelerator table format, a precursor of the
 /// DWARF 5 accelerator table format.
-class AppleAcceleratorTable : public DWARFAcceleratorTable {
+class AppleAcceleratorTable final : public DWARFAcceleratorTable {
   struct Header {
     uint32_t Magic;
     uint16_t Version;
     uint16_t HashFunction;
     uint32_t BucketCount;
     uint32_t HashCount;
     uint32_t HeaderDataLength;
 

 /// The structure of the entries is described by an abbreviations table, which
 /// comes after the name table. Unlike the apple tables, which have a uniform
 /// entry structure described in the header, each .debug_names entry may have
 /// different index attributes (DW_IDX_???) attached to it.
 ///
 /// The last segment consists of a list of entries, which is a 0-terminated list
 /// referenced by the name table and interpreted with the help of the
 /// abbreviation table.
-class DWARFDebugNames : public DWARFAcceleratorTable {
+class DWARFDebugNames final : public DWARFAcceleratorTable {
 public:
   class NameIndex;
   class NameIterator;
   class ValueIterator;
 
   /// DWARF v5 Name Index header.
   struct Header {
     uint64_t UnitLength;
public:
     void dump(ScopedPrinter &W) const;
 
     friend class NameIndex;
     friend class ValueIterator;
   };
 
   /// Error returned by NameIndex::getEntry to report it has reached the end of
   /// the entry list.
-  class SentinelError : public ErrorInfo<SentinelError> {
+  class SentinelError final : public ErrorInfo<SentinelError> {
   public:
     static char ID;
 
     void log(raw_ostream &OS) const override { OS << "Sentinel"; }
     std::error_code convertToErrorCode() const override;
   };
 
 private:

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

 class DWARFDebugNames;
 class DWARFGdbIndex;
 class DWARFTypeUnit;
 class DWARFUnitIndex;
 
 /// DWARFContext
 /// This data structure is the top level entity that deals with dwarf debug
 /// information parsing. The actual data is supplied through DWARFObj.
-class DWARFContext : public DIContext {
+class DWARFContext final : public DIContext {
   DWARFUnitVector NormalUnits;
   Optional<DenseMap<uint64_t, DWARFTypeUnit*>> NormalTypeUnits;
   std::unique_ptr<DWARFUnitIndex> CUIndex;
   std::unique_ptr<DWARFGdbIndex> GdbIndex;
   std::unique_ptr<DWARFUnitIndex> TUIndex;
   std::unique_ptr<DWARFDebugAbbrev> Abbrev;
   std::unique_ptr<DWARFDebugLoc> Loc;
   std::unique_ptr<DWARFDebugAranges> Aranges;

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

protected:
 
   /// Entry length as specified in DWARF.
   const uint64_t Length;
 
   CFIProgram CFIs;
 };
 
 /// DWARF Common Information Entry (CIE)
-class CIE : public FrameEntry {
+class CIE final : public FrameEntry {
 public:
   // CIEs (and FDEs) are simply container classes, so the only sensible way to
   // create them is by providing the full parsed contents in the constructor.
   CIE(bool IsDWARF64, uint64_t Offset, uint64_t Length, uint8_t Version,
       SmallString<8> Augmentation, uint8_t AddressSize,
       uint8_t SegmentDescriptorSize, uint64_t CodeAlignmentFactor,
       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister,
       SmallString<8> AugmentationData, uint32_t FDEPointerEncoding,
private:
   const SmallString<8> AugmentationData;
   const uint32_t FDEPointerEncoding;
   const uint32_t LSDAPointerEncoding;
   const Optional<uint64_t> Personality;
   const Optional<uint32_t> PersonalityEnc;
 };
 
 /// DWARF Frame Description Entry (FDE)
-class FDE : public FrameEntry {
+class FDE final : public FrameEntry {
 public:
   FDE(bool IsDWARF64, uint64_t Offset, uint64_t Length, uint64_t CIEPointer,
       uint64_t InitialLocation, uint64_t AddressRange, CIE *Cie,
       Optional<uint64_t> LSDAAddress, Triple::ArchType Arch)
       : FrameEntry(FK_FDE, IsDWARF64, Offset, Length,
                    Cie ? Cie->getCodeAlignmentFactor() : 0,
                    Cie ? Cie->getDataAlignmentFactor() : 0,
                    Arch),

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h

protected:
   void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
                     unsigned Indent, DIDumpOptions DumpOpts,
                     const DWARFObject &Obj) const override;
 
 private:
   uint16_t Version;
 };
 
-class ResolverError : public ErrorInfo<ResolverError> {
+class ResolverError final : public ErrorInfo<ResolverError> {
 public:
   static char ID;
 
   ResolverError(uint32_t Index, dwarf::LoclistEntries Kind) : Index(Index), Kind(Kind) {}
 
   void log(raw_ostream &OS) const override;
   std::error_code convertToErrorCode() const override {
     return llvm::errc::invalid_argument;

llvm/include/llvm/Object/COFF.h

 };
 
 struct debug_h_header {
   support::ulittle32_t Magic;
   support::ulittle16_t Version;
   support::ulittle16_t HashAlgorithm;
 };
 
-class COFFObjectFile : public ObjectFile {
+class COFFObjectFile final : public ObjectFile {
 private:
   COFFObjectFile(MemoryBufferRef Object);
 
   friend class ImportDirectoryEntryRef;
   friend class ExportDirectoryEntryRef;
   const coff_file_header *COFFHeader;
   const coff_bigobj_file_header *COFFBigObjHeader;
   const pe32_header *PE32Header;

llvm/include/llvm/Object/MachO.h

private:
   ArrayRef<uint8_t> SegmentData;
   FixupKind Kind;
   uint32_t InfoSegIndex = 0; // Index into Segments
   uint32_t PageIndex = 0;    // Index into Segments[InfoSegIdx].PageStarts
   uint32_t PageOffset = 0;   // Page offset of the current fixup
 };
 using fixup_iterator = content_iterator<MachOChainedFixupEntry>;
 
-class MachOObjectFile : public ObjectFile {
+class MachOObjectFile final : public ObjectFile {
 public:
   struct LoadCommandInfo {
     const char *Ptr;      // Where in memory the load command is.
     MachO::load_command C; // The command itself.
   };
   using LoadCommandList = SmallVector<LoadCommandInfo, 4>;
   using load_command_iterator = LoadCommandList::const_iterator;
 

llvm/include/llvm/Object/Wasm.h

struct WasmSection {
   std::vector<wasm::WasmRelocation> Relocations; // Relocations for this section
 };
 
 struct WasmSegment {
   uint32_t SectionOffset;
   wasm::WasmDataSegment Data;
 };
 
-class WasmObjectFile : public ObjectFile {
+class WasmObjectFile final : public ObjectFile {
 
 public:
   WasmObjectFile(MemoryBufferRef Object, Error &Err);
 
   const wasm::WasmObjectHeader &getHeader() const;
   const WasmSymbol &getWasmSymbol(const DataRefImpl &Symb) const;
   const WasmSymbol &getWasmSymbol(const SymbolRef &Symbol) const;
   const WasmSection &getWasmSection(const SectionRef &Section) const;

llvm/include/llvm/Object/XCOFFObjectFile.h

 extern template struct XCOFFRelocation<llvm::support::ubig32_t>;
 extern template struct XCOFFRelocation<llvm::support::ubig64_t>;
 
 struct XCOFFRelocation32 : XCOFFRelocation<llvm::support::ubig32_t> {};
 struct XCOFFRelocation64 : XCOFFRelocation<llvm::support::ubig64_t> {};
 
 class XCOFFSymbolRef;
 
-class XCOFFObjectFile : public ObjectFile {
+class XCOFFObjectFile final : public ObjectFile {
 private:
   const void *FileHeader = nullptr;
   const void *AuxiliaryHeader = nullptr;
   const void *SectionHeaderTable = nullptr;
 
   const void *SymbolTblPtr = nullptr;
   XCOFFStringTable StringTable = {0, nullptr};
 

llvm/include/llvm/ProfileData/InstrProfReader.h

 public:
   virtual ~InstrProfReaderRemapper() = default;
   virtual Error populateRemappings() { return Error::success(); }
   virtual Error getRecords(StringRef FuncName,
                            ArrayRef<NamedInstrProfRecord> &Data) = 0;
 };
 
 /// Reader for the indexed binary instrprof format.
-class IndexedInstrProfReader : public InstrProfReader {
+class IndexedInstrProfReader final : public InstrProfReader {
 private:
   /// The profile data file contents.
   std::unique_ptr<MemoryBuffer> DataBuffer;
   /// The profile remapping file contents.
   std::unique_ptr<MemoryBuffer> RemappingBuffer;
   /// The index into the profile data.
   std::unique_ptr<InstrProfReaderIndexBase> Index;
   /// The profile remapping file contents.

llvm/include/llvm/Support/VirtualFileSystem.h

 ///
 /// Consists of a stack of >=1 \p FileSystem objects, which are treated as being
 /// one merged file system. When there is a directory that exists in more than
 /// one file system, the \p OverlayFileSystem contains a directory containing
 /// the union of their contents.  The attributes (permissions, etc.) of the
 /// top-most (most recently added) directory are used.  When there is a file
 /// that exists in more than one file system, the file in the top-most file
 /// system overrides the other(s).
-class OverlayFileSystem : public FileSystem {
+class OverlayFileSystem final : public FileSystem {
   using FileSystemList = SmallVector<IntrusiveRefCntPtr<FileSystem>, 1>;
 
   /// The stack of file systems, implemented as a list in order of
   /// their addition.
   FileSystemList FSList;
 
 public:
   OverlayFileSystem(IntrusiveRefCntPtr<FileSystem> Base);
public:
   operator std::error_code() const { return Value.getError(); }
   std::error_code getError() const { return Value.getError(); }
   const detail::InMemoryNode *operator*() const { return (*Value).second; }
 };
 
 } // namespace detail
 
 /// An in-memory file system.
-class InMemoryFileSystem : public FileSystem {
+class InMemoryFileSystem final : public FileSystem {
   std::unique_ptr<detail::InMemoryDirectory> Root;
   std::string WorkingDirectory;
   bool UseNormalizedPaths = true;
 
   using MakeNodeFn = llvm::function_ref<std::unique_ptr<detail::InMemoryNode>(
       detail::NewInMemoryNodeInfo)>;
 
   /// Create node with \p MakeNode and add it into this filesystem at \p Path.

 /// was accessed by. This is an intentional leak through the \a
 /// RedirectingFileSystem abstraction layer. It enables clients to discover
 /// (and use) the external file location when communicating with users or tools
 /// that don't use the same VFS overlay.
 ///
 /// FIXME: 'use-external-name' causes behaviour that's inconsistent with how
 /// "real" filesystems behave. Maybe there should be a separate channel for
 /// this information.
-class RedirectingFileSystem : public vfs::FileSystem {
+class RedirectingFileSystem final : public vfs::FileSystem {
 public:
   enum EntryKind { EK_Directory, EK_DirectoryRemap, EK_File };
   enum NameKind { NK_NotSet, NK_External, NK_Virtual };
 
   /// The type of redirection to perform.
   enum class RedirectKind {
     /// Lookup the redirected path first (ie. the one specified in
     /// 'external-contents') and if that fails "fallthrough" to a lookup of the
public:
     Entry(EntryKind K, StringRef Name) : Kind(K), Name(Name) {}
     virtual ~Entry() = default;
 
     StringRef getName() const { return Name; }
     EntryKind getKind() const { return Kind; }
   };
 
   /// A directory in the vfs with explicitly specified contents.
-  class DirectoryEntry : public Entry {
+  class DirectoryEntry final : public Entry {
     std::vector<std::unique_ptr<Entry>> Contents;
     Status S;
 
   public:
     /// Constructs a directory entry with explicitly specified contents.
     DirectoryEntry(StringRef Name, std::vector<std::unique_ptr<Entry>> Contents,
                    Status S)
         : Entry(EK_Directory, Name), Contents(std::move(Contents)),
static bool classof(const Entry *E) {
         return false;
       }
       llvm_unreachable("invalid entry kind");
     }
   };
 
   /// A directory in the vfs that maps to a directory in the external file
   /// system.
-  class DirectoryRemapEntry : public RemapEntry {
+  class DirectoryRemapEntry final : public RemapEntry {
   public:
     DirectoryRemapEntry(StringRef Name, StringRef ExternalContentsPath,
                         NameKind UseName)
         : RemapEntry(EK_DirectoryRemap, Name, ExternalContentsPath, UseName) {}
 
     static bool classof(const Entry *E) {
       return E->getKind() == EK_DirectoryRemap;
     }
   };
 
   /// A file in the vfs that maps to a file in the external file system.
-  class FileEntry : public RemapEntry {
+  class FileEntry final : public RemapEntry {
   public:
     FileEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
         : RemapEntry(EK_File, Name, ExternalContentsPath, UseName) {}
 
     static bool classof(const Entry *E) { return E->getKind() == EK_File; }
   };
 
   /// Represents the result of a path lookup into the RedirectingFileSystem.

llvm/include/llvm/TableGen/Record.h

public:
 
   std::string getAsString() const override;
 
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
 };
 
 /// 'list<Ty>' - Represent a list of element values, all of which must be of
 /// the specified type. The type is stored in ElementTy.
-class ListRecTy : public RecTy {
+class ListRecTy final : public RecTy {
   friend ListRecTy *RecTy::getListTy();
 
   RecTy *ElementTy;
 
   explicit ListRecTy(RecTy *T)
       : RecTy(ListRecTyKind, T->getRecordKeeper()), ElementTy(T) {}
 
 public:
public:
 
   Init *getBit(unsigned Bit) const override {
     assert(Bit < NumBits && "Bit index out of range!");
     return getTrailingObjects<Init *>()[Bit];
   }
 };
 
 /// '7' - Represent an initialization by a literal integer value.
-class IntInit : public TypedInit {
+class IntInit final : public TypedInit {
   int64_t Value;
 
   explicit IntInit(RecordKeeper &RK, int64_t V)
       : TypedInit(IK_IntInit, IntRecTy::get(RK)), Value(V) {}
 
 public:
   IntInit(const IntInit &) = delete;
   IntInit &operator=(const IntInit &) = delete;
public:
   std::string getAsString() const override;
 
   Init *getBit(unsigned Bit) const override {
     return BitInit::get(getRecordKeeper(), (Value & (1ULL << Bit)) != 0);
   }
 };
 
 /// "anonymous_n" - Represent an anonymous record name
-class AnonymousNameInit : public TypedInit {
+class AnonymousNameInit final : public TypedInit {
   unsigned Value;
 
   explicit AnonymousNameInit(RecordKeeper &RK, unsigned V)
       : TypedInit(IK_AnonymousNameInit, StringRecTy::get(RK)), Value(V) {}
 
 public:
   AnonymousNameInit(const AnonymousNameInit &) = delete;
   AnonymousNameInit &operator=(const AnonymousNameInit &) = delete;
public:
   Init *resolveReferences(Resolver &R) const override;
 
   Init *getBit(unsigned Bit) const override {
     llvm_unreachable("Illegal bit reference off string");
   }
 };
 
 /// "foo" - Represent an initialization by a string value.
-class StringInit : public TypedInit {
+class StringInit final : public TypedInit {
 public:
   enum StringFormat {
     SF_String, // Format as "text"
     SF_Code,   // Format as [{text}]
   };
 
 private:
   StringRef Value;
public:
   virtual unsigned getNumOperands() const = 0;
   virtual Init *getOperand(unsigned i) const = 0;
 
   Init *getBit(unsigned Bit) const override;
 };
 
 /// !op (X) - Transform an init.
 ///
-class UnOpInit : public OpInit, public FoldingSetNode {
+class UnOpInit final : public OpInit, public FoldingSetNode {
 public:
   enum UnaryOp : uint8_t { CAST, NOT, HEAD, TAIL, SIZE, EMPTY, GETDAGOP, LOG2 };
 
 private:
   Init *LHS;
 
   UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
     : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {}
public:
   Init *resolveReferences(Resolver &R) const override;
 
   Init *getBit(unsigned Bit) const override;
 
   std::string getAsString() const override;
 };
 
 /// 'Opcode' - Represent a reference to an entire variable object.
-class VarInit : public TypedInit {
+class VarInit final : public TypedInit {
   Init *VarName;
 
   explicit VarInit(Init *VN, RecTy *T)
       : TypedInit(IK_VarInit, T), VarName(VN) {}
 
 public:
   VarInit(const VarInit &) = delete;
   VarInit &operator=(const VarInit &) = delete;
public:
 
   std::string getAsString() const override;
   Init *resolveReferences(Resolver &R) const override;
 
   Init *getBit(unsigned Bit) const override;
 };
 
 /// AL - Represent a reference to a 'def' in the description
-class DefInit : public TypedInit {
+class DefInit final : public TypedInit {
   friend class Record;
 
   Record *Def;
 
   explicit DefInit(Record *D);
 
 public:
   DefInit(const DefInit &) = delete;

llvm/lib/Support/VirtualFileSystem.cpp

public:
   virtual Status getStatus(const Twine &RequestedName) const = 0;
 
   /// Get the filename of this node (the name without the directory part).
   StringRef getFileName() const { return FileName; }
   InMemoryNodeKind getKind() const { return Kind; }
   virtual std::string toString(unsigned Indent) const = 0;
 };
 
-class InMemoryFile : public InMemoryNode {
+class InMemoryFile final : public InMemoryNode {
   Status Stat;
   std::unique_ptr<llvm::MemoryBuffer> Buffer;
 
 public:
   InMemoryFile(Status Stat, std::unique_ptr<llvm::MemoryBuffer> Buffer)
       : InMemoryNode(Stat.getName(), IME_File), Stat(std::move(Stat)),
         Buffer(std::move(Buffer)) {}
 
public:
   }
 
   std::error_code close() override { return {}; }
 
   void setPath(const Twine &Path) override { RequestedName = Path.str(); }
 };
 } // namespace
 
-class InMemoryDirectory : public InMemoryNode {
+class InMemoryDirectory final : public InMemoryNode {
   Status Stat;
   llvm::StringMap<std::unique_ptr<InMemoryNode>> Entries;
 
 public:
   InMemoryDirectory(Status Stat)
       : InMemoryNode(Stat.getName(), IME_Directory), Stat(std::move(Stat)) {}
 
   /// Return the \p Status for this node. \p RequestedName should be the name
if (auto *F = dyn_cast<detail::InMemoryFile>(*Node))
     return std::unique_ptr<File>(
         new detail::InMemoryFileAdaptor(*F, Path.str()));
 
   // FIXME: errc::not_a_file?
   return make_error_code(llvm::errc::invalid_argument);
 }
 
 /// Adaptor from InMemoryDir::iterator to directory_iterator.
-class InMemoryFileSystem::DirIterator : public llvm::vfs::detail::DirIterImpl {
+class InMemoryFileSystem::DirIterator final : public llvm::vfs::detail::DirIterImpl {
   const InMemoryFileSystem *FS;
   detail::InMemoryDirectory::const_iterator I;
   detail::InMemoryDirectory::const_iterator E;
   std::string RequestedDirName;
 
   void setCurrentEntry() {
     if (I != E) {
       SmallString<256> Path(RequestedDirName);
if (ExternalFS)
     if (auto ExternalWorkingDirectory =
             ExternalFS->getCurrentWorkingDirectory()) {
       WorkingDirectory = *ExternalWorkingDirectory;
     }
 }
 
 /// Directory iterator implementation for \c RedirectingFileSystem's
 /// directory entries.
-class llvm::vfs::RedirectingFSDirIterImpl
+class llvm::vfs::RedirectingFSDirIterImpl final
     : public llvm::vfs::detail::DirIterImpl {
   std::string Dir;
   RedirectingFileSystem::DirectoryEntry::iterator Current, End;
 
   std::error_code incrementImpl(bool IsFirstTime) {
     assert((IsFirstTime || Current != End) && "cannot iterate past end");
     if (!IsFirstTime)
       ++Current;

llvm/lib/Target/AArch64/AArch64FrameLowering.h

 #ifndef LLVM_LIB_TARGET_AARCH64_AARCH64FRAMELOWERING_H
 #define LLVM_LIB_TARGET_AARCH64_AARCH64FRAMELOWERING_H
 
 #include "llvm/Support/TypeSize.h"
 #include "llvm/CodeGen/TargetFrameLowering.h"
 
 namespace llvm {
 
-class AArch64FrameLowering : public TargetFrameLowering {
+class AArch64FrameLowering final : public TargetFrameLowering {
 public:
   explicit AArch64FrameLowering()
       : TargetFrameLowering(StackGrowsDown, Align(16), 0, Align(16),
                             true /*StackRealignable*/) {}
 
   void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator MBBI) const;
 

llvm/lib/Target/AArch64/AArch64ISelLowering.h

 };
 
 // Bit position of rounding mode bits in FPCR.
 const unsigned RoundingBitsPos = 22;
 } // namespace AArch64
 
 class AArch64Subtarget;
 
-class AArch64TargetLowering : public TargetLowering {
+class AArch64TargetLowering final : public TargetLowering {
 public:
   explicit AArch64TargetLowering(const TargetMachine &TM,
                                  const AArch64Subtarget &STI);
 
   /// Control the following reassociation of operands: (op (op x, c1), y) -> (op
   /// (op x, y), c1) where N0 is (op x, c1) and N1 is y.
   bool isReassocProfitable(SelectionDAG &DAG, SDValue N0,
                            SDValue N1) const override;

llvm/lib/Target/AArch64/MCTargetDesc/AArch64InstPrinter.h

protected:
   template <int Width>
   void printZPRasFPR(const MCInst *MI, unsigned OpNum,
                      const MCSubtargetInfo &STI, raw_ostream &O);
   template <unsigned ImmIs0, unsigned ImmIs1>
   void printExactFPImm(const MCInst *MI, unsigned OpNum,
                        const MCSubtargetInfo &STI, raw_ostream &O);
 };
 
-class AArch64AppleInstPrinter : public AArch64InstPrinter {
+class AArch64AppleInstPrinter final : public AArch64InstPrinter {
 public:
   AArch64AppleInstPrinter(const MCAsmInfo &MAI, const MCInstrInfo &MII,
                           const MCRegisterInfo &MRI);
 
   void printInst(const MCInst *MI, uint64_t Address, StringRef Annot,
                  const MCSubtargetInfo &STI, raw_ostream &O) override;
 
   std::pair<const char *, uint64_t> getMnemonic(const MCInst *MI) override;

llvm/lib/Target/ARM/ARMISelLowering.h

namespace ARM {
 
     bool isBitFieldInvertedMask(unsigned v);
 
   } // end namespace ARM
 
   //===--------------------------------------------------------------------===//
   //  ARMTargetLowering - ARM Implementation of the TargetLowering interface
 
-  class ARMTargetLowering : public TargetLowering {
+  class ARMTargetLowering final : public TargetLowering {
   public:
     explicit ARMTargetLowering(const TargetMachine &TM,
                                const ARMSubtarget &STI);
 
     unsigned getJumpTableEncoding() const override;
     bool useSoftFloat() const override;
 
     SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;

llvm/lib/Target/ARM/ARMSubtarget.h

 #include "ARMGenSubtargetInfo.inc"
 
 namespace llvm {
 
 class ARMBaseTargetMachine;
 class GlobalValue;
 class StringRef;
 
-class ARMSubtarget : public ARMGenSubtargetInfo {
+class ARMSubtarget final : public ARMGenSubtargetInfo {
 protected:
   enum ARMProcFamilyEnum {
     Others,
 
     CortexA12,
     CortexA15,
     CortexA17,
     CortexA32,

llvm/lib/Target/ARM/MCTargetDesc/ARMInstPrinter.h

 #ifndef LLVM_LIB_TARGET_ARM_MCTARGETDESC_ARMINSTPRINTER_H
 #define LLVM_LIB_TARGET_ARM_MCTARGETDESC_ARMINSTPRINTER_H
 
 #include "MCTargetDesc/ARMMCTargetDesc.h"
 #include "llvm/MC/MCInstPrinter.h"
 
 namespace llvm {
 
-class ARMInstPrinter : public MCInstPrinter {
+class ARMInstPrinter final : public MCInstPrinter {
 public:
   ARMInstPrinter(const MCAsmInfo &MAI, const MCInstrInfo &MII,
                  const MCRegisterInfo &MRI);
 
   bool applyTargetSpecificCLOption(StringRef Opt) override;
 
   void printInst(const MCInst *MI, uint64_t Address, StringRef Annot,
                  const MCSubtargetInfo &STI, raw_ostream &O) override;

llvm/lib/Target/X86/X86FrameLowering.h

 namespace llvm {
 
 class MachineInstrBuilder;
 class MCCFIInstruction;
 class X86InstrInfo;
 class X86Subtarget;
 class X86RegisterInfo;
 
-class X86FrameLowering : public TargetFrameLowering {
+class X86FrameLowering final : public TargetFrameLowering {
 public:
   X86FrameLowering(const X86Subtarget &STI, MaybeAlign StackAlignOverride);
 
   // Cached subtarget predicates.
 
   const X86Subtarget &STI;
   const X86InstrInfo &TII;
   const X86RegisterInfo *TRI;

llvm/utils/TableGen/DAGISelMatcher.h

private:
   bool isEqualImpl(const Matcher *M) const override {
     return cast<CheckPredicateMatcher>(M)->Pred == Pred;
   }
 };
 
 
 /// CheckOpcodeMatcher - This checks to see if the current node has the
 /// specified opcode, if not it fails to match.
-class CheckOpcodeMatcher : public Matcher {
+class CheckOpcodeMatcher final : public Matcher {
   const SDNodeInfo &Opcode;
 public:
   CheckOpcodeMatcher(const SDNodeInfo &opcode)
     : Matcher(CheckOpcode), Opcode(opcode) {}
 
   const SDNodeInfo &getOpcode() const { return Opcode; }
 
   static bool classof(const Matcher *N) {

 
 private:
   void printImpl(raw_ostream &OS, unsigned indent) const override;
   bool isEqualImpl(const Matcher *M) const override { return false; }
 };
 
 /// CheckTypeMatcher - This checks to see if the current node has the
 /// specified type at the specified result, if not it fails to match.
-class CheckTypeMatcher : public Matcher {
+class CheckTypeMatcher final : public Matcher {
   MVT::SimpleValueType Type;
   unsigned ResNo;
 public:
   CheckTypeMatcher(MVT::SimpleValueType type, unsigned resno)
     : Matcher(CheckType), Type(type), ResNo(resno) {}
 
   MVT::SimpleValueType getType() const { return Type; }
   unsigned getResNo() const { return ResNo; }

llvm/utils/TableGen/GlobalISel/GIMatchDagPredicate.h

public:
   virtual void print(raw_ostream &OS) const;
   virtual void printDescription(raw_ostream &OS) const;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   virtual LLVM_DUMP_METHOD void dump() const { print(errs()); }
 #endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 };
 
-class GIMatchDagOpcodePredicate : public GIMatchDagPredicate {
+class GIMatchDagOpcodePredicate final : public GIMatchDagPredicate {
   const CodeGenInstruction &Instr;
 
 public:
   GIMatchDagOpcodePredicate(GIMatchDagContext &Ctx, StringRef Name,
                             const CodeGenInstruction &Instr);
 
   static bool classof(const GIMatchDagPredicate *P) {
     return P->getKind() == GIMatchDagPredicateKind_Opcode;
   }
 
   const CodeGenInstruction *getInstr() const { return &Instr; }
 
   void printDescription(raw_ostream &OS) const override;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const override { print(errs()); }
 #endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 };
 
-class GIMatchDagOneOfOpcodesPredicate : public GIMatchDagPredicate {
+class GIMatchDagOneOfOpcodesPredicate final : public GIMatchDagPredicate {
   SmallVector<const CodeGenInstruction *, 4> Instrs;
 
 public:
   GIMatchDagOneOfOpcodesPredicate(GIMatchDagContext &Ctx, StringRef Name);
 
   void addOpcode(const CodeGenInstruction *Instr) { Instrs.push_back(Instr); }
 
   static bool classof(const GIMatchDagPredicate *P) {
     return P->getKind() == GIMatchDagPredicateKind_OneOfOpcodes;
   }
 
   const SmallVectorImpl<const CodeGenInstruction *> &getInstrs() const {
     return Instrs;
   }
 
   void printDescription(raw_ostream &OS) const override;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const override { print(errs()); }
 #endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 };
 
-class GIMatchDagSameMOPredicate : public GIMatchDagPredicate {
+class GIMatchDagSameMOPredicate final : public GIMatchDagPredicate {
 public:
   GIMatchDagSameMOPredicate(GIMatchDagContext &Ctx, StringRef Name);
 
   static bool classof(const GIMatchDagPredicate *P) {
     return P->getKind() == GIMatchDagPredicateKind_SameMO;
   }
 
   void printDescription(raw_ostream &OS) const override;

llvm/utils/TableGen/GlobalISel/GIMatchTree.h

 ///   including the wildcard nullptr partition. What becomes known as a result
 ///   varies between partitions.
 /// * If the instruction to be tested is not declared then add the leaf to all
 ///   partitions. This occurs when we encounter one rule that is a superset of
 ///   the other and we are still matching the remainder of the superset. The
 ///   result is that the cases that don't match the superset will match the
 ///   subset rule, while the ones that do match the superset will match either
 ///   (which one is algorithm dependent but will usually be the superset).
-class GIMatchTreeOpcodePartitioner : public GIMatchTreePartitioner {
+class GIMatchTreeOpcodePartitioner final : public GIMatchTreePartitioner {
   unsigned InstrID;
   DenseMap<const CodeGenInstruction *, unsigned> InstrToPartition;
   std::vector<const CodeGenInstruction *> PartitionToInstr;
   std::vector<BitVector> TestedPredicates;
 
 public:
   GIMatchTreeOpcodePartitioner(unsigned InstrID) : InstrID(InstrID) {}
 
void applyForPartition(unsigned Idx, GIMatchTreeBuilder &SubBuilder,
                          GIMatchTreeBuilder &Builder) override;
 
   void emitPartitionResults(raw_ostream &OS) const override;
 
   void generatePartitionSelectorCode(raw_ostream &OS,
                                      StringRef Indent) const override;
 };
 
-class GIMatchTreeVRegDefPartitioner : public GIMatchTreePartitioner {
+class GIMatchTreeVRegDefPartitioner final : public GIMatchTreePartitioner {
   unsigned NewInstrID = -1;
   unsigned InstrID;
   unsigned OpIdx;
   std::vector<BitVector> TraversedEdges;
   DenseMap<unsigned, unsigned> ResultToPartition;
   BitVector PartitionToResult;
 
   void addToPartition(bool Result, unsigned LeafIdx);