Roll-back r250822.

[angelgarcia]

Summary

It breaks the build for the ASTMatchers

[ariccio]

Whatever happened to this? What in ASTMatchers did it break? It seems like a good change, and nobody followed up to fix it?

[ariccio]

See original diff here: http://reviews.llvm.org/D13890

[angelgarcia]

The compiler complained about creating constant instances of classes
without a user provided constructor (which is the case for the ASTMatchers).

I gave up this change because it broke the build for a huge amount of
people and I didn't want that to happen again.

[ariccio]

In D13893#343436, @angelgarcia wrote:

The compiler complained about creating constant instances of classes
without a user provided constructor (which is the case for the ASTMatchers).

I gave up this change because it broke the build for a huge amount of
people and I didn't want that to happen again.

Ahh, ok. I saw one of these in MemRegion.cpp, and noticed this.

include/clang/AST/ASTConsumer.h

class ASTConsumer {
   /// semantic analysis.
   bool SemaConsumer;
 
   friend class SemaConsumer;
 
 public:
   ASTConsumer() : SemaConsumer(false) { }
 
-  virtual ~ASTConsumer() = default;
+  virtual ~ASTConsumer() {}
 
   /// Initialize - This is called to initialize the consumer, providing the
   /// ASTContext.
   virtual void Initialize(ASTContext &Context) {}
 
   /// HandleTopLevelDecl - Handle the specified top-level declaration.  This is
   /// called by the parser to process every top-level Decl*.
   ///

include/clang/AST/CanonicalType.h

 ///
 /// The CanProxy type mainly exists as a proxy through which operator-> will
 /// look to either map down to a raw T* (e.g., PointerType*) or to a proxy
 /// type that provides canonical-type access to the fields of the type.
 template<typename T>
 class CanProxy : public CanProxyAdaptor<T> {
 public:
   /// \brief Build a NULL proxy.
-  CanProxy() = default;
+  CanProxy() { }
 
   /// \brief Build a proxy to the given canonical type.
   CanProxy(CanQual<T> Stored) { this->Stored = Stored; }
 
   /// \brief Implicit conversion to the stored canonical type.
   operator CanQual<T>() const { return this->Stored; }
 };
 

 template <typename InputIterator>
 struct CanTypeIterator
     : llvm::iterator_adaptor_base<
           CanTypeIterator<InputIterator>, InputIterator,
           typename std::iterator_traits<InputIterator>::iterator_category,
           CanQualType,
           typename std::iterator_traits<InputIterator>::difference_type,
           CanProxy<Type>, CanQualType> {
-  CanTypeIterator() = default;
+  CanTypeIterator() {}
   explicit CanTypeIterator(InputIterator Iter)
       : CanTypeIterator::iterator_adaptor_base(std::move(Iter)) {}
 
   CanQualType operator*() const { return CanQualType::CreateUnsafe(*this->I); }
   CanProxy<Type> operator->() const;
 };
 
 template<>

include/clang/AST/DeclFriend.h

 
 /// An iterator over the friend declarations of a class.
 class CXXRecordDecl::friend_iterator {
   FriendDecl *Ptr;
 
   friend class CXXRecordDecl;
   explicit friend_iterator(FriendDecl *Ptr) : Ptr(Ptr) {}
 public:
-  friend_iterator() = default;
+  friend_iterator() {}
 
   typedef FriendDecl *value_type;
   typedef FriendDecl *reference;
   typedef FriendDecl *pointer;
   typedef int difference_type;
   typedef std::forward_iterator_tag iterator_category;
 
   reference operator*() const { return Ptr; }

include/clang/AST/DeclTemplate.h

template <typename EntryType, typename SETraits = SpecEntryTraits<EntryType>,
             typename DeclType = typename SETraits::DeclType>
   struct SpecIterator
       : llvm::iterator_adaptor_base<
             SpecIterator<EntryType, SETraits, DeclType>,
             typename llvm::FoldingSetVector<EntryType>::iterator,
             typename std::iterator_traits<typename llvm::FoldingSetVector<
                 EntryType>::iterator>::iterator_category,
             DeclType *, ptrdiff_t, DeclType *, DeclType *> {
-    SpecIterator() = default;
+    SpecIterator() {}
     explicit SpecIterator(
         typename llvm::FoldingSetVector<EntryType>::iterator SetIter)
         : SpecIterator::iterator_adaptor_base(std::move(SetIter)) {}
 
     DeclType *operator*() const {
       return SETraits::getDecl(&*this->I)->getMostRecentDecl();
     }
     DeclType *operator->() const { return **this; }

include/clang/AST/Expr.h

private:
     unsigned short Kind;
     unsigned short Modifiable;
 
     explicit Classification(Kinds k, ModifiableType m)
       : Kind(k), Modifiable(m)
     {}
 
   public:
-    Classification() = default;
+    Classification() {}
 
     Kinds getKind() const { return static_cast<Kinds>(Kind); }
     ModifiableType getModifiable() const {
       assert(Modifiable != CM_Untested && "Did not test for modifiability.");
       return static_cast<ModifiableType>(Modifiable);
     }
     bool isLValue() const { return Kind == CL_LValue; }
     bool isXValue() const { return Kind == CL_XValue; }
union {
       /// A field designator, e.g., ".x".
       struct FieldDesignator Field;
       /// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
       struct ArrayOrRangeDesignator ArrayOrRange;
     };
     friend class DesignatedInitExpr;
 
   public:
-    Designator() = default;
+    Designator() {}
 
     /// @brief Initializes a field designator.
     Designator(const IdentifierInfo *FieldName, SourceLocation DotLoc,
                SourceLocation FieldLoc)
       : Kind(FieldDesignator) {
       Field.NameOrField = reinterpret_cast<uintptr_t>(FieldName) | 0x01;
       Field.DotLoc = DotLoc.getRawEncoding();
       Field.FieldLoc = FieldLoc.getRawEncoding();

include/clang/AST/ExprCXX.h

: Expr(ArrayTypeTraitExprClass, ty, VK_RValue, OK_Ordinary,
       ATT(att), Value(value), Dimension(dimension),
       Loc(loc), RParen(rparen), QueriedType(queried) { }
 
 
   explicit ArrayTypeTraitExpr(EmptyShell Empty)
     : Expr(ArrayTypeTraitExprClass, Empty), ATT(0), Value(false),
       QueriedType() { }
 
-  virtual ~ArrayTypeTraitExpr() = default;
+  virtual ~ArrayTypeTraitExpr() { }
 
   SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
   SourceLocation getLocEnd() const LLVM_READONLY { return RParen; }
 
   ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); }
 
   QualType getQueriedType() const { return QueriedType->getType(); }
 

include/clang/AST/Mangle.h

 public:
   ManglerKind getKind() const { return Kind; }
 
   explicit MangleContext(ASTContext &Context,
                          DiagnosticsEngine &Diags,
                          ManglerKind Kind)
       : Context(Context), Diags(Diags), Kind(Kind) {}
 
-  virtual ~MangleContext() = default;
+  virtual ~MangleContext() { }
 
   ASTContext &getASTContext() const { return Context; }
 
   DiagnosticsEngine &getDiags() const { return Diags; }
 
   virtual void startNewFunction() { LocalBlockIds.clear(); }
   
   unsigned getBlockId(const BlockDecl *BD, bool Local) {

include/clang/AST/MangleNumberingContext.h

 class TagDecl;
 class Type;
 class VarDecl;
 
 /// \brief Keeps track of the mangled names of lambda expressions and block
 /// literals within a particular context.
 class MangleNumberingContext : public RefCountedBase<MangleNumberingContext> {
 public:
-  virtual ~MangleNumberingContext() = default;
+  virtual ~MangleNumberingContext() {}
 
   /// \brief Retrieve the mangling number of a new lambda expression with the
   /// given call operator within this context.
   virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator) = 0;
 
   /// \brief Retrieve the mangling number of a new block literal within this
   /// context.
   virtual unsigned getManglingNumber(const BlockDecl *BD) = 0;

include/clang/AST/Redeclarable.h

 Decl *getPrimaryMergedDecl(Decl *D);
 
 /// \brief Provides common interface for the Decls that cannot be redeclared,
 /// but can be merged if the same declaration is brought in from multiple
 /// modules.
 template<typename decl_type>
 class Mergeable {
 public:
-  Mergeable() = default;
+  Mergeable() {}
 
   /// \brief Return the first declaration of this declaration or itself if this
   /// is the only declaration.
   decl_type *getFirstDecl() {
     decl_type *D = static_cast<decl_type*>(this);
     if (!D->isFromASTFile())
       return D;
     return cast<decl_type>(getPrimaryMergedDecl(const_cast<decl_type*>(D)));

include/clang/AST/StmtIterator.h

 template <typename DERIVED, typename REFERENCE>
 class StmtIteratorImpl : public StmtIteratorBase,
                          public std::iterator<std::forward_iterator_tag,
                                               REFERENCE, ptrdiff_t,
                                               REFERENCE, REFERENCE> {
 protected:
   StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {}
 public:
-  StmtIteratorImpl() = default;
+  StmtIteratorImpl() {}
   StmtIteratorImpl(Stmt **s) : StmtIteratorBase(s) {}
   StmtIteratorImpl(Decl **dgi, Decl **dge) : StmtIteratorBase(dgi, dge) {}
   StmtIteratorImpl(const VariableArrayType *t) : StmtIteratorBase(t) {}
 
   DERIVED& operator++() {
     if (inStmt())
       ++stmt;
     else if (getVAPtr())

include/clang/AST/UnresolvedSet.h

 /// \brief A set of unresolved declarations.
 class UnresolvedSetImpl {
   typedef SmallVectorImpl<DeclAccessPair> DeclsTy;
 
   // Don't allow direct construction, and only permit subclassing by
   // UnresolvedSet.
 private:
   template <unsigned N> friend class UnresolvedSet;
-  UnresolvedSetImpl() = default;
+  UnresolvedSetImpl() {}
   UnresolvedSetImpl(const UnresolvedSetImpl &) {}
 
 public:
   // We don't currently support assignment through this iterator, so we might
   // as well use the same implementation twice.
   typedef UnresolvedSetIterator iterator;
   typedef UnresolvedSetIterator const_iterator;
 

include/clang/AST/VTableBuilder.h

 };
 
 class VTableContextBase {
 public:
   typedef SmallVector<ThunkInfo, 1> ThunkInfoVectorTy;
 
   bool isMicrosoft() const { return IsMicrosoftABI; }
 
-  virtual ~VTableContextBase() = default;
+  virtual ~VTableContextBase() {}
 
 protected:
   typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy;
 
   /// \brief Contains all thunks that a given method decl will need.
   ThunksMapTy Thunks;
 
   /// Compute and store all vtable related information (vtable layout, vbase

include/clang/ASTMatchers/ASTMatchersInternal.h

 /// The tree builder is used during the matching process to insert the bound
 /// nodes from the Id matcher.
 class BoundNodesTreeBuilder {
 public:
   /// \brief A visitor interface to visit all BoundNodes results for a
   /// BoundNodesTree.
   class Visitor {
   public:
-    virtual ~Visitor() = default;
+    virtual ~Visitor() {}
 
     /// \brief Called multiple times during a single call to VisitMatches(...).
     ///
     /// 'BoundNodesView' contains the bound nodes for a single match.
     virtual void visitMatch(const BoundNodes& BoundNodesView) = 0;
   };
 
   /// \brief Add a binding from an id to a node.

 /// Implement this if your matcher may need to inspect the children or
 /// descendants of the node or bind matched nodes to names. If you are
 /// writing a simple matcher that only inspects properties of the
 /// current node and doesn't care about its children or descendants,
 /// implement SingleNodeMatcherInterface instead.
 template <typename T>
 class MatcherInterface : public DynMatcherInterface {
 public:
-  ~MatcherInterface() override = default;
+  ~MatcherInterface() override {}
 
   /// \brief Returns true if 'Node' can be matched.
   ///
   /// May bind 'Node' to an ID via 'Builder', or recurse into
   /// the AST via 'Finder'.
   virtual bool matches(const T &Node,
                        ASTMatchFinder *Finder,
                        BoundNodesTreeBuilder *Builder) const = 0;
public:
   /// \brief Defines which ancestors are considered for a match.
   enum AncestorMatchMode {
     /// All ancestors.
     AMM_All,
     /// Direct parent only.
     AMM_ParentOnly
   };
 
-  virtual ~ASTMatchFinder() = default;
+  virtual ~ASTMatchFinder() {}
 
   /// \brief Returns true if the given class is directly or indirectly derived
   /// from a base type matching \c base.
   ///
   /// A class is considered to be also derived from itself.
   virtual bool classIsDerivedFrom(const CXXRecordDecl *Declaration,
                                   const Matcher<NamedDecl> &Base,
                                   BoundNodesTreeBuilder *Builder) = 0;

 /// The returned matcher matches if the given Decl can by dynamically
 /// casted to CXXRecordDecl and all given matchers match.
 template <typename SourceT, typename TargetT>
 class VariadicDynCastAllOfMatcher
     : public llvm::VariadicFunction<
         BindableMatcher<SourceT>, Matcher<TargetT>,
         makeDynCastAllOfComposite<SourceT, TargetT> > {
 public:
-  VariadicDynCastAllOfMatcher() = default;
+  VariadicDynCastAllOfMatcher() {}
 };
 
 /// \brief A \c VariadicAllOfMatcher<T> object is a variadic functor that takes
 /// a number of \c Matcher<T> and returns a \c Matcher<T> that matches \c T
 /// nodes that are matched by all of the given matchers.
 ///
 /// For example:
 ///   const VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier;
 /// Creates a functor nestedNameSpecifier(...) that creates a
 /// \c Matcher<NestedNameSpecifier> given a variable number of arguments of type
 /// \c Matcher<NestedNameSpecifier>.
 /// The returned matcher matches if all given matchers match.
 template <typename T>
 class VariadicAllOfMatcher : public llvm::VariadicFunction<
                                BindableMatcher<T>, Matcher<T>,
                                makeAllOfComposite<T> > {
 public:
-  VariadicAllOfMatcher() = default;
+  VariadicAllOfMatcher() {}
 };
 
 /// \brief Matches nodes of type \c TLoc for which the inner
 /// \c Matcher<T> matches.
 template <typename TLoc, typename T>
 class LocMatcher : public WrapperMatcherInterface<TLoc> {
 public:
   explicit LocMatcher(const Matcher<T> &InnerMatcher)
public:
 
   template <typename OuterT> operator Matcher<OuterT>() const {
     return Matcher<OuterT>(
         new MatcherImpl<OuterT>(InnerMatcher, Getter<OuterT>::value()));
   }
 
   struct Func : public llvm::VariadicFunction<Self, Matcher<InnerTBase>,
                                               &Self::create> {
-    Func() = default;
+    Func() {}
   };
 
 private:
   const Matcher<InnerTBase> InnerMatcher;
 };
 
 /// \brief A simple memoizer of T(*)() functions.
 ///

include/clang/Analysis/Analyses/FormatString.h

 // Parsing and processing of format strings (both fprintf and fscanf).
 
 namespace analyze_format_string {
 
 enum PositionContext { FieldWidthPos = 0, PrecisionPos = 1 };
 
 class FormatStringHandler {
 public:
-  FormatStringHandler() = default;
+  FormatStringHandler() {}
   virtual ~FormatStringHandler();
 
   virtual void HandleNullChar(const char *nullCharacter) {}
 
   virtual void HandlePosition(const char *startPos, unsigned posLen) {}
 
   virtual void HandleInvalidPosition(const char *startPos, unsigned posLen,
                                      PositionContext p) {}

include/clang/Analysis/Analyses/LiveVariables.h

public:
     bool isLive(const VarDecl *D) const;
     
     friend class LiveVariables;    
   };
   
   class Observer {
     virtual void anchor();
   public:
-    virtual ~Observer() = default;
+    virtual ~Observer() {}
     
     /// A callback invoked right before invoking the
     ///  liveness transfer function on the given statement.
     virtual void observeStmt(const Stmt *S,
                              const CFGBlock *currentBlock,
                              const LivenessValues& V) {}
     
     /// Called when the live variables analysis registers

include/clang/Analysis/Analyses/ReachableCode.h

enum UnreachableKind {
   UK_Break,
   UK_Loop_Increment,
   UK_Other
 };
 
 class Callback {
   virtual void anchor();
 public:
-  virtual ~Callback() = default;
+  virtual ~Callback() {}
   virtual void HandleUnreachable(UnreachableKind UK,
                                  SourceLocation L,
                                  SourceRange ConditionVal,
                                  SourceRange R1,
                                  SourceRange R2) = 0;
 };
 
 /// ScanReachableFromBlock - Mark all blocks reachable from Start.

include/clang/Analysis/Analyses/ThreadSafetyTraverse.h

 
 
 // Implements a traversal that visits each subexpression, and returns either
 // true or false.
 template <class Self>
 class VisitReducer : public Traversal<Self, VisitReducerBase>,
                      public VisitReducerBase {
 public:
-  VisitReducer() = default;
+  VisitReducer() {}
 
 public:
   R_SExpr reduceNull() { return true; }
   R_SExpr reduceUndefined(Undefined &Orig) { return true; }
   R_SExpr reduceWildcard(Wildcard &Orig) { return true; }
 
   R_SExpr reduceLiteral(Literal &Orig) { return true; }
   template<class T>

include/clang/Analysis/Analyses/UninitializedValues.h

public:
   /// Branches which inevitably result in the variable being used uninitialized.
   branch_iterator branch_begin() const { return UninitBranches.begin(); }
   branch_iterator branch_end() const { return UninitBranches.end(); }
   bool branch_empty() const { return UninitBranches.empty(); }
 };
 
 class UninitVariablesHandler {
 public:
-  UninitVariablesHandler() = default;
+  UninitVariablesHandler() {}
   virtual ~UninitVariablesHandler();
 
   /// Called when the uninitialized variable is used at the given expression.
   virtual void handleUseOfUninitVariable(const VarDecl *vd,
                                          const UninitUse &use) {}
 
   /// Called when the uninitialized variable analysis detects the
   /// idiom 'int x = x'.  All other uses of 'x' within the initializer

include/clang/Analysis/AnalysisContext.h

 class LocationContext;
 
 namespace idx { class TranslationUnit; }
 
 /// The base class of a hierarchy of objects representing analyses tied
 /// to AnalysisDeclContext.
 class ManagedAnalysis {
 protected:
-  ManagedAnalysis() = default;
+  ManagedAnalysis() {}
 public:
   virtual ~ManagedAnalysis();
 
   // Subclasses need to implement:
   //
   //  static const void *getTag();
   //
   // Which returns a fixed pointer address to distinguish classes of
class StackFrameContext : public LocationContext {
   friend class LocationContextManager;
   StackFrameContext(AnalysisDeclContext *ctx, const LocationContext *parent,
                     const Stmt *s, const CFGBlock *blk,
                     unsigned idx)
     : LocationContext(StackFrame, ctx, parent), CallSite(s),
       Block(blk), Index(idx) {}
 
 public:
-  ~StackFrameContext() override = default;
+  ~StackFrameContext() override {}
 
   const Stmt *getCallSite() const { return CallSite; }
 
   const CFGBlock *getCallSiteBlock() const { return Block; }
 
   /// Return true if the current LocationContext has no caller context.
   bool inTopFrame() const override { return getParent() == nullptr;  }
 
class ScopeContext : public LocationContext {
   const Stmt *Enter;
 
   friend class LocationContextManager;
   ScopeContext(AnalysisDeclContext *ctx, const LocationContext *parent,
                const Stmt *s)
     : LocationContext(Scope, ctx, parent), Enter(s) {}
 
 public:
-  ~ScopeContext() override = default;
+  ~ScopeContext() override {}
 
   void Profile(llvm::FoldingSetNodeID &ID) override;
 
   static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,
                       const LocationContext *parent, const Stmt *s) {
     ProfileCommon(ID, Scope, ctx, parent, s);
   }
 
class BlockInvocationContext : public LocationContext {
   friend class LocationContextManager;
 
   BlockInvocationContext(AnalysisDeclContext *ctx,
                          const LocationContext *parent,
                          const BlockDecl *bd, const void *contextData)
     : LocationContext(Block, ctx, parent), BD(bd), ContextData(contextData) {}
 
 public:
-  ~BlockInvocationContext() override = default;
+  ~BlockInvocationContext() override {}
 
   const BlockDecl *getBlockDecl() const { return BD; }
   
   const void *getContextData() const { return ContextData; }
 
   void Profile(llvm::FoldingSetNodeID &ID) override;
 
   static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,

include/clang/Analysis/CFG.h

iterator insertAutomaticObjDtor(iterator I, VarDecl *VD, Stmt *S) {
     return ++I;
   }
 };
 
 /// \brief CFGCallback defines methods that should be called when a logical
 /// operator error is found when building the CFG.
 class CFGCallback {
 public:
-  CFGCallback() = default;
+  CFGCallback() {}
   virtual void compareAlwaysTrue(const BinaryOperator *B, bool isAlwaysTrue) {}
   virtual void compareBitwiseEquality(const BinaryOperator *B,
                                       bool isAlwaysTrue) {}
-  virtual ~CFGCallback() = default;
+  virtual ~CFGCallback() {}
 };
 
 /// CFG - Represents a source-level, intra-procedural CFG that represents the
 ///  control-flow of a Stmt.  The Stmt can represent an entire function body,
 ///  or a single expression.  A CFG will always contain one empty block that
 ///  represents the Exit point of the CFG.  A CFG will also contain a designated
 ///  Entry block.  The CFG solely represents control-flow; it consists of
 ///  CFGBlocks which are simply containers of Stmt*'s in the AST the CFG

include/clang/Basic/FileSystemStatCache.h

 /// system calls, which is used by precompiled and pretokenized headers to
 /// improve performance.
 class FileSystemStatCache {
   virtual void anchor();
 protected:
   std::unique_ptr<FileSystemStatCache> NextStatCache;
 
 public:
-  virtual ~FileSystemStatCache() = default;
+  virtual ~FileSystemStatCache() {}
   
   enum LookupResult {
     CacheExists,   ///< We know the file exists and its cached stat data.
     CacheMissing   ///< We know that the file doesn't exist.
   };
 
   /// \brief Get the 'stat' information for the specified path, using the cache
   /// to accelerate it if possible.

include/clang/Basic/IdentifierTable.h

 /// operation. Subclasses of this iterator type will provide the
 /// actual functionality.
 class IdentifierIterator {
 private:
   IdentifierIterator(const IdentifierIterator &) = delete;
   void operator=(const IdentifierIterator &) = delete;
 
 protected:
-  IdentifierIterator() = default;
+  IdentifierIterator() { }
   
 public:
   virtual ~IdentifierIterator();
 
   /// \brief Retrieve the next string in the identifier table and
   /// advances the iterator for the following string.
   ///
   /// \returns The next string in the identifier table. If there is

include/clang/Driver/Job.h

 
 public:
   Command(const Action &Source, const Tool &Creator, const char *Executable,
           const llvm::opt::ArgStringList &Arguments,
           ArrayRef<InputInfo> Inputs);
   // FIXME: This really shouldn't be copyable, but is currently copied in some
   // error handling in Driver::generateCompilationDiagnostics.
   Command(const Command &) = default;
-  virtual ~Command() = default;
+  virtual ~Command() {}
 
   virtual void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote,
                      CrashReportInfo *CrashInfo = nullptr) const;
 
   virtual int Execute(const StringRef **Redirects, std::string *ErrMsg,
                       bool *ExecutionFailed) const;
 
   /// getSource - Return the Action which caused the creation of this job.

include/clang/Edit/EditsReceiver.h

 namespace clang {
   class SourceLocation;
   class CharSourceRange;
 
 namespace edit {
 
 class EditsReceiver {
 public:
-  virtual ~EditsReceiver() = default;
+  virtual ~EditsReceiver() { }
 
   virtual void insert(SourceLocation loc, StringRef text) = 0;
   virtual void replace(CharSourceRange range, StringRef text) = 0;
   /// \brief By default it calls replace with an empty string.
   virtual void remove(CharSourceRange range);
 };
 
 }
 
 } // end namespace clang
 
 #endif

include/clang/Frontend/SerializedDiagnosticReader.h

 };
 
 /// \brief A base class that handles reading serialized diagnostics from a file.
 ///
 /// Subclasses should override the visit* methods with their logic for handling
 /// the various constructs that are found in serialized diagnostics.
 class SerializedDiagnosticReader {
 public:
-  SerializedDiagnosticReader() = default;
-  virtual ~SerializedDiagnosticReader() = default;
+  SerializedDiagnosticReader() {}
+  virtual ~SerializedDiagnosticReader() {}
 
   /// \brief Read the diagnostics in \c File
   std::error_code readDiagnostics(StringRef File);
 
 private:
   enum class Cursor;
 
   /// \brief Read to the next record or block to process.

include/clang/Frontend/VerifyDiagnosticConsumer.h

public:
     static const unsigned MaxCount = UINT_MAX;
 
     SourceLocation DirectiveLoc;
     SourceLocation DiagnosticLoc;
     const std::string Text;
     unsigned Min, Max;
     bool MatchAnyLine;
 
-    virtual ~Directive() = default;
+    virtual ~Directive() { }
 
     // Returns true if directive text is valid.
     // Otherwise returns false and populates E.
     virtual bool isValid(std::string &Error) = 0;
 
     // Returns true on match.
     virtual bool match(StringRef S) = 0;
 

include/clang/Lex/ModuleMap.h

 class DiagnosticsEngine;
 class HeaderSearch;
 class ModuleMapParser;
 
 /// \brief A mechanism to observe the actions of the module map parser as it
 /// reads module map files.
 class ModuleMapCallbacks {
 public:
-  virtual ~ModuleMapCallbacks() = default;
+  virtual ~ModuleMapCallbacks() {}
 
   /// \brief Called when a module map file has been read.
   ///
   /// \param FileStart A SourceLocation referring to the start of the file's
   /// contents.
   /// \param File The file itself.
   /// \param IsSystem Whether this is a module map from a system include path.
   virtual void moduleMapFileRead(SourceLocation FileStart,

include/clang/Lex/PTHLexer.h

 
 protected:
   friend class PTHManager;
 
   /// Create a PTHLexer for the specified token stream.
   PTHLexer(Preprocessor& pp, FileID FID, const unsigned char *D,
            const unsigned char* ppcond, PTHManager &PM);
 public:
-  ~PTHLexer() override = default;
+  ~PTHLexer() override {}
 
   /// Lex - Return the next token.
   bool Lex(Token &Tok);
 
   void getEOF(Token &Tok);
 
   /// DiscardToEndOfLine - Read the rest of the current preprocessor line as an
   /// uninterpreted string.  This switches the lexer out of directive mode.

include/clang/Lex/PreprocessorLexer.h

protected:
   PreprocessorLexer(Preprocessor *pp, FileID fid);
 
   PreprocessorLexer()
     : PP(nullptr), InitialNumSLocEntries(0),
       ParsingPreprocessorDirective(false),
       ParsingFilename(false),
       LexingRawMode(false) {}
 
-  virtual ~PreprocessorLexer() = default;
+  virtual ~PreprocessorLexer() {}
 
   virtual void IndirectLex(Token& Result) = 0;
 
   /// \brief Return the source location for the next observable location.
   virtual SourceLocation getSourceLocation() = 0;
 
   //===--------------------------------------------------------------------===//
   // #if directive handling.

include/clang/Sema/Sema.h

public:
 
   /// \brief Abstract class used to diagnose incomplete types.
   struct TypeDiagnoser {
     bool Suppressed;
 
     TypeDiagnoser(bool Suppressed = false) : Suppressed(Suppressed) { }
 
     virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0;
-    virtual ~TypeDiagnoser() = default;
+    virtual ~TypeDiagnoser() {}
   };
 
   static int getPrintable(int I) { return I; }
   static unsigned getPrintable(unsigned I) { return I; }
   static bool getPrintable(bool B) { return B; }
   static const char * getPrintable(const char *S) { return S; }
   static StringRef getPrintable(StringRef S) { return S; }
   static const std::string &getPrintable(const std::string &S) { return S; }
public:
     virtual SemaDiagnosticBuilder
     noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
 
     /// \brief Emits a diagnostic when we picked a conversion function
     /// (for cases when we are not allowed to pick a conversion function).
     virtual SemaDiagnosticBuilder diagnoseConversion(
         Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
 
-    virtual ~ContextualImplicitConverter() = default;
+    virtual ~ContextualImplicitConverter() {}
   };
 
   class ICEConvertDiagnoser : public ContextualImplicitConverter {
     bool AllowScopedEnumerations;
 
   public:
     ICEConvertDiagnoser(bool AllowScopedEnumerations,
                         bool Suppress, bool SuppressConversion)
public:
   class VerifyICEDiagnoser {
   public:
     bool Suppress;
 
     VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { }
 
     virtual void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) =0;
     virtual void diagnoseFold(Sema &S, SourceLocation Loc, SourceRange SR);
-    virtual ~VerifyICEDiagnoser() = default;
+    virtual ~VerifyICEDiagnoser() { }
   };
 
   /// VerifyIntegerConstantExpression - Verifies that an expression is an ICE,
   /// and reports the appropriate diagnostics. Returns false on success.
   /// Can optionally return the value of the expression.
   ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
                                              VerifyICEDiagnoser &Diagnoser,
                                              bool AllowFold = true);

include/clang/Sema/TypoCorrection.h

public:
   explicit CorrectionCandidateCallback(IdentifierInfo *Typo = nullptr,
                                        NestedNameSpecifier *TypoNNS = nullptr)
       : WantTypeSpecifiers(true), WantExpressionKeywords(true),
         WantCXXNamedCasts(true), WantFunctionLikeCasts(true),
         WantRemainingKeywords(true), WantObjCSuper(false),
         IsObjCIvarLookup(false), IsAddressOfOperand(false), Typo(Typo),
         TypoNNS(TypoNNS) {}
 
-  virtual ~CorrectionCandidateCallback() = default;
+  virtual ~CorrectionCandidateCallback() {}
 
   /// \brief Simple predicate used by the default RankCandidate to
   /// determine whether to return an edit distance of 0 or InvalidDistance.
   /// This can be overrided by validators that only need to determine if a
   /// candidate is viable, without ranking potentially viable candidates.
   /// Only ValidateCandidate or RankCandidate need to be overriden by a
   /// callback wishing to check the viability of correction candidates.
   /// The default predicate always returns true if the candidate is not a type

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

 
 /// This class provides an interface through which checkers can create
 /// individual bug reports.
 class BugReport : public llvm::ilist_node<BugReport> {
 public:  
   class NodeResolver {
     virtual void anchor();
   public:
-    virtual ~NodeResolver() = default;
+    virtual ~NodeResolver() {}
     virtual const ExplodedNode*
             getOriginalNode(const ExplodedNode *N) = 0;
   };
 
   typedef const SourceRange *ranges_iterator;
   typedef SmallVector<std::unique_ptr<BugReporterVisitor>, 8> VisitorList;
   typedef VisitorList::iterator visitor_iterator;
   typedef SmallVector<StringRef, 2> ExtraTextList;

 };
 
 class BugReporterContext {
   virtual void anchor();
   GRBugReporter &BR;
 public:
   BugReporterContext(GRBugReporter& br) : BR(br) {}
 
-  virtual ~BugReporterContext() = default;
+  virtual ~BugReporterContext() {}
 
   GRBugReporter& getBugReporter() { return BR; }
 
   ExplodedGraph &getGraph() { return BR.getGraph(); }
 
   ProgramStateManager& getStateManager() {
     return BR.getStateManager();
   }

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

private:
 
   virtual void anchor();
 public:
   BugType(class CheckName check, StringRef name, StringRef cat)
       : Check(check), Name(name), Category(cat), SuppressonSink(false) {}
   BugType(const CheckerBase *checker, StringRef name, StringRef cat)
       : Check(checker->getCheckName()), Name(name), Category(cat),
         SuppressonSink(false) {}
-  virtual ~BugType() = default;
+  virtual ~BugType() {}
 
   // FIXME: Should these be made strings as well?
   StringRef getName() const { return Name; }
   StringRef getCategory() const { return Category; }
   StringRef getCheckName() const { return Check.getName(); }
 
   /// isSuppressOnSink - Returns true if bug reports associated with this bug
   ///  type should be suppressed if the end node of the report is post-dominated

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

 /// The hint can be customized by redefining 'getMessageForX()' methods.
 class StackHintGeneratorForSymbol : public StackHintGenerator {
 private:
   SymbolRef Sym;
   std::string Msg;
 
 public:
   StackHintGeneratorForSymbol(SymbolRef S, StringRef M) : Sym(S), Msg(M) {}
-  ~StackHintGeneratorForSymbol() override = default;
+  ~StackHintGeneratorForSymbol() override {}
 
   /// \brief Search the call expression for the symbol Sym and dispatch the
   /// 'getMessageForX()' methods to construct a specific message.
   std::string getMessage(const ExplodedNode *N) override;
 
   /// Produces the message of the following form:
   ///   'Msg via Nth parameter'
   virtual std::string getMessageForArg(const Expr *ArgE, unsigned ArgIndex);

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

protected:
   typedef SmallVectorImpl<SVal> ValueList;
 
   /// \brief Used to specify non-argument regions that will be invalidated as a
   /// result of this call.
   virtual void getExtraInvalidatedValues(ValueList &Values,
                  RegionAndSymbolInvalidationTraits *ETraits) const {}
 
 public:
-  virtual ~CallEvent() = default;
+  virtual ~CallEvent() {}
 
   /// \brief Returns the kind of call this is.
   virtual Kind getKind() const = 0;
 
   /// \brief Returns the declaration of the function or method that will be
   /// called. May be null.
   virtual const Decl *getDecl() const {
     return Origin.dyn_cast<const Decl *>();

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

public:
 
   NodeBuilder(const ExplodedNodeSet &SrcSet, ExplodedNodeSet &DstSet,
               const NodeBuilderContext &Ctx, bool F = true)
     : C(Ctx), Finalized(F), HasGeneratedNodes(false), Frontier(DstSet) {
     Frontier.insert(SrcSet);
     assert(hasNoSinksInFrontier());
   }
 
-  virtual ~NodeBuilder() = default;
+  virtual ~NodeBuilder() {}
 
   /// \brief Generates a node in the ExplodedGraph.
   ExplodedNode *generateNode(const ProgramPoint &PP,
                              ProgramStateRef State,
                              ExplodedNode *Pred) {
     return generateNodeImpl(PP, State, Pred, false);
   }
 

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

SValBuilder(llvm::BumpPtrAllocator &alloc, ASTContext &context,
               ProgramStateManager &stateMgr)
     : Context(context), BasicVals(context, alloc),
       SymMgr(context, BasicVals, alloc),
       MemMgr(context, alloc),
       StateMgr(stateMgr),
       ArrayIndexTy(context.IntTy),
       ArrayIndexWidth(context.getTypeSize(ArrayIndexTy)) {}
 
-  virtual ~SValBuilder() = default;
+  virtual ~SValBuilder() {}
 
   bool haveSameType(const SymExpr *Sym1, const SymExpr *Sym2) {
     return haveSameType(Sym1->getType(), Sym2->getType());
   }
 
   bool haveSameType(QualType Ty1, QualType Ty2) {
     // FIXME: Remove the second disjunct when we support symbolic
     // truncation/extension.

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

protected:
 
   /// MRMgr - Manages region objects associated with this StoreManager.
   MemRegionManager &MRMgr;
   ASTContext &Ctx;
 
   StoreManager(ProgramStateManager &stateMgr);
 
 public:
-  virtual ~StoreManager() = default;
+  virtual ~StoreManager() {}
 
   /// Return the value bound to specified location in a given state.
   /// \param[in] store The analysis state.
   /// \param[in] loc The symbolic memory location.
   /// \param[in] T An optional type that provides a hint indicating the
   ///   expected type of the returned value.  This is used if the value is
   ///   lazily computed.
   /// \return The value bound to the location \c loc.

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

 class SwitchNodeBuilder;
 class EndOfFunctionNodeBuilder;
 class NodeBuilderWithSinks;
 class MemRegion;
 
 class SubEngine {
   virtual void anchor();
 public:
-  virtual ~SubEngine() = default;
+  virtual ~SubEngine() {}
 
   virtual ProgramStateRef getInitialState(const LocationContext *InitLoc) = 0;
 
   virtual AnalysisManager &getAnalysisManager() = 0;
 
   virtual ProgramStateManager &getStateManager() = 0;
 
   /// Called by CoreEngine. Used to generate new successor

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

enum Kind { RegionValueKind, ConjuredKind, DerivedKind, ExtentKind,
               CastSymbolKind };
 private:
   Kind K;
 
 protected:
   SymExpr(Kind k) : K(k) {}
 
 public:
-  virtual ~SymExpr() = default;
+  virtual ~SymExpr() {}
 
   Kind getKind() const { return K; }
 
   virtual void dump() const;
 
   virtual void dumpToStream(raw_ostream &os) const {}
 
   virtual QualType getType() const = 0;

 class SymbolData : public SymExpr {
   void anchor() override;
   const SymbolID Sym;
 
 protected:
   SymbolData(Kind k, SymbolID sym) : SymExpr(k), Sym(sym) {}
 
 public:
-  ~SymbolData() override = default;
+  ~SymbolData() override {}
 
   SymbolID getSymbolID() const { return Sym; }
 
   // Implement isa<T> support.
   static inline bool classof(const SymExpr *SE) {
     Kind k = SE->getKind();
     return k >= BEGIN_SYMBOLS && k <= END_SYMBOLS;
   }

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

 typedef llvm::ImmutableMap<SymbolRef, TaintTagType> TaintMapImpl;
 template<> struct ProgramStateTrait<TaintMap>
     :  public ProgramStatePartialTrait<TaintMapImpl> {
   static void *GDMIndex() { static int index = 0; return &index; }
 };
 
 class TaintManager {
 
-  TaintManager() = default;
+  TaintManager() {}
 };
 
 }
 }
 
 #endif

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

public:
 
   virtual WorkListUnit dequeue() = 0;
 
   void setBlockCounter(BlockCounter C) { CurrentCounter = C; }
   BlockCounter getBlockCounter() const { return CurrentCounter; }
 
   class Visitor {
   public:
-    Visitor() = default;
+    Visitor() {}
     virtual ~Visitor();
     virtual bool visit(const WorkListUnit &U) = 0;
   };
   virtual bool visitItemsInWorkList(Visitor &V) = 0;
   
   static WorkList *makeDFS();
   static WorkList *makeBFS();
   static WorkList *makeBFSBlockDFSContents();
 };
 
 } // end GR namespace
 
 } // end clang namespace
 
 #endif

include/clang/Tooling/FileMatchTrie.h

 #include <memory>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace tooling {
 
 struct PathComparator {
-  virtual ~PathComparator() = default;
+  virtual ~PathComparator() {}
   virtual bool equivalent(StringRef FileA, StringRef FileB) const = 0;
 };
 class FileMatchTrieNode;
 
 /// \brief A trie to efficiently match against the entries of the compilation
 /// database in order of matching suffix length.
 ///
 /// When a clang tool is supposed to operate on a specific file, we have to

include/clang/Tooling/Tooling.h

 template <typename T>
 std::unique_ptr<FrontendActionFactory> newFrontendActionFactory();
 
 /// \brief Callbacks called before and after each source file processed by a
 /// FrontendAction created by the FrontedActionFactory returned by \c
 /// newFrontendActionFactory.
 class SourceFileCallbacks {
 public:
-  virtual ~SourceFileCallbacks() = default;
+  virtual ~SourceFileCallbacks() {}
 
   /// \brief Called before a source file is processed by a FrontEndAction.
   /// \see clang::FrontendAction::BeginSourceFileAction
   virtual bool handleBeginSource(CompilerInstance &CI, StringRef Filename) {
     return true;
   }
 
   /// \brief Called after a source file is processed by a FrontendAction.

lib/ARCMigrate/ARCMT.cpp

void increaseIndentation(CharSourceRange range,
                             SourceLocation parentIndent) override {
     rewriter.IncreaseIndentation(range, parentIndent);
   }
 };
 
 } // end anonymous namespace.
 
 /// \brief Anchor for VTable.
-MigrationProcess::RewriteListener::~RewriteListener() = default;
+MigrationProcess::RewriteListener::~RewriteListener() { }
 
 MigrationProcess::MigrationProcess(
     const CompilerInvocation &CI,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     DiagnosticConsumer *diagClient, StringRef outputDir)
     : OrigCI(CI), PCHContainerOps(PCHContainerOps), DiagClient(diagClient),
       HadARCErrors(false) {
   if (!outputDir.empty()) {

lib/ARCMigrate/TransformActions.cpp

 SourceLocation TransformActionsImpl::getLocForEndOfToken(SourceLocation loc,
                                                          SourceManager &SM,
                                                          Preprocessor &PP) {
   if (loc.isMacroID())
     loc = SM.getExpansionRange(loc).second;
   return PP.getLocForEndOfToken(loc);
 }
 
-TransformActions::RewriteReceiver::~RewriteReceiver() = default;
+TransformActions::RewriteReceiver::~RewriteReceiver() { }
 
 TransformActions::TransformActions(DiagnosticsEngine &diag,
                                    CapturedDiagList &capturedDiags,
                                    ASTContext &ctx, Preprocessor &PP)
     : Diags(diag), CapturedDiags(capturedDiags) {
   Impl = new TransformActionsImpl(capturedDiags, ctx, PP);
 }
 

lib/ARCMigrate/Transforms.cpp

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringSwitch.h"
 #include <map>
 
 using namespace clang;
 using namespace arcmt;
 using namespace trans;
 
-ASTTraverser::~ASTTraverser() = default;
+ASTTraverser::~ASTTraverser() { }
 
 bool MigrationPass::CFBridgingFunctionsDefined() {
   if (!EnableCFBridgeFns.hasValue())
     EnableCFBridgeFns = SemaRef.isKnownName("CFBridgingRetain") &&
                         SemaRef.isKnownName("CFBridgingRelease");
   return *EnableCFBridgeFns;
 }
 

lib/AST/ASTContext.cpp

case BuiltinType::LongLong:
     return UnsignedLongLongTy;
   case BuiltinType::Int128:
     return UnsignedInt128Ty;
   default:
     llvm_unreachable("Unexpected signed integer type");
   }
 }
 
-ASTMutationListener::~ASTMutationListener() = default;
+ASTMutationListener::~ASTMutationListener() { }
 
 void ASTMutationListener::DeducedReturnType(const FunctionDecl *FD,
                                             QualType ReturnType) {}
 
 //===----------------------------------------------------------------------===//
 //                          Builtin Type Computation
 //===----------------------------------------------------------------------===//
 
MangleContext *ASTContext::createMangleContext() {
   case TargetCXXABI::WebAssembly:
     return ItaniumMangleContext::create(*this, getDiagnostics());
   case TargetCXXABI::Microsoft:
     return MicrosoftMangleContext::create(*this, getDiagnostics());
   }
   llvm_unreachable("Unsupported ABI");
 }
 
-CXXABI::~CXXABI() = default;
+CXXABI::~CXXABI() {}
 
 size_t ASTContext::getSideTableAllocatedMemory() const {
   return ASTRecordLayouts.getMemorySize() +
          llvm::capacity_in_bytes(ObjCLayouts) +
          llvm::capacity_in_bytes(KeyFunctions) +
          llvm::capacity_in_bytes(ObjCImpls) +
          llvm::capacity_in_bytes(BlockVarCopyInits) +
          llvm::capacity_in_bytes(DeclAttrs) +

lib/AST/ASTImporter.cpp

ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
   : ToContext(ToContext), FromContext(FromContext),
     ToFileManager(ToFileManager), FromFileManager(FromFileManager),
     Minimal(MinimalImport), LastDiagFromFrom(false)
 {
   ImportedDecls[FromContext.getTranslationUnitDecl()]
     = ToContext.getTranslationUnitDecl();
 }
 
-ASTImporter::~ASTImporter() = default;
+ASTImporter::~ASTImporter() { }
 
 QualType ASTImporter::Import(QualType FromT) {
   if (FromT.isNull())
     return QualType();
 
   const Type *fromTy = FromT.getTypePtr();
   
   // Check whether we've already imported this type.  

lib/AST/DeclBase.cpp

void PrettyStackTraceDecl::print(raw_ostream &OS) const {
   OS << '\n';
 }
 
 //===----------------------------------------------------------------------===//
 // Decl Implementation
 //===----------------------------------------------------------------------===//
 
 // Out-of-line virtual method providing a home for Decl.
-Decl::~Decl() = default;
+Decl::~Decl() { }
 
 void Decl::setDeclContext(DeclContext *DC) {
   DeclCtx = DC;
 }
 
 void Decl::setLexicalDeclContext(DeclContext *DC) {
   if (DC == getLexicalDeclContext())
     return;
#define DECL_CONTEXT_BASE(NAME)                 \
       if (D->getKind() >= Decl::first##NAME &&  \
           D->getKind() <= Decl::last##NAME)     \
         return true;
 #include "clang/AST/DeclNodes.inc"
       return false;
   }
 }
 
-DeclContext::~DeclContext() = default;
+DeclContext::~DeclContext() { }
 
 /// \brief Find the parent context of this context that will be
 /// used for unqualified name lookup.
 ///
 /// Generally, the parent lookup context is the semantic context. However, for
 /// a friend function the parent lookup context is the lexical context, which
 /// is the class in which the friend is declared.
 DeclContext *DeclContext::getLookupParent() {

lib/AST/ExternalASTSource.cpp

 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/Basic/Module.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace clang;
 
-ExternalASTSource::~ExternalASTSource() = default;
+ExternalASTSource::~ExternalASTSource() { }
 
 llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
 ExternalASTSource::getSourceDescriptor(unsigned ID) {
   return None;
 }
 
 ExternalASTSource::ASTSourceDescriptor::ASTSourceDescriptor(const Module &M)
   : Signature(M.Signature), ClangModule(&M) {

lib/AST/StmtPrinter.cpp

void Stmt::printPretty(raw_ostream &OS,
   P.Visit(const_cast<Stmt*>(this));
 }
 
 //===----------------------------------------------------------------------===//
 // PrinterHelper
 //===----------------------------------------------------------------------===//
 
 // Implement virtual destructor.
-PrinterHelper::~PrinterHelper() = default;
+PrinterHelper::~PrinterHelper() {}

lib/AST/VTableBuilder.cpp

std::sort(this->VTableThunks.get(),
             [](const VTableLayout::VTableThunkTy &LHS,
                const VTableLayout::VTableThunkTy &RHS) {
     assert((LHS.first != RHS.first || LHS.second == RHS.second) &&
            "Different thunks should have unique indices!");
     return LHS.first < RHS.first;
   });
 }
 
-VTableLayout::~VTableLayout() = default;
+VTableLayout::~VTableLayout() { }
 
 ItaniumVTableContext::ItaniumVTableContext(ASTContext &Context)
     : VTableContextBase(/*MS=*/false) {}
 
 ItaniumVTableContext::~ItaniumVTableContext() {
   llvm::DeleteContainerSeconds(VTableLayouts);
 }
 

lib/ASTMatchers/ASTMatchFinder.cpp

 } // end namespace
 } // end namespace internal
 
 MatchFinder::MatchResult::MatchResult(const BoundNodes &Nodes,
                                       ASTContext *Context)
   : Nodes(Nodes), Context(Context),
     SourceManager(&Context->getSourceManager()) {}
 
-MatchFinder::MatchCallback::~MatchCallback() = default;
-MatchFinder::ParsingDoneTestCallback::~ParsingDoneTestCallback() = default;
+MatchFinder::MatchCallback::~MatchCallback() {}
+MatchFinder::ParsingDoneTestCallback::~ParsingDoneTestCallback() {}
 
 MatchFinder::MatchFinder(MatchFinderOptions Options)
     : Options(std::move(Options)), ParsingDone(nullptr) {}
 
-MatchFinder::~MatchFinder() = default;
+MatchFinder::~MatchFinder() {}
 
 void MatchFinder::addMatcher(const DeclarationMatcher &NodeMatch,
                              MatchCallback *Action) {
   Matchers.DeclOrStmt.emplace_back(NodeMatch, Action);
   Matchers.AllCallbacks.insert(Action);
 }
 
 void MatchFinder::addMatcher(const TypeMatcher &NodeMatch,

lib/ASTMatchers/Dynamic/Marshallers.h

 };
 
 /// \brief Matcher descriptor interface.
 ///
 /// Provides a \c create() method that constructs the matcher from the provided
 /// arguments, and various other methods for type introspection.
 class MatcherDescriptor {
 public:
-  virtual ~MatcherDescriptor() = default;
+  virtual ~MatcherDescriptor() {}
   virtual VariantMatcher create(SourceRange NameRange,
                                 ArrayRef<ParserValue> Args,
                                 Diagnostics *Error) const = 0;
 
   /// Returns whether the matcher is variadic. Variadic matchers can take any
   /// number of arguments, but they must be of the same type.
   virtual bool isVariadic() const = 0;
 

 ///
 /// It will try every overload and generate appropriate errors for when none or
 /// more than one overloads match the arguments.
 class OverloadedMatcherDescriptor : public MatcherDescriptor {
 public:
   OverloadedMatcherDescriptor(ArrayRef<MatcherDescriptor *> Callbacks)
       : Overloads(Callbacks.begin(), Callbacks.end()) {}
 
-  ~OverloadedMatcherDescriptor() override = default;
+  ~OverloadedMatcherDescriptor() override {}
 
   VariantMatcher create(SourceRange NameRange,
                         ArrayRef<ParserValue> Args,
                         Diagnostics *Error) const override {
     std::vector<VariantMatcher> Constructed;
     Diagnostics::OverloadContext Ctx(Error);
     for (const auto &O : Overloads) {
       VariantMatcher SubMatcher = O->create(NameRange, Args, Error);

lib/ASTMatchers/Dynamic/Parser.cpp

private:
   StringRef Code;
   StringRef StartOfLine;
   unsigned Line;
   Diagnostics *Error;
   TokenInfo NextToken;
   const char *CodeCompletionLocation;
 };
 
-Parser::Sema::~Sema() = default;
+Parser::Sema::~Sema() {}
 
 std::vector<ArgKind> Parser::Sema::getAcceptedCompletionTypes(
     llvm::ArrayRef<std::pair<MatcherCtor, unsigned>> Context) {
   return std::vector<ArgKind>();
 }
 
 std::vector<MatcherCompletion>
 Parser::Sema::getMatcherCompletions(llvm::ArrayRef<ArgKind> AcceptedTypes) {

 
 static llvm::ManagedStatic<Parser::RegistrySema> DefaultRegistrySema;
 
 Parser::Parser(CodeTokenizer *Tokenizer, Sema *S,
                const NamedValueMap *NamedValues, Diagnostics *Error)
     : Tokenizer(Tokenizer), S(S ? S : &*DefaultRegistrySema),
       NamedValues(NamedValues), Error(Error) {}
 
-Parser::RegistrySema::~RegistrySema() = default;
+Parser::RegistrySema::~RegistrySema() {}
 
 llvm::Optional<MatcherCtor>
 Parser::RegistrySema::lookupMatcherCtor(StringRef MatcherName) {
   return Registry::lookupMatcherCtor(MatcherName);
 }
 
 VariantMatcher Parser::RegistrySema::actOnMatcherExpression(
     MatcherCtor Ctor, SourceRange NameRange, StringRef BindID,

lib/ASTMatchers/Dynamic/VariantValue.cpp

llvm::Optional<DynTypedMatcher> Inner =
         InnerMatcher.Value->getTypedMatcher(*this);
     if (!Inner)
       return llvm::None;
     DynMatchers.push_back(*Inner);
   }
   return DynTypedMatcher::constructVariadic(Op, NodeKind, DynMatchers);
 }
 
-VariantMatcher::Payload::~Payload() = default;
+VariantMatcher::Payload::~Payload() {}
 
 class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
 public:
   SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
 
   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
     return Matcher;
   }
private:
   const DynTypedMatcher Matcher;
 };
 
 class VariantMatcher::PolymorphicPayload : public VariantMatcher::Payload {
 public:
   PolymorphicPayload(std::vector<DynTypedMatcher> MatchersIn)
       : Matchers(std::move(MatchersIn)) {}
 
-  ~PolymorphicPayload() override = default;
+  ~PolymorphicPayload() override {}
 
   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
     if (Matchers.size() != 1)
       return llvm::Optional<DynTypedMatcher>();
     return Matchers[0];
   }
 
   std::string getTypeAsString() const override {

lib/Analysis/AnalysisDeclContext.cpp

ManagedAnalysis *&AnalysisDeclContext::getAnalysisImpl(const void *tag) {
   ManagedAnalysisMap *M = (ManagedAnalysisMap*) ManagedAnalyses;
   return (*M)[tag];
 }
 
 //===----------------------------------------------------------------------===//
 // Cleanup.
 //===----------------------------------------------------------------------===//
 
-ManagedAnalysis::~ManagedAnalysis() = default;
+ManagedAnalysis::~ManagedAnalysis() {}
 
 AnalysisDeclContext::~AnalysisDeclContext() {
   delete forcedBlkExprs;
   delete ReferencedBlockVars;
   // Release the managed analyses.
   if (ManagedAnalyses) {
     ManagedAnalysisMap *M = (ManagedAnalysisMap*) ManagedAnalyses;
     llvm::DeleteContainerSeconds(*M);
     delete M;
   }
 }
 
 AnalysisDeclContextManager::~AnalysisDeclContextManager() {
   llvm::DeleteContainerSeconds(Contexts);
 }
 
-LocationContext::~LocationContext() = default;
+LocationContext::~LocationContext() {}
 
 LocationContextManager::~LocationContextManager() {
   clear();
 }
 
 void LocationContextManager::clear() {
   for (llvm::FoldingSet<LocationContext>::iterator I = Contexts.begin(),
        E = Contexts.end(); I != E; ) {
     LocationContext *LC = &*I;
     ++I;
     delete LC;
   }
 
   Contexts.clear();
 }
 

lib/Analysis/CFG.cpp

for (CFG::const_iterator I = cfg->begin(), E = cfg->end(); I != E; ++I ) {
             default:
               break;
           }
         }
       }
     }
   }
 
-  ~StmtPrinterHelper() override = default;
+  ~StmtPrinterHelper() override {}
 
   const LangOptions &getLangOpts() const { return LangOpts; }
   void setBlockID(signed i) { currentBlock = i; }
   void setStmtID(unsigned i) { currStmt = i; }
 
   bool handledStmt(Stmt *S, raw_ostream &OS) override {
     StmtMapTy::iterator I = StmtMap.find(S);
 

lib/Analysis/CodeInjector.cpp

 //===-- CodeInjector.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/CodeInjector.h"
 
 using namespace clang;
 
-CodeInjector::CodeInjector() = default;
-CodeInjector::~CodeInjector() = default;
+CodeInjector::CodeInjector() {}
+CodeInjector::~CodeInjector() {}

lib/Analysis/Consumed.cpp

 //       (Deferred)
 // TODO: Test nested conditionals: A) Checking the same value multiple times,
 //       and 2) Checking different values. (Deferred)
 
 using namespace clang;
 using namespace consumed;
 
 // Key method definition
-ConsumedWarningsHandlerBase::~ConsumedWarningsHandlerBase() = default;
+ConsumedWarningsHandlerBase::~ConsumedWarningsHandlerBase() {}
 
 static SourceLocation getFirstStmtLoc(const CFGBlock *Block) {
   // Find the source location of the first statement in the block, if the block
   // is not empty.
   for (const auto &B : *Block)
     if (Optional<CFGStmt> CS = B.getAs<CFGStmt>())
       return CS->getStmt()->getLocStart();
 

lib/Analysis/FormatString.cpp

 using clang::analyze_format_string::FormatSpecifier;
 using clang::analyze_format_string::LengthModifier;
 using clang::analyze_format_string::OptionalAmount;
 using clang::analyze_format_string::PositionContext;
 using clang::analyze_format_string::ConversionSpecifier;
 using namespace clang;
 
 // Key function to FormatStringHandler.
-FormatStringHandler::~FormatStringHandler() = default;
+FormatStringHandler::~FormatStringHandler() {}
 
 //===----------------------------------------------------------------------===//
 // Functions for parsing format strings components in both printf and
 // scanf format strings.
 //===----------------------------------------------------------------------===//
 
 OptionalAmount
 clang::analyze_format_string::ParseAmount(const char *&Beg, const char *E) {

lib/Analysis/ProgramPoint.cpp

 //  distinct location in a function.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/ProgramPoint.h"
 
 using namespace clang;
 
-ProgramPointTag::~ProgramPointTag() = default;
+ProgramPointTag::~ProgramPointTag() {}
 
 ProgramPoint ProgramPoint::getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
                                            const LocationContext *LC,
                                            const ProgramPointTag *tag){
   switch (K) {
     default:
       llvm_unreachable("Unhandled ProgramPoint kind");
     case ProgramPoint::PreStmtKind:

lib/Analysis/ThreadSafety.cpp

 #include <ostream>
 #include <sstream>
 #include <utility>
 #include <vector>
 using namespace clang;
 using namespace threadSafety;
 
 // Key method definition
-ThreadSafetyHandler::~ThreadSafetyHandler() = default;
+ThreadSafetyHandler::~ThreadSafetyHandler() {}
 
 namespace {
 class TILPrinter :
   public til::PrettyPrinter<TILPrinter, llvm::raw_ostream> {};
 
 
 /// Issue a warning about an invalid lock expression
 static void warnInvalidLock(ThreadSafetyHandler &Handler,
private:
   bool              Declared;         ///<  true if the lock was declared
 
 public:
   FactEntry(const CapabilityExpr &CE, LockKind LK, SourceLocation Loc,
             bool Asrt, bool Declrd = false)
       : CapabilityExpr(CE), LKind(LK), AcquireLoc(Loc), Asserted(Asrt),
         Declared(Declrd) {}
 
-  virtual ~FactEntry() = default;
+  virtual ~FactEntry() {}
 
   LockKind          kind()       const { return LKind;      }
   SourceLocation    loc()        const { return AcquireLoc; }
   bool              asserted()   const { return Asserted; }
   bool              declared()   const { return Declared; }
 
   void setDeclared(bool D) { Declared = D; }
 

lib/Analysis/UninitializedValues.cpp

 /// variable.  It is mainly used to prune out work during the final
 /// reporting pass.
 namespace {
 struct PruneBlocksHandler : public UninitVariablesHandler {
   PruneBlocksHandler(unsigned numBlocks)
     : hadUse(numBlocks, false), hadAnyUse(false),
       currentBlock(0) {}
 
-  ~PruneBlocksHandler() override = default;
+  ~PruneBlocksHandler() override {}
 
   /// Records if a CFGBlock had a potential use of an uninitialized variable.
   llvm::BitVector hadUse;
 
   /// Records if any CFGBlock had a potential use of an uninitialized variable.
   bool hadAnyUse;
 
   /// The current block to scribble use information.
for (CFG::const_iterator BI = cfg.begin(), BE = cfg.end(); BI != BE; ++BI) {
     const CFGBlock *block = *BI;
     if (PBH.hadUse[block->getBlockID()]) {
       runOnBlock(block, cfg, ac, vals, classification, wasAnalyzed, handler);
       ++stats.NumBlockVisits;
     }
   }
 }
 
-UninitVariablesHandler::~UninitVariablesHandler() = default;
+UninitVariablesHandler::~UninitVariablesHandler() {}

lib/Basic/Diagnostic.cpp

bool DiagnosticsEngine::EmitCurrentDiagnostic(bool Force) {
   // If there was a delayed diagnostic, emit it now.
   if (!Force && DelayedDiagID && DelayedDiagID != DiagID)
     ReportDelayed();
 
   return Emitted;
 }
 
 
-DiagnosticConsumer::~DiagnosticConsumer() = default;
+DiagnosticConsumer::~DiagnosticConsumer() {}
 
 void DiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                                         const Diagnostic &Info) {
   if (!IncludeInDiagnosticCounts())
     return;
 
   if (DiagLevel == DiagnosticsEngine::Warning)
     ++NumWarnings;

 /// IncludeInDiagnosticCounts - This method (whose default implementation
 ///  returns true) indicates whether the diagnostics handled by this
 ///  DiagnosticConsumer should be included in the number of diagnostics
 ///  reported by DiagnosticsEngine.
 bool DiagnosticConsumer::IncludeInDiagnosticCounts() const { return true; }
 
 void IgnoringDiagConsumer::anchor() { }
 
-ForwardingDiagnosticConsumer::~ForwardingDiagnosticConsumer() = default;
+ForwardingDiagnosticConsumer::~ForwardingDiagnosticConsumer() {}
 
 void ForwardingDiagnosticConsumer::HandleDiagnostic(
        DiagnosticsEngine::Level DiagLevel,
        const Diagnostic &Info) {
   Target.HandleDiagnostic(DiagLevel, Info);
 }
 
 void ForwardingDiagnosticConsumer::clear() {

lib/Basic/FileManager.cpp

llvm::errs() << NumDirLookups << " dir lookups, "
                << NumDirCacheMisses << " dir cache misses.\n";
   llvm::errs() << NumFileLookups << " file lookups, "
                << NumFileCacheMisses << " file cache misses.\n";
 
   //llvm::errs() << PagesMapped << BytesOfPagesMapped << FSLookups;
 }
 
 // Virtual destructors for abstract base classes that need live in Basic.
-PCHContainerWriter::~PCHContainerWriter() = default;
-PCHContainerReader::~PCHContainerReader() = default;
+PCHContainerWriter::~PCHContainerWriter() {}
+PCHContainerReader::~PCHContainerReader() {}

lib/Basic/IdentifierTable.cpp

IdentifierInfo::IdentifierInfo() {
   FETokenInfo = nullptr;
   Entry = nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // IdentifierTable Implementation
 //===----------------------------------------------------------------------===//
 
-IdentifierIterator::~IdentifierIterator() = default;
+IdentifierIterator::~IdentifierIterator() { }
 
-IdentifierInfoLookup::~IdentifierInfoLookup() = default;
+IdentifierInfoLookup::~IdentifierInfoLookup() {}
 
 namespace {
   /// \brief A simple identifier lookup iterator that represents an
   /// empty sequence of identifiers.
   class EmptyLookupIterator : public IdentifierIterator
   {
   public:
     StringRef Next() override { return StringRef(); }

lib/Basic/SourceManager.cpp

if (SLocEntryLoaded[Index]) {
       DumpSLocEntry(ID, LoadedSLocEntryTable[Index], NextStart);
       NextStart = LoadedSLocEntryTable[Index].getOffset();
     } else {
       NextStart = None;
     }
   }
 }
 
-ExternalSLocEntrySource::~ExternalSLocEntrySource() = default;
+ExternalSLocEntrySource::~ExternalSLocEntrySource() { }
 
 /// Return the amount of memory used by memory buffers, breaking down
 /// by heap-backed versus mmap'ed memory.
 SourceManager::MemoryBufferSizes SourceManager::getMemoryBufferSizes() const {
   size_t malloc_bytes = 0;
   size_t mmap_bytes = 0;
   
   for (unsigned i = 0, e = MemBufferInfos.size(); i != e; ++i)

lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   UseAddrSpaceMapMangling = false;
 
   // Default to an unknown platform name.
   PlatformName = "unknown";
   PlatformMinVersion = VersionTuple();
 }
 
 // Out of line virtual dtor for TargetInfo.
-TargetInfo::~TargetInfo() = default;
+TargetInfo::~TargetInfo() {}
 
 /// getTypeName - Return the user string for the specified integer type enum.
 /// For example, SignedShort -> "short".
 const char *TargetInfo::getTypeName(IntType T) {
   switch (T) {
   default: llvm_unreachable("not an integer!");
   case SignedChar:       return "signed char";
   case UnsignedChar:     return "unsigned char";

lib/Basic/VirtualFileSystem.cpp

 }
 bool Status::isStatusKnown() const {
   return Type != file_type::status_error;
 }
 bool Status::exists() const {
   return isStatusKnown() && Type != file_type::file_not_found;
 }
 
-File::~File() = default;
+File::~File() {}
 
-FileSystem::~FileSystem() = default;
+FileSystem::~FileSystem() {}
 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
 FileSystem::getBufferForFile(const llvm::Twine &Name, int64_t FileSize,
                              bool RequiresNullTerminator, bool IsVolatile) {
   auto F = openFileForRead(Name);
   if (!F)
     return F.getError();
 

 std::error_code
 OverlayFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
   for (auto &FS : FSList)
     if (std::error_code EC = FS->setCurrentWorkingDirectory(Path))
       return EC;
   return std::error_code();
 }
 
-clang::vfs::detail::DirIterImpl::~DirIterImpl() = default;
+clang::vfs::detail::DirIterImpl::~DirIterImpl() { }
 
 namespace {
 class OverlayFSDirIterImpl : public clang::vfs::detail::DirIterImpl {
   OverlayFileSystem &Overlays;
   std::string Path;
   OverlayFileSystem::iterator CurrentFS;
   directory_iterator CurrentDirIter;
   llvm::StringSet<> SeenNames;

 /// file or a directory.
 class InMemoryNode {
   Status Stat;
   InMemoryNodeKind Kind;
 
 public:
   InMemoryNode(Status Stat, InMemoryNodeKind Kind)
       : Stat(std::move(Stat)), Kind(Kind) {}
-  virtual ~InMemoryNode() = default;
+  virtual ~InMemoryNode() {}
   const Status &getStatus() const { return Stat; }
   InMemoryNodeKind getKind() const { return Kind; }
   virtual std::string toString(unsigned Indent) const = 0;
 };
 
 namespace {
 class InMemoryFile : public InMemoryNode {
   std::unique_ptr<llvm::MemoryBuffer> Buffer;

 
 InMemoryFileSystem::InMemoryFileSystem(bool UseNormalizedPaths)
     : Root(new detail::InMemoryDirectory(
           Status("", getNextVirtualUniqueID(), llvm::sys::TimeValue::MinTime(),
                  0, 0, 0, llvm::sys::fs::file_type::directory_file,
                  llvm::sys::fs::perms::all_all))),
       UseNormalizedPaths(UseNormalizedPaths) {}
 
-InMemoryFileSystem::~InMemoryFileSystem() = default;
+InMemoryFileSystem::~InMemoryFileSystem() {}
 
 std::string InMemoryFileSystem::toString() const {
   return Root->toString(/*Indent=*/0);
 }
 
 bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime,
                                  std::unique_ptr<llvm::MemoryBuffer> Buffer) {
   SmallString<128> Path;

lib/CodeGen/CGBlocks.cpp

CGBlockInfo::CGBlockInfo(const BlockDecl *block, StringRef name)
 
   // Skip asm prefix, if any.  'name' is usually taken directly from
   // the mangled name of the enclosing function.
   if (!name.empty() && name[0] == '\01')
     name = name.substr(1);
 }
 
 // Anchor the vtable to this translation unit.
-BlockByrefHelpers::~BlockByrefHelpers() = default;
+BlockByrefHelpers::~BlockByrefHelpers() {}
 
 /// Build the given block as a global block.
 static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM,
                                         const CGBlockInfo &blockInfo,
                                         llvm::Constant *blockFn);
 
 /// Build the helper function to copy a block.
 static llvm::Constant *buildCopyHelper(CodeGenModule &CGM,

lib/CodeGen/CGCUDARuntime.cpp

 #include "CGCall.h"
 #include "CodeGenFunction.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/ExprCXX.h"
 
 using namespace clang;
 using namespace CodeGen;
 
-CGCUDARuntime::~CGCUDARuntime() = default;
+CGCUDARuntime::~CGCUDARuntime() {}
 
 RValue CGCUDARuntime::EmitCUDAKernelCallExpr(CodeGenFunction &CGF,
                                              const CUDAKernelCallExpr *E,
                                              ReturnValueSlot ReturnValue) {
   llvm::BasicBlock *ConfigOKBlock = CGF.createBasicBlock("kcall.configok");
   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("kcall.end");
 
   CodeGenFunction::ConditionalEvaluation eval(CGF);

lib/CodeGen/CGCXXABI.cpp

 //===----------------------------------------------------------------------===//
 
 #include "CGCXXABI.h"
 #include "CGCleanup.h"
 
 using namespace clang;
 using namespace CodeGen;
 
-CGCXXABI::~CGCXXABI() = default;
+CGCXXABI::~CGCXXABI() { }
 
 void CGCXXABI::ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S) {
   DiagnosticsEngine &Diags = CGF.CGM.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
                                           "cannot yet compile %0 in this ABI");
   Diags.Report(CGF.getContext().getFullLoc(CGF.CurCodeDecl->getLocation()),
                DiagID)
     << S;

lib/CodeGen/CGCall.cpp

enum TypeExpansionKind {
     TEK_Complex,
     // All other types are not expandable.
     TEK_None
   };
 
   const TypeExpansionKind Kind;
 
   TypeExpansion(TypeExpansionKind K) : Kind(K) {}
-  virtual ~TypeExpansion() = default;
+  virtual ~TypeExpansion() {}
 };
 
 struct ConstantArrayExpansion : TypeExpansion {
   QualType EltTy;
   uint64_t NumElts;
 
   ConstantArrayExpansion(QualType EltTy, uint64_t NumElts)
       : TypeExpansion(TEK_ConstantArray), EltTy(EltTy), NumElts(NumElts) {}

lib/CodeGen/CGObjC.cpp

CodeGenFunction::EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty) {
   Result = Runtime.GenerateMessageSend(*this, ReturnValueSlot(),
                                        Ty, AutoreleaseSelector,
                                        Val, CallArgList(), nullptr, nullptr);
   Val = Result.getScalarVal();
   return Val;
 }
 
 
-CGObjCRuntime::~CGObjCRuntime() = default;
+CGObjCRuntime::~CGObjCRuntime() {}

lib/CodeGen/CGOpenCLRuntime.cpp

 #include "CodeGenFunction.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalValue.h"
 #include <assert.h>
 
 using namespace clang;
 using namespace CodeGen;
 
-CGOpenCLRuntime::~CGOpenCLRuntime() = default;
+CGOpenCLRuntime::~CGOpenCLRuntime() {}
 
 void CGOpenCLRuntime::EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF,
                                                 const VarDecl &D) {
   return CGF.EmitStaticVarDecl(D, llvm::GlobalValue::InternalLinkage);
 }
 
 llvm::Type *CGOpenCLRuntime::convertOpenCLSpecificType(const Type *T) {
   assert(T->isOpenCLSpecificType() &&

lib/CodeGen/CGOpenMPRuntime.h

private:
   /// name. If the lock object does not exist it is created, otherwise the
   /// reference to the existing copy is returned.
   /// \param CriticalName Name of the critical region.
   ///
   llvm::Value *getCriticalRegionLock(StringRef CriticalName);
 
 public:
   explicit CGOpenMPRuntime(CodeGenModule &CGM);
-  virtual ~CGOpenMPRuntime() = default;
+  virtual ~CGOpenMPRuntime() {}
   virtual void clear();
 
   /// \brief Emits outlined function for the specified OpenMP parallel directive
   /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
   /// kmp_int32 BoundID, struct context_vars*).
   /// \param D OpenMP directive.
   /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
   /// \param InnermostKind Kind of innermost directive (for simple directives it

lib/CodeGen/CodeGenFunction.cpp

if (VTy != CGM.Int8PtrTy)
       V = Builder.Insert(new llvm::BitCastInst(V, CGM.Int8PtrTy));
     V = EmitAnnotationCall(F, V, I->getAnnotation(), D->getLocation());
     V = Builder.CreateBitCast(V, VTy);
   }
 
   return Address(V, Addr.getAlignment());
 }
 
-CodeGenFunction::CGCapturedStmtInfo::~CGCapturedStmtInfo() = default;
+CodeGenFunction::CGCapturedStmtInfo::~CGCapturedStmtInfo() { }
 
 CodeGenFunction::SanitizerScope::SanitizerScope(CodeGenFunction *CGF)
     : CGF(CGF) {
   assert(!CGF->IsSanitizerScope);
   CGF->IsSanitizerScope = true;
 }
 
 CodeGenFunction::SanitizerScope::~SanitizerScope() {

lib/CodeGen/CodeGenTBAA.cpp

 
 CodeGenTBAA::CodeGenTBAA(ASTContext &Ctx, llvm::LLVMContext& VMContext,
                          const CodeGenOptions &CGO,
                          const LangOptions &Features, MangleContext &MContext)
   : Context(Ctx), CodeGenOpts(CGO), Features(Features), MContext(MContext),
     MDHelper(VMContext), Root(nullptr), Char(nullptr) {
 }
 
-CodeGenTBAA::~CodeGenTBAA() = default;
+CodeGenTBAA::~CodeGenTBAA() {
+}
 
 llvm::MDNode *CodeGenTBAA::getRoot() {
   // Define the root of the tree. This identifies the tree, so that
   // if our LLVM IR is linked with LLVM IR from a different front-end
   // (or a different version of this front-end), their TBAA trees will
   // remain distinct, and the optimizer will treat them conservatively.
   if (!Root)
     Root = MDHelper.createTBAARoot("Simple C/C++ TBAA");

lib/CodeGen/TargetInfo.cpp

return ABIArgInfo::getIndirectInReg(getContext().getTypeAlignInChars(Ty),
                                       /*ByRef*/ false, Realign);
 }
 
 Address ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
                              QualType Ty) const {
   return Address::invalid();
 }
 
-ABIInfo::~ABIInfo() = default;
+ABIInfo::~ABIInfo() {}
 
 static CGCXXABI::RecordArgABI getRecordArgABI(const RecordType *RT,
                                               CGCXXABI &CXXABI) {
   const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
   if (!RD)
     return CGCXXABI::RAA_Default;
   return CXXABI.getRecordArgABI(RD);
 }

lib/Driver/Tool.cpp

 Tool::Tool(const char *_Name, const char *_ShortName, const ToolChain &TC,
            ResponseFileSupport _ResponseSupport,
            llvm::sys::WindowsEncodingMethod _ResponseEncoding,
            const char *_ResponseFlag)
     : Name(_Name), ShortName(_ShortName), TheToolChain(TC),
       ResponseSupport(_ResponseSupport), ResponseEncoding(_ResponseEncoding),
       ResponseFlag(_ResponseFlag) {}
 
-Tool::~Tool() = default;
+Tool::~Tool() {
+}

lib/Driver/ToolChain.cpp

ToolChain::ToolChain(const Driver &D, const llvm::Triple &T,
     : D(D), Triple(T), Args(Args), CachedRTTIArg(GetRTTIArgument(Args)),
       CachedRTTIMode(CalculateRTTIMode(Args, Triple, CachedRTTIArg)) {
   if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
     if (!isThreadModelSupported(A->getValue()))
       D.Diag(diag::err_drv_invalid_thread_model_for_target)
           << A->getValue() << A->getAsString(Args);
 }
 
-ToolChain::~ToolChain() = default;
+ToolChain::~ToolChain() {
+}
 
 vfs::FileSystem &ToolChain::getVFS() const { return getDriver().getVFS(); }
 
 bool ToolChain::useIntegratedAs() const {
   return Args.hasFlag(options::OPT_fintegrated_as,
                       options::OPT_fno_integrated_as,
                       IsIntegratedAssemblerDefault());
 }

lib/Driver/ToolChains.cpp

case llvm::Triple::arm:
     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
       if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
         return Arch;
 
     return "arm";
   }
 }
 
-Darwin::~Darwin() = default;
+Darwin::~Darwin() {}
 
-MachO::~MachO() = default;
+MachO::~MachO() {}
 
 std::string MachO::ComputeEffectiveClangTriple(const ArgList &Args,
                                                types::ID InputType) const {
   llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
 
   return Triple.getTriple();
 }
 

 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
                          const ArgList &Args)
     : ToolChain(D, Triple, Args), GCCInstallation(D), CudaInstallation(D) {
   getProgramPaths().push_back(getDriver().getInstalledDir());
   if (getDriver().getInstalledDir() != getDriver().Dir)
     getProgramPaths().push_back(getDriver().Dir);
 }
 
-Generic_GCC::~Generic_GCC() = default;
+Generic_GCC::~Generic_GCC() {}
 
 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
   switch (AC) {
   case Action::PreprocessJobClass:
     if (!Preprocess)
       Preprocess.reset(new tools::gcc::Preprocessor(*this));
     return Preprocess.get();
   case Action::CompileJobClass:
HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
   // 'elf' OS type, so the Linux paths are not appropriate. When we actually
   // support 'linux' we'll need to fix this up
   LibPaths->clear();
 
   GetHexagonLibraryPaths(*this, Args, GetGCCLibAndIncVersion(),
                          GetTargetCPU(Args), InstalledDir, LibPaths);
 }
 
-HexagonToolChain::~HexagonToolChain() = default;
+HexagonToolChain::~HexagonToolChain() {}
 
 Tool *HexagonToolChain::buildAssembler() const {
   return new tools::hexagon::Assembler(*this);
 }
 
 Tool *HexagonToolChain::buildLinker() const {
   return new tools::hexagon::Linker(*this);
 }
TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple &Triple,
     : ToolChain(D, Triple, Args) {
   // Path mangling to find libexec
   std::string Path(getDriver().Dir);
 
   Path += "/../libexec";
   getProgramPaths().push_back(Path);
 }
 
-TCEToolChain::~TCEToolChain() = default;
+TCEToolChain::~TCEToolChain() {}
 
 bool TCEToolChain::IsMathErrnoDefault() const { return true; }
 
 bool TCEToolChain::isPICDefault() const { return false; }
 
 bool TCEToolChain::isPIEDefault() const { return false; }
 
 bool TCEToolChain::isPICDefaultForced() const { return false; }
default:
     D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName() << "myriad";
   case llvm::Triple::sparc:
   case llvm::Triple::sparcel:
   case llvm::Triple::shave:
     GCCInstallation.init(Triple, Args, {"sparc-myriad-elf"});
   }
 }
 
-MyriadToolChain::~MyriadToolChain() = default;
+MyriadToolChain::~MyriadToolChain() {}
 
 void MyriadToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                                 ArgStringList &CC1Args) const {
   if (!DriverArgs.hasArg(options::OPT_nostdinc))
     addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + "/include");
 }
 
 void MyriadToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,

lib/Format/BreakableToken.h

 ///
 /// FIXME: The interface seems set in stone, so we might want to just pull the
 /// strategy into the class, instead of controlling it from the outside.
 class BreakableToken {
 public:
   /// \brief Contains starting character index and length of split.
   typedef std::pair<StringRef::size_type, unsigned> Split;
 
-  virtual ~BreakableToken() = default;
+  virtual ~BreakableToken() {}
 
   /// \brief Returns the number of lines in this token in the original code.
   virtual unsigned getLineCount() const = 0;
 
   /// \brief Returns the number of columns required to format the piece of line
   /// at \p LineIndex, from byte offset \p Offset with length \p Length.
   ///
   /// Note that previous breaks are not taken into account. \p Offset is always

lib/Format/FormatToken.cpp

bool FormatToken::isSimpleTypeSpecifier() const {
   case tok::kw_typeof:
   case tok::kw_decltype:
     return true;
   default:
     return false;
   }
 }
 
-TokenRole::~TokenRole() = default;
+TokenRole::~TokenRole() {}
 
 void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {}
 
 unsigned CommaSeparatedList::formatAfterToken(LineState &State,
                                               ContinuationIndenter *Indenter,
                                               bool DryRun) {
   if (State.NextToken == nullptr || !State.NextToken->Previous)
     return 0;

lib/Format/UnwrappedLineFormatter.cpp

 /// \brief Base class for classes that format one \c AnnotatedLine.
 class LineFormatter {
 public:
   LineFormatter(ContinuationIndenter *Indenter, WhitespaceManager *Whitespaces,
                 const FormatStyle &Style,
                 UnwrappedLineFormatter *BlockFormatter)
       : Indenter(Indenter), Whitespaces(Whitespaces), Style(Style),
         BlockFormatter(BlockFormatter) {}
-  virtual ~LineFormatter() = default;
+  virtual ~LineFormatter() {}
 
   /// \brief Formats an \c AnnotatedLine and returns the penalty.
   ///
   /// If \p DryRun is \c false, directly applies the changes.
   virtual unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
                               bool DryRun) = 0;
 
 protected:

lib/Format/UnwrappedLineParser.h

struct UnwrappedLine {
   /// \brief Whether this \c UnwrappedLine is part of a preprocessor directive.
   bool InPPDirective;
 
   bool MustBeDeclaration;
 };
 
 class UnwrappedLineConsumer {
 public:
-  virtual ~UnwrappedLineConsumer() = default;
+  virtual ~UnwrappedLineConsumer() {}
   virtual void consumeUnwrappedLine(const UnwrappedLine &Line) = 0;
   virtual void finishRun() = 0;
 };
 
 class FormatTokenSource;
 
 class UnwrappedLineParser {
 public:

lib/Format/UnwrappedLineParser.cpp

 
 #define DEBUG_TYPE "format-parser"
 
 namespace clang {
 namespace format {
 
 class FormatTokenSource {
 public:
-  virtual ~FormatTokenSource() = default;
+  virtual ~FormatTokenSource() {}
   virtual FormatToken *getNextToken() = 0;
 
   virtual unsigned getPosition() = 0;
   virtual FormatToken *setPosition(unsigned Position) = 0;
 };
 
 namespace {
 

lib/Frontend/ASTUnit.cpp

 
 void ASTUnit::ConcurrencyState::finish() {
   static_cast<llvm::sys::MutexImpl *>(Mutex)->release();
 }
 
 #else // NDEBUG
 
 ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = nullptr; }
-ASTUnit::ConcurrencyState::~ConcurrencyState() = default;
+ASTUnit::ConcurrencyState::~ConcurrencyState() {}
 void ASTUnit::ConcurrencyState::start() {}
 void ASTUnit::ConcurrencyState::finish() {}
 
 #endif // NDEBUG

lib/Frontend/CacheTokens.cpp

 
 typedef uint32_t Offset;
 
 namespace {
 class PTHEntry {
   Offset TokenData, PPCondData;
 
 public:
-  PTHEntry() = default;
+  PTHEntry() {}
 
   PTHEntry(Offset td, Offset ppcd)
     : TokenData(td), PPCondData(ppcd) {}
 
   Offset getTokenOffset() const { return TokenData; }
   Offset getPPCondTableOffset() const { return PPCondData; }
 };
 

 /// invoked by FileManager while processing the original sources used
 /// as input to PTH generation.  StatListener populates the PTHWriter's
 /// file map with stat information for directories as well as negative stats.
 /// Stat information for files are populated elsewhere.
 class StatListener : public FileSystemStatCache {
   PTHMap ±
 public:
   StatListener(PTHMap &pm) : PM(pm) {}
-  ~StatListener() override = default;
+  ~StatListener() override {}
 
   LookupResult getStat(const char *Path, FileData &Data, bool isFile,
                        std::unique_ptr<vfs::File> *F,
                        vfs::FileSystem &FS) override {
     LookupResult Result = statChained(Path, Data, isFile, F, FS);
 
     if (Result == CacheMissing) // Failed 'stat'.
       PM.insert(PTHEntryKeyVariant(Path), PTHEntry());

lib/Frontend/CompilerInvocation.cpp

 CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &X)
   : RefCountedBase<CompilerInvocation>(),
     LangOpts(new LangOptions(*X.getLangOpts())),
     TargetOpts(new TargetOptions(X.getTargetOpts())),
     DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
     HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
     PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())) {}
 
-CompilerInvocationBase::~CompilerInvocationBase() = default;
+CompilerInvocationBase::~CompilerInvocationBase() {}
 
 //===----------------------------------------------------------------------===//
 // Deserialization (from args)
 //===----------------------------------------------------------------------===//
 
 using namespace clang::driver;
 using namespace clang::driver::options;
 using namespace llvm::opt;

lib/Frontend/DependencyFile.cpp

 
 bool DependencyCollector::sawDependency(StringRef Filename, bool FromModule,
                                        bool IsSystem, bool IsModuleFile,
                                        bool IsMissing) {
   return !isSpecialFilename(Filename) &&
          (needSystemDependencies() || !IsSystem);
 }
 
-DependencyCollector::~DependencyCollector() = default;
+DependencyCollector::~DependencyCollector() { }
 void DependencyCollector::attachToPreprocessor(Preprocessor &PP) {
   PP.addPPCallbacks(
       llvm::make_unique<DepCollectorPPCallbacks>(*this, PP.getSourceManager()));
   PP.getHeaderSearchInfo().getModuleMap().addModuleMapCallbacks(
       llvm::make_unique<DepCollectorMMCallbacks>(*this));
 }
 void DependencyCollector::attachToASTReader(ASTReader &R) {
   R.addListener(llvm::make_unique<DepCollectorASTListener>(*this));

lib/Frontend/DiagnosticRenderer.cpp

static StringRef getImmediateMacroName(SourceLocation Loc,
    StringRef ExpansionBuffer = SM.getBufferData(ExpansionInfo.first);
    return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength);
 }
 
 DiagnosticRenderer::DiagnosticRenderer(const LangOptions &LangOpts,
                                        DiagnosticOptions *DiagOpts)
   : LangOpts(LangOpts), DiagOpts(DiagOpts), LastLevel() {}
 
-DiagnosticRenderer::~DiagnosticRenderer() = default;
+DiagnosticRenderer::~DiagnosticRenderer() {}
 
 namespace {
 
 class FixitReceiver : public edit::EditsReceiver {
   SmallVectorImpl<FixItHint> &MergedFixits;
 
 public:
   FixitReceiver(SmallVectorImpl<FixItHint> &MergedFixits)
void DiagnosticRenderer::emitMacroExpansions(SourceLocation Loc,
   emitBasicNote(Message.str());
 
   for (auto I = LocationStack.rend() - MacroEndMessages,
             E = LocationStack.rend();
        I != E; ++I)
     emitSingleMacroExpansion(*I, Level, Ranges, SM);
 }
 
-DiagnosticNoteRenderer::~DiagnosticNoteRenderer() = default;
+DiagnosticNoteRenderer::~DiagnosticNoteRenderer() {}
 
 void DiagnosticNoteRenderer::emitIncludeLocation(SourceLocation Loc,
                                                  PresumedLoc PLoc,
                                                  const SourceManager &SM) {
   // Generate a note indicating the include location.
   SmallString<200> MessageStorage;
   llvm::raw_svector_ostream Message(MessageStorage);
   Message << "in file included from " << PLoc.getFilename() << ':'

lib/Frontend/FrontendAction.cpp

void DeclRead(serialization::DeclID ID, const Decl *D) override {
     DelegatingDeserializationListener::DeclRead(ID, D);
   }
 };
 
 } // end anonymous namespace
 
 FrontendAction::FrontendAction() : Instance(nullptr) {}
 
-FrontendAction::~FrontendAction() = default;
+FrontendAction::~FrontendAction() {}
 
 void FrontendAction::setCurrentInput(const FrontendInputFile &CurrentInput,
                                      std::unique_ptr<ASTUnit> AST) {
   this->CurrentInput = CurrentInput;
   CurrentASTUnit = std::move(AST);
 }
 
 std::unique_ptr<ASTConsumer>

lib/Frontend/MultiplexConsumer.cpp

MultiplexConsumer::MultiplexConsumer(
   }
   if (!serializationListeners.empty()) {
     DeserializationListener =
         llvm::make_unique<MultiplexASTDeserializationListener>(
             serializationListeners);
   }
 }
 
-MultiplexConsumer::~MultiplexConsumer() = default;
+MultiplexConsumer::~MultiplexConsumer() {}
 
 void MultiplexConsumer::Initialize(ASTContext &Context) {
   for (auto &Consumer : Consumers)
     Consumer->Initialize(Context);
 }
 
 bool MultiplexConsumer::HandleTopLevelDecl(DeclGroupRef D) {
   bool Continue = true;

lib/Frontend/Rewrite/FixItRewriter.cpp

void FixItRewriter::Diag(SourceLocation Loc, unsigned DiagID) {
   // clear out any current diagnostic, and let the downstream client
   // format the diagnostic.
   Diags.setClient(Client, false);
   Diags.Clear();
   Diags.Report(Loc, DiagID);
   Diags.setClient(this, false);
 }
 
-FixItOptions::~FixItOptions() = default;
+FixItOptions::~FixItOptions() {}

lib/Frontend/Rewrite/FrontendActions.cpp

 std::unique_ptr<ASTConsumer>
 HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile))
     return CreateHTMLPrinter(OS, CI.getPreprocessor());
   return nullptr;
 }
 
 FixItAction::FixItAction() {}
-FixItAction::~FixItAction() = default;
+FixItAction::~FixItAction() {}
 
 std::unique_ptr<ASTConsumer>
 FixItAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   return llvm::make_unique<ASTConsumer>();
 }
 
 namespace {
 class FixItRewriteInPlace : public FixItOptions {

lib/Frontend/Rewrite/RewriteModernObjC.cpp

public:
     }
     
     void HandleTopLevelSingleDecl(Decl *D);
     void HandleDeclInMainFile(Decl *D);
     RewriteModernObjC(std::string inFile, raw_ostream *OS,
                 DiagnosticsEngine &D, const LangOptions &LOpts,
                 bool silenceMacroWarn, bool LineInfo);
 
-    ~RewriteModernObjC() override = default;
+    ~RewriteModernObjC() override {}
 
     void HandleTranslationUnit(ASTContext &C) override;
 
     void ReplaceStmt(Stmt *Old, Stmt *New) {
       ReplaceStmtWithRange(Old, New, Old->getSourceRange());
     }
 
     void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {

lib/Frontend/Rewrite/RewriteObjC.cpp

bool HandleTopLevelDecl(DeclGroupRef D) override {
       return true;
     }
     void HandleTopLevelSingleDecl(Decl *D);
     void HandleDeclInMainFile(Decl *D);
     RewriteObjC(std::string inFile, raw_ostream *OS,
                 DiagnosticsEngine &D, const LangOptions &LOpts,
                 bool silenceMacroWarn);
 
-    ~RewriteObjC() override = default;
+    ~RewriteObjC() override {}
 
     void HandleTranslationUnit(ASTContext &C) override;
 
     void ReplaceStmt(Stmt *Old, Stmt *New) {
       ReplaceStmtWithRange(Old, New, Old->getSourceRange());
     }
 
     void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {
namespace {
   public:
     
     RewriteObjCFragileABI(std::string inFile, raw_ostream *OS,
                 DiagnosticsEngine &D, const LangOptions &LOpts,
                 bool silenceMacroWarn) : RewriteObjC(inFile, OS,
                                                      D, LOpts,
                                                      silenceMacroWarn) {}
 
-    ~RewriteObjCFragileABI() override = default;
+    ~RewriteObjCFragileABI() override {}
     void Initialize(ASTContext &context) override;
 
     // Rewriting metadata
     template<typename MethodIterator>
     void RewriteObjCMethodsMetaData(MethodIterator MethodBegin,
                                     MethodIterator MethodEnd,
                                     bool IsInstanceMethod,
                                     StringRef prefix,

lib/Frontend/SerializedDiagnosticPrinter.cpp

   
 class SDiagsRenderer : public DiagnosticNoteRenderer {
   SDiagsWriter &Writer;
 public:
   SDiagsRenderer(SDiagsWriter &Writer, const LangOptions &LangOpts,
                  DiagnosticOptions *DiagOpts)
     : DiagnosticNoteRenderer(LangOpts, DiagOpts), Writer(Writer) {}
 
-  ~SDiagsRenderer() override = default;
+  ~SDiagsRenderer() override {}
 
 protected:
   void emitDiagnosticMessage(SourceLocation Loc,
                              PresumedLoc PLoc,
                              DiagnosticsEngine::Level Level,
                              StringRef Message,
                              ArrayRef<CharSourceRange> Ranges,
                              const SourceManager *SM,
SDiagsWriter(StringRef File, DiagnosticOptions *Diags, bool MergeChildRecords)
       : LangOpts(nullptr), OriginalInstance(true),
         MergeChildRecords(MergeChildRecords),
         State(new SharedState(File, Diags)) {
     if (MergeChildRecords)
       RemoveOldDiagnostics();
     EmitPreamble();
   }
 
-  ~SDiagsWriter() override = default;
+  ~SDiagsWriter() override {}
 
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                         const Diagnostic &Info) override;
 
   void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override {
     LangOpts = &LO;
   }
 

lib/Frontend/TextDiagnostic.cpp

static bool printWordWrapped(raw_ostream &OS, StringRef Str,
   return Wrapped;
 }
 
 TextDiagnostic::TextDiagnostic(raw_ostream &OS,
                                const LangOptions &LangOpts,
                                DiagnosticOptions *DiagOpts)
   : DiagnosticRenderer(LangOpts, DiagOpts), OS(OS) {}
 
-TextDiagnostic::~TextDiagnostic() = default;
+TextDiagnostic::~TextDiagnostic() {}
 
 void
 TextDiagnostic::emitDiagnosticMessage(SourceLocation Loc,
                                       PresumedLoc PLoc,
                                       DiagnosticsEngine::Level Level,
                                       StringRef Message,
                                       ArrayRef<clang::CharSourceRange> Ranges,
                                       const SourceManager *SM,

lib/Index/CommentToXML.cpp

while (!S.empty()) {
     Result << S.substr(0, Pos);
 
     S = S.drop_front(Pos);
   }
   Result << "]]>";
 }
 
 CommentToXMLConverter::CommentToXMLConverter() : FormatInMemoryUniqueId(0) {}
-CommentToXMLConverter::~CommentToXMLConverter() = default;
+CommentToXMLConverter::~CommentToXMLConverter() {}
 
 void CommentToXMLConverter::convertCommentToHTML(const FullComment *FC,
                                                  SmallVectorImpl<char> &HTML,
                                                  const ASTContext &Context) {
   CommentASTToHTMLConverter Converter(FC, HTML,
                                       Context.getCommentCommandTraits());
   Converter.visit(FC);
 }

lib/Lex/HeaderSearch.cpp

HeaderFileInfo::getControllingMacro(ExternalPreprocessorSource *External) {
 
   if (!ControllingMacroID || !External)
     return nullptr;
 
   ControllingMacro = External->GetIdentifier(ControllingMacroID);
   return ControllingMacro;
 }
 
-ExternalHeaderFileInfoSource::~ExternalHeaderFileInfoSource() = default;
+ExternalHeaderFileInfoSource::~ExternalHeaderFileInfoSource() {}
 
 HeaderSearch::HeaderSearch(IntrusiveRefCntPtr<HeaderSearchOptions> HSOpts,
                            SourceManager &SourceMgr, DiagnosticsEngine &Diags,
                            const LangOptions &LangOpts,
                            const TargetInfo *Target)
     : HSOpts(HSOpts), Diags(Diags), FileMgr(SourceMgr.getFileManager()),
       FrameworkMap(64), ModMap(SourceMgr, Diags, LangOpts, Target, *this),
       LangOpts(LangOpts) {

lib/Lex/PPLexerChange.cpp

 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/MacroInfo.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 using namespace clang;
 
-PPCallbacks::~PPCallbacks() = default;
+PPCallbacks::~PPCallbacks() {}
 
 //===----------------------------------------------------------------------===//
 // Miscellaneous Methods.
 //===----------------------------------------------------------------------===//
 
 /// isInPrimaryFile - Return true if we're in the top-level file, not in a
 /// \#include.  This looks through macro expansions and active _Pragma lexers.
 bool Preprocessor::isInPrimaryFile() const {

lib/Lex/PTHLexer.cpp

PTHManager::PTHManager(
     std::unique_ptr<IdentifierInfo *[], llvm::FreeDeleter> perIDCache,
     std::unique_ptr<PTHStringIdLookup> stringIdLookup, unsigned numIds,
     const unsigned char *spellingBase, const char *originalSourceFile)
     : Buf(std::move(buf)), PerIDCache(std::move(perIDCache)),
       FileLookup(std::move(fileLookup)), IdDataTable(idDataTable),
       StringIdLookup(std::move(stringIdLookup)), NumIds(numIds), PP(nullptr),
       SpellingBase(spellingBase), OriginalSourceFile(originalSourceFile) {}
 
-PTHManager::~PTHManager() = default;
+PTHManager::~PTHManager() {
+}
 
 static void InvalidPTH(DiagnosticsEngine &Diags, const char *Msg) {
   Diags.Report(Diags.getCustomDiagID(DiagnosticsEngine::Error, "%0")) << Msg;
 }
 
 PTHManager *PTHManager::Create(StringRef file, DiagnosticsEngine &Diags) {
   // Memory map the PTH file.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileOrErr =

lib/Lex/Pragma.cpp

 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 using namespace clang;
 
 #include "llvm/Support/raw_ostream.h"
 
 // Out-of-line destructor to provide a home for the class.
-PragmaHandler::~PragmaHandler() = default;
+PragmaHandler::~PragmaHandler() {
+}
 
 //===----------------------------------------------------------------------===//
 // EmptyPragmaHandler Implementation.
 //===----------------------------------------------------------------------===//
 
 EmptyPragmaHandler::EmptyPragmaHandler(StringRef Name) : PragmaHandler(Name) {}
 
 void EmptyPragmaHandler::HandlePragma(Preprocessor &PP, 

lib/Lex/PreprocessingRecord.cpp

 #include "clang/Lex/PreprocessingRecord.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/Token.h"
 #include "llvm/Support/Capacity.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace clang;
 
-ExternalPreprocessingRecordSource::~ExternalPreprocessingRecordSource() = default;
+ExternalPreprocessingRecordSource::~ExternalPreprocessingRecordSource() { }
 
 
 InclusionDirective::InclusionDirective(PreprocessingRecord &PPRec,
                                        InclusionKind Kind, 
                                        StringRef FileName, 
                                        bool InQuotes, bool ImportedModule,
                                        const FileEntry *File,
                                        SourceRange Range)

lib/Lex/Preprocessor.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Capacity.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
-ExternalPreprocessorSource::~ExternalPreprocessorSource() = default;
+ExternalPreprocessorSource::~ExternalPreprocessorSource() { }
 
 Preprocessor::Preprocessor(IntrusiveRefCntPtr<PreprocessorOptions> PPOpts,
                            DiagnosticsEngine &diags, LangOptions &opts,
                            SourceManager &SM, HeaderSearch &Headers,
                            ModuleLoader &TheModuleLoader,
                            IdentifierInfoLookup *IILookup, bool OwnsHeaders,
                            TranslationUnitKind TUKind)
     : PPOpts(PPOpts), Diags(&diags), LangOpts(opts), Target(nullptr),
if ((*H)->HandleComment(*this, Comment))
       AnyPendingTokens = true;
   }
   if (!AnyPendingTokens || getCommentRetentionState())
     return false;
   Lex(result);
   return true;
 }
 
-ModuleLoader::~ModuleLoader() = default;
+ModuleLoader::~ModuleLoader() { }
 
-CommentHandler::~CommentHandler() = default;
+CommentHandler::~CommentHandler() { }
 
-CodeCompletionHandler::~CodeCompletionHandler() = default;
+CodeCompletionHandler::~CodeCompletionHandler() { }
 
 void Preprocessor::createPreprocessingRecord() {
   if (Record)
     return;
   
   Record = new PreprocessingRecord(getSourceManager());
   addPPCallbacks(std::unique_ptr<PPCallbacks>(Record));
 }

lib/Parse/ParseCXXInlineMethods.cpp

void Parser::ParseCXXNonStaticMemberInitializer(Decl *VarD) {
   Token Eof;
   Eof.startToken();
   Eof.setKind(tok::eof);
   Eof.setLocation(Tok.getLocation());
   Eof.setEofData(VarD);
   Toks.push_back(Eof);
 }
 
-Parser::LateParsedDeclaration::~LateParsedDeclaration() = default;
+Parser::LateParsedDeclaration::~LateParsedDeclaration() {}
 void Parser::LateParsedDeclaration::ParseLexedMethodDeclarations() {}
 void Parser::LateParsedDeclaration::ParseLexedMemberInitializers() {}
 void Parser::LateParsedDeclaration::ParseLexedMethodDefs() {}
 
 Parser::LateParsedClass::LateParsedClass(Parser *P, ParsingClass *C)
   : Self(P), Class(C) {}
 
 Parser::LateParsedClass::~LateParsedClass() {

lib/Rewrite/TokenRewriter.cpp

#if 0
     }
 #endif
 
     AddToken(RawTok, TokenList.end());
     RawLex.LexFromRawLexer(RawTok);
   }
 }
 
-TokenRewriter::~TokenRewriter() = default;
+TokenRewriter::~TokenRewriter() {
+}
 
 
 /// RemapIterator - Convert from token_iterator (a const iterator) to
 /// TokenRefTy (a non-const iterator).
 TokenRewriter::TokenRefTy TokenRewriter::RemapIterator(token_iterator I) {
   if (I == token_end()) return TokenList.end();
 
   // FIXME: This is horrible, we should use our own list or something to avoid

lib/Sema/AttributeList.cpp

else if (IsProperty)
     return AttributeFactory::PropertyAllocSize;
   return (sizeof(AttributeList) + NumArgs * sizeof(ArgsUnion));
 }
 
 AttributeFactory::AttributeFactory() {
   // Go ahead and configure all the inline capacity.  This is just a memset.
   FreeLists.resize(InlineFreeListsCapacity);
 }
-AttributeFactory::~AttributeFactory() = default;
+AttributeFactory::~AttributeFactory() {}
 
 static size_t getFreeListIndexForSize(size_t size) {
   assert(size >= sizeof(AttributeList));
   assert((size % sizeof(void*)) == 0);
   return ((size - sizeof(AttributeList)) / sizeof(void*));
 }
 
 void *AttributeFactory::allocate(size_t size) {

lib/Sema/CodeCompleteConsumer.cpp

CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
 
   llvm_unreachable("Invalid CandidateKind!");
 }
 
 //===----------------------------------------------------------------------===//
 // Code completion consumer implementation
 //===----------------------------------------------------------------------===//
 
-CodeCompleteConsumer::~CodeCompleteConsumer() = default;
+CodeCompleteConsumer::~CodeCompleteConsumer() { }
 
 void 
 PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
                                                  CodeCompletionContext Context,
                                                  CodeCompletionResult *Results,
                                                          unsigned NumResults) {
   std::stable_sort(Results, Results + NumResults);
   

lib/Sema/MultiplexExternalSemaSource.cpp

 ///
 MultiplexExternalSemaSource::MultiplexExternalSemaSource(ExternalSemaSource &s1,
                                                         ExternalSemaSource &s2){
   Sources.push_back(&s1);
   Sources.push_back(&s2);
 }
 
 // pin the vtable here.
-MultiplexExternalSemaSource::~MultiplexExternalSemaSource() = default;
+MultiplexExternalSemaSource::~MultiplexExternalSemaSource() {}
 
 ///\brief Appends new source to the source list.
 ///
 ///\param[in] source - An ExternalSemaSource.
 ///
 void MultiplexExternalSemaSource::addSource(ExternalSemaSource &source) {
   Sources.push_back(&source);
 }

lib/Sema/ScopeInfo.cpp

void LambdaScopeInfo::getPotentialVariableCapture(unsigned Idx, VarDecl *&VD,
   else if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
     VD = dyn_cast<VarDecl>(ME->getMemberDecl());
   else
     llvm_unreachable("Only DeclRefExprs or MemberExprs should be added for "
     "potential captures");
   assert(VD);
 }
 
-FunctionScopeInfo::~FunctionScopeInfo() = default;
-BlockScopeInfo::~BlockScopeInfo() = default;
-CapturedRegionScopeInfo::~CapturedRegionScopeInfo() = default;
+FunctionScopeInfo::~FunctionScopeInfo() { }
+BlockScopeInfo::~BlockScopeInfo() { }
+CapturedRegionScopeInfo::~CapturedRegionScopeInfo() { }

lib/Sema/Sema.cpp

if (RC.isAlmostTrailingComment()) {
     }
     Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
       FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
   }
   Context.addComment(RC);
 }
 
 // Pin this vtable to this file.
-ExternalSemaSource::~ExternalSemaSource() = default;
+ExternalSemaSource::~ExternalSemaSource() {}
 
 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
 
 void ExternalSemaSource::ReadKnownNamespaces(
                            SmallVectorImpl<NamespaceDecl *> &Namespaces) {
 }
 
 void ExternalSemaSource::ReadUndefinedButUsed(

lib/Sema/SemaDeclCXX.cpp

 
 protected:
   static Expr *assertNotNull(Expr *E) {
     assert(E && "Expression construction must not fail.");
     return E;
   }
 
 public:
-  ExprBuilder() = default;
-  virtual ~ExprBuilder() = default;
+  ExprBuilder() {}
+  virtual ~ExprBuilder() {}
 
   virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
 };
 
 class RefBuilder: public ExprBuilder {
   VarDecl *Var;
   QualType VarType;
 

lib/Sema/SemaLookup.cpp

for (auto *D : R) {
       Result.insert(D);
     }
   }
 }
 
 //----------------------------------------------------------------------------
 // Search for all visible declarations.
 //----------------------------------------------------------------------------
-VisibleDeclConsumer::~VisibleDeclConsumer() = default;
+VisibleDeclConsumer::~VisibleDeclConsumer() { }
 
 bool VisibleDeclConsumer::includeHiddenDecls() const { return false; }
 
 namespace {
 
 class ShadowContextRAII;
 
 class VisibleDeclsRecord {

lib/Sema/SemaOpenMP.cpp

for (auto KindEl : Arr)
         return true;
     return false;
   }
 
 private:
   ArrayRef<T> Arr;
 };
 struct MatchesAlways {
-  MatchesAlways() = default;
+  MatchesAlways() {}
   template <class T> bool operator()(T) { return true; }
 };
 
 typedef MatchesAny<OpenMPClauseKind> MatchesAnyClause;
 typedef MatchesAny<OpenMPDirectiveKind> MatchesAnyDirective;
 
 /// \brief Stack for tracking declarations used in OpenMP directives and
 /// clauses and their data-sharing attributes.

lib/Sema/SemaPseudoObject.cpp

public:
     unsigned ResultIndex;
     SourceLocation GenericLoc;
     SmallVector<Expr *, 4> Semantics;
 
     PseudoOpBuilder(Sema &S, SourceLocation genericLoc)
       : S(S), ResultIndex(PseudoObjectExpr::NoResult),
         GenericLoc(genericLoc) {}
 
-    virtual ~PseudoOpBuilder() = default;
+    virtual ~PseudoOpBuilder() {}
 
     /// Add a normal semantic expression.
     void addSemanticExpr(Expr *semantic) {
       Semantics.push_back(semantic);
     }
 
     /// Add the 'result' semantic expression.
     void addResultSemanticExpr(Expr *resultExpr) {

lib/Sema/TreeTransform.h

class pointer {
     TemplateArgumentLoc Arg;
 
   public:
     explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
 
     const TemplateArgumentLoc *operator->() const { return &Arg; }
   };
 
-  TemplateArgumentLocInventIterator() = default;
+  TemplateArgumentLocInventIterator() { }
 
   explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self,
                                              InputIterator Iter)
     : Self(Self), Iter(Iter) { }
 
   TemplateArgumentLocInventIterator &operator++() {
     ++Iter;
     return *this;
public:
       explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
 
       const TemplateArgumentLoc *operator->() const {
         return &Arg;
       }
     };
 
 
-    TemplateArgumentLocContainerIterator() = default;
+    TemplateArgumentLocContainerIterator() {}
 
     TemplateArgumentLocContainerIterator(ArgLocContainer &Container,
                                  unsigned Index)
       : Container(&Container), Index(Index) { }
 
     TemplateArgumentLocContainerIterator &operator++() {
       ++Index;
       return *this;

lib/Serialization/ASTCommon.cpp

 #include "clang/AST/DeclObjC.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Serialization/ASTDeserializationListener.h"
 #include "llvm/ADT/StringExtras.h"
 
 using namespace clang;
 
 // Give ASTDeserializationListener's VTable a home.
-ASTDeserializationListener::~ASTDeserializationListener() = default;
+ASTDeserializationListener::~ASTDeserializationListener() { }
 
 serialization::TypeIdx
 serialization::TypeIdxFromBuiltin(const BuiltinType *BT) {
   unsigned ID = 0;
   switch (BT->getKind()) {
   case BuiltinType::Void:
     ID = PREDEF_TYPE_VOID_ID;
     break;

lib/Serialization/ASTReader.cpp

Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
                                        isExplicitModule);
   return Continue;
 }
 
 //===----------------------------------------------------------------------===//
 // PCH validator implementation
 //===----------------------------------------------------------------------===//
 
-ASTReaderListener::~ASTReaderListener() = default;
+ASTReaderListener::~ASTReaderListener() {}
 
 /// \brief Compare the given set of language options against an existing set of
 /// language options.
 ///
 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
 /// \param AllowCompatibleDifferences If true, differences between compatible
 ///        language options will be permitted.
 ///

lib/Serialization/GeneratePCH.cpp

PCHGenerator::PCHGenerator(const Preprocessor &PP, StringRef OutputFile,
                            bool AllowASTWithErrors, bool IncludeTimestamps)
     : PP(PP), OutputFile(OutputFile), Module(Module), isysroot(isysroot.str()),
       SemaPtr(nullptr), Buffer(Buffer), Stream(Buffer->Data),
       Writer(Stream, IncludeTimestamps),
       AllowASTWithErrors(AllowASTWithErrors) {
   Buffer->IsComplete = false;
 }
 
-PCHGenerator::~PCHGenerator() = default;
+PCHGenerator::~PCHGenerator() {
+}
 
 void PCHGenerator::HandleTranslationUnit(ASTContext &Ctx) {
   // Don't create a PCH if there were fatal failures during module loading.
   if (PP.getModuleLoader().HadFatalFailure)
     return;
 
   bool hasErrors = PP.getDiagnostics().hasErrorOccurred();
   if (hasErrors && !AllowASTWithErrors)

lib/Serialization/MultiOnDiskHashTable.h

void condense() {
     Tables.push_back(Table(Merged).getOpaqueValue());
   }
 
   /// The generator is permitted to read our merged table.
   template<typename ReaderInfo, typename WriterInfo>
   friend class MultiOnDiskHashTableGenerator;
 
 public:
-  MultiOnDiskHashTable() = default;
+  MultiOnDiskHashTable() {}
   MultiOnDiskHashTable(MultiOnDiskHashTable &&O)
       : Tables(std::move(O.Tables)),
         PendingOverrides(std::move(O.PendingOverrides)) {
     O.Tables.clear();
   }
   MultiOnDiskHashTable &operator=(MultiOnDiskHashTable &&O) {
     if (&O == this)
       return *this;

lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp

 public:
   DeadStoreObs(const CFG &cfg, ASTContext &ctx, BugReporter &br,
                const CheckerBase *checker, AnalysisDeclContext *ac,
                ParentMap &parents,
                llvm::SmallPtrSet<const VarDecl *, 20> &escaped)
       : cfg(cfg), Ctx(ctx), BR(br), Checker(checker), AC(ac), Parents(parents),
         Escaped(escaped), currentBlock(nullptr) {}
 
-  ~DeadStoreObs() override = default;
+  ~DeadStoreObs() override {}
 
   bool isLive(const LiveVariables::LivenessValues &Live, const VarDecl *D) {
     if (Live.isLive(D))
       return true;
     // Lazily construct the set that records which VarDecls are in
     // EH code.
     if (!InEH.get()) {
       InEH.reset(new llvm::DenseSet<const VarDecl *>());

lib/StaticAnalyzer/Core/BugReporter.cpp

 #define DEBUG_TYPE "BugReporter"
 
 STATISTIC(MaxBugClassSize,
           "The maximum number of bug reports in the same equivalence class");
 STATISTIC(MaxValidBugClassSize,
           "The maximum number of bug reports in the same equivalence class "
           "where at least one report is valid (not suppressed)");
 
-BugReporterVisitor::~BugReporterVisitor() = default;
+BugReporterVisitor::~BugReporterVisitor() {}
 
 void BugReporterContext::anchor() {}
 
 //===----------------------------------------------------------------------===//
 // Helper routines for walking the ExplodedGraph and fetching statements.
 //===----------------------------------------------------------------------===//
 
 static const Stmt *GetPreviousStmt(const ExplodedNode *N) {
PathDiagnosticLocation BugReport::getLocation(const SourceManager &SM) const {
   assert(Location.isValid());
   return Location;
 }
 
 //===----------------------------------------------------------------------===//
 // Methods for BugReporter and subclasses.
 //===----------------------------------------------------------------------===//
 
-BugReportEquivClass::~BugReportEquivClass() = default;
-GRBugReporter::~GRBugReporter() = default;
-BugReporterData::~BugReporterData() = default;
+BugReportEquivClass::~BugReportEquivClass() { }
+GRBugReporter::~GRBugReporter() { }
+BugReporterData::~BugReporterData() {}
 
 ExplodedGraph &GRBugReporter::getGraph() { return Eng.getGraph(); }
 
 ProgramStateManager&
 GRBugReporter::getStateManager() { return Eng.getStateManager(); }
 
 BugReporter::~BugReporter() {
   FlushReports();

lib/StaticAnalyzer/Core/ConstraintManager.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 
 using namespace clang;
 using namespace ento;
 
-ConstraintManager::~ConstraintManager() = default;
+ConstraintManager::~ConstraintManager() {}
 
 static DefinedSVal getLocFromSymbol(const ProgramStateRef &State,
                                     SymbolRef Sym) {
   const MemRegion *R = State->getStateManager().getRegionManager()
                                                .getSymbolicRegion(Sym);
   return loc::MemRegionVal(R);
 }
 

lib/StaticAnalyzer/Core/CoreEngine.cpp

STATISTIC(NumReachedMaxSteps,
             "The # of times we reached the max number of steps.");
 STATISTIC(NumPathsExplored,
             "The # of paths explored by the analyzer.");
 
 //===----------------------------------------------------------------------===//
 // Worklist classes for exploration of reachable states.
 //===----------------------------------------------------------------------===//
 
-WorkList::Visitor::~Visitor() = default;
+WorkList::Visitor::~Visitor() {}
 
 namespace {
 class DFS : public WorkList {
   SmallVector<WorkListUnit,20> Stack;
 public:
   bool hasWork() const override {
     return !Stack.empty();
   }
bool visitItemsInWorkList(Visitor &V) override {
     return false;
   }
 };
 
 } // end anonymous namespace
 
 // Place the dstor for WorkList here because it contains virtual member
 // functions, and we the code for the dstor generated in one compilation unit.
-WorkList::~WorkList() = default;
+WorkList::~WorkList() {}
 
 WorkList *WorkList::makeDFS() { return new DFS(); }
 WorkList *WorkList::makeBFS() { return new BFS(); }
 
 namespace {
   class BFSBlockDFSContents : public WorkList {
     std::deque<WorkListUnit> Queue;
     SmallVector<WorkListUnit,20> Stack;

lib/StaticAnalyzer/Core/ExplodedGraph.cpp

 using namespace clang;
 using namespace ento;
 
 //===----------------------------------------------------------------------===//
 // Node auditing.
 //===----------------------------------------------------------------------===//
 
 // An out of line virtual method to provide a home for the class vtable.
-ExplodedNode::Auditor::~Auditor() = default;
+ExplodedNode::Auditor::~Auditor() {}
 
 #ifndef NDEBUG
 static ExplodedNode::Auditor* NodeAuditor = nullptr;
 #endif
 
 void ExplodedNode::SetAuditor(ExplodedNode::Auditor* A) {
 #ifndef NDEBUG
   NodeAuditor = A;
 #endif
 }
 
 //===----------------------------------------------------------------------===//
 // Cleanup.
 //===----------------------------------------------------------------------===//
 
 ExplodedGraph::ExplodedGraph()
   : NumNodes(0), ReclaimNodeInterval(0) {}
 
-ExplodedGraph::~ExplodedGraph() = default;
+ExplodedGraph::~ExplodedGraph() {}
 
 //===----------------------------------------------------------------------===//
 // Node reclamation.
 //===----------------------------------------------------------------------===//
 
 bool ExplodedGraph::isInterestingLValueExpr(const Expr *Ex) {
   if (!Ex->isLValue())
     return false;

lib/StaticAnalyzer/Core/MemRegion.cpp

RegionTy* MemRegionManager::getSubRegion(const A1 a1, const A2 a2, const A3 a3,
 
   return R;
 }
 
 //===----------------------------------------------------------------------===//
 // Object destruction.
 //===----------------------------------------------------------------------===//
 
-MemRegion::~MemRegion() = default;
+MemRegion::~MemRegion() {}
 
-// All regions and their data are BumpPtrAllocated.  No need to call their
-// destructors.
-MemRegionManager::~MemRegionManager() = default;
+MemRegionManager::~MemRegionManager() {
+  // All regions and their data are BumpPtrAllocated.  No need to call
+  // their destructors.
+}
 
 //===----------------------------------------------------------------------===//
 // Basic methods.
 //===----------------------------------------------------------------------===//
 
 bool SubRegion::isSubRegionOf(const MemRegion* R) const {
   const MemRegion* r = getSuperRegion();
   while (r != nullptr) {

lib/StaticAnalyzer/Core/PathDiagnostic.cpp

 PathDiagnosticPiece::PathDiagnosticPiece(StringRef s,
                                          Kind k, DisplayHint hint)
   : str(StripTrailingDots(s)), kind(k), Hint(hint),
     LastInMainSourceFile(false) {}
 
 PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint)
   : kind(k), Hint(hint), LastInMainSourceFile(false) {}
 
-PathDiagnosticPiece::~PathDiagnosticPiece() = default;
-PathDiagnosticEventPiece::~PathDiagnosticEventPiece() = default;
-PathDiagnosticCallPiece::~PathDiagnosticCallPiece() = default;
-PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() = default;
-PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() = default;
+PathDiagnosticPiece::~PathDiagnosticPiece() {}
+PathDiagnosticEventPiece::~PathDiagnosticEventPiece() {}
+PathDiagnosticCallPiece::~PathDiagnosticCallPiece() {}
+PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() {}
+PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() {}
 
 
 void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current,
                            bool ShouldFlattenMacros) const {
   for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) {
     PathDiagnosticPiece *Piece = I->get();
 
     switch (Piece->getKind()) {
for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) {
     case PathDiagnosticPiece::ControlFlow:
       Current.push_back(Piece);
       break;
     }
   }
 }
 
 
-PathDiagnostic::~PathDiagnostic() = default;
+PathDiagnostic::~PathDiagnostic() {}
 
 PathDiagnostic::PathDiagnostic(StringRef CheckName, const Decl *declWithIssue,
                                StringRef bugtype, StringRef verboseDesc,
                                StringRef shortDesc, StringRef category,
                                PathDiagnosticLocation LocationToUnique,
                                const Decl *DeclToUnique)
   : CheckName(CheckName),
     DeclWithIssue(declWithIssue),

 void PathDiagnostic::FullProfile(llvm::FoldingSetNodeID &ID) const {
   Profile(ID);
   for (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E; ++I)
     ID.Add(**I);
   for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I)
     ID.AddString(*I);
 }
 
-StackHintGenerator::~StackHintGenerator() = default;
+StackHintGenerator::~StackHintGenerator() {}
 
 std::string StackHintGeneratorForSymbol::getMessage(const ExplodedNode *N){
   ProgramPoint P = N->getLocation();
   CallExitEnd CExit = P.castAs<CallExitEnd>();
 
   // FIXME: Use CallEvent to abstract this over all calls.
   const Stmt *CallSite = CExit.getCalleeContext()->getCallSite();
   const CallExpr *CE = dyn_cast_or_null<CallExpr>(CallSite);

lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

class PlistDiagnostics : public PathDiagnosticConsumer {
     const LangOptions &LangOpts;
     const bool SupportsCrossFileDiagnostics;
   public:
     PlistDiagnostics(AnalyzerOptions &AnalyzerOpts,
                      const std::string& prefix,
                      const LangOptions &LangOpts,
                      bool supportsMultipleFiles);
 
-    ~PlistDiagnostics() override = default;
+    ~PlistDiagnostics() override {}
 
     void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
                               FilesMade *filesMade) override;
 
     StringRef getName() const override {
       return "PlistDiagnostics";
     }
 

lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp

 #include "clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 
 namespace clang {
 
 namespace ento {
 
-SimpleConstraintManager::~SimpleConstraintManager() = default;
+SimpleConstraintManager::~SimpleConstraintManager() {}
 
 bool SimpleConstraintManager::canReasonAbout(SVal X) const {
   Optional<nonloc::SymbolVal> SymVal = X.getAs<nonloc::SymbolVal>();
   if (SymVal && SymVal->isExpression()) {
     const SymExpr *SE = SymVal->getSymbol();
 
     if (const SymIntExpr *SIE = dyn_cast<SymIntExpr>(SE)) {
       switch (SIE->getOpcode()) {

lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp

protected:
   SVal dispatchCast(SVal val, QualType castTy) override;
   SVal evalCastFromNonLoc(NonLoc val, QualType castTy) override;
   SVal evalCastFromLoc(Loc val, QualType castTy) override;
 
 public:
   SimpleSValBuilder(llvm::BumpPtrAllocator &alloc, ASTContext &context,
                     ProgramStateManager &stateMgr)
                     : SValBuilder(alloc, context, stateMgr) {}
-  ~SimpleSValBuilder() override = default;
+  ~SimpleSValBuilder() override {}
 
   SVal evalMinus(NonLoc val) override;
   SVal evalComplement(NonLoc val) override;
   SVal evalBinOpNN(ProgramStateRef state, BinaryOperator::Opcode op,
                    NonLoc lhs, NonLoc rhs, QualType resultTy) override;
   SVal evalBinOpLL(ProgramStateRef state, BinaryOperator::Opcode op,
                    Loc lhs, Loc rhs, QualType resultTy) override;
   SVal evalBinOpLN(ProgramStateRef state, BinaryOperator::Opcode op,

lib/StaticAnalyzer/Core/Store.cpp

nonloc::ConcreteInt NewIdx(svalBuilder.getBasicValueFactory().getValue(BaseIdxI +
                                                                     OffI));
 
   // Construct the new ElementRegion.
   const MemRegion *ArrayR = ElemR->getSuperRegion();
   return loc::MemRegionVal(MRMgr.getElementRegion(elementType, NewIdx, ArrayR,
                                                   Ctx));
 }
 
-StoreManager::BindingsHandler::~BindingsHandler() = default;
+StoreManager::BindingsHandler::~BindingsHandler() {}
 
 bool StoreManager::FindUniqueBinding::HandleBinding(StoreManager& SMgr,
                                                     Store store,
                                                     const MemRegion* R,
                                                     SVal val) {
   SymbolRef SymV = val.getAsLocSymbol();
   if (!SymV || SymV != Sym)
     return true;

lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

 
 namespace {
 class ClangDiagPathDiagConsumer : public PathDiagnosticConsumer {
   DiagnosticsEngine &Diag;
   bool IncludePath;
 public:
   ClangDiagPathDiagConsumer(DiagnosticsEngine &Diag)
     : Diag(Diag), IncludePath(false) {}
-  ~ClangDiagPathDiagConsumer() override = default;
+  ~ClangDiagPathDiagConsumer() override {}
   StringRef getName() const override { return "ClangDiags"; }
 
   bool supportsLogicalOpControlFlow() const override { return true; }
   bool supportsCrossFileDiagnostics() const override { return true; }
 
   PathGenerationScheme getGenerationScheme() const override {
     return IncludePath ? Minimal : None;
   }

lib/Tooling/CompilationDatabase.cpp

 #include "llvm/Option/Arg.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include <sstream>
 #include <system_error>
 using namespace clang;
 using namespace tooling;
 
-CompilationDatabase::~CompilationDatabase() = default;
+CompilationDatabase::~CompilationDatabase() {}
 
 std::unique_ptr<CompilationDatabase>
 CompilationDatabase::loadFromDirectory(StringRef BuildDirectory,
                                        std::string &ErrorMessage) {
   std::stringstream ErrorStream;
   for (CompilationDatabasePluginRegistry::iterator
        It = CompilationDatabasePluginRegistry::begin(),
        Ie = CompilationDatabasePluginRegistry::end();
std::unique_ptr<CompilationDatabase> DB =
       findCompilationDatabaseFromDirectory(AbsolutePath, ErrorMessage);
 
   if (!DB)
     ErrorMessage = ("Could not auto-detect compilation database from directory \"" +
                    SourceDir + "\"\n" + ErrorMessage).str();
   return DB;
 }
 
-CompilationDatabasePlugin::~CompilationDatabasePlugin() = default;
+CompilationDatabasePlugin::~CompilationDatabasePlugin() {}
 
 namespace {
 // Helper for recursively searching through a chain of actions and collecting
 // all inputs, direct and indirect, of compile jobs.
 struct CompileJobAnalyzer {
   void run(const driver::Action *A) {
     runImpl(A, false);
   }

lib/Tooling/Tooling.cpp

 #include "llvm/Support/Host.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "clang-tooling"
 
 namespace clang {
 namespace tooling {
 
-ToolAction::~ToolAction() = default;
+ToolAction::~ToolAction() {}
 
-FrontendActionFactory::~FrontendActionFactory() = default;
+FrontendActionFactory::~FrontendActionFactory() {}
 
 // FIXME: This file contains structural duplication with other parts of the
 // code that sets up a compiler to run tools on it, and we should refactor
 // it to be based on the same framework.
 
 /// \brief Builds a clang driver initialized for running clang tools.
 static clang::driver::Driver *newDriver(
     clang::DiagnosticsEngine *Diagnostics, const char *BinaryName,
: Compilations(Compilations), SourcePaths(SourcePaths),
       InMemoryFileSystem(new vfs::InMemoryFileSystem),
       Files(new FileManager(FileSystemOptions(), OverlayFileSystem)),
       DiagConsumer(nullptr) {
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   appendArgumentsAdjuster(getClangStripOutputAdjuster());
   appendArgumentsAdjuster(getClangSyntaxOnlyAdjuster());
 }
 
-ClangTool::~ClangTool() = default;
+ClangTool::~ClangTool() {}
 
 void ClangTool::mapVirtualFile(StringRef FilePath, StringRef Content) {
   MappedFileContents.push_back(std::make_pair(FilePath, Content));
 }
 
 void ClangTool::appendArgumentsAdjuster(ArgumentsAdjuster Adjuster) {
   if (ArgsAdjuster)
     ArgsAdjuster = combineAdjusters(ArgsAdjuster, Adjuster);

tools/diagtool/DiagTool.cpp

 #include <vector>
 
 using namespace diagtool;
 
 DiagTool::DiagTool(llvm::StringRef toolCmd,
                    llvm::StringRef toolDesc)
   : cmd(toolCmd), description(toolDesc) {}
 
-DiagTool::~DiagTool() = default;
+DiagTool::~DiagTool() {}
 
 typedef llvm::StringMap<DiagTool *> ToolMap;
 static inline ToolMap *getTools(void *v) { return static_cast<ToolMap*>(v); }
 
 DiagTools::DiagTools() : tools(new ToolMap()) {}
 DiagTools::~DiagTools() { delete getTools(tools); }
 
 DiagTool *DiagTools::getTool(llvm::StringRef toolCmd) {

tools/libclang/CIndexDiagnostic.h

struct CXStoredDiagnostic : public CXDiagnosticImpl {
   const StoredDiagnostic &Diag;
   const LangOptions &LangOpts;
   
   CXStoredDiagnostic(const StoredDiagnostic &Diag,
                      const LangOptions &LangOpts)
     : CXDiagnosticImpl(StoredDiagnosticKind),
       Diag(Diag), LangOpts(LangOpts) { }
 
-  ~CXStoredDiagnostic() override = default;
+  ~CXStoredDiagnostic() override {}
 
   /// \brief Return the severity of the diagnostic.
   CXDiagnosticSeverity getSeverity() const override;
 
   /// \brief Return the location of the diagnostic.
   CXSourceLocation getLocation() const override;
 
   /// \brief Return the spelling of the diagnostic.

tools/libclang/CIndexDiagnostic.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace clang::cxloc;
 using namespace clang::cxdiag;
 using namespace llvm;
 
-CXDiagnosticSetImpl::~CXDiagnosticSetImpl() = default;
+CXDiagnosticSetImpl::~CXDiagnosticSetImpl() {}
 
 void
 CXDiagnosticSetImpl::appendDiagnostic(std::unique_ptr<CXDiagnosticImpl> D) {
   Diagnostics.push_back(std::move(D));
 }
 
-CXDiagnosticImpl::~CXDiagnosticImpl() = default;
+CXDiagnosticImpl::~CXDiagnosticImpl() {}
 
 namespace {
 class CXDiagnosticCustomNoteImpl : public CXDiagnosticImpl {
   std::string Message;
   CXSourceLocation Loc;
 public:
   CXDiagnosticCustomNoteImpl(StringRef Msg, CXSourceLocation L)
     : CXDiagnosticImpl(CustomNoteDiagnosticKind),
       Message(Msg), Loc(L) {}
 
-  ~CXDiagnosticCustomNoteImpl() override = default;
+  ~CXDiagnosticCustomNoteImpl() override {}
 
   CXDiagnosticSeverity getSeverity() const override {
     return CXDiagnostic_Note;
   }
 
   CXSourceLocation getLocation() const override {
     return Loc;
   }

 class CXDiagnosticRenderer : public DiagnosticNoteRenderer {
 public:  
   CXDiagnosticRenderer(const LangOptions &LangOpts,
                        DiagnosticOptions *DiagOpts,
                        CXDiagnosticSetImpl *mainSet)
   : DiagnosticNoteRenderer(LangOpts, DiagOpts),
     CurrentSet(mainSet), MainSet(mainSet) {}
 
-  ~CXDiagnosticRenderer() override = default;
+  ~CXDiagnosticRenderer() override {}
 
   void beginDiagnostic(DiagOrStoredDiag D,
                        DiagnosticsEngine::Level Level) override {
 
     const StoredDiagnostic *SD = D.dyn_cast<const StoredDiagnostic*>();
     if (!SD)
       return;
     

tools/libclang/CXLoadedDiagnostic.cpp

 //===----------------------------------------------------------------------===//
 
 typedef llvm::DenseMap<unsigned, const char *> Strings;
 
 namespace {
 class CXLoadedDiagnosticSetImpl : public CXDiagnosticSetImpl {
 public:
   CXLoadedDiagnosticSetImpl() : CXDiagnosticSetImpl(true), FakeFiles(FO) {}
-  ~CXLoadedDiagnosticSetImpl() override = default;
+  ~CXLoadedDiagnosticSetImpl() override {}
 
   llvm::BumpPtrAllocator Alloc;
   Strings Categories;
   Strings WarningFlags;
   Strings FileNames;
   
   FileSystemOptions FO;
   FileManager FakeFiles;
   llvm::DenseMap<unsigned, const FileEntry *> Files;
 
   /// \brief Copy the string into our own allocator.
   const char *copyString(StringRef Blob) {
     char *mem = Alloc.Allocate<char>(Blob.size() + 1);
     memcpy(mem, Blob.data(), Blob.size());
     mem[Blob.size()] = '\0';
     return mem;
   }
 };
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // Cleanup.
 //===----------------------------------------------------------------------===//
 
-CXLoadedDiagnostic::~CXLoadedDiagnostic() = default;
+CXLoadedDiagnostic::~CXLoadedDiagnostic() {}
 
 //===----------------------------------------------------------------------===//
 // Public CXLoadedDiagnostic methods.
 //===----------------------------------------------------------------------===//
 
 CXDiagnosticSeverity CXLoadedDiagnostic::getSeverity() const {
   // FIXME: Fail more softly if the diagnostic level is unknown?
   auto severityAsLevel = static_cast<serialized_diags::Level>(severity);

tools/libclang/Indexing.cpp

 namespace {
 
 class SessionSkipBodyData {
   llvm::sys::Mutex Mux;
   PPRegionSetTy ParsedRegions;
 
 public:
   SessionSkipBodyData() : Mux(/*recursive=*/false) {}
-  ~SessionSkipBodyData() = default;
+  ~SessionSkipBodyData() {
+    //llvm::errs() << "RegionData: " << Skipped.size() << " - " << Skipped.getMemorySize() << "\n";
+  }
 
   void copyTo(PPRegionSetTy &Set) {
     llvm::MutexGuard MG(Mux);
     Set = ParsedRegions;
   }
 
   void update(ArrayRef<PPRegion> Regions) {
     llvm::MutexGuard MG(Mux);

unittests/AST/EvaluateAsRValueTest.cpp

public:
    CreateASTConsumer(clang::CompilerInstance &Compiler,
                      llvm::StringRef FilePath) override {
      return llvm::make_unique<Consumer>();
   }
 
  private:
   class Consumer : public clang::ASTConsumer {
    public:
-    ~Consumer() override = default;
+    ~Consumer() override {}
 
     void HandleTranslationUnit(clang::ASTContext &Ctx) override {
       VarInfoMap VarInfo;
       EvaluateConstantInitializersVisitor Evaluator(VarInfo);
       Evaluator.TraverseDecl(Ctx.getTranslationUnitDecl());
       EXPECT_EQ(2u, VarInfo.size());
       EXPECT_FALSE(VarInfo["Dependent"]);
       EXPECT_TRUE(VarInfo["Constant"]);

unittests/ASTMatchers/ASTMatchersTest.h

 using clang::tooling::buildASTFromCodeWithArgs;
 using clang::tooling::newFrontendActionFactory;
 using clang::tooling::runToolOnCodeWithArgs;
 using clang::tooling::FrontendActionFactory;
 using clang::tooling::FileContentMappings;
 
 class BoundNodesCallback {
 public:
-  virtual ~BoundNodesCallback() = default;
+  virtual ~BoundNodesCallback() {}
   virtual bool run(const BoundNodes *BoundNodes) = 0;
   virtual bool run(const BoundNodes *BoundNodes, ASTContext *Context) = 0;
   virtual void onEndOfTranslationUnit() {}
 };
 
 // If 'FindResultVerifier' is not NULL, sets *Verified to the result of
 // running 'FindResultVerifier' with the bound nodes as argument.
 // If 'FindResultVerifier' is NULL, sets *Verified to true when Run is called.

unittests/ASTMatchers/Dynamic/ParserTest.cpp

 
 namespace clang {
 namespace ast_matchers {
 namespace dynamic {
 namespace {
 
 class MockSema : public Parser::Sema {
 public:
-  ~MockSema() override = default;
+  ~MockSema() override {}
 
   uint64_t expectMatcher(StringRef MatcherName) {
     // Optimizations on the matcher framework make simple matchers like
     // 'stmt()' to be all the same matcher.
     // Use a more complex expression to prevent that.
     ast_matchers::internal::Matcher<Stmt> M = stmt(stmt(), stmt());
     ExpectedMatchers.insert(std::make_pair(MatcherName, M));
     return M.getID().second;

unittests/Tooling/CompilationDatabaseTest.cpp

CompileCommand FoundCommand = findCompileArgsInJsonDatabase(
          "\"file\":\"" + FileName + "\"}]").str(),
       ErrorMessage);
    EXPECT_EQ(Directory, FoundCommand.Directory) << ErrorMessage;
    EXPECT_EQ(1u, FoundCommand.CommandLine.size()) << ErrorMessage;
    EXPECT_EQ(Arguments, FoundCommand.CommandLine[0]) << ErrorMessage;
 }
 
 struct FakeComparator : public PathComparator {
-  ~FakeComparator() override = default;
+  ~FakeComparator() override {}
   bool equivalent(StringRef FileA, StringRef FileB) const override {
     return FileA.equals_lower(FileB);
   }
 };
 
 class FileMatchTrieTest : public ::testing::Test {
 protected:
   FileMatchTrieTest() : Trie(new FakeComparator()) {}

unittests/Tooling/RewriterTestContext.h

RewriterTestContext()
          Files(FileSystemOptions(), OverlayFileSystem),
          Sources(Diagnostics, Files), Rewrite(Sources, Options) {
     Diagnostics.setClient(&DiagnosticPrinter, false);
     // FIXME: To make these tests truly in-memory, we need to overlay the
     // builtin headers.
     OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   }
 
-  ~RewriterTestContext() = default;
+  ~RewriterTestContext() {}
 
   FileID createInMemoryFile(StringRef Name, StringRef Content) {
     std::unique_ptr<llvm::MemoryBuffer> Source =
         llvm::MemoryBuffer::getMemBuffer(Content);
     InMemoryFileSystem->addFile(Name, 0, std::move(Source));
 
     const FileEntry *Entry = Files.getFile(Name);
     assert(Entry != nullptr);

unittests/Tooling/TestVisitor.h

 ///
 /// This is a drop-in replacement for RecursiveASTVisitor itself, with the
 /// additional capability of running it over a snippet of code.
 ///
 /// Visits template instantiations and implicit code by default.
 template <typename T>
 class TestVisitor : public RecursiveASTVisitor<T> {
 public:
-  TestVisitor() = default;
+  TestVisitor() { }
 
-  virtual ~TestVisitor() = default;
+  virtual ~TestVisitor() { }
 
   enum Language {
     Lang_C,
     Lang_CXX98,
     Lang_CXX11,
     Lang_OBJC,
     Lang_OBJCXX11,
     Lang_CXX = Lang_CXX98