Lines Matching defs:Copy
261 // copy-initialization semantics (8.5).
1571 // Copy non-redundant base specifiers into permanent storage.
3479 // C++11 [class.copy]p15:
3549 // Direct-initialize to use the copy constructor.
3713 // In an implicit copy or move constructor, ignore any in-class initializer.
3977 // If we're not generating the implicit copy/move constructor, then we'll
4682 // defaulted methods, and the copy and move assignment operators. The
4793 // MSVC2015 doesn't export trivial defaulted x-tor but copy assign
5050 /// \param ConstRHS True if this is a copy operation with a const object
5211 // For copy or move constructors, we need to perform overload resolution.
5244 // C++1y [class.copy]p26:
5251 // -- the assignment operator selected to copy/move each direct base
5268 // thereof), the assignment operator selected to copy/move that member is
5367 // copy operation can take a non-const reference) as an implicit
5374 // This also checks for default arguments: a copy or move constructor with a
5442 // A copy assignment operator can take its argument by value, but a
5727 // C++11 [class.copy]p11, C++11 [class.copy]p23:
5741 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
5817 // For a copy constructor, data members must not be of rvalue reference
5834 // C++11 [class.copy]p23:
5904 /// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
5905 /// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
5918 // deleted (8.4.3) default constructor and a deleted copy
5927 // For an anonymous struct or union, the copy and assignment special members
5934 // C++11 [class.copy]p7, p18:
5936 // operator, an implicitly declared copy constructor or copy assignment
5943 // corresponding copy operation, not both copy operations.
6093 // C++11 [class.copy]p12:
6094 // A copy constructor is trivial if:
6095 // - the constructor selected to copy each direct [subobject] is trivial
6098 // We must either select the trivial copy constructor or reach an
6106 // cases like B as having a non-trivial copy constructor:
6112 // C++11 [class.copy]p25:
6113 // A copy assignment operator is trivial if:
6114 // - the assignment operator selected to copy each direct [subobject] is
6262 // default constructible, copy constructible, move constructible, copy
6292 /// as specified in C++11 [class.ctor]p5, C++11 [class.copy]p12,
6293 /// C++11 [class.copy]p25, and C++11 [class.dtor]p5.
6302 // C++11 [class.copy]p12, p25: [DR1593]
6313 // Trivial copy operations always have const, non-volatile parameter types.
6362 // A copy/move [constructor or assignment operator] is trivial if
6363 // -- the [member] selected to copy/move each direct base class subobject
6366 // C++11 [class.copy]p12, C++11 [class.copy]p25:
6376 // A copy/move [constructor or assignment operator] for a class X is
6379 // thereof), the constructor selected to copy/move that member is
6382 // C++11 [class.copy]p12, C++11 [class.copy]p25:
6399 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
6600 /// special functions, such as the default constructor, copy
6615 // If the properties or semantics of the copy constructor couldn't be
6634 // If we have a dynamic class, then the copy assignment operator may be
6886 // C++ [class.copy]p3:
9631 // be called again, so use a local copy of DelayedDllExportClasses.
9670 // copy/move operators. These classes serve as factory functions and help us
9798 /// When generating a defaulted copy or move assignment operator, if a field
9801 /// of class type where the selected copy/move-assignment operator is trivial.
9857 /// This routine is used to copy/move the members of a class with an
9858 /// implicitly-declared copy/move assignment operator. When the entities being
9859 /// copied are arrays, this routine builds for loops to copy them.
9863 /// \param Loc The location where the implicit copy/move is being generated.
9886 // C++11 [class.copy]p28:
9895 // C++03 [class.copy]p13:
9896 // - if the subobject is of class type, the copy assignment operator for
9909 // Prior to C++11, filter out any result that isn't a copy/move-assignment
9927 // we're assigning via a base classes's copy-assignment operator. To
9932 // this means that if the base class has a protected copy assignment
10003 // that will copy each of the array elements.
10041 // Build the copy/move for an individual element of the array.
10042 StmtResult Copy =
10047 if (Copy.isInvalid() || !Copy.get())
10048 return Copy;
10068 S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
10101 assert(T->getNumParams() == 1 && "not a copy assignment op");
10109 // It is unspecified whether or not an implicit copy assignment operator
10149 // Note: The following rules are largely analoguous to the copy
10170 // An implicitly-declared copy assignment operator is an inline public
10208 // Note that we have added this copy-assignment operator.
10224 /// Diagnose an implicit copy operation for a class which is odr-used, but
10225 /// which is deprecated because the class has a user-declared copy constructor,
10226 /// copy assignment operator, or destructor.
10241 // Find any user-declared copy constructor.
10265 << RD << /*copy assignment*/!isa<CXXConstructorDecl>(CopyOp)
10290 // C++11 [class.copy]p18:
10291 // The [definition of an implicitly declared copy assignment operator] is
10292 // deprecated if the class has a user-declared copy constructor or a
10302 // C++0x [class.copy]p30:
10303 // The implicitly-defined or explicitly-defaulted copy assignment operator
10304 // for a non-union class X performs memberwise copy assignment of its
10360 // Build the copy.
10361 StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
10365 if (Copy.isInvalid()) {
10372 // Success! Record the copy.
10373 Statements.push_back(Copy.getAs<Expr>());
10379 // memcpy in a union copy operation.
10388 // Check for members of reference type; we can't copy those.
10433 // Build the copy of this field.
10434 StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
10438 if (Copy.isInvalid()) {
10445 // Success! Record the copy.
10446 Statements.push_back(Copy.getAs<Stmt>());
10600 // Note that we have added this copy-assignment operator.
10723 // C++0x [class.copy]p28:
10761 // C++11 [class.copy]p28:
10763 // are assigned more than once by the implicitly-defined copy assignment
10812 // memcpy in a union copy operation.
10881 // Success! Record the copy.
10937 assert(T->getNumParams() >= 1 && "not a copy ctor");
10976 // C++ [class.copy]p4:
10977 // If the class definition does not explicitly declare a copy
11002 // An implicitly-declared copy constructor is an inline public
11059 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
11064 // C++11 [class.copy]p7:
11065 // The [definition of an implicitly declared copy constructor] is
11066 // deprecated if the class has a user-declared copy assignment operator
11181 // C++11 [class.copy]p11:
11182 // An implicitly-declared copy/move constructor is an inline public
11368 // Copy-initialize the lambda object as needed to capture it.
11444 // C++0x [class.copy]p34:
11446 // omit the copy/move construction of a class object, even if the
11447 // copy/move constructor and/or destructor for the object have
11451 // with the same cv-unqualified type, the copy/move operation
11453 // directly into the target of the omitted copy/move
12270 // copy-initialized (8.5) from the exception object. [...]
