[analyzer][NFC] Remove unused default SVal constructors

[martong]

LGTM

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

public:
   // We want calling these methods to be a compiler error since they are
   // tautologically false.
   bool isUndef() const = delete;
   bool isValid() const = delete;
 
   static bool classof(SVal V) { return !V.isUndef(); }
 
 protected:
-  DefinedOrUnknownSVal() = default;
   explicit DefinedOrUnknownSVal(const void *d, bool isLoc, unsigned ValKind)
       : SVal(d, isLoc, ValKind) {}
   explicit DefinedOrUnknownSVal(BaseKind k, void *D = nullptr) : SVal(k, D) {}
 };
 
 class UnknownVal : public DefinedOrUnknownSVal {
 public:
   explicit UnknownVal() : DefinedOrUnknownSVal(UnknownValKind) {}
 
   static bool classof(SVal V) { return V.getBaseKind() == UnknownValKind; }
 };
 
 class DefinedSVal : public DefinedOrUnknownSVal {
 public:
   // We want calling these methods to be a compiler error since they are
   // tautologically true/false.
   bool isUnknown() const = delete;
   bool isUnknownOrUndef() const = delete;
   bool isValid() const = delete;
 
   static bool classof(SVal V) { return !V.isUnknownOrUndef(); }
 
 protected:
-  DefinedSVal() = default;
   explicit DefinedSVal(const void *d, bool isLoc, unsigned ValKind)
       : DefinedOrUnknownSVal(d, isLoc, ValKind) {}
 };
 
 /// Represents an SVal that is guaranteed to not be UnknownVal.
 class KnownSVal : public SVal {
-  KnownSVal() = default;
-
 public:
   KnownSVal(const DefinedSVal &V) : SVal(V) {}
   KnownSVal(const UndefinedVal &V) : SVal(V) {}
   static bool classof(SVal V) { return !V.isUnknown(); }
 };
 
 class NonLoc : public DefinedSVal {
 protected:
-  NonLoc() = default;
   explicit NonLoc(unsigned SubKind, const void *d)
       : DefinedSVal(d, false, SubKind) {}
 
 public:
   void dumpToStream(raw_ostream &Out) const;
 
   static bool isCompoundType(QualType T) {
     return T->isArrayType() || T->isRecordType() ||
            T->isAnyComplexType() || T->isVectorType();
   }
 
   static bool classof(SVal V) { return V.getBaseKind() == NonLocKind; }
 };
 
 class Loc : public DefinedSVal {
 protected:
-  Loc() = default;
   explicit Loc(unsigned SubKind, const void *D)
       : DefinedSVal(const_cast<void *>(D), true, SubKind) {}
 
 public:
   void dumpToStream(raw_ostream &Out) const;
 
   static bool isLocType(QualType T) {
     return T->isAnyPointerType() || T->isBlockPointerType() ||
public:
 
   ConcreteInt evalMinus(SValBuilder &svalBuilder) const;
 
   static bool classof(SVal V) {
     return V.getBaseKind() == NonLocKind && V.getSubKind() == ConcreteIntKind;
   }
 
   static bool classof(NonLoc V) { return V.getSubKind() == ConcreteIntKind; }
-
-private:
-  ConcreteInt() = default;
 };
 
 class LocAsInteger : public NonLoc {
   friend class ento::SValBuilder;
 
   explicit LocAsInteger(const std::pair<SVal, uintptr_t> &data)
       : NonLoc(LocAsIntegerKind, &data) {
     // We do not need to represent loc::ConcreteInt as LocAsInteger,
unsigned getNumBits() const {
     return D->second;
   }
 
   static bool classof(SVal V) {
     return V.getBaseKind() == NonLocKind && V.getSubKind() == LocAsIntegerKind;
   }
 
   static bool classof(NonLoc V) { return V.getSubKind() == LocAsIntegerKind; }
-
-private:
-  LocAsInteger() = default;
 };
 
 class CompoundVal : public NonLoc {
   friend class ento::SValBuilder;
 
   explicit CompoundVal(const CompoundValData* D) : NonLoc(CompoundValKind, D) {}
 
 public:
   const CompoundValData* getValue() const {
     return static_cast<const CompoundValData *>(Data);
   }
 
   using iterator = llvm::ImmutableList<SVal>::iterator;
 
   iterator begin() const;
   iterator end() const;
 
   static bool classof(SVal V) {
     return V.getBaseKind() == NonLocKind && V.getSubKind() == CompoundValKind;
   }
 
   static bool classof(NonLoc V) { return V.getSubKind() == CompoundValKind; }
-
-private:
-  CompoundVal() = default;
 };
 
 class LazyCompoundVal : public NonLoc {
   friend class ento::SValBuilder;
 
   explicit LazyCompoundVal(const LazyCompoundValData *D)
       : NonLoc(LazyCompoundValKind, D) {}
 
 public:
   const LazyCompoundValData *getCVData() const {
     return static_cast<const LazyCompoundValData *>(Data);
   }
 
   const void *getStore() const;
   const TypedValueRegion *getRegion() const;
 
   static bool classof(SVal V) {
     return V.getBaseKind() == NonLocKind &&
            V.getSubKind() == LazyCompoundValKind;
   }
 
   static bool classof(NonLoc V) {
     return V.getSubKind() == LazyCompoundValKind;
   }
-
-private:
-  LazyCompoundVal() = default;
 };
 
 /// Value representing pointer-to-member.
 ///
 /// This value is qualified as NonLoc because neither loading nor storing
 /// operations are applied to it. Instead, the analyzer uses the L-value coming
 /// from pointer-to-member applied to an object.
 /// This SVal is represented by a NamedDecl which can be a member function
return V.getBaseKind() == NonLocKind &&
            V.getSubKind() == PointerToMemberKind;
   }
 
   static bool classof(NonLoc V) {
     return V.getSubKind() == PointerToMemberKind;
   }
 
 private:
-  PointerToMember() = default;
   explicit PointerToMember(const PTMDataType D)
       : NonLoc(PointerToMemberKind, D.getOpaqueValue()) {}
 };
 
 } // namespace nonloc
 
 //==------------------------------------------------------------------------==//
 //  Subclasses of Loc.
const LabelDecl *getLabel() const {
     return static_cast<const LabelDecl *>(Data);
   }
 
   static bool classof(SVal V) {
     return V.getBaseKind() == LocKind && V.getSubKind() == GotoLabelKind;
   }
 
   static bool classof(Loc V) { return V.getSubKind() == GotoLabelKind; }
-
-private:
-  GotoLabel() = default;
 };
 
 class MemRegionVal : public Loc {
 public:
   explicit MemRegionVal(const MemRegion* r) : Loc(MemRegionValKind, r) {
     assert(r);
   }
 
bool operator!=(const MemRegionVal &R) const {
     return getRegion() != R.getRegion();
   }
 
   static bool classof(SVal V) {
     return V.getBaseKind() == LocKind && V.getSubKind() == MemRegionValKind;
   }
 
   static bool classof(Loc V) { return V.getSubKind() == MemRegionValKind; }
-
-private:
-  MemRegionVal() = default;
 };
 
 class ConcreteInt : public Loc {
 public:
   explicit ConcreteInt(const llvm::APSInt& V) : Loc(ConcreteIntKind, &V) {}
 
   const llvm::APSInt &getValue() const {
     return *static_cast<const llvm::APSInt *>(Data);
   }
 
   static bool classof(SVal V) {
     return V.getBaseKind() == LocKind && V.getSubKind() == ConcreteIntKind;
   }
 
   static bool classof(Loc V) { return V.getSubKind() == ConcreteIntKind; }
-
-private:
-  ConcreteInt() = default;
 };
 
 } // namespace loc
 } // namespace ento
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALS_H