LLVM Cleanup for -Wdeprecated-copy

[craig.topper]

lib/MC/StringTableBuilder.cpp

27

So you can't have an out of line default destructor to hide it from the inliner or to act as vtable anchor?

[dexonsmith]

We shouldn't be dropping vtable anchors like this.

include/llvm/DebugInfo/CodeView/DebugSubsection.h

23

This moves the vtable anchor from the implementation to the header, which bloats object files considerably and causes the symbol to be weak unnecessarily.

36

This moves the vtable anchor.

include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h

31

This moves the vtable anchor.

include/llvm/MC/StringTableBuilder.h

40

This moves the vtable anchor.

include/llvm/ObjectYAML/MachOYAML.h

57

This moves the vtable anchor.

include/llvm/Support/FormatVariadicDetails.h

25

This moves the vtable anchor.

[rtrieu]

https://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers

Well, learned something new today. I'll follow up with something that doesn't mess with the vtable anchors.

[dexonsmith]

In D52863#1256253, @rtrieu wrote:

https://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers

Well, learned something new today. I'll follow up with something that doesn't mess with the vtable anchors.

Bonus points if you can *add* vtable anchors to the classes that are missing them :).

[rtrieu]

Looking through other classes, I see that it is common to use an anchor() method as the vtable anchor. I think having it that way makes it more clear what the purpose of the out-of-line function definition is.

include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h

31

None of these methods are virtual, so this shouldn't affect the vtable anchor or am I misreading the coding standard?

include/llvm/ADT/STLExtras.h

 
 template <typename R> struct result_pair {
   friend class enumerator_iter<R>;
 
   result_pair() = default;
   result_pair(std::size_t Index, IterOfRange<R> Iter)
       : Index(Index), Iter(Iter) {}
 
-  result_pair<R> &operator=(const result_pair<R> &Other) {
-    Index = Other.Index;
-    Iter = Other.Iter;
-    return *this;
-  }
+  result_pair(const result_pair &) = default;
+  result_pair &operator=(const result_pair &) = default;
 
   std::size_t index() const { return Index; }
   const ValueOfRange<R> &value() const { return *Iter; }
   ValueOfRange<R> &value() { return *Iter; }
 
 private:
   std::size_t Index = std::numeric_limits<std::size_t>::max();
   IterOfRange<R> Iter;
public:
 
   bool operator==(const enumerator_iter<R> &RHS) const {
     // Don't compare indices here, only iterators.  It's possible for an end
     // iterator to have different indices depending on whether it was created
     // by calling std::end() versus incrementing a valid iterator.
     return Result.Iter == RHS.Result.Iter;
   }
 
-  enumerator_iter<R> &operator=(const enumerator_iter<R> &Other) {
-    Result = Other.Result;
-    return *this;
-  }
+  enumerator_iter(const enumerator_iter &) = default;
+  enumerator_iter &operator=(const enumerator_iter &) = default;
 
 private:
   result_type Result;
 };
 
 template <typename R> class enumerator {
 public:
   explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}

include/llvm/DebugInfo/CodeView/DebugSubsection.h

 #include "llvm/Support/Casting.h"
 
 namespace llvm {
 namespace codeview {
 
 class DebugSubsectionRef {
 public:
   explicit DebugSubsectionRef(DebugSubsectionKind Kind) : Kind(Kind) {}
-  virtual ~DebugSubsectionRef();
+  virtual ~DebugSubsectionRef() = default;
 
   static bool classof(const DebugSubsectionRef *S) { return true; }
 
   DebugSubsectionKind kind() const { return Kind; }
 
 protected:
   DebugSubsectionKind Kind;
 };
 
 class DebugSubsection {
 public:
   explicit DebugSubsection(DebugSubsectionKind Kind) : Kind(Kind) {}
-  virtual ~DebugSubsection();
+  virtual ~DebugSubsection() = default;
 
   static bool classof(const DebugSubsection *S) { return true; }
 
   DebugSubsectionKind kind() const { return Kind; }
 
   virtual Error commit(BinaryStreamWriter &Writer) const = 0;
   virtual uint32_t calculateSerializedSize() const = 0;
 
 protected:
   DebugSubsectionKind Kind;
 };
 
 } // namespace codeview
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_MODULEDEBUGFRAGMENT_H

include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h

 namespace llvm {
 
 namespace pdb {
 
 class DbiModuleDescriptor {
   friend class DbiStreamBuilder;
 
 public:
-  DbiModuleDescriptor();
-  DbiModuleDescriptor(const DbiModuleDescriptor &Info);
-  ~DbiModuleDescriptor();
+  DbiModuleDescriptor() = default;
+  DbiModuleDescriptor(const DbiModuleDescriptor &Info) = default;
+  ~DbiModuleDescriptor() = default;
 
   static Error initialize(BinaryStreamRef Stream, DbiModuleDescriptor &Info);
 
   bool hasECInfo() const;
   uint16_t getTypeServerIndex() const;
   uint16_t getModuleStreamIndex() const;
   uint32_t getSymbolDebugInfoByteSize() const;
   uint32_t getC11LineInfoByteSize() const;

include/llvm/DebugInfo/PDB/Native/HashTable.h

if (I == -1) {
       Index = 0;
       IsEnd = true;
     } else {
       Index = static_cast<uint32_t>(I);
       IsEnd = false;
     }
   }
 
-  HashTableIterator &operator=(const HashTableIterator &R) {
-    Map = R.Map;
-    return *this;
-  }
+  HashTableIterator &operator=(const HashTableIterator &R) = default;
+  HashTableIterator(const HashTableIterator &R) = default;
+
   bool operator==(const HashTableIterator &R) const {
     if (IsEnd && R.IsEnd)
       return true;
     if (IsEnd != R.IsEnd)
       return false;
 
     return (Map == R.Map) && (Index == R.Index);
   }

include/llvm/MC/StringTableBuilder.h

private:
   unsigned Alignment;
   bool Finalized = false;
 
   void finalizeStringTable(bool Optimize);
   void initSize();
 
 public:
   StringTableBuilder(Kind K, unsigned Alignment = 1);
-  ~StringTableBuilder();
+  ~StringTableBuilder() = default;
 
   /// Add a string to the builder. Returns the position of S in the
   /// table. The position will be changed if finalize is used.
   /// Can only be used before the table is finalized.
   size_t add(CachedHashStringRef S);
   size_t add(StringRef S) { return add(CachedHashStringRef(S)); }
 
   /// Analyze the strings and build the final table. No more strings can

include/llvm/ObjectYAML/MachOYAML.h

struct FileHeader {
   llvm::yaml::Hex32 filetype;
   uint32_t ncmds;
   uint32_t sizeofcmds;
   llvm::yaml::Hex32 flags;
   llvm::yaml::Hex32 reserved;
 };
 
 struct LoadCommand {
-  virtual ~LoadCommand();
+  virtual ~LoadCommand() = default;
 
   llvm::MachO::macho_load_command Data;
   std::vector<Section> Sections;
   std::vector<MachO::build_tool_version> Tools;
   std::vector<llvm::yaml::Hex8> PayloadBytes;
   std::string PayloadString;
   uint64_t ZeroPadBytes;
 };

include/llvm/ProfileData/Coverage/CoverageMappingReader.h

public:
   CoverageMappingIterator()
       : Reader(nullptr), Record(), ReadErr(coveragemap_error::success) {}
 
   CoverageMappingIterator(CoverageMappingReader *Reader)
       : Reader(Reader), Record(), ReadErr(coveragemap_error::success) {
     increment();
   }
 
+  CoverageMappingIterator(const CoverageMappingIterator &) = default;
+  CoverageMappingIterator &operator=(const CoverageMappingIterator &) = default;
+
   ~CoverageMappingIterator() {
     if (ReadErr != coveragemap_error::success)
       llvm_unreachable("Unexpected error in coverage mapping iterator");
   }
 
   CoverageMappingIterator &operator++() {
     increment();
     return *this;

include/llvm/Support/BinaryStreamArray.h

 class FixedStreamArrayIterator
     : public iterator_facade_base<FixedStreamArrayIterator<T>,
                                   std::random_access_iterator_tag, const T> {
 
 public:
   FixedStreamArrayIterator(const FixedStreamArray<T> &Array, uint32_t Index)
       : Array(Array), Index(Index) {}
 
+  FixedStreamArrayIterator<T>(const FixedStreamArrayIterator<T> &) = default;
   FixedStreamArrayIterator<T> &
-  operator=(const FixedStreamArrayIterator<T> &Other) {
-    Array = Other.Array;
-    Index = Other.Index;
-    return *this;
-  }
+  operator=(const FixedStreamArrayIterator<T> &) = default;
 
   const T &operator*() const { return Array[Index]; }
   const T &operator*() { return Array[Index]; }
 
   bool operator==(const FixedStreamArrayIterator<T> &R) const {
     assert(Array == R.Array);
     return (Index == R.Index) && (Array == R.Array);
   }

include/llvm/Support/FormatVariadicDetails.h

 
 namespace llvm {
 template <typename T, typename Enable = void> struct format_provider {};
 class Error;
 
 namespace detail {
 class format_adapter {
 protected:
-  virtual ~format_adapter() {}
+  virtual ~format_adapter() = default;
 
 public:
   virtual void format(raw_ostream &S, StringRef Options) = 0;
 };
 
 template <typename T> class provider_format_adapter : public format_adapter {
   T Item;
 

include/llvm/Support/WithColor.h

 class WithColor {
   raw_ostream &OS;
   /// Determine whether colors should be displayed.
   bool colorsEnabled(raw_ostream &OS);
 
 public:
   /// To be used like this: WithColor(OS, HighlightColor::String) << "text";
   WithColor(raw_ostream &OS, HighlightColor S);
+  WithColor(const WithColor &) = default;
   ~WithColor();
 
   raw_ostream &get() { return OS; }
   operator raw_ostream &() { return OS; }
 
   /// Convenience method for printing "error: " to stderr.
   static raw_ostream &error();
   /// Convenience method for printing "warning: " to stderr.

lib/DebugInfo/CodeView/DebugSubsection.cpp

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

lib/DebugInfo/PDB/Native/DbiModuleDescriptor.cpp

 #include "llvm/Support/Error.h"
 #include "llvm/Support/MathExtras.h"
 #include <cstdint>
 
 using namespace llvm;
 using namespace llvm::pdb;
 using namespace llvm::support;
 
-DbiModuleDescriptor::DbiModuleDescriptor() = default;
-
-DbiModuleDescriptor::DbiModuleDescriptor(const DbiModuleDescriptor &Info) =
-    default;
-
-DbiModuleDescriptor::~DbiModuleDescriptor() = default;
-
 Error DbiModuleDescriptor::initialize(BinaryStreamRef Stream,
                                       DbiModuleDescriptor &Info) {
   BinaryStreamReader Reader(Stream);
   if (auto EC = Reader.readObject(Info.Layout))
     return EC;
 
   if (auto EC = Reader.readCString(Info.ModuleName))
     return EC;

lib/MC/StringTableBuilder.cpp

 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
-StringTableBuilder::~StringTableBuilder() = default;
-
 void StringTableBuilder::initSize() {
   // Account for leading bytes in table so that offsets returned from add are
   // correct.
   switch (K) {
   case RAW:
   case DWARF:
     Size = 0;
     break;

lib/ObjectYAML/MachOYAML.cpp

 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <cstdint>
 #include <cstring>
 
 namespace llvm {
 
-MachOYAML::LoadCommand::~LoadCommand() = default;
-
 bool MachOYAML::LinkEditData::isEmpty() const {
   return 0 ==
          RebaseOpcodes.size() + BindOpcodes.size() + WeakBindOpcodes.size() +
              LazyBindOpcodes.size() + ExportTrie.Children.size() +
              NameList.size() + StringTable.size();
 }
 
 namespace yaml {

lib/Target/AMDGPU/AMDGPULibFunc.h

static unsigned getAddrSpaceFromEPtrKind(unsigned Kind) {
     assert(Kind >= 1);
     return Kind - 1;
   }
 };
 
 class AMDGPULibFuncImpl : public AMDGPULibFuncBase {
 public:
   AMDGPULibFuncImpl() {}
-  virtual ~AMDGPULibFuncImpl() {}
+  virtual ~AMDGPULibFuncImpl() = default;
 
   /// Get unmangled name for mangled library function and name for unmangled
   /// library function.
   virtual std::string getName() const = 0;
   virtual unsigned getNumArgs() const = 0;
   EFuncId getId() const { return FuncId; }
   ENamePrefix getPrefix() const { return FKind; }
 

lib/Target/Hexagon/HexagonConstPropagation.cpp

public:
     }
 
     bool meet(const LatticeCell &L);
     bool add(const Constant *C);
     bool add(uint32_t Property);
     uint32_t properties() const;
     unsigned size() const { return Size; }
 
+    LatticeCell(const LatticeCell &L) {
+      // This memcpy also copies Properties (when L.Size == 0).
+      uint32_t N =
+          L.IsSpecial ? sizeof L.Properties : L.Size * sizeof(const Constant *);
+      memcpy(Values, L.Values, N);
+      Kind = L.Kind;
+      Size = L.Size;
+      IsSpecial = L.IsSpecial;
+    }
+
     LatticeCell &operator= (const LatticeCell &L) {
       if (this != &L) {
         // This memcpy also copies Properties (when L.Size == 0).
         uint32_t N = L.IsSpecial ? sizeof L.Properties
                                  : L.Size*sizeof(const Constant*);
         memcpy(Values, L.Values, N);
         Kind = L.Kind;
         Size = L.Size;

lib/Target/Hexagon/HexagonGenInsert.cpp

 }
 
 namespace {
 
   // Set of virtual registers, based on BitVector.
   struct RegisterSet : private BitVector {
     RegisterSet() = default;
     explicit RegisterSet(unsigned s, bool t = false) : BitVector(s, t) {}
-    RegisterSet(const RegisterSet &RS) : BitVector(RS) {}
+    RegisterSet(const RegisterSet &RS) = default;
+    RegisterSet &operator=(const RegisterSet &RS) = default;
 
     using BitVector::clear;
 
     unsigned find_first() const {
       int First = BitVector::find_first();
       if (First < 0)
         return 0;
       return x2v(First);

tools/llvm-cov/CoverageExporter.h

protected:
   /// Output stream to print to.
   raw_ostream &OS;
 
   CoverageExporter(const coverage::CoverageMapping &CoverageMapping,
                    const CoverageViewOptions &Options, raw_ostream &OS)
       : Coverage(CoverageMapping), Options(Options), OS(OS) {}
 
 public:
-  virtual ~CoverageExporter(){};
+  virtual ~CoverageExporter() = default;
 
   /// Render the CoverageMapping object.
   virtual void renderRoot(const CoverageFilters &IgnoreFilters) = 0;
 
   /// Render the CoverageMapping object for specified source files.
   virtual void renderRoot(ArrayRef<std::string> SourceFiles) = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_COV_COVERAGEEXPORTER_H

tools/llvm-rc/ResourceScriptStmt.h

public:
   IntOrString ResName;
   uint16_t MemoryFlags = getDefaultMemoryFlags();
   void setName(const IntOrString &Name) { ResName = Name; }
   virtual raw_ostream &log(raw_ostream &OS) const {
     return OS << "Base statement\n";
   };
   RCResource() {}
   RCResource(uint16_t Flags) : MemoryFlags(Flags) {}
-  virtual ~RCResource() {}
+  virtual ~RCResource() = default;
 
   virtual Error visit(Visitor *) const {
     llvm_unreachable("This is unable to call methods from Visitor base");
   }
 
   // Apply the statements attached to this resource. Generic resources
   // don't have any.
   virtual Error applyStmts(Visitor *) const { return Error::success(); }
public:
 
   static constexpr size_t NumFlags = 6;
   static StringRef OptionsStr[NumFlags];
   static uint32_t OptionsFlags[NumFlags];
   static raw_ostream &logFlags(raw_ostream &, uint16_t Flags);
   virtual raw_ostream &log(raw_ostream &OS) const {
     return OS << "Base menu definition\n";
   }
-  virtual ~MenuDefinition() {}
+  virtual ~MenuDefinition() = default;
 
   virtual uint16_t getResFlags() const { return 0; }
   virtual MenuDefKind getKind() const { return MkBase; }
 };
 
 // Recursive description of a whole submenu.
 class MenuDefinitionList : public MenuDefinition {
 public:

 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381058(v=vs.85).aspx
 
 // A single VERSIONINFO statement;
 class VersionInfoStmt {
 public:
   enum StmtKind { StBase = 0, StBlock = 1, StValue = 2 };
 
   virtual raw_ostream &log(raw_ostream &OS) const { return OS << "VI stmt\n"; }
-  virtual ~VersionInfoStmt() {}
+  virtual ~VersionInfoStmt() = default;
 
   virtual StmtKind getKind() const { return StBase; }
   static bool classof(const VersionInfoStmt *S) {
     return S->getKind() == StBase;
   }
 };
 
 // BLOCK definition; also the main VERSIONINFO declaration is considered a

unittests/ADT/BumpPtrListTest.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 struct CountsDestructors {
   static unsigned NumCalls;
+  CountsDestructors() = default;
+  CountsDestructors(const CountsDestructors &) = default;
   ~CountsDestructors() { ++NumCalls; }
 };
 unsigned CountsDestructors::NumCalls = 0;
 
 struct MoveOnly {
   int V;
   explicit MoveOnly(int V) : V(V) {}
   MoveOnly() = delete;

unittests/ADT/TestGraph.h

class ChildIterator {
     NodeSubset Children;
 
     ChildIterator(); // Disable default constructor.
   protected:
     ChildIterator(NodeType *F, NodeSubset C) : FirstNode(F), Children(C) {}
 
   public:
     /// ChildIterator - Copy constructor.
-    ChildIterator(const ChildIterator& other) : FirstNode(other.FirstNode),
-      Children(other.Children) {}
+    ChildIterator(const ChildIterator& other) = default;
+    ChildIterator &operator=(const ChildIterator& other) = default;
 
     /// Comparison operators.
     bool operator==(const ChildIterator &other) const {
       return other.FirstNode == this->FirstNode &&
         other.Children == this->Children;
     }
     bool operator!=(const ChildIterator &other) const {
       return !(*this == other);

utils/unittest/googlemock/include/gmock/gmock-actions.h

public:
   // STL containers.
   Action() : impl_(NULL) {}
 
   // Constructs an Action from its implementation.  A NULL impl is
   // used to represent the "do-default" action.
   explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
 
   // Copy constructor.
-  Action(const Action& action) : impl_(action.impl_) {}
+  Action(const Action &action) = default;
+  Action &operator=(const Action &action) = default;
 
   // This constructor allows us to turn an Action<Func> object into an
   // Action<F>, as long as F's arguments can be implicitly converted
   // to Func's and Func's return type can be implicitly converted to
   // F's.
   template <typename Func>
   explicit Action(const Action<Func>& action);
 

utils/unittest/googlemock/include/gmock/gmock-matchers.h

 
  protected:
   MatcherBase() {}
 
   // Constructs a matcher from its implementation.
   explicit MatcherBase(const MatcherInterface<T>* impl)
       : impl_(impl) {}
 
-  virtual ~MatcherBase() {}
+  virtual ~MatcherBase() = default;
 
  private:
   // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar
   // interfaces.  The former dynamically allocates a chunk of memory
   // to hold the reference count, while the latter tracks all
   // references using a circular linked list without allocating
   // memory.  It has been observed that linked_ptr performs better in
   // typical scenarios.  However, shared_ptr can out-perform

utils/unittest/googlemock/include/gmock/gmock-spec-builders.h

 //     the Symbian WINSCW compiler wants to otherwise instantiate them
 //     when it sees this class definition, at which point it doesn't have
 //     ExpectationBase available yet, leading to incorrect destruction
 //     in the linked_ptr (or compilation errors if using a checking
 //     linked_ptr).
 class GTEST_API_ Expectation {
  public:
   // Constructs a null object that doesn't reference any expectation.
-  Expectation();
+  Expectation() = default;
 
-  ~Expectation();
+  ~Expectation() = default;
 
   // This single-argument ctor must not be explicit, in order to support the
   //   Expectation e = EXPECT_CALL(...);
   // syntax.
   //
   // A TypedExpectation object stores its pre-requisites as
   // Expectation objects, and needs to call the non-const Retire()
   // method on the ExpectationBase objects they reference.  Therefore

utils/unittest/googlemock/src/gmock-spec-builders.cc

for (FunctionMockers::const_iterator it = mockers.begin();
        it != mockers.end(); ++it) {
     (*it)->ClearDefaultActionsLocked();
   }
 
   // We don't clear the content of mockers, as they may still be
   // needed by VerifyAndClearExpectationsLocked().
 }
 
-Expectation::Expectation() {}
-
 Expectation::Expectation(
     const internal::linked_ptr<internal::ExpectationBase>& an_expectation_base)
     : expectation_base_(an_expectation_base) {}
 
-Expectation::~Expectation() {}
-
 // Adds an expectation to a sequence.
 void Sequence::AddExpectation(const Expectation& expectation) const {
   if (*last_expectation_ != expectation) {
     if (last_expectation_->expectation_base() != NULL) {
       expectation.expectation_base()->immediate_prerequisites_
           += *last_expectation_;
     }
     *last_expectation_ = expectation;

utils/unittest/googletest/include/gtest/internal/gtest-param-util-generated.h

public:
   template <typename T>
   operator ParamGenerator<T>() const {
     const T array[] = {static_cast<T>(v1_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray1& other);
+  void operator=(const ValueArray1& other) = delete;
 
   const T1 v1_;
 };
 
 template <typename T1, typename T2>
 class ValueArray2 {
  public:
   ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
 
   template <typename T>
   operator ParamGenerator<T>() const {
     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray2& other);
+  void operator=(const ValueArray2& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
 };
 
 template <typename T1, typename T2, typename T3>
 class ValueArray3 {
  public:
   ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
 
   template <typename T>
   operator ParamGenerator<T>() const {
     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v3_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray3& other);
+  void operator=(const ValueArray3& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
 };
 
 template <typename T1, typename T2, typename T3, typename T4>
 class ValueArray4 {
  public:
   ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
       v4_(v4) {}
 
   template <typename T>
   operator ParamGenerator<T>() const {
     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v3_), static_cast<T>(v4_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray4& other);
+  void operator=(const ValueArray4& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
 };
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5>
 class ValueArray5 {
  public:
   ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),
       v4_(v4), v5_(v5) {}
 
   template <typename T>
   operator ParamGenerator<T>() const {
     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray5& other);
+  void operator=(const ValueArray5& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
 };
 
operator ParamGenerator<T>() const {
     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
         static_cast<T>(v6_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray6& other);
+  void operator=(const ValueArray6& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
 };
operator ParamGenerator<T>() const {
     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
         static_cast<T>(v6_), static_cast<T>(v7_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray7& other);
+  void operator=(const ValueArray7& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
operator ParamGenerator<T>() const {
     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray8& other);
+  void operator=(const ValueArray8& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
         static_cast<T>(v9_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray9& other);
+  void operator=(const ValueArray9& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
         static_cast<T>(v9_), static_cast<T>(v10_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray10& other);
+  void operator=(const ValueArray10& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray11& other);
+  void operator=(const ValueArray11& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
         static_cast<T>(v12_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray12& other);
+  void operator=(const ValueArray12& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
         static_cast<T>(v12_), static_cast<T>(v13_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray13& other);
+  void operator=(const ValueArray13& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray14& other);
+  void operator=(const ValueArray14& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
         static_cast<T>(v15_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray15& other);
+  void operator=(const ValueArray15& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
         static_cast<T>(v15_), static_cast<T>(v16_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray16& other);
+  void operator=(const ValueArray16& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray17& other);
+  void operator=(const ValueArray17& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
         static_cast<T>(v18_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray18& other);
+  void operator=(const ValueArray18& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
         static_cast<T>(v18_), static_cast<T>(v19_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray19& other);
+  void operator=(const ValueArray19& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray20& other);
+  void operator=(const ValueArray20& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
         static_cast<T>(v21_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray21& other);
+  void operator=(const ValueArray21& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
         static_cast<T>(v21_), static_cast<T>(v22_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray22& other);
+  void operator=(const ValueArray22& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray23& other);
+  void operator=(const ValueArray23& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
         static_cast<T>(v24_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray24& other);
+  void operator=(const ValueArray24& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
         static_cast<T>(v24_), static_cast<T>(v25_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray25& other);
+  void operator=(const ValueArray25& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray26& other);
+  void operator=(const ValueArray26& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
         static_cast<T>(v27_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray27& other);
+  void operator=(const ValueArray27& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
         static_cast<T>(v27_), static_cast<T>(v28_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray28& other);
+  void operator=(const ValueArray28& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray29& other);
+  void operator=(const ValueArray29& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
         static_cast<T>(v30_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray30& other);
+  void operator=(const ValueArray30& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
         static_cast<T>(v30_), static_cast<T>(v31_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray31& other);
+  void operator=(const ValueArray31& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray32& other);
+  void operator=(const ValueArray32& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
         static_cast<T>(v33_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray33& other);
+  void operator=(const ValueArray33& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
         static_cast<T>(v33_), static_cast<T>(v34_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray34& other);
+  void operator=(const ValueArray34& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray35& other);
+  void operator=(const ValueArray35& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
         static_cast<T>(v36_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray36& other);
+  void operator=(const ValueArray36& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
         static_cast<T>(v36_), static_cast<T>(v37_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray37& other);
+  void operator=(const ValueArray37& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray38& other);
+  void operator=(const ValueArray38& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
         static_cast<T>(v39_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray39& other);
+  void operator=(const ValueArray39& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
         static_cast<T>(v39_), static_cast<T>(v40_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray40& other);
+  void operator=(const ValueArray40& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray41& other);
+  void operator=(const ValueArray41& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
         static_cast<T>(v42_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray42& other);
+  void operator=(const ValueArray42& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
         static_cast<T>(v42_), static_cast<T>(v43_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray43& other);
+  void operator=(const ValueArray43& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray44& other);
+  void operator=(const ValueArray44& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
         static_cast<T>(v45_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray45& other);
+  void operator=(const ValueArray45& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
         static_cast<T>(v45_), static_cast<T>(v46_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray46& other);
+  void operator=(const ValueArray46& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray47& other);
+  void operator=(const ValueArray47& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
         static_cast<T>(v48_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray48& other);
+  void operator=(const ValueArray48& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
         static_cast<T>(v48_), static_cast<T>(v49_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray49& other);
+  void operator=(const ValueArray49& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
         static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
     return ValuesIn(array);
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const ValueArray50& other);
+  void operator=(const ValueArray50& other) = delete;
 
   const T1 v1_;
   const T2 v2_;
   const T3 v3_;
   const T4 v4_;
   const T5 v5_;
   const T6 v6_;
   const T7 v7_;
bool AtEnd() const {
       // We must report iterator past the end of the range when either of the
       // component iterators has reached the end of its range.
       return
           current1_ == end1_ ||
           current2_ == end2_;
     }
 
     // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
+    void operator=(const Iterator& other) = delete;
 
     const ParamGeneratorInterface<ParamType>* const base_;
     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
     // current[i]_ is the actual traversing iterator.
     const typename ParamGenerator<T1>::iterator begin1_;
     const typename ParamGenerator<T1>::iterator end1_;
     typename ParamGenerator<T1>::iterator current1_;
     const typename ParamGenerator<T2>::iterator begin2_;
     const typename ParamGenerator<T2>::iterator end2_;
     typename ParamGenerator<T2>::iterator current2_;
     ParamType current_value_;
   };  // class CartesianProductGenerator2::Iterator
 
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator2& other);
+  void operator=(const CartesianProductGenerator2& other) = delete;
 
   const ParamGenerator<T1> g1_;
   const ParamGenerator<T2> g2_;
 };  // class CartesianProductGenerator2
 
 
 template <typename T1, typename T2, typename T3>
 class CartesianProductGenerator3
bool AtEnd() const {
       // component iterators has reached the end of its range.
       return
           current1_ == end1_ ||
           current2_ == end2_ ||
           current3_ == end3_;
     }
 
     // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
+    void operator=(const Iterator& other) = delete;
 
     const ParamGeneratorInterface<ParamType>* const base_;
     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
     // current[i]_ is the actual traversing iterator.
     const typename ParamGenerator<T1>::iterator begin1_;
     const typename ParamGenerator<T1>::iterator end1_;
     typename ParamGenerator<T1>::iterator current1_;
     const typename ParamGenerator<T2>::iterator begin2_;
     const typename ParamGenerator<T2>::iterator end2_;
     typename ParamGenerator<T2>::iterator current2_;
     const typename ParamGenerator<T3>::iterator begin3_;
     const typename ParamGenerator<T3>::iterator end3_;
     typename ParamGenerator<T3>::iterator current3_;
     ParamType current_value_;
   };  // class CartesianProductGenerator3::Iterator
 
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator3& other);
+  void operator=(const CartesianProductGenerator3& other) = delete;
 
   const ParamGenerator<T1> g1_;
   const ParamGenerator<T2> g2_;
   const ParamGenerator<T3> g3_;
 };  // class CartesianProductGenerator3
 
 
 template <typename T1, typename T2, typename T3, typename T4>
bool AtEnd() const {
       return
           current1_ == end1_ ||
           current2_ == end2_ ||
           current3_ == end3_ ||
           current4_ == end4_;
     }
 
     // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
+    void operator=(const Iterator& other) = delete;
 
     const ParamGeneratorInterface<ParamType>* const base_;
     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
     // current[i]_ is the actual traversing iterator.
     const typename ParamGenerator<T1>::iterator begin1_;
     const typename ParamGenerator<T1>::iterator end1_;
     typename ParamGenerator<T1>::iterator current1_;
     const typename ParamGenerator<T2>::iterator begin2_;
     const typename ParamGenerator<T2>::iterator end2_;
     typename ParamGenerator<T2>::iterator current2_;
     const typename ParamGenerator<T3>::iterator begin3_;
     const typename ParamGenerator<T3>::iterator end3_;
     typename ParamGenerator<T3>::iterator current3_;
     const typename ParamGenerator<T4>::iterator begin4_;
     const typename ParamGenerator<T4>::iterator end4_;
     typename ParamGenerator<T4>::iterator current4_;
     ParamType current_value_;
   };  // class CartesianProductGenerator4::Iterator
 
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator4& other);
+  void operator=(const CartesianProductGenerator4& other) = delete;
 
   const ParamGenerator<T1> g1_;
   const ParamGenerator<T2> g2_;
   const ParamGenerator<T3> g3_;
   const ParamGenerator<T4> g4_;
 };  // class CartesianProductGenerator4
 
 
bool AtEnd() const {
           current1_ == end1_ ||
           current2_ == end2_ ||
           current3_ == end3_ ||
           current4_ == end4_ ||
           current5_ == end5_;
     }
 
     // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
+    void operator=(const Iterator& other) = delete;
 
     const ParamGeneratorInterface<ParamType>* const base_;
     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
     // current[i]_ is the actual traversing iterator.
     const typename ParamGenerator<T1>::iterator begin1_;
     const typename ParamGenerator<T1>::iterator end1_;
     typename ParamGenerator<T1>::iterator current1_;
     const typename ParamGenerator<T2>::iterator begin2_;
     const typename ParamGenerator<T2>::iterator end2_;
     typename ParamGenerator<T2>::iterator current2_;
     const typename ParamGenerator<T3>::iterator begin3_;
     const typename ParamGenerator<T3>::iterator end3_;
     typename ParamGenerator<T3>::iterator current3_;
     const typename ParamGenerator<T4>::iterator begin4_;
     const typename ParamGenerator<T4>::iterator end4_;
     typename ParamGenerator<T4>::iterator current4_;
     const typename ParamGenerator<T5>::iterator begin5_;
     const typename ParamGenerator<T5>::iterator end5_;
     typename ParamGenerator<T5>::iterator current5_;
     ParamType current_value_;
   };  // class CartesianProductGenerator5::Iterator
 
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator5& other);
+  void operator=(const CartesianProductGenerator5& other) = delete;
 
   const ParamGenerator<T1> g1_;
   const ParamGenerator<T2> g2_;
   const ParamGenerator<T3> g3_;
   const ParamGenerator<T4> g4_;
   const ParamGenerator<T5> g5_;
 };  // class CartesianProductGenerator5
 
bool AtEnd() const {
           current2_ == end2_ ||
           current3_ == end3_ ||
           current4_ == end4_ ||
           current5_ == end5_ ||
           current6_ == end6_;
     }
 
     // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
+    void operator=(const Iterator& other) = delete;
 
     const ParamGeneratorInterface<ParamType>* const base_;
     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
     // current[i]_ is the actual traversing iterator.
     const typename ParamGenerator<T1>::iterator begin1_;
     const typename ParamGenerator<T1>::iterator end1_;
     typename ParamGenerator<T1>::iterator current1_;
     const typename ParamGenerator<T2>::iterator begin2_;
private:
     typename ParamGenerator<T5>::iterator current5_;
     const typename ParamGenerator<T6>::iterator begin6_;
     const typename ParamGenerator<T6>::iterator end6_;
     typename ParamGenerator<T6>::iterator current6_;
     ParamType current_value_;
   };  // class CartesianProductGenerator6::Iterator
 
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator6& other);
+  void operator=(const CartesianProductGenerator6& other) = delete;
 
   const ParamGenerator<T1> g1_;
   const ParamGenerator<T2> g2_;
   const ParamGenerator<T3> g3_;
   const ParamGenerator<T4> g4_;
   const ParamGenerator<T5> g5_;
   const ParamGenerator<T6> g6_;
 };  // class CartesianProductGenerator6
bool AtEnd() const {
           current3_ == end3_ ||
           current4_ == end4_ ||
           current5_ == end5_ ||
           current6_ == end6_ ||
           current7_ == end7_;
     }
 
     // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
+    void operator=(const Iterator& other) = delete;
 
     const ParamGeneratorInterface<ParamType>* const base_;
     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
     // current[i]_ is the actual traversing iterator.
     const typename ParamGenerator<T1>::iterator begin1_;
     const typename ParamGenerator<T1>::iterator end1_;
     typename ParamGenerator<T1>::iterator current1_;
     const typename ParamGenerator<T2>::iterator begin2_;
private:
     typename ParamGenerator<T6>::iterator current6_;
     const typename ParamGenerator<T7>::iterator begin7_;
     const typename ParamGenerator<T7>::iterator end7_;
     typename ParamGenerator<T7>::iterator current7_;
     ParamType current_value_;
   };  // class CartesianProductGenerator7::Iterator
 
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator7& other);
+  void operator=(const CartesianProductGenerator7& other) = delete;
 
   const ParamGenerator<T1> g1_;
   const ParamGenerator<T2> g2_;
   const ParamGenerator<T3> g3_;
   const ParamGenerator<T4> g4_;
   const ParamGenerator<T5> g5_;
   const ParamGenerator<T6> g6_;
   const ParamGenerator<T7> g7_;
bool AtEnd() const {
           current4_ == end4_ ||
           current5_ == end5_ ||
           current6_ == end6_ ||
           current7_ == end7_ ||
           current8_ == end8_;
     }
 
     // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
+    void operator=(const Iterator& other) = delete;
 
     const ParamGeneratorInterface<ParamType>* const base_;
     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
     // current[i]_ is the actual traversing iterator.
     const typename ParamGenerator<T1>::iterator begin1_;
     const typename ParamGenerator<T1>::iterator end1_;
     typename ParamGenerator<T1>::iterator current1_;
     const typename ParamGenerator<T2>::iterator begin2_;
private:
     typename ParamGenerator<T7>::iterator current7_;
     const typename ParamGenerator<T8>::iterator begin8_;
     const typename ParamGenerator<T8>::iterator end8_;
     typename ParamGenerator<T8>::iterator current8_;
     ParamType current_value_;
   };  // class CartesianProductGenerator8::Iterator
 
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator8& other);
+  void operator=(const CartesianProductGenerator8& other) = delete;
 
   const ParamGenerator<T1> g1_;
   const ParamGenerator<T2> g2_;
   const ParamGenerator<T3> g3_;
   const ParamGenerator<T4> g4_;
   const ParamGenerator<T5> g5_;
   const ParamGenerator<T6> g6_;
   const ParamGenerator<T7> g7_;
bool AtEnd() const {
           current5_ == end5_ ||
           current6_ == end6_ ||
           current7_ == end7_ ||
           current8_ == end8_ ||
           current9_ == end9_;
     }
 
     // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
+    void operator=(const Iterator& other) = delete;
 
     const ParamGeneratorInterface<ParamType>* const base_;
     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
     // current[i]_ is the actual traversing iterator.
     const typename ParamGenerator<T1>::iterator begin1_;
     const typename ParamGenerator<T1>::iterator end1_;
     typename ParamGenerator<T1>::iterator current1_;
     const typename ParamGenerator<T2>::iterator begin2_;
private:
     typename ParamGenerator<T8>::iterator current8_;
     const typename ParamGenerator<T9>::iterator begin9_;
     const typename ParamGenerator<T9>::iterator end9_;
     typename ParamGenerator<T9>::iterator current9_;
     ParamType current_value_;
   };  // class CartesianProductGenerator9::Iterator
 
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator9& other);
+  void operator=(const CartesianProductGenerator9& other) = delete;
 
   const ParamGenerator<T1> g1_;
   const ParamGenerator<T2> g2_;
   const ParamGenerator<T3> g3_;
   const ParamGenerator<T4> g4_;
   const ParamGenerator<T5> g5_;
   const ParamGenerator<T6> g6_;
   const ParamGenerator<T7> g7_;
bool AtEnd() const {
           current6_ == end6_ ||
           current7_ == end7_ ||
           current8_ == end8_ ||
           current9_ == end9_ ||
           current10_ == end10_;
     }
 
     // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
+    void operator=(const Iterator& other) = delete;
 
     const ParamGeneratorInterface<ParamType>* const base_;
     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
     // current[i]_ is the actual traversing iterator.
     const typename ParamGenerator<T1>::iterator begin1_;
     const typename ParamGenerator<T1>::iterator end1_;
     typename ParamGenerator<T1>::iterator current1_;
     const typename ParamGenerator<T2>::iterator begin2_;
private:
     typename ParamGenerator<T9>::iterator current9_;
     const typename ParamGenerator<T10>::iterator begin10_;
     const typename ParamGenerator<T10>::iterator end10_;
     typename ParamGenerator<T10>::iterator current10_;
     ParamType current_value_;
   };  // class CartesianProductGenerator10::Iterator
 
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator10& other);
+  void operator=(const CartesianProductGenerator10& other) = delete;
 
   const ParamGenerator<T1> g1_;
   const ParamGenerator<T2> g2_;
   const ParamGenerator<T3> g3_;
   const ParamGenerator<T4> g4_;
   const ParamGenerator<T5> g5_;
   const ParamGenerator<T6> g6_;
   const ParamGenerator<T7> g7_;
operator ParamGenerator< ::testing::tuple<T1, T2> >() const {
     return ParamGenerator< ::testing::tuple<T1, T2> >(
         new CartesianProductGenerator2<T1, T2>(
         static_cast<ParamGenerator<T1> >(g1_),
         static_cast<ParamGenerator<T2> >(g2_)));
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder2& other);
+  void operator=(const CartesianProductHolder2& other) = delete;
 
   const Generator1 g1_;
   const Generator2 g2_;
 };  // class CartesianProductHolder2
 
 template <class Generator1, class Generator2, class Generator3>
 class CartesianProductHolder3 {
  public:
 CartesianProductHolder3(const Generator1& g1, const Generator2& g2,
     const Generator3& g3)
       : g1_(g1), g2_(g2), g3_(g3) {}
   template <typename T1, typename T2, typename T3>
   operator ParamGenerator< ::testing::tuple<T1, T2, T3> >() const {
     return ParamGenerator< ::testing::tuple<T1, T2, T3> >(
         new CartesianProductGenerator3<T1, T2, T3>(
         static_cast<ParamGenerator<T1> >(g1_),
         static_cast<ParamGenerator<T2> >(g2_),
         static_cast<ParamGenerator<T3> >(g3_)));
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder3& other);
+  void operator=(const CartesianProductHolder3& other) = delete;
 
   const Generator1 g1_;
   const Generator2 g2_;
   const Generator3 g3_;
 };  // class CartesianProductHolder3
 
 template <class Generator1, class Generator2, class Generator3,
     class Generator4>
return ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >(
         static_cast<ParamGenerator<T1> >(g1_),
         static_cast<ParamGenerator<T2> >(g2_),
         static_cast<ParamGenerator<T3> >(g3_),
         static_cast<ParamGenerator<T4> >(g4_)));
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder4& other);
+  void operator=(const CartesianProductHolder4& other) = delete;
 
   const Generator1 g1_;
   const Generator2 g2_;
   const Generator3 g3_;
   const Generator4 g4_;
 };  // class CartesianProductHolder4
 
 template <class Generator1, class Generator2, class Generator3,
return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >(
         static_cast<ParamGenerator<T2> >(g2_),
         static_cast<ParamGenerator<T3> >(g3_),
         static_cast<ParamGenerator<T4> >(g4_),
         static_cast<ParamGenerator<T5> >(g5_)));
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder5& other);
+  void operator=(const CartesianProductHolder5& other) = delete;
 
   const Generator1 g1_;
   const Generator2 g2_;
   const Generator3 g3_;
   const Generator4 g4_;
   const Generator5 g5_;
 };  // class CartesianProductHolder5
 
return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >(
         static_cast<ParamGenerator<T3> >(g3_),
         static_cast<ParamGenerator<T4> >(g4_),
         static_cast<ParamGenerator<T5> >(g5_),
         static_cast<ParamGenerator<T6> >(g6_)));
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder6& other);
+  void operator=(const CartesianProductHolder6& other) = delete;
 
   const Generator1 g1_;
   const Generator2 g2_;
   const Generator3 g3_;
   const Generator4 g4_;
   const Generator5 g5_;
   const Generator6 g6_;
 };  // class CartesianProductHolder6
return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> >(
         static_cast<ParamGenerator<T4> >(g4_),
         static_cast<ParamGenerator<T5> >(g5_),
         static_cast<ParamGenerator<T6> >(g6_),
         static_cast<ParamGenerator<T7> >(g7_)));
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder7& other);
+  void operator=(const CartesianProductHolder7& other) = delete;
 
   const Generator1 g1_;
   const Generator2 g2_;
   const Generator3 g3_;
   const Generator4 g4_;
   const Generator5 g5_;
   const Generator6 g6_;
   const Generator7 g7_;
return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >(
         static_cast<ParamGenerator<T5> >(g5_),
         static_cast<ParamGenerator<T6> >(g6_),
         static_cast<ParamGenerator<T7> >(g7_),
         static_cast<ParamGenerator<T8> >(g8_)));
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder8& other);
+  void operator=(const CartesianProductHolder8& other) = delete;
 
   const Generator1 g1_;
   const Generator2 g2_;
   const Generator3 g3_;
   const Generator4 g4_;
   const Generator5 g5_;
   const Generator6 g6_;
   const Generator7 g7_;
return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
         static_cast<ParamGenerator<T6> >(g6_),
         static_cast<ParamGenerator<T7> >(g7_),
         static_cast<ParamGenerator<T8> >(g8_),
         static_cast<ParamGenerator<T9> >(g9_)));
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder9& other);
+  void operator=(const CartesianProductHolder9& other) = delete;
 
   const Generator1 g1_;
   const Generator2 g2_;
   const Generator3 g3_;
   const Generator4 g4_;
   const Generator5 g5_;
   const Generator6 g6_;
   const Generator7 g7_;
return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9,
         static_cast<ParamGenerator<T7> >(g7_),
         static_cast<ParamGenerator<T8> >(g8_),
         static_cast<ParamGenerator<T9> >(g9_),
         static_cast<ParamGenerator<T10> >(g10_)));
   }
 
  private:
   // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder10& other);
+  void operator=(const CartesianProductHolder10& other) = delete;
 
   const Generator1 g1_;
   const Generator2 g2_;
   const Generator3 g3_;
   const Generator4 g4_;
   const Generator5 g5_;
   const Generator6 g6_;
   const Generator7 g7_;

utils/unittest/googletest/include/gtest/internal/gtest-port.h

 #endif
 #ifndef GTEST_ATTRIBUTE_UNUSED_
 # define GTEST_ATTRIBUTE_UNUSED_
 #endif
 
 // A macro to disallow operator=
 // This should be used in the private: declarations for a class.
 #define GTEST_DISALLOW_ASSIGN_(type)\
-  void operator=(type const &)
+  void operator=(type const &) = delete
 
 // A macro to disallow copy constructor and operator=
 // This should be used in the private: declarations for a class.
 #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
-  type(type const &);\
+  type(type const &) = delete;\
   GTEST_DISALLOW_ASSIGN_(type)
 
 // Tell the compiler to warn about unused return values for functions declared
 // with this macro.  The macro should be used on function declarations
 // following the argument list:
 //
 //   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
 #if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)