"constructor (the implicit move constructor)|"
"function (the implicit copy assignment operator)|"
"function (the implicit move assignment operator)|"
- "constructor (inherited)}0%1 "
- "has been explicitly %select{made unavailable|deleted}2">;
+ "constructor (inherited)}0%1 has been "
+ "%select{explicitly made unavailable|explicitly deleted|"
+ "implicitly deleted}2">;
// Giving the index of the bad argument really clutters this message, and
// it's relatively unimportant because 1) it's generally obvious which
"no function template matches function template specialization %0">;
def err_function_template_spec_ambiguous : Error<
"function template specialization %0 ambiguously refers to more than one "
- "function template; explicitly specify%select{|additional }1 template "
+ "function template; explicitly specify%select{| additional}1 template "
"arguments to identify a particular function template">;
def note_function_template_spec_matched : Note<
"function template matches specialization %0">;
def note_unavailable_here : Note<
"%select{declaration|function}0 has been explicitly marked "
"%select{unavailable|deleted|deprecated}1 here">;
+def note_implicitly_deleted : Note<
+ "explicitly defaulted function was implicitly deleted here">;
def warn_not_enough_argument : Warning<
"not enough variable arguments in %0 declaration to fit a sentinel">,
InGroup<Sentinel>;
return true;
}
+ // For an anonymous struct or union, the copy and assignment special members
+ // will never be used, so skip the check. For an anonymous union declared at
+ // namespace scope, the constructor and destructor are used.
+ if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
+ RD->isAnonymousStructOrUnion())
+ return false;
+
// C++11 [class.copy]p7, p18:
// If the class definition declares a move constructor or move assignment
// operator, an implicitly declared copy constructor or copy assignment
}
}
+ // Do access control from the special member function
+ ContextRAII MethodContext(*this, MD);
+
// C++11 [class.dtor]p5:
// -- for a virtual destructor, lookup of the non-array deallocation function
// results in an ambiguity or in a function that is deleted or inaccessible
}
}
- // For an anonymous struct or union, the copy and assignment special members
- // will never be used, so skip the check. For an anonymous union declared at
- // namespace scope, the constructor and destructor are used.
- if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
- RD->isAnonymousStructOrUnion())
- return false;
-
- // Do access control from the special member function
- ContextRAII MethodContext(*this, MD);
-
SpecialMemberDeletionInfo SMI(*this, MD, CSM, Diagnose);
for (CXXRecordDecl::base_class_iterator BI = RD->bases_begin(),
void Sema::NoteDeletedFunction(FunctionDecl *Decl) {
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Decl);
- if (Method && Method->isImplicit()) {
+ if (Method && Method->isDeleted() && !Method->isDeletedAsWritten()) {
+ // If the method was explicitly defaulted, point at that declaration.
+ if (!Method->isImplicit())
+ Diag(Decl->getLocation(), diag::note_implicitly_deleted);
+
+ // Try to diagnose why this special member function was implicitly
+ // deleted. This might fail, if that reason no longer applies.
CXXSpecialMember CSM = getSpecialMember(Method);
- // It is possible for us to no longer be able to determine why the special
- // member function was deleted, due to a field or base class having acquired
- // a new special member function by the addition of a default argument.
- // FIXME: Add a test and a special-case diagnostic for this.
- if (CSM != CXXInvalid &&
- ShouldDeleteSpecialMember(Method, CSM, /*Diagnose=*/true))
- return;
+ if (CSM != CXXInvalid)
+ ShouldDeleteSpecialMember(Method, CSM, /*Diagnose=*/true);
+
+ return;
}
Diag(Decl->getLocation(), diag::note_unavailable_here)
OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc);
S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
- << FnKind << FnDesc << Fn->isDeleted();
+ << FnKind << FnDesc
+ << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
MaybeEmitInheritedConstructorNote(S, Fn);
return;
}
<< getSpecialMember(Method)
<< BinaryOperator::getOpcodeStr(Opc)
<< getDeletedOrUnavailableSuffix(Best->Function);
-
- if (Method->getParent()->isLambda()) {
- Diag(Method->getParent()->getLocation(), diag::note_lambda_decl);
+
+ if (getSpecialMember(Method) != CXXInvalid) {
+ // The user probably meant to call this special member. Just
+ // explain why it's deleted.
+ NoteDeletedFunction(Method);
return ExprError();
}
} else {
HasCopyAssignment & operator =(const HasCopyAssignment &) noexcept(false);
};
-struct HasMoveConstructor { // expected-note {{implicit copy assignment}}
+struct HasMoveConstructor {
ThrowingCopy tc;
HasMoveConstructor() noexcept;
- HasMoveConstructor(HasMoveConstructor &&) noexcept;
+ HasMoveConstructor(HasMoveConstructor &&) noexcept; // expected-note {{deleted because 'HasMoveConstructor' has a user-declared move constructor}}
};
struct HasMoveAssignment { // expected-note {{implicit copy constructor}}
// - any non-static data member with no brace-or-equal-initializer is of
// reference type,
class Deleted2a {
- // FIXME: We should explain that the function was implicitly deleted as a
- // result of being defaulted, and why.
- Deleted2a() = default; // expected-note 4{{explicitly marked deleted here}}
- int &a;
-};
+ Deleted2a() = default; // expected-note 4{{implicitly deleted here}}
+ int &a; // expected-note 4{{because field 'a' of reference type 'int &' would not be initialized}}
+};
Deleted2a d2a; // expected-error {{implicitly-deleted default constructor}}
struct Deleted2b {
int &&b; // expected-note {{default constructor of 'Deleted2b' is implicitly deleted because field 'b' of reference type 'int &&' would not be initialized}}
public:
virtual ~D1() = default;
} d1; // ok
-struct D2 : D1 { // expected-note {{deleted here}}
+struct D2 : D1 { // expected-note {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
// implicitly-virtual destructor
} d2; // expected-error {{deleted function}}
-struct D3 {
- virtual ~D3() = default; // expected-note {{deleted here}}
+struct D3 { // expected-note {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
+ virtual ~D3() = default; // expected-note {{explicitly defaulted function was implicitly deleted here}}
void operator delete(void*, double = 0.0);
void operator delete(void*, char = 0);
} d3; // expected-error {{deleted function}}
-struct D4 {
- virtual ~D4() = default; // expected-note {{deleted here}}
+struct D4 { // expected-note {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
+ virtual ~D4() = default; // expected-note {{implicitly deleted here}}
void operator delete(void*) = delete;
} d4; // expected-error {{deleted function}}
good_const gc;
struct no_default {
- no_default() = delete; // expected-note 2{{deleted here}}
+ no_default() = delete; // expected-note 3{{deleted here}}
};
struct no_dtor {
~no_dtor() = delete; // expected-note 2{{deleted here}}
has_friend hf;
struct defaulted_delete {
- no_default nd;
- defaulted_delete() = default; // expected-note{{deleted here}}
+ no_default nd; // expected-note {{because field 'nd' has a deleted default constructor}}
+ defaulted_delete() = default; // expected-note{{implicitly deleted here}}
};
defaulted_delete dd; // expected-error {{call to implicitly-deleted default constructor}}
int a = A().n; // expected-error {{no matching constructor}}
struct B {
- B() = delete; // expected-note 2{{here}}
+ B() = delete; // expected-note 3{{here}}
int n;
};
int b = B().n; // expected-error {{call to deleted}}
struct D {
D() = default; // expected-note {{here}}
- B b;
+ B b; // expected-note {{'b' has a deleted default constructor}}
};
int d = D().b.n; // expected-error {{call to implicitly-deleted default}}
projects / clang / commitdiff