1 //===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// Implements semantic analysis for C++ expressions.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Sema/SemaInternal.h"
16 #include "TreeTransform.h"
17 #include "TypeLocBuilder.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/ASTLambda.h"
20 #include "clang/AST/CXXInheritance.h"
21 #include "clang/AST/CharUnits.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/ExprObjC.h"
25 #include "clang/AST/RecursiveASTVisitor.h"
26 #include "clang/AST/TypeLoc.h"
27 #include "clang/Basic/AlignedAllocation.h"
28 #include "clang/Basic/PartialDiagnostic.h"
29 #include "clang/Basic/TargetInfo.h"
30 #include "clang/Lex/Preprocessor.h"
31 #include "clang/Sema/DeclSpec.h"
32 #include "clang/Sema/Initialization.h"
33 #include "clang/Sema/Lookup.h"
34 #include "clang/Sema/ParsedTemplate.h"
35 #include "clang/Sema/Scope.h"
36 #include "clang/Sema/ScopeInfo.h"
37 #include "clang/Sema/SemaLambda.h"
38 #include "clang/Sema/TemplateDeduction.h"
39 #include "llvm/ADT/APInt.h"
40 #include "llvm/ADT/STLExtras.h"
41 #include "llvm/Support/ErrorHandling.h"
42 using namespace clang;
43 using namespace sema;
44 
45 /// Handle the result of the special case name lookup for inheriting
46 /// constructor declarations. 'NS::X::X' and 'NS::X<...>::X' are treated as
47 /// constructor names in member using declarations, even if 'X' is not the
48 /// name of the corresponding type.
49 ParsedType Sema::getInheritingConstructorName(CXXScopeSpec &SS,
50                                               SourceLocation NameLoc,
51                                               IdentifierInfo &Name) {
52   NestedNameSpecifier *NNS = SS.getScopeRep();
53 
54   // Convert the nested-name-specifier into a type.
55   QualType Type;
56   switch (NNS->getKind()) {
57   case NestedNameSpecifier::TypeSpec:
58   case NestedNameSpecifier::TypeSpecWithTemplate:
59     Type = QualType(NNS->getAsType(), 0);
60     break;
61 
62   case NestedNameSpecifier::Identifier:
63     // Strip off the last layer of the nested-name-specifier and build a
64     // typename type for it.
65     assert(NNS->getAsIdentifier() == &Name && "not a constructor name");
66     Type = Context.getDependentNameType(ETK_None, NNS->getPrefix(),
67                                         NNS->getAsIdentifier());
68     break;
69 
70   case NestedNameSpecifier::Global:
71   case NestedNameSpecifier::Super:
72   case NestedNameSpecifier::Namespace:
73   case NestedNameSpecifier::NamespaceAlias:
74     llvm_unreachable("Nested name specifier is not a type for inheriting ctor");
75   }
76 
77   // This reference to the type is located entirely at the location of the
78   // final identifier in the qualified-id.
79   return CreateParsedType(Type,
80                           Context.getTrivialTypeSourceInfo(Type, NameLoc));
81 }
82 
83 ParsedType Sema::getConstructorName(IdentifierInfo &II,
84                                     SourceLocation NameLoc,
85                                     Scope *S, CXXScopeSpec &SS,
86                                     bool EnteringContext) {
87   CXXRecordDecl *CurClass = getCurrentClass(S, &SS);
88   assert(CurClass && &II == CurClass->getIdentifier() &&
89          "not a constructor name");
90 
91   // When naming a constructor as a member of a dependent context (eg, in a
92   // friend declaration or an inherited constructor declaration), form an
93   // unresolved "typename" type.
94   if (CurClass->isDependentContext() && !EnteringContext) {
95     QualType T = Context.getDependentNameType(ETK_None, SS.getScopeRep(), &II);
96     return ParsedType::make(T);
97   }
98 
99   if (SS.isNotEmpty() && RequireCompleteDeclContext(SS, CurClass))
100     return ParsedType();
101 
102   // Find the injected-class-name declaration. Note that we make no attempt to
103   // diagnose cases where the injected-class-name is shadowed: the only
104   // declaration that can validly shadow the injected-class-name is a
105   // non-static data member, and if the class contains both a non-static data
106   // member and a constructor then it is ill-formed (we check that in
107   // CheckCompletedCXXClass).
108   CXXRecordDecl *InjectedClassName = nullptr;
109   for (NamedDecl *ND : CurClass->lookup(&II)) {
110     auto *RD = dyn_cast<CXXRecordDecl>(ND);
111     if (RD && RD->isInjectedClassName()) {
112       InjectedClassName = RD;
113       break;
114     }
115   }
116   assert(InjectedClassName && "couldn't find injected class name");
117 
118   QualType T = Context.getTypeDeclType(InjectedClassName);
119   DiagnoseUseOfDecl(InjectedClassName, NameLoc);
120   MarkAnyDeclReferenced(NameLoc, InjectedClassName, /*OdrUse=*/false);
121 
122   return ParsedType::make(T);
123 }
124 
125 ParsedType Sema::getDestructorName(SourceLocation TildeLoc,
126                                    IdentifierInfo &II,
127                                    SourceLocation NameLoc,
128                                    Scope *S, CXXScopeSpec &SS,
129                                    ParsedType ObjectTypePtr,
130                                    bool EnteringContext) {
131   // Determine where to perform name lookup.
132 
133   // FIXME: This area of the standard is very messy, and the current
134   // wording is rather unclear about which scopes we search for the
135   // destructor name; see core issues 399 and 555. Issue 399 in
136   // particular shows where the current description of destructor name
137   // lookup is completely out of line with existing practice, e.g.,
138   // this appears to be ill-formed:
139   //
140   //   namespace N {
141   //     template <typename T> struct S {
142   //       ~S();
143   //     };
144   //   }
145   //
146   //   void f(N::S<int>* s) {
147   //     s->N::S<int>::~S();
148   //   }
149   //
150   // See also PR6358 and PR6359.
151   // For this reason, we're currently only doing the C++03 version of this
152   // code; the C++0x version has to wait until we get a proper spec.
153   QualType SearchType;
154   DeclContext *LookupCtx = nullptr;
155   bool isDependent = false;
156   bool LookInScope = false;
157 
158   if (SS.isInvalid())
159     return nullptr;
160 
161   // If we have an object type, it's because we are in a
162   // pseudo-destructor-expression or a member access expression, and
163   // we know what type we're looking for.
164   if (ObjectTypePtr)
165     SearchType = GetTypeFromParser(ObjectTypePtr);
166 
167   if (SS.isSet()) {
168     NestedNameSpecifier *NNS = SS.getScopeRep();
169 
170     bool AlreadySearched = false;
171     bool LookAtPrefix = true;
172     // C++11 [basic.lookup.qual]p6:
173     //   If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier,
174     //   the type-names are looked up as types in the scope designated by the
175     //   nested-name-specifier. Similarly, in a qualified-id of the form:
176     //
177     //     nested-name-specifier[opt] class-name :: ~ class-name
178     //
179     //   the second class-name is looked up in the same scope as the first.
180     //
181     // Here, we determine whether the code below is permitted to look at the
182     // prefix of the nested-name-specifier.
183     DeclContext *DC = computeDeclContext(SS, EnteringContext);
184     if (DC && DC->isFileContext()) {
185       AlreadySearched = true;
186       LookupCtx = DC;
187       isDependent = false;
188     } else if (DC && isa<CXXRecordDecl>(DC)) {
189       LookAtPrefix = false;
190       LookInScope = true;
191     }
192 
193     // The second case from the C++03 rules quoted further above.
194     NestedNameSpecifier *Prefix = nullptr;
195     if (AlreadySearched) {
196       // Nothing left to do.
197     } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) {
198       CXXScopeSpec PrefixSS;
199       PrefixSS.Adopt(NestedNameSpecifierLoc(Prefix, SS.location_data()));
200       LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
201       isDependent = isDependentScopeSpecifier(PrefixSS);
202     } else if (ObjectTypePtr) {
203       LookupCtx = computeDeclContext(SearchType);
204       isDependent = SearchType->isDependentType();
205     } else {
206       LookupCtx = computeDeclContext(SS, EnteringContext);
207       isDependent = LookupCtx && LookupCtx->isDependentContext();
208     }
209   } else if (ObjectTypePtr) {
210     // C++ [basic.lookup.classref]p3:
211     //   If the unqualified-id is ~type-name, the type-name is looked up
212     //   in the context of the entire postfix-expression. If the type T
213     //   of the object expression is of a class type C, the type-name is
214     //   also looked up in the scope of class C. At least one of the
215     //   lookups shall find a name that refers to (possibly
216     //   cv-qualified) T.
217     LookupCtx = computeDeclContext(SearchType);
218     isDependent = SearchType->isDependentType();
219     assert((isDependent || !SearchType->isIncompleteType()) &&
220            "Caller should have completed object type");
221 
222     LookInScope = true;
223   } else {
224     // Perform lookup into the current scope (only).
225     LookInScope = true;
226   }
227 
228   TypeDecl *NonMatchingTypeDecl = nullptr;
229   LookupResult Found(*this, &II, NameLoc, LookupOrdinaryName);
230   for (unsigned Step = 0; Step != 2; ++Step) {
231     // Look for the name first in the computed lookup context (if we
232     // have one) and, if that fails to find a match, in the scope (if
233     // we're allowed to look there).
234     Found.clear();
235     if (Step == 0 && LookupCtx) {
236       if (RequireCompleteDeclContext(SS, LookupCtx))
237         return nullptr;
238       LookupQualifiedName(Found, LookupCtx);
239     } else if (Step == 1 && LookInScope && S) {
240       LookupName(Found, S);
241     } else {
242       continue;
243     }
244 
245     // FIXME: Should we be suppressing ambiguities here?
246     if (Found.isAmbiguous())
247       return nullptr;
248 
249     if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
250       QualType T = Context.getTypeDeclType(Type);
251       MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
252 
253       if (SearchType.isNull() || SearchType->isDependentType() ||
254           Context.hasSameUnqualifiedType(T, SearchType)) {
255         // We found our type!
256 
257         return CreateParsedType(T,
258                                 Context.getTrivialTypeSourceInfo(T, NameLoc));
259       }
260 
261       if (!SearchType.isNull())
262         NonMatchingTypeDecl = Type;
263     }
264 
265     // If the name that we found is a class template name, and it is
266     // the same name as the template name in the last part of the
267     // nested-name-specifier (if present) or the object type, then
268     // this is the destructor for that class.
269     // FIXME: This is a workaround until we get real drafting for core
270     // issue 399, for which there isn't even an obvious direction.
271     if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) {
272       QualType MemberOfType;
273       if (SS.isSet()) {
274         if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
275           // Figure out the type of the context, if it has one.
276           if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx))
277             MemberOfType = Context.getTypeDeclType(Record);
278         }
279       }
280       if (MemberOfType.isNull())
281         MemberOfType = SearchType;
282 
283       if (MemberOfType.isNull())
284         continue;
285 
286       // We're referring into a class template specialization. If the
287       // class template we found is the same as the template being
288       // specialized, we found what we are looking for.
289       if (const RecordType *Record = MemberOfType->getAs<RecordType>()) {
290         if (ClassTemplateSpecializationDecl *Spec
291               = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
292           if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
293                 Template->getCanonicalDecl())
294             return CreateParsedType(
295                 MemberOfType,
296                 Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
297         }
298 
299         continue;
300       }
301 
302       // We're referring to an unresolved class template
303       // specialization. Determine whether we class template we found
304       // is the same as the template being specialized or, if we don't
305       // know which template is being specialized, that it at least
306       // has the same name.
307       if (const TemplateSpecializationType *SpecType
308             = MemberOfType->getAs<TemplateSpecializationType>()) {
309         TemplateName SpecName = SpecType->getTemplateName();
310 
311         // The class template we found is the same template being
312         // specialized.
313         if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) {
314           if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
315             return CreateParsedType(
316                 MemberOfType,
317                 Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
318 
319           continue;
320         }
321 
322         // The class template we found has the same name as the
323         // (dependent) template name being specialized.
324         if (DependentTemplateName *DepTemplate
325                                     = SpecName.getAsDependentTemplateName()) {
326           if (DepTemplate->isIdentifier() &&
327               DepTemplate->getIdentifier() == Template->getIdentifier())
328             return CreateParsedType(
329                 MemberOfType,
330                 Context.getTrivialTypeSourceInfo(MemberOfType, NameLoc));
331 
332           continue;
333         }
334       }
335     }
336   }
337 
338   if (isDependent) {
339     // We didn't find our type, but that's okay: it's dependent
340     // anyway.
341 
342     // FIXME: What if we have no nested-name-specifier?
343     QualType T = CheckTypenameType(ETK_None, SourceLocation(),
344                                    SS.getWithLocInContext(Context),
345                                    II, NameLoc);
346     return ParsedType::make(T);
347   }
348 
349   if (NonMatchingTypeDecl) {
350     QualType T = Context.getTypeDeclType(NonMatchingTypeDecl);
351     Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
352       << T << SearchType;
353     Diag(NonMatchingTypeDecl->getLocation(), diag::note_destructor_type_here)
354       << T;
355   } else if (ObjectTypePtr)
356     Diag(NameLoc, diag::err_ident_in_dtor_not_a_type)
357       << &II;
358   else {
359     SemaDiagnosticBuilder DtorDiag = Diag(NameLoc,
360                                           diag::err_destructor_class_name);
361     if (S) {
362       const DeclContext *Ctx = S->getEntity();
363       if (const CXXRecordDecl *Class = dyn_cast_or_null<CXXRecordDecl>(Ctx))
364         DtorDiag << FixItHint::CreateReplacement(SourceRange(NameLoc),
365                                                  Class->getNameAsString());
366     }
367   }
368 
369   return nullptr;
370 }
371 
372 ParsedType Sema::getDestructorTypeForDecltype(const DeclSpec &DS,
373                                               ParsedType ObjectType) {
374   if (DS.getTypeSpecType() == DeclSpec::TST_error)
375     return nullptr;
376 
377   if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto) {
378     Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
379     return nullptr;
380   }
381 
382   assert(DS.getTypeSpecType() == DeclSpec::TST_decltype &&
383          "unexpected type in getDestructorType");
384   QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
385 
386   // If we know the type of the object, check that the correct destructor
387   // type was named now; we can give better diagnostics this way.
388   QualType SearchType = GetTypeFromParser(ObjectType);
389   if (!SearchType.isNull() && !SearchType->isDependentType() &&
390       !Context.hasSameUnqualifiedType(T, SearchType)) {
391     Diag(DS.getTypeSpecTypeLoc(), diag::err_destructor_expr_type_mismatch)
392       << T << SearchType;
393     return nullptr;
394   }
395 
396   return ParsedType::make(T);
397 }
398 
399 bool Sema::checkLiteralOperatorId(const CXXScopeSpec &SS,
400                                   const UnqualifiedId &Name) {
401   assert(Name.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId);
402 
403   if (!SS.isValid())
404     return false;
405 
406   switch (SS.getScopeRep()->getKind()) {
407   case NestedNameSpecifier::Identifier:
408   case NestedNameSpecifier::TypeSpec:
409   case NestedNameSpecifier::TypeSpecWithTemplate:
410     // Per C++11 [over.literal]p2, literal operators can only be declared at
411     // namespace scope. Therefore, this unqualified-id cannot name anything.
412     // Reject it early, because we have no AST representation for this in the
413     // case where the scope is dependent.
414     Diag(Name.getLocStart(), diag::err_literal_operator_id_outside_namespace)
415       << SS.getScopeRep();
416     return true;
417 
418   case NestedNameSpecifier::Global:
419   case NestedNameSpecifier::Super:
420   case NestedNameSpecifier::Namespace:
421   case NestedNameSpecifier::NamespaceAlias:
422     return false;
423   }
424 
425   llvm_unreachable("unknown nested name specifier kind");
426 }
427 
428 /// Build a C++ typeid expression with a type operand.
429 ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
430                                 SourceLocation TypeidLoc,
431                                 TypeSourceInfo *Operand,
432                                 SourceLocation RParenLoc) {
433   // C++ [expr.typeid]p4:
434   //   The top-level cv-qualifiers of the lvalue expression or the type-id
435   //   that is the operand of typeid are always ignored.
436   //   If the type of the type-id is a class type or a reference to a class
437   //   type, the class shall be completely-defined.
438   Qualifiers Quals;
439   QualType T
440     = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
441                                       Quals);
442   if (T->getAs<RecordType>() &&
443       RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
444     return ExprError();
445 
446   if (T->isVariablyModifiedType())
447     return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);
448 
449   return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), Operand,
450                                      SourceRange(TypeidLoc, RParenLoc));
451 }
452 
453 /// Build a C++ typeid expression with an expression operand.
454 ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
455                                 SourceLocation TypeidLoc,
456                                 Expr *E,
457                                 SourceLocation RParenLoc) {
458   bool WasEvaluated = false;
459   if (E && !E->isTypeDependent()) {
460     if (E->getType()->isPlaceholderType()) {
461       ExprResult result = CheckPlaceholderExpr(E);
462       if (result.isInvalid()) return ExprError();
463       E = result.get();
464     }
465 
466     QualType T = E->getType();
467     if (const RecordType *RecordT = T->getAs<RecordType>()) {
468       CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
469       // C++ [expr.typeid]p3:
470       //   [...] If the type of the expression is a class type, the class
471       //   shall be completely-defined.
472       if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
473         return ExprError();
474 
475       // C++ [expr.typeid]p3:
476       //   When typeid is applied to an expression other than an glvalue of a
477       //   polymorphic class type [...] [the] expression is an unevaluated
478       //   operand. [...]
479       if (RecordD->isPolymorphic() && E->isGLValue()) {
480         // The subexpression is potentially evaluated; switch the context
481         // and recheck the subexpression.
482         ExprResult Result = TransformToPotentiallyEvaluated(E);
483         if (Result.isInvalid()) return ExprError();
484         E = Result.get();
485 
486         // We require a vtable to query the type at run time.
487         MarkVTableUsed(TypeidLoc, RecordD);
488         WasEvaluated = true;
489       }
490     }
491 
492     // C++ [expr.typeid]p4:
493     //   [...] If the type of the type-id is a reference to a possibly
494     //   cv-qualified type, the result of the typeid expression refers to a
495     //   std::type_info object representing the cv-unqualified referenced
496     //   type.
497     Qualifiers Quals;
498     QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals);
499     if (!Context.hasSameType(T, UnqualT)) {
500       T = UnqualT;
501       E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->getValueKind()).get();
502     }
503   }
504 
505   if (E->getType()->isVariablyModifiedType())
506     return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid)
507                      << E->getType());
508   else if (!inTemplateInstantiation() &&
509            E->HasSideEffects(Context, WasEvaluated)) {
510     // The expression operand for typeid is in an unevaluated expression
511     // context, so side effects could result in unintended consequences.
512     Diag(E->getExprLoc(), WasEvaluated
513                               ? diag::warn_side_effects_typeid
514                               : diag::warn_side_effects_unevaluated_context);
515   }
516 
517   return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), E,
518                                      SourceRange(TypeidLoc, RParenLoc));
519 }
520 
521 /// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);
522 ExprResult
523 Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
524                      bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
525   // OpenCL C++ 1.0 s2.9: typeid is not supported.
526   if (getLangOpts().OpenCLCPlusPlus) {
527     return ExprError(Diag(OpLoc, diag::err_openclcxx_not_supported)
528                      << "typeid");
529   }
530 
531   // Find the std::type_info type.
532   if (!getStdNamespace())
533     return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
534 
535   if (!CXXTypeInfoDecl) {
536     IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
537     LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
538     LookupQualifiedName(R, getStdNamespace());
539     CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
540     // Microsoft's typeinfo doesn't have type_info in std but in the global
541     // namespace if _HAS_EXCEPTIONS is defined to 0. See PR13153.
542     if (!CXXTypeInfoDecl && LangOpts.MSVCCompat) {
543       LookupQualifiedName(R, Context.getTranslationUnitDecl());
544       CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
545     }
546     if (!CXXTypeInfoDecl)
547       return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
548   }
549 
550   if (!getLangOpts().RTTI) {
551     return ExprError(Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
552   }
553 
554   QualType TypeInfoType = Context.getTypeDeclType(CXXTypeInfoDecl);
555 
556   if (isType) {
557     // The operand is a type; handle it as such.
558     TypeSourceInfo *TInfo = nullptr;
559     QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
560                                    &TInfo);
561     if (T.isNull())
562       return ExprError();
563 
564     if (!TInfo)
565       TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
566 
567     return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
568   }
569 
570   // The operand is an expression.
571   return BuildCXXTypeId(TypeInfoType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
572 }
573 
574 /// Grabs __declspec(uuid()) off a type, or returns 0 if we cannot resolve to
575 /// a single GUID.
576 static void
577 getUuidAttrOfType(Sema &SemaRef, QualType QT,
578                   llvm::SmallSetVector<const UuidAttr *, 1> &UuidAttrs) {
579   // Optionally remove one level of pointer, reference or array indirection.
580   const Type *Ty = QT.getTypePtr();
581   if (QT->isPointerType() || QT->isReferenceType())
582     Ty = QT->getPointeeType().getTypePtr();
583   else if (QT->isArrayType())
584     Ty = Ty->getBaseElementTypeUnsafe();
585 
586   const auto *TD = Ty->getAsTagDecl();
587   if (!TD)
588     return;
589 
590   if (const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {
591     UuidAttrs.insert(Uuid);
592     return;
593   }
594 
595   // __uuidof can grab UUIDs from template arguments.
596   if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
597     const TemplateArgumentList &TAL = CTSD->getTemplateArgs();
598     for (const TemplateArgument &TA : TAL.asArray()) {
599       const UuidAttr *UuidForTA = nullptr;
600       if (TA.getKind() == TemplateArgument::Type)
601         getUuidAttrOfType(SemaRef, TA.getAsType(), UuidAttrs);
602       else if (TA.getKind() == TemplateArgument::Declaration)
603         getUuidAttrOfType(SemaRef, TA.getAsDecl()->getType(), UuidAttrs);
604 
605       if (UuidForTA)
606         UuidAttrs.insert(UuidForTA);
607     }
608   }
609 }
610 
611 /// Build a Microsoft __uuidof expression with a type operand.
612 ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
613                                 SourceLocation TypeidLoc,
614                                 TypeSourceInfo *Operand,
615                                 SourceLocation RParenLoc) {
616   StringRef UuidStr;
617   if (!Operand->getType()->isDependentType()) {
618     llvm::SmallSetVector<const UuidAttr *, 1> UuidAttrs;
619     getUuidAttrOfType(*this, Operand->getType(), UuidAttrs);
620     if (UuidAttrs.empty())
621       return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
622     if (UuidAttrs.size() > 1)
623       return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
624     UuidStr = UuidAttrs.back()->getGuid();
625   }
626 
627   return new (Context) CXXUuidofExpr(TypeInfoType.withConst(), Operand, UuidStr,
628                                      SourceRange(TypeidLoc, RParenLoc));
629 }
630 
631 /// Build a Microsoft __uuidof expression with an expression operand.
632 ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType,
633                                 SourceLocation TypeidLoc,
634                                 Expr *E,
635                                 SourceLocation RParenLoc) {
636   StringRef UuidStr;
637   if (!E->getType()->isDependentType()) {
638     if (E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
639       UuidStr = "00000000-0000-0000-0000-000000000000";
640     } else {
641       llvm::SmallSetVector<const UuidAttr *, 1> UuidAttrs;
642       getUuidAttrOfType(*this, E->getType(), UuidAttrs);
643       if (UuidAttrs.empty())
644         return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
645       if (UuidAttrs.size() > 1)
646         return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
647       UuidStr = UuidAttrs.back()->getGuid();
648     }
649   }
650 
651   return new (Context) CXXUuidofExpr(TypeInfoType.withConst(), E, UuidStr,
652                                      SourceRange(TypeidLoc, RParenLoc));
653 }
654 
655 /// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression);
656 ExprResult
657 Sema::ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc,
658                      bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
659   // If MSVCGuidDecl has not been cached, do the lookup.
660   if (!MSVCGuidDecl) {
661     IdentifierInfo *GuidII = &PP.getIdentifierTable().get("_GUID");
662     LookupResult R(*this, GuidII, SourceLocation(), LookupTagName);
663     LookupQualifiedName(R, Context.getTranslationUnitDecl());
664     MSVCGuidDecl = R.getAsSingle<RecordDecl>();
665     if (!MSVCGuidDecl)
666       return ExprError(Diag(OpLoc, diag::err_need_header_before_ms_uuidof));
667   }
668 
669   QualType GuidType = Context.getTypeDeclType(MSVCGuidDecl);
670 
671   if (isType) {
672     // The operand is a type; handle it as such.
673     TypeSourceInfo *TInfo = nullptr;
674     QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
675                                    &TInfo);
676     if (T.isNull())
677       return ExprError();
678 
679     if (!TInfo)
680       TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
681 
682     return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
683   }
684 
685   // The operand is an expression.
686   return BuildCXXUuidof(GuidType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
687 }
688 
689 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
690 ExprResult
691 Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
692   assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
693          "Unknown C++ Boolean value!");
694   return new (Context)
695       CXXBoolLiteralExpr(Kind == tok::kw_true, Context.BoolTy, OpLoc);
696 }
697 
698 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
699 ExprResult
700 Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
701   return new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
702 }
703 
704 /// ActOnCXXThrow - Parse throw expressions.
705 ExprResult
706 Sema::ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *Ex) {
707   bool IsThrownVarInScope = false;
708   if (Ex) {
709     // C++0x [class.copymove]p31:
710     //   When certain criteria are met, an implementation is allowed to omit the
711     //   copy/move construction of a class object [...]
712     //
713     //     - in a throw-expression, when the operand is the name of a
714     //       non-volatile automatic object (other than a function or catch-
715     //       clause parameter) whose scope does not extend beyond the end of the
716     //       innermost enclosing try-block (if there is one), the copy/move
717     //       operation from the operand to the exception object (15.1) can be
718     //       omitted by constructing the automatic object directly into the
719     //       exception object
720     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex->IgnoreParens()))
721       if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
722         if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
723           for( ; S; S = S->getParent()) {
724             if (S->isDeclScope(Var)) {
725               IsThrownVarInScope = true;
726               break;
727             }
728 
729             if (S->getFlags() &
730                 (Scope::FnScope | Scope::ClassScope | Scope::BlockScope |
731                  Scope::FunctionPrototypeScope | Scope::ObjCMethodScope |
732                  Scope::TryScope))
733               break;
734           }
735         }
736       }
737   }
738 
739   return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
740 }
741 
742 ExprResult Sema::BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
743                                bool IsThrownVarInScope) {
744   // Don't report an error if 'throw' is used in system headers.
745   if (!getLangOpts().CXXExceptions &&
746       !getSourceManager().isInSystemHeader(OpLoc) &&
747       (!getLangOpts().OpenMPIsDevice ||
748        !getLangOpts().OpenMPHostCXXExceptions ||
749        isInOpenMPTargetExecutionDirective() ||
750        isInOpenMPDeclareTargetContext()))
751     Diag(OpLoc, diag::err_exceptions_disabled) << "throw";
752 
753   // Exceptions aren't allowed in CUDA device code.
754   if (getLangOpts().CUDA)
755     CUDADiagIfDeviceCode(OpLoc, diag::err_cuda_device_exceptions)
756         << "throw" << CurrentCUDATarget();
757 
758   if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
759     Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) << "throw";
760 
761   if (Ex && !Ex->isTypeDependent()) {
762     QualType ExceptionObjectTy = Context.getExceptionObjectType(Ex->getType());
763     if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
764       return ExprError();
765 
766     // Initialize the exception result.  This implicitly weeds out
767     // abstract types or types with inaccessible copy constructors.
768 
769     // C++0x [class.copymove]p31:
770     //   When certain criteria are met, an implementation is allowed to omit the
771     //   copy/move construction of a class object [...]
772     //
773     //     - in a throw-expression, when the operand is the name of a
774     //       non-volatile automatic object (other than a function or
775     //       catch-clause
776     //       parameter) whose scope does not extend beyond the end of the
777     //       innermost enclosing try-block (if there is one), the copy/move
778     //       operation from the operand to the exception object (15.1) can be
779     //       omitted by constructing the automatic object directly into the
780     //       exception object
781     const VarDecl *NRVOVariable = nullptr;
782     if (IsThrownVarInScope)
783       NRVOVariable = getCopyElisionCandidate(QualType(), Ex, CES_Strict);
784 
785     InitializedEntity Entity = InitializedEntity::InitializeException(
786         OpLoc, ExceptionObjectTy,
787         /*NRVO=*/NRVOVariable != nullptr);
788     ExprResult Res = PerformMoveOrCopyInitialization(
789         Entity, NRVOVariable, QualType(), Ex, IsThrownVarInScope);
790     if (Res.isInvalid())
791       return ExprError();
792     Ex = Res.get();
793   }
794 
795   return new (Context)
796       CXXThrowExpr(Ex, Context.VoidTy, OpLoc, IsThrownVarInScope);
797 }
798 
799 static void
800 collectPublicBases(CXXRecordDecl *RD,
801                    llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
802                    llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
803                    llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
804                    bool ParentIsPublic) {
805   for (const CXXBaseSpecifier &BS : RD->bases()) {
806     CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
807     bool NewSubobject;
808     // Virtual bases constitute the same subobject.  Non-virtual bases are
809     // always distinct subobjects.
810     if (BS.isVirtual())
811       NewSubobject = VBases.insert(BaseDecl).second;
812     else
813       NewSubobject = true;
814 
815     if (NewSubobject)
816       ++SubobjectsSeen[BaseDecl];
817 
818     // Only add subobjects which have public access throughout the entire chain.
819     bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() == AS_public;
820     if (PublicPath)
821       PublicSubobjectsSeen.insert(BaseDecl);
822 
823     // Recurse on to each base subobject.
824     collectPublicBases(BaseDecl, SubobjectsSeen, VBases, PublicSubobjectsSeen,
825                        PublicPath);
826   }
827 }
828 
829 static void getUnambiguousPublicSubobjects(
830     CXXRecordDecl *RD, llvm::SmallVectorImpl<CXXRecordDecl *> &Objects) {
831   llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
832   llvm::SmallSet<CXXRecordDecl *, 2> VBases;
833   llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
834   SubobjectsSeen[RD] = 1;
835   PublicSubobjectsSeen.insert(RD);
836   collectPublicBases(RD, SubobjectsSeen, VBases, PublicSubobjectsSeen,
837                      /*ParentIsPublic=*/true);
838 
839   for (CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
840     // Skip ambiguous objects.
841     if (SubobjectsSeen[PublicSubobject] > 1)
842       continue;
843 
844     Objects.push_back(PublicSubobject);
845   }
846 }
847 
848 /// CheckCXXThrowOperand - Validate the operand of a throw.
849 bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc,
850                                 QualType ExceptionObjectTy, Expr *E) {
851   //   If the type of the exception would be an incomplete type or a pointer
852   //   to an incomplete type other than (cv) void the program is ill-formed.
853   QualType Ty = ExceptionObjectTy;
854   bool isPointer = false;
855   if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
856     Ty = Ptr->getPointeeType();
857     isPointer = true;
858   }
859   if (!isPointer || !Ty->isVoidType()) {
860     if (RequireCompleteType(ThrowLoc, Ty,
861                             isPointer ? diag::err_throw_incomplete_ptr
862                                       : diag::err_throw_incomplete,
863                             E->getSourceRange()))
864       return true;
865 
866     if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
867                                diag::err_throw_abstract_type, E))
868       return true;
869   }
870 
871   // If the exception has class type, we need additional handling.
872   CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
873   if (!RD)
874     return false;
875 
876   // If we are throwing a polymorphic class type or pointer thereof,
877   // exception handling will make use of the vtable.
878   MarkVTableUsed(ThrowLoc, RD);
879 
880   // If a pointer is thrown, the referenced object will not be destroyed.
881   if (isPointer)
882     return false;
883 
884   // If the class has a destructor, we must be able to call it.
885   if (!RD->hasIrrelevantDestructor()) {
886     if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
887       MarkFunctionReferenced(E->getExprLoc(), Destructor);
888       CheckDestructorAccess(E->getExprLoc(), Destructor,
889                             PDiag(diag::err_access_dtor_exception) << Ty);
890       if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
891         return true;
892     }
893   }
894 
895   // The MSVC ABI creates a list of all types which can catch the exception
896   // object.  This list also references the appropriate copy constructor to call
897   // if the object is caught by value and has a non-trivial copy constructor.
898   if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
899     // We are only interested in the public, unambiguous bases contained within
900     // the exception object.  Bases which are ambiguous or otherwise
901     // inaccessible are not catchable types.
902     llvm::SmallVector<CXXRecordDecl *, 2> UnambiguousPublicSubobjects;
903     getUnambiguousPublicSubobjects(RD, UnambiguousPublicSubobjects);
904 
905     for (CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
906       // Attempt to lookup the copy constructor.  Various pieces of machinery
907       // will spring into action, like template instantiation, which means this
908       // cannot be a simple walk of the class's decls.  Instead, we must perform
909       // lookup and overload resolution.
910       CXXConstructorDecl *CD = LookupCopyingConstructor(Subobject, 0);
911       if (!CD)
912         continue;
913 
914       // Mark the constructor referenced as it is used by this throw expression.
915       MarkFunctionReferenced(E->getExprLoc(), CD);
916 
917       // Skip this copy constructor if it is trivial, we don't need to record it
918       // in the catchable type data.
919       if (CD->isTrivial())
920         continue;
921 
922       // The copy constructor is non-trivial, create a mapping from this class
923       // type to this constructor.
924       // N.B.  The selection of copy constructor is not sensitive to this
925       // particular throw-site.  Lookup will be performed at the catch-site to
926       // ensure that the copy constructor is, in fact, accessible (via
927       // friendship or any other means).
928       Context.addCopyConstructorForExceptionObject(Subobject, CD);
929 
930       // We don't keep the instantiated default argument expressions around so
931       // we must rebuild them here.
932       for (unsigned I = 1, E = CD->getNumParams(); I != E; ++I) {
933         if (CheckCXXDefaultArgExpr(ThrowLoc, CD, CD->getParamDecl(I)))
934           return true;
935       }
936     }
937   }
938 
939   return false;
940 }
941 
942 static QualType adjustCVQualifiersForCXXThisWithinLambda(
943     ArrayRef<FunctionScopeInfo *> FunctionScopes, QualType ThisTy,
944     DeclContext *CurSemaContext, ASTContext &ASTCtx) {
945 
946   QualType ClassType = ThisTy->getPointeeType();
947   LambdaScopeInfo *CurLSI = nullptr;
948   DeclContext *CurDC = CurSemaContext;
949 
950   // Iterate through the stack of lambdas starting from the innermost lambda to
951   // the outermost lambda, checking if '*this' is ever captured by copy - since
952   // that could change the cv-qualifiers of the '*this' object.
953   // The object referred to by '*this' starts out with the cv-qualifiers of its
954   // member function.  We then start with the innermost lambda and iterate
955   // outward checking to see if any lambda performs a by-copy capture of '*this'
956   // - and if so, any nested lambda must respect the 'constness' of that
957   // capturing lamdbda's call operator.
958   //
959 
960   // Since the FunctionScopeInfo stack is representative of the lexical
961   // nesting of the lambda expressions during initial parsing (and is the best
962   // place for querying information about captures about lambdas that are
963   // partially processed) and perhaps during instantiation of function templates
964   // that contain lambda expressions that need to be transformed BUT not
965   // necessarily during instantiation of a nested generic lambda's function call
966   // operator (which might even be instantiated at the end of the TU) - at which
967   // time the DeclContext tree is mature enough to query capture information
968   // reliably - we use a two pronged approach to walk through all the lexically
969   // enclosing lambda expressions:
970   //
971   //  1) Climb down the FunctionScopeInfo stack as long as each item represents
972   //  a Lambda (i.e. LambdaScopeInfo) AND each LSI's 'closure-type' is lexically
973   //  enclosed by the call-operator of the LSI below it on the stack (while
974   //  tracking the enclosing DC for step 2 if needed).  Note the topmost LSI on
975   //  the stack represents the innermost lambda.
976   //
977   //  2) If we run out of enclosing LSI's, check if the enclosing DeclContext
978   //  represents a lambda's call operator.  If it does, we must be instantiating
979   //  a generic lambda's call operator (represented by the Current LSI, and
980   //  should be the only scenario where an inconsistency between the LSI and the
981   //  DeclContext should occur), so climb out the DeclContexts if they
982   //  represent lambdas, while querying the corresponding closure types
983   //  regarding capture information.
984 
985   // 1) Climb down the function scope info stack.
986   for (int I = FunctionScopes.size();
987        I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
988        (!CurLSI || !CurLSI->Lambda || CurLSI->Lambda->getDeclContext() ==
989                        cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
990        CurDC = getLambdaAwareParentOfDeclContext(CurDC)) {
991     CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
992 
993     if (!CurLSI->isCXXThisCaptured())
994         continue;
995 
996     auto C = CurLSI->getCXXThisCapture();
997 
998     if (C.isCopyCapture()) {
999       ClassType.removeLocalCVRQualifiers(Qualifiers::CVRMask);
1000       if (CurLSI->CallOperator->isConst())
1001         ClassType.addConst();
1002       return ASTCtx.getPointerType(ClassType);
1003     }
1004   }
1005 
1006   // 2) We've run out of ScopeInfos but check if CurDC is a lambda (which can
1007   // happen during instantiation of its nested generic lambda call operator)
1008   if (isLambdaCallOperator(CurDC)) {
1009     assert(CurLSI && "While computing 'this' capture-type for a generic "
1010                      "lambda, we must have a corresponding LambdaScopeInfo");
1011     assert(isGenericLambdaCallOperatorSpecialization(CurLSI->CallOperator) &&
1012            "While computing 'this' capture-type for a generic lambda, when we "
1013            "run out of enclosing LSI's, yet the enclosing DC is a "
1014            "lambda-call-operator we must be (i.e. Current LSI) in a generic "
1015            "lambda call oeprator");
1016     assert(CurDC == getLambdaAwareParentOfDeclContext(CurLSI->CallOperator));
1017 
1018     auto IsThisCaptured =
1019         [](CXXRecordDecl *Closure, bool &IsByCopy, bool &IsConst) {
1020       IsConst = false;
1021       IsByCopy = false;
1022       for (auto &&C : Closure->captures()) {
1023         if (C.capturesThis()) {
1024           if (C.getCaptureKind() == LCK_StarThis)
1025             IsByCopy = true;
1026           if (Closure->getLambdaCallOperator()->isConst())
1027             IsConst = true;
1028           return true;
1029         }
1030       }
1031       return false;
1032     };
1033 
1034     bool IsByCopyCapture = false;
1035     bool IsConstCapture = false;
1036     CXXRecordDecl *Closure = cast<CXXRecordDecl>(CurDC->getParent());
1037     while (Closure &&
1038            IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {
1039       if (IsByCopyCapture) {
1040         ClassType.removeLocalCVRQualifiers(Qualifiers::CVRMask);
1041         if (IsConstCapture)
1042           ClassType.addConst();
1043         return ASTCtx.getPointerType(ClassType);
1044       }
1045       Closure = isLambdaCallOperator(Closure->getParent())
1046                     ? cast<CXXRecordDecl>(Closure->getParent()->getParent())
1047                     : nullptr;
1048     }
1049   }
1050   return ASTCtx.getPointerType(ClassType);
1051 }
1052 
1053 QualType Sema::getCurrentThisType() {
1054   DeclContext *DC = getFunctionLevelDeclContext();
1055   QualType ThisTy = CXXThisTypeOverride;
1056 
1057   if (CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(DC)) {
1058     if (method && method->isInstance())
1059       ThisTy = method->getThisType(Context);
1060   }
1061 
1062   if (ThisTy.isNull() && isLambdaCallOperator(CurContext) &&
1063       inTemplateInstantiation()) {
1064 
1065     assert(isa<CXXRecordDecl>(DC) &&
1066            "Trying to get 'this' type from static method?");
1067 
1068     // This is a lambda call operator that is being instantiated as a default
1069     // initializer. DC must point to the enclosing class type, so we can recover
1070     // the 'this' type from it.
1071 
1072     QualType ClassTy = Context.getTypeDeclType(cast<CXXRecordDecl>(DC));
1073     // There are no cv-qualifiers for 'this' within default initializers,
1074     // per [expr.prim.general]p4.
1075     ThisTy = Context.getPointerType(ClassTy);
1076   }
1077 
1078   // If we are within a lambda's call operator, the cv-qualifiers of 'this'
1079   // might need to be adjusted if the lambda or any of its enclosing lambda's
1080   // captures '*this' by copy.
1081   if (!ThisTy.isNull() && isLambdaCallOperator(CurContext))
1082     return adjustCVQualifiersForCXXThisWithinLambda(FunctionScopes, ThisTy,
1083                                                     CurContext, Context);
1084   return ThisTy;
1085 }
1086 
1087 Sema::CXXThisScopeRAII::CXXThisScopeRAII(Sema &S,
1088                                          Decl *ContextDecl,
1089                                          unsigned CXXThisTypeQuals,
1090                                          bool Enabled)
1091   : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(false)
1092 {
1093   if (!Enabled || !ContextDecl)
1094     return;
1095 
1096   CXXRecordDecl *Record = nullptr;
1097   if (ClassTemplateDecl *Template = dyn_cast<ClassTemplateDecl>(ContextDecl))
1098     Record = Template->getTemplatedDecl();
1099   else
1100     Record = cast<CXXRecordDecl>(ContextDecl);
1101 
1102   // We care only for CVR qualifiers here, so cut everything else.
1103   CXXThisTypeQuals &= Qualifiers::FastMask;
1104   S.CXXThisTypeOverride
1105     = S.Context.getPointerType(
1106         S.Context.getRecordType(Record).withCVRQualifiers(CXXThisTypeQuals));
1107 
1108   this->Enabled = true;
1109 }
1110 
1111 
1112 Sema::CXXThisScopeRAII::~CXXThisScopeRAII() {
1113   if (Enabled) {
1114     S.CXXThisTypeOverride = OldCXXThisTypeOverride;
1115   }
1116 }
1117 
1118 static Expr *captureThis(Sema &S, ASTContext &Context, RecordDecl *RD,
1119                          QualType ThisTy, SourceLocation Loc,
1120                          const bool ByCopy) {
1121 
1122   QualType AdjustedThisTy = ThisTy;
1123   // The type of the corresponding data member (not a 'this' pointer if 'by
1124   // copy').
1125   QualType CaptureThisFieldTy = ThisTy;
1126   if (ByCopy) {
1127     // If we are capturing the object referred to by '*this' by copy, ignore any
1128     // cv qualifiers inherited from the type of the member function for the type
1129     // of the closure-type's corresponding data member and any use of 'this'.
1130     CaptureThisFieldTy = ThisTy->getPointeeType();
1131     CaptureThisFieldTy.removeLocalCVRQualifiers(Qualifiers::CVRMask);
1132     AdjustedThisTy = Context.getPointerType(CaptureThisFieldTy);
1133   }
1134 
1135   FieldDecl *Field = FieldDecl::Create(
1136       Context, RD, Loc, Loc, nullptr, CaptureThisFieldTy,
1137       Context.getTrivialTypeSourceInfo(CaptureThisFieldTy, Loc), nullptr, false,
1138       ICIS_NoInit);
1139 
1140   Field->setImplicit(true);
1141   Field->setAccess(AS_private);
1142   RD->addDecl(Field);
1143   Expr *This =
1144       new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit*/ true);
1145   if (ByCopy) {
1146     Expr *StarThis =  S.CreateBuiltinUnaryOp(Loc,
1147                                       UO_Deref,
1148                                       This).get();
1149     InitializedEntity Entity = InitializedEntity::InitializeLambdaCapture(
1150       nullptr, CaptureThisFieldTy, Loc);
1151     InitializationKind InitKind = InitializationKind::CreateDirect(Loc, Loc, Loc);
1152     InitializationSequence Init(S, Entity, InitKind, StarThis);
1153     ExprResult ER = Init.Perform(S, Entity, InitKind, StarThis);
1154     if (ER.isInvalid()) return nullptr;
1155     return ER.get();
1156   }
1157   return This;
1158 }
1159 
1160 bool Sema::CheckCXXThisCapture(SourceLocation Loc, const bool Explicit,
1161     bool BuildAndDiagnose, const unsigned *const FunctionScopeIndexToStopAt,
1162     const bool ByCopy) {
1163   // We don't need to capture this in an unevaluated context.
1164   if (isUnevaluatedContext() && !Explicit)
1165     return true;
1166 
1167   assert((!ByCopy || Explicit) && "cannot implicitly capture *this by value");
1168 
1169   const int MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
1170                                          ? *FunctionScopeIndexToStopAt
1171                                          : FunctionScopes.size() - 1;
1172 
1173   // Check that we can capture the *enclosing object* (referred to by '*this')
1174   // by the capturing-entity/closure (lambda/block/etc) at
1175   // MaxFunctionScopesIndex-deep on the FunctionScopes stack.
1176 
1177   // Note: The *enclosing object* can only be captured by-value by a
1178   // closure that is a lambda, using the explicit notation:
1179   //    [*this] { ... }.
1180   // Every other capture of the *enclosing object* results in its by-reference
1181   // capture.
1182 
1183   // For a closure 'L' (at MaxFunctionScopesIndex in the FunctionScopes
1184   // stack), we can capture the *enclosing object* only if:
1185   // - 'L' has an explicit byref or byval capture of the *enclosing object*
1186   // -  or, 'L' has an implicit capture.
1187   // AND
1188   //   -- there is no enclosing closure
1189   //   -- or, there is some enclosing closure 'E' that has already captured the
1190   //      *enclosing object*, and every intervening closure (if any) between 'E'
1191   //      and 'L' can implicitly capture the *enclosing object*.
1192   //   -- or, every enclosing closure can implicitly capture the
1193   //      *enclosing object*
1194 
1195 
1196   unsigned NumCapturingClosures = 0;
1197   for (int idx = MaxFunctionScopesIndex; idx >= 0; idx--) {
1198     if (CapturingScopeInfo *CSI =
1199             dyn_cast<CapturingScopeInfo>(FunctionScopes[idx])) {
1200       if (CSI->CXXThisCaptureIndex != 0) {
1201         // 'this' is already being captured; there isn't anything more to do.
1202         CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
1203         break;
1204       }
1205       LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI);
1206       if (LSI && isGenericLambdaCallOperatorSpecialization(LSI->CallOperator)) {
1207         // This context can't implicitly capture 'this'; fail out.
1208         if (BuildAndDiagnose)
1209           Diag(Loc, diag::err_this_capture)
1210               << (Explicit && idx == MaxFunctionScopesIndex);
1211         return true;
1212       }
1213       if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByref ||
1214           CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByval ||
1215           CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_Block ||
1216           CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_CapturedRegion ||
1217           (Explicit && idx == MaxFunctionScopesIndex)) {
1218         // Regarding (Explicit && idx == MaxFunctionScopesIndex): only the first
1219         // iteration through can be an explicit capture, all enclosing closures,
1220         // if any, must perform implicit captures.
1221 
1222         // This closure can capture 'this'; continue looking upwards.
1223         NumCapturingClosures++;
1224         continue;
1225       }
1226       // This context can't implicitly capture 'this'; fail out.
1227       if (BuildAndDiagnose)
1228         Diag(Loc, diag::err_this_capture)
1229             << (Explicit && idx == MaxFunctionScopesIndex);
1230       return true;
1231     }
1232     break;
1233   }
1234   if (!BuildAndDiagnose) return false;
1235 
1236   // If we got here, then the closure at MaxFunctionScopesIndex on the
1237   // FunctionScopes stack, can capture the *enclosing object*, so capture it
1238   // (including implicit by-reference captures in any enclosing closures).
1239 
1240   // In the loop below, respect the ByCopy flag only for the closure requesting
1241   // the capture (i.e. first iteration through the loop below).  Ignore it for
1242   // all enclosing closure's up to NumCapturingClosures (since they must be
1243   // implicitly capturing the *enclosing  object* by reference (see loop
1244   // above)).
1245   assert((!ByCopy ||
1246           dyn_cast<LambdaScopeInfo>(FunctionScopes[MaxFunctionScopesIndex])) &&
1247          "Only a lambda can capture the enclosing object (referred to by "
1248          "*this) by copy");
1249   // FIXME: We need to delay this marking in PotentiallyPotentiallyEvaluated
1250   // contexts.
1251   QualType ThisTy = getCurrentThisType();
1252   for (int idx = MaxFunctionScopesIndex; NumCapturingClosures;
1253        --idx, --NumCapturingClosures) {
1254     CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[idx]);
1255     Expr *ThisExpr = nullptr;
1256 
1257     if (LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI)) {
1258       // For lambda expressions, build a field and an initializing expression,
1259       // and capture the *enclosing object* by copy only if this is the first
1260       // iteration.
1261       ThisExpr = captureThis(*this, Context, LSI->Lambda, ThisTy, Loc,
1262                              ByCopy && idx == MaxFunctionScopesIndex);
1263 
1264     } else if (CapturedRegionScopeInfo *RSI
1265         = dyn_cast<CapturedRegionScopeInfo>(FunctionScopes[idx]))
1266       ThisExpr =
1267           captureThis(*this, Context, RSI->TheRecordDecl, ThisTy, Loc,
1268                       false/*ByCopy*/);
1269 
1270     bool isNested = NumCapturingClosures > 1;
1271     CSI->addThisCapture(isNested, Loc, ThisExpr, ByCopy);
1272   }
1273   return false;
1274 }
1275 
1276 ExprResult Sema::ActOnCXXThis(SourceLocation Loc) {
1277   /// C++ 9.3.2: In the body of a non-static member function, the keyword this
1278   /// is a non-lvalue expression whose value is the address of the object for
1279   /// which the function is called.
1280 
1281   QualType ThisTy = getCurrentThisType();
1282   if (ThisTy.isNull()) return Diag(Loc, diag::err_invalid_this_use);
1283 
1284   CheckCXXThisCapture(Loc);
1285   return new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit=*/false);
1286 }
1287 
1288 bool Sema::isThisOutsideMemberFunctionBody(QualType BaseType) {
1289   // If we're outside the body of a member function, then we'll have a specified
1290   // type for 'this'.
1291   if (CXXThisTypeOverride.isNull())
1292     return false;
1293 
1294   // Determine whether we're looking into a class that's currently being
1295   // defined.
1296   CXXRecordDecl *Class = BaseType->getAsCXXRecordDecl();
1297   return Class && Class->isBeingDefined();
1298 }
1299 
1300 /// Parse construction of a specified type.
1301 /// Can be interpreted either as function-style casting ("int(x)")
1302 /// or class type construction ("ClassType(x,y,z)")
1303 /// or creation of a value-initialized type ("int()").
1304 ExprResult
1305 Sema::ActOnCXXTypeConstructExpr(ParsedType TypeRep,
1306                                 SourceLocation LParenOrBraceLoc,
1307                                 MultiExprArg exprs,
1308                                 SourceLocation RParenOrBraceLoc,
1309                                 bool ListInitialization) {
1310   if (!TypeRep)
1311     return ExprError();
1312 
1313   TypeSourceInfo *TInfo;
1314   QualType Ty = GetTypeFromParser(TypeRep, &TInfo);
1315   if (!TInfo)
1316     TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation());
1317 
1318   auto Result = BuildCXXTypeConstructExpr(TInfo, LParenOrBraceLoc, exprs,
1319                                           RParenOrBraceLoc, ListInitialization);
1320   // Avoid creating a non-type-dependent expression that contains typos.
1321   // Non-type-dependent expressions are liable to be discarded without
1322   // checking for embedded typos.
1323   if (!Result.isInvalid() && Result.get()->isInstantiationDependent() &&
1324       !Result.get()->isTypeDependent())
1325     Result = CorrectDelayedTyposInExpr(Result.get());
1326   return Result;
1327 }
1328 
1329 ExprResult
1330 Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,
1331                                 SourceLocation LParenOrBraceLoc,
1332                                 MultiExprArg Exprs,
1333                                 SourceLocation RParenOrBraceLoc,
1334                                 bool ListInitialization) {
1335   QualType Ty = TInfo->getType();
1336   SourceLocation TyBeginLoc = TInfo->getTypeLoc().getBeginLoc();
1337 
1338   if (Ty->isDependentType() || CallExpr::hasAnyTypeDependentArguments(Exprs)) {
1339     // FIXME: CXXUnresolvedConstructExpr does not model list-initialization
1340     // directly. We work around this by dropping the locations of the braces.
1341     SourceRange Locs = ListInitialization
1342                            ? SourceRange()
1343                            : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1344     return CXXUnresolvedConstructExpr::Create(Context, TInfo, Locs.getBegin(),
1345                                               Exprs, Locs.getEnd());
1346   }
1347 
1348   assert((!ListInitialization ||
1349           (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0]))) &&
1350          "List initialization must have initializer list as expression.");
1351   SourceRange FullRange = SourceRange(TyBeginLoc, RParenOrBraceLoc);
1352 
1353   InitializedEntity Entity = InitializedEntity::InitializeTemporary(TInfo);
1354   InitializationKind Kind =
1355       Exprs.size()
1356           ? ListInitialization
1357                 ? InitializationKind::CreateDirectList(
1358                       TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)
1359                 : InitializationKind::CreateDirect(TyBeginLoc, LParenOrBraceLoc,
1360                                                    RParenOrBraceLoc)
1361           : InitializationKind::CreateValue(TyBeginLoc, LParenOrBraceLoc,
1362                                             RParenOrBraceLoc);
1363 
1364   // C++1z [expr.type.conv]p1:
1365   //   If the type is a placeholder for a deduced class type, [...perform class
1366   //   template argument deduction...]
1367   DeducedType *Deduced = Ty->getContainedDeducedType();
1368   if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1369     Ty = DeduceTemplateSpecializationFromInitializer(TInfo, Entity,
1370                                                      Kind, Exprs);
1371     if (Ty.isNull())
1372       return ExprError();
1373     Entity = InitializedEntity::InitializeTemporary(TInfo, Ty);
1374   }
1375 
1376   // C++ [expr.type.conv]p1:
1377   // If the expression list is a parenthesized single expression, the type
1378   // conversion expression is equivalent (in definedness, and if defined in
1379   // meaning) to the corresponding cast expression.
1380   if (Exprs.size() == 1 && !ListInitialization &&
1381       !isa<InitListExpr>(Exprs[0])) {
1382     Expr *Arg = Exprs[0];
1383     return BuildCXXFunctionalCastExpr(TInfo, Ty, LParenOrBraceLoc, Arg,
1384                                       RParenOrBraceLoc);
1385   }
1386 
1387   //   For an expression of the form T(), T shall not be an array type.
1388   QualType ElemTy = Ty;
1389   if (Ty->isArrayType()) {
1390     if (!ListInitialization)
1391       return ExprError(Diag(TyBeginLoc, diag::err_value_init_for_array_type)
1392                          << FullRange);
1393     ElemTy = Context.getBaseElementType(Ty);
1394   }
1395 
1396   // There doesn't seem to be an explicit rule against this but sanity demands
1397   // we only construct objects with object types.
1398   if (Ty->isFunctionType())
1399     return ExprError(Diag(TyBeginLoc, diag::err_init_for_function_type)
1400                        << Ty << FullRange);
1401 
1402   // C++17 [expr.type.conv]p2:
1403   //   If the type is cv void and the initializer is (), the expression is a
1404   //   prvalue of the specified type that performs no initialization.
1405   if (!Ty->isVoidType() &&
1406       RequireCompleteType(TyBeginLoc, ElemTy,
1407                           diag::err_invalid_incomplete_type_use, FullRange))
1408     return ExprError();
1409 
1410   //   Otherwise, the expression is a prvalue of the specified type whose
1411   //   result object is direct-initialized (11.6) with the initializer.
1412   InitializationSequence InitSeq(*this, Entity, Kind, Exprs);
1413   ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Exprs);
1414 
1415   if (Result.isInvalid())
1416     return Result;
1417 
1418   Expr *Inner = Result.get();
1419   if (CXXBindTemporaryExpr *BTE = dyn_cast_or_null<CXXBindTemporaryExpr>(Inner))
1420     Inner = BTE->getSubExpr();
1421   if (!isa<CXXTemporaryObjectExpr>(Inner) &&
1422       !isa<CXXScalarValueInitExpr>(Inner)) {
1423     // If we created a CXXTemporaryObjectExpr, that node also represents the
1424     // functional cast. Otherwise, create an explicit cast to represent
1425     // the syntactic form of a functional-style cast that was used here.
1426     //
1427     // FIXME: Creating a CXXFunctionalCastExpr around a CXXConstructExpr
1428     // would give a more consistent AST representation than using a
1429     // CXXTemporaryObjectExpr. It's also weird that the functional cast
1430     // is sometimes handled by initialization and sometimes not.
1431     QualType ResultType = Result.get()->getType();
1432     SourceRange Locs = ListInitialization
1433                            ? SourceRange()
1434                            : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1435     Result = CXXFunctionalCastExpr::Create(
1436         Context, ResultType, Expr::getValueKindForType(Ty), TInfo, CK_NoOp,
1437         Result.get(), /*Path=*/nullptr, Locs.getBegin(), Locs.getEnd());
1438   }
1439 
1440   return Result;
1441 }
1442 
1443 /// Determine whether the given function is a non-placement
1444 /// deallocation function.
1445 static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
1446   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
1447     return Method->isUsualDeallocationFunction();
1448 
1449   if (FD->getOverloadedOperator() != OO_Delete &&
1450       FD->getOverloadedOperator() != OO_Array_Delete)
1451     return false;
1452 
1453   unsigned UsualParams = 1;
1454 
1455   if (S.getLangOpts().SizedDeallocation && UsualParams < FD->getNumParams() &&
1456       S.Context.hasSameUnqualifiedType(
1457           FD->getParamDecl(UsualParams)->getType(),
1458           S.Context.getSizeType()))
1459     ++UsualParams;
1460 
1461   if (S.getLangOpts().AlignedAllocation && UsualParams < FD->getNumParams() &&
1462       S.Context.hasSameUnqualifiedType(
1463           FD->getParamDecl(UsualParams)->getType(),
1464           S.Context.getTypeDeclType(S.getStdAlignValT())))
1465     ++UsualParams;
1466 
1467   return UsualParams == FD->getNumParams();
1468 }
1469 
1470 namespace {
1471   struct UsualDeallocFnInfo {
1472     UsualDeallocFnInfo() : Found(), FD(nullptr) {}
1473     UsualDeallocFnInfo(Sema &S, DeclAccessPair Found)
1474         : Found(Found), FD(dyn_cast<FunctionDecl>(Found->getUnderlyingDecl())),
1475           Destroying(false), HasSizeT(false), HasAlignValT(false),
1476           CUDAPref(Sema::CFP_Native) {
1477       // A function template declaration is never a usual deallocation function.
1478       if (!FD)
1479         return;
1480       unsigned NumBaseParams = 1;
1481       if (FD->isDestroyingOperatorDelete()) {
1482         Destroying = true;
1483         ++NumBaseParams;
1484       }
1485       if (FD->getNumParams() == NumBaseParams + 2)
1486         HasAlignValT = HasSizeT = true;
1487       else if (FD->getNumParams() == NumBaseParams + 1) {
1488         HasSizeT = FD->getParamDecl(NumBaseParams)->getType()->isIntegerType();
1489         HasAlignValT = !HasSizeT;
1490       }
1491 
1492       // In CUDA, determine how much we'd like / dislike to call this.
1493       if (S.getLangOpts().CUDA)
1494         if (auto *Caller = dyn_cast<FunctionDecl>(S.CurContext))
1495           CUDAPref = S.IdentifyCUDAPreference(Caller, FD);
1496     }
1497 
1498     explicit operator bool() const { return FD; }
1499 
1500     bool isBetterThan(const UsualDeallocFnInfo &Other, bool WantSize,
1501                       bool WantAlign) const {
1502       // C++ P0722:
1503       //   A destroying operator delete is preferred over a non-destroying
1504       //   operator delete.
1505       if (Destroying != Other.Destroying)
1506         return Destroying;
1507 
1508       // C++17 [expr.delete]p10:
1509       //   If the type has new-extended alignment, a function with a parameter
1510       //   of type std::align_val_t is preferred; otherwise a function without
1511       //   such a parameter is preferred
1512       if (HasAlignValT != Other.HasAlignValT)
1513         return HasAlignValT == WantAlign;
1514 
1515       if (HasSizeT != Other.HasSizeT)
1516         return HasSizeT == WantSize;
1517 
1518       // Use CUDA call preference as a tiebreaker.
1519       return CUDAPref > Other.CUDAPref;
1520     }
1521 
1522     DeclAccessPair Found;
1523     FunctionDecl *FD;
1524     bool Destroying, HasSizeT, HasAlignValT;
1525     Sema::CUDAFunctionPreference CUDAPref;
1526   };
1527 }
1528 
1529 /// Determine whether a type has new-extended alignment. This may be called when
1530 /// the type is incomplete (for a delete-expression with an incomplete pointee
1531 /// type), in which case it will conservatively return false if the alignment is
1532 /// not known.
1533 static bool hasNewExtendedAlignment(Sema &S, QualType AllocType) {
1534   return S.getLangOpts().AlignedAllocation &&
1535          S.getASTContext().getTypeAlignIfKnown(AllocType) >
1536              S.getASTContext().getTargetInfo().getNewAlign();
1537 }
1538 
1539 /// Select the correct "usual" deallocation function to use from a selection of
1540 /// deallocation functions (either global or class-scope).
1541 static UsualDeallocFnInfo resolveDeallocationOverload(
1542     Sema &S, LookupResult &R, bool WantSize, bool WantAlign,
1543     llvm::SmallVectorImpl<UsualDeallocFnInfo> *BestFns = nullptr) {
1544   UsualDeallocFnInfo Best;
1545 
1546   for (auto I = R.begin(), E = R.end(); I != E; ++I) {
1547     UsualDeallocFnInfo Info(S, I.getPair());
1548     if (!Info || !isNonPlacementDeallocationFunction(S, Info.FD) ||
1549         Info.CUDAPref == Sema::CFP_Never)
1550       continue;
1551 
1552     if (!Best) {
1553       Best = Info;
1554       if (BestFns)
1555         BestFns->push_back(Info);
1556       continue;
1557     }
1558 
1559     if (Best.isBetterThan(Info, WantSize, WantAlign))
1560       continue;
1561 
1562     //   If more than one preferred function is found, all non-preferred
1563     //   functions are eliminated from further consideration.
1564     if (BestFns && Info.isBetterThan(Best, WantSize, WantAlign))
1565       BestFns->clear();
1566 
1567     Best = Info;
1568     if (BestFns)
1569       BestFns->push_back(Info);
1570   }
1571 
1572   return Best;
1573 }
1574 
1575 /// Determine whether a given type is a class for which 'delete[]' would call
1576 /// a member 'operator delete[]' with a 'size_t' parameter. This implies that
1577 /// we need to store the array size (even if the type is
1578 /// trivially-destructible).
1579 static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc,
1580                                          QualType allocType) {
1581   const RecordType *record =
1582     allocType->getBaseElementTypeUnsafe()->getAs<RecordType>();
1583   if (!record) return false;
1584 
1585   // Try to find an operator delete[] in class scope.
1586 
1587   DeclarationName deleteName =
1588     S.Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete);
1589   LookupResult ops(S, deleteName, loc, Sema::LookupOrdinaryName);
1590   S.LookupQualifiedName(ops, record->getDecl());
1591 
1592   // We're just doing this for information.
1593   ops.suppressDiagnostics();
1594 
1595   // Very likely: there's no operator delete[].
1596   if (ops.empty()) return false;
1597 
1598   // If it's ambiguous, it should be illegal to call operator delete[]
1599   // on this thing, so it doesn't matter if we allocate extra space or not.
1600   if (ops.isAmbiguous()) return false;
1601 
1602   // C++17 [expr.delete]p10:
1603   //   If the deallocation functions have class scope, the one without a
1604   //   parameter of type std::size_t is selected.
1605   auto Best = resolveDeallocationOverload(
1606       S, ops, /*WantSize*/false,
1607       /*WantAlign*/hasNewExtendedAlignment(S, allocType));
1608   return Best && Best.HasSizeT;
1609 }
1610 
1611 /// Parsed a C++ 'new' expression (C++ 5.3.4).
1612 ///
1613 /// E.g.:
1614 /// @code new (memory) int[size][4] @endcode
1615 /// or
1616 /// @code ::new Foo(23, "hello") @endcode
1617 ///
1618 /// \param StartLoc The first location of the expression.
1619 /// \param UseGlobal True if 'new' was prefixed with '::'.
1620 /// \param PlacementLParen Opening paren of the placement arguments.
1621 /// \param PlacementArgs Placement new arguments.
1622 /// \param PlacementRParen Closing paren of the placement arguments.
1623 /// \param TypeIdParens If the type is in parens, the source range.
1624 /// \param D The type to be allocated, as well as array dimensions.
1625 /// \param Initializer The initializing expression or initializer-list, or null
1626 ///   if there is none.
1627 ExprResult
1628 Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1629                   SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
1630                   SourceLocation PlacementRParen, SourceRange TypeIdParens,
1631                   Declarator &D, Expr *Initializer) {
1632   Expr *ArraySize = nullptr;
1633   // If the specified type is an array, unwrap it and save the expression.
1634   if (D.getNumTypeObjects() > 0 &&
1635       D.getTypeObject(0).Kind == DeclaratorChunk::Array) {
1636     DeclaratorChunk &Chunk = D.getTypeObject(0);
1637     if (D.getDeclSpec().hasAutoTypeSpec())
1638       return ExprError(Diag(Chunk.Loc, diag::err_new_array_of_auto)
1639         << D.getSourceRange());
1640     if (Chunk.Arr.hasStatic)
1641       return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
1642         << D.getSourceRange());
1643     if (!Chunk.Arr.NumElts)
1644       return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
1645         << D.getSourceRange());
1646 
1647     ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
1648     D.DropFirstTypeObject();
1649   }
1650 
1651   // Every dimension shall be of constant size.
1652   if (ArraySize) {
1653     for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) {
1654       if (D.getTypeObject(I).Kind != DeclaratorChunk::Array)
1655         break;
1656 
1657       DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr;
1658       if (Expr *NumElts = (Expr *)Array.NumElts) {
1659         if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
1660           if (getLangOpts().CPlusPlus14) {
1661 	    // C++1y [expr.new]p6: Every constant-expression in a noptr-new-declarator
1662 	    //   shall be a converted constant expression (5.19) of type std::size_t
1663 	    //   and shall evaluate to a strictly positive value.
1664             unsigned IntWidth = Context.getTargetInfo().getIntWidth();
1665             assert(IntWidth && "Builtin type of size 0?");
1666             llvm::APSInt Value(IntWidth);
1667             Array.NumElts
1668              = CheckConvertedConstantExpression(NumElts, Context.getSizeType(), Value,
1669                                                 CCEK_NewExpr)
1670                  .get();
1671           } else {
1672             Array.NumElts
1673               = VerifyIntegerConstantExpression(NumElts, nullptr,
1674                                                 diag::err_new_array_nonconst)
1675                   .get();
1676           }
1677           if (!Array.NumElts)
1678             return ExprError();
1679         }
1680       }
1681     }
1682   }
1683 
1684   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, /*Scope=*/nullptr);
1685   QualType AllocType = TInfo->getType();
1686   if (D.isInvalidType())
1687     return ExprError();
1688 
1689   SourceRange DirectInitRange;
1690   if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer))
1691     DirectInitRange = List->getSourceRange();
1692 
1693   return BuildCXXNew(SourceRange(StartLoc, D.getLocEnd()), UseGlobal,
1694                      PlacementLParen,
1695                      PlacementArgs,
1696                      PlacementRParen,
1697                      TypeIdParens,
1698                      AllocType,
1699                      TInfo,
1700                      ArraySize,
1701                      DirectInitRange,
1702                      Initializer);
1703 }
1704 
1705 static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style,
1706                                        Expr *Init) {
1707   if (!Init)
1708     return true;
1709   if (ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init))
1710     return PLE->getNumExprs() == 0;
1711   if (isa<ImplicitValueInitExpr>(Init))
1712     return true;
1713   else if (CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init))
1714     return !CCE->isListInitialization() &&
1715            CCE->getConstructor()->isDefaultConstructor();
1716   else if (Style == CXXNewExpr::ListInit) {
1717     assert(isa<InitListExpr>(Init) &&
1718            "Shouldn't create list CXXConstructExprs for arrays.");
1719     return true;
1720   }
1721   return false;
1722 }
1723 
1724 // Emit a diagnostic if an aligned allocation/deallocation function that is not
1725 // implemented in the standard library is selected.
1726 static void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD,
1727                                                  SourceLocation Loc, bool IsDelete,
1728                                                  Sema &S) {
1729   if (!S.getLangOpts().AlignedAllocationUnavailable)
1730     return;
1731 
1732   // Return if there is a definition.
1733   if (FD.isDefined())
1734     return;
1735 
1736   bool IsAligned = false;
1737   if (FD.isReplaceableGlobalAllocationFunction(&IsAligned) && IsAligned) {
1738     const llvm::Triple &T = S.getASTContext().getTargetInfo().getTriple();
1739     StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
1740         S.getASTContext().getTargetInfo().getPlatformName());
1741 
1742     S.Diag(Loc, diag::warn_aligned_allocation_unavailable)
1743          << IsDelete << FD.getType().getAsString() << OSName
1744          << alignedAllocMinVersion(T.getOS()).getAsString();
1745     S.Diag(Loc, diag::note_silence_unligned_allocation_unavailable);
1746   }
1747 }
1748 
1749 ExprResult
1750 Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
1751                   SourceLocation PlacementLParen,
1752                   MultiExprArg PlacementArgs,
1753                   SourceLocation PlacementRParen,
1754                   SourceRange TypeIdParens,
1755                   QualType AllocType,
1756                   TypeSourceInfo *AllocTypeInfo,
1757                   Expr *ArraySize,
1758                   SourceRange DirectInitRange,
1759                   Expr *Initializer) {
1760   SourceRange TypeRange = AllocTypeInfo->getTypeLoc().getSourceRange();
1761   SourceLocation StartLoc = Range.getBegin();
1762 
1763   CXXNewExpr::InitializationStyle initStyle;
1764   if (DirectInitRange.isValid()) {
1765     assert(Initializer && "Have parens but no initializer.");
1766     initStyle = CXXNewExpr::CallInit;
1767   } else if (Initializer && isa<InitListExpr>(Initializer))
1768     initStyle = CXXNewExpr::ListInit;
1769   else {
1770     assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
1771             isa<CXXConstructExpr>(Initializer)) &&
1772            "Initializer expression that cannot have been implicitly created.");
1773     initStyle = CXXNewExpr::NoInit;
1774   }
1775 
1776   Expr **Inits = &Initializer;
1777   unsigned NumInits = Initializer ? 1 : 0;
1778   if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
1779     assert(initStyle == CXXNewExpr::CallInit && "paren init for non-call init");
1780     Inits = List->getExprs();
1781     NumInits = List->getNumExprs();
1782   }
1783 
1784   // C++11 [expr.new]p15:
1785   //   A new-expression that creates an object of type T initializes that
1786   //   object as follows:
1787   InitializationKind Kind
1788   //     - If the new-initializer is omitted, the object is default-
1789   //       initialized (8.5); if no initialization is performed,
1790   //       the object has indeterminate value
1791     = initStyle == CXXNewExpr::NoInit
1792         ? InitializationKind::CreateDefault(TypeRange.getBegin())
1793   //     - Otherwise, the new-initializer is interpreted according to the
1794   //       initialization rules of 8.5 for direct-initialization.
1795         : initStyle == CXXNewExpr::ListInit
1796             ? InitializationKind::CreateDirectList(TypeRange.getBegin(),
1797                                                    Initializer->getLocStart(),
1798                                                    Initializer->getLocEnd())
1799             : InitializationKind::CreateDirect(TypeRange.getBegin(),
1800                                                DirectInitRange.getBegin(),
1801                                                DirectInitRange.getEnd());
1802 
1803   // C++11 [dcl.spec.auto]p6. Deduce the type which 'auto' stands in for.
1804   auto *Deduced = AllocType->getContainedDeducedType();
1805   if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
1806     if (ArraySize)
1807       return ExprError(Diag(ArraySize->getExprLoc(),
1808                             diag::err_deduced_class_template_compound_type)
1809                        << /*array*/ 2 << ArraySize->getSourceRange());
1810 
1811     InitializedEntity Entity
1812       = InitializedEntity::InitializeNew(StartLoc, AllocType);
1813     AllocType = DeduceTemplateSpecializationFromInitializer(
1814         AllocTypeInfo, Entity, Kind, MultiExprArg(Inits, NumInits));
1815     if (AllocType.isNull())
1816       return ExprError();
1817   } else if (Deduced) {
1818     bool Braced = (initStyle == CXXNewExpr::ListInit);
1819     if (NumInits == 1) {
1820       if (auto p = dyn_cast_or_null<InitListExpr>(Inits[0])) {
1821         Inits = p->getInits();
1822         NumInits = p->getNumInits();
1823         Braced = true;
1824       }
1825     }
1826 
1827     if (initStyle == CXXNewExpr::NoInit || NumInits == 0)
1828       return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
1829                        << AllocType << TypeRange);
1830     if (NumInits > 1) {
1831       Expr *FirstBad = Inits[1];
1832       return ExprError(Diag(FirstBad->getLocStart(),
1833                             diag::err_auto_new_ctor_multiple_expressions)
1834                        << AllocType << TypeRange);
1835     }
1836     if (Braced && !getLangOpts().CPlusPlus17)
1837       Diag(Initializer->getLocStart(), diag::ext_auto_new_list_init)
1838           << AllocType << TypeRange;
1839     Expr *Deduce = Inits[0];
1840     QualType DeducedType;
1841     if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedType) == DAR_Failed)
1842       return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
1843                        << AllocType << Deduce->getType()
1844                        << TypeRange << Deduce->getSourceRange());
1845     if (DeducedType.isNull())
1846       return ExprError();
1847     AllocType = DeducedType;
1848   }
1849 
1850   // Per C++0x [expr.new]p5, the type being constructed may be a
1851   // typedef of an array type.
1852   if (!ArraySize) {
1853     if (const ConstantArrayType *Array
1854                               = Context.getAsConstantArrayType(AllocType)) {
1855       ArraySize = IntegerLiteral::Create(Context, Array->getSize(),
1856                                          Context.getSizeType(),
1857                                          TypeRange.getEnd());
1858       AllocType = Array->getElementType();
1859     }
1860   }
1861 
1862   if (CheckAllocatedType(AllocType, TypeRange.getBegin(), TypeRange))
1863     return ExprError();
1864 
1865   if (initStyle == CXXNewExpr::ListInit &&
1866       isStdInitializerList(AllocType, nullptr)) {
1867     Diag(AllocTypeInfo->getTypeLoc().getBeginLoc(),
1868          diag::warn_dangling_std_initializer_list)
1869         << /*at end of FE*/0 << Inits[0]->getSourceRange();
1870   }
1871 
1872   // In ARC, infer 'retaining' for the allocated
1873   if (getLangOpts().ObjCAutoRefCount &&
1874       AllocType.getObjCLifetime() == Qualifiers::OCL_None &&
1875       AllocType->isObjCLifetimeType()) {
1876     AllocType = Context.getLifetimeQualifiedType(AllocType,
1877                                     AllocType->getObjCARCImplicitLifetime());
1878   }
1879 
1880   QualType ResultType = Context.getPointerType(AllocType);
1881 
1882   if (ArraySize && ArraySize->getType()->isNonOverloadPlaceholderType()) {
1883     ExprResult result = CheckPlaceholderExpr(ArraySize);
1884     if (result.isInvalid()) return ExprError();
1885     ArraySize = result.get();
1886   }
1887   // C++98 5.3.4p6: "The expression in a direct-new-declarator shall have
1888   //   integral or enumeration type with a non-negative value."
1889   // C++11 [expr.new]p6: The expression [...] shall be of integral or unscoped
1890   //   enumeration type, or a class type for which a single non-explicit
1891   //   conversion function to integral or unscoped enumeration type exists.
1892   // C++1y [expr.new]p6: The expression [...] is implicitly converted to
1893   //   std::size_t.
1894   llvm::Optional<uint64_t> KnownArraySize;
1895   if (ArraySize && !ArraySize->isTypeDependent()) {
1896     ExprResult ConvertedSize;
1897     if (getLangOpts().CPlusPlus14) {
1898       assert(Context.getTargetInfo().getIntWidth() && "Builtin type of size 0?");
1899 
1900       ConvertedSize = PerformImplicitConversion(ArraySize, Context.getSizeType(),
1901 						AA_Converting);
1902 
1903       if (!ConvertedSize.isInvalid() &&
1904           ArraySize->getType()->getAs<RecordType>())
1905         // Diagnose the compatibility of this conversion.
1906         Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
1907           << ArraySize->getType() << 0 << "'size_t'";
1908     } else {
1909       class SizeConvertDiagnoser : public ICEConvertDiagnoser {
1910       protected:
1911         Expr *ArraySize;
1912 
1913       public:
1914         SizeConvertDiagnoser(Expr *ArraySize)
1915             : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false, false, false),
1916               ArraySize(ArraySize) {}
1917 
1918         SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
1919                                              QualType T) override {
1920           return S.Diag(Loc, diag::err_array_size_not_integral)
1921                    << S.getLangOpts().CPlusPlus11 << T;
1922         }
1923 
1924         SemaDiagnosticBuilder diagnoseIncomplete(
1925             Sema &S, SourceLocation Loc, QualType T) override {
1926           return S.Diag(Loc, diag::err_array_size_incomplete_type)
1927                    << T << ArraySize->getSourceRange();
1928         }
1929 
1930         SemaDiagnosticBuilder diagnoseExplicitConv(
1931             Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
1932           return S.Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy;
1933         }
1934 
1935         SemaDiagnosticBuilder noteExplicitConv(
1936             Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
1937           return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1938                    << ConvTy->isEnumeralType() << ConvTy;
1939         }
1940 
1941         SemaDiagnosticBuilder diagnoseAmbiguous(
1942             Sema &S, SourceLocation Loc, QualType T) override {
1943           return S.Diag(Loc, diag::err_array_size_ambiguous_conversion) << T;
1944         }
1945 
1946         SemaDiagnosticBuilder noteAmbiguous(
1947             Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
1948           return S.Diag(Conv->getLocation(), diag::note_array_size_conversion)
1949                    << ConvTy->isEnumeralType() << ConvTy;
1950         }
1951 
1952         SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
1953                                                  QualType T,
1954                                                  QualType ConvTy) override {
1955           return S.Diag(Loc,
1956                         S.getLangOpts().CPlusPlus11
1957                           ? diag::warn_cxx98_compat_array_size_conversion
1958                           : diag::ext_array_size_conversion)
1959                    << T << ConvTy->isEnumeralType() << ConvTy;
1960         }
1961       } SizeDiagnoser(ArraySize);
1962 
1963       ConvertedSize = PerformContextualImplicitConversion(StartLoc, ArraySize,
1964                                                           SizeDiagnoser);
1965     }
1966     if (ConvertedSize.isInvalid())
1967       return ExprError();
1968 
1969     ArraySize = ConvertedSize.get();
1970     QualType SizeType = ArraySize->getType();
1971 
1972     if (!SizeType->isIntegralOrUnscopedEnumerationType())
1973       return ExprError();
1974 
1975     // C++98 [expr.new]p7:
1976     //   The expression in a direct-new-declarator shall have integral type
1977     //   with a non-negative value.
1978     //
1979     // Let's see if this is a constant < 0. If so, we reject it out of hand,
1980     // per CWG1464. Otherwise, if it's not a constant, we must have an
1981     // unparenthesized array type.
1982     if (!ArraySize->isValueDependent()) {
1983       llvm::APSInt Value;
1984       // We've already performed any required implicit conversion to integer or
1985       // unscoped enumeration type.
1986       // FIXME: Per CWG1464, we are required to check the value prior to
1987       // converting to size_t. This will never find a negative array size in
1988       // C++14 onwards, because Value is always unsigned here!
1989       if (ArraySize->isIntegerConstantExpr(Value, Context)) {
1990         if (Value.isSigned() && Value.isNegative()) {
1991           return ExprError(Diag(ArraySize->getLocStart(),
1992                                 diag::err_typecheck_negative_array_size)
1993                            << ArraySize->getSourceRange());
1994         }
1995 
1996         if (!AllocType->isDependentType()) {
1997           unsigned ActiveSizeBits =
1998             ConstantArrayType::getNumAddressingBits(Context, AllocType, Value);
1999           if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context))
2000             return ExprError(Diag(ArraySize->getLocStart(),
2001                                   diag::err_array_too_large)
2002                              << Value.toString(10)
2003                              << ArraySize->getSourceRange());
2004         }
2005 
2006         KnownArraySize = Value.getZExtValue();
2007       } else if (TypeIdParens.isValid()) {
2008         // Can't have dynamic array size when the type-id is in parentheses.
2009         Diag(ArraySize->getLocStart(), diag::ext_new_paren_array_nonconst)
2010           << ArraySize->getSourceRange()
2011           << FixItHint::CreateRemoval(TypeIdParens.getBegin())
2012           << FixItHint::CreateRemoval(TypeIdParens.getEnd());
2013 
2014         TypeIdParens = SourceRange();
2015       }
2016     }
2017 
2018     // Note that we do *not* convert the argument in any way.  It can
2019     // be signed, larger than size_t, whatever.
2020   }
2021 
2022   FunctionDecl *OperatorNew = nullptr;
2023   FunctionDecl *OperatorDelete = nullptr;
2024   unsigned Alignment =
2025       AllocType->isDependentType() ? 0 : Context.getTypeAlign(AllocType);
2026   unsigned NewAlignment = Context.getTargetInfo().getNewAlign();
2027   bool PassAlignment = getLangOpts().AlignedAllocation &&
2028                        Alignment > NewAlignment;
2029 
2030   AllocationFunctionScope Scope = UseGlobal ? AFS_Global : AFS_Both;
2031   if (!AllocType->isDependentType() &&
2032       !Expr::hasAnyTypeDependentArguments(PlacementArgs) &&
2033       FindAllocationFunctions(StartLoc,
2034                               SourceRange(PlacementLParen, PlacementRParen),
2035                               Scope, Scope, AllocType, ArraySize, PassAlignment,
2036                               PlacementArgs, OperatorNew, OperatorDelete))
2037     return ExprError();
2038 
2039   // If this is an array allocation, compute whether the usual array
2040   // deallocation function for the type has a size_t parameter.
2041   bool UsualArrayDeleteWantsSize = false;
2042   if (ArraySize && !AllocType->isDependentType())
2043     UsualArrayDeleteWantsSize =
2044         doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType);
2045 
2046   SmallVector<Expr *, 8> AllPlaceArgs;
2047   if (OperatorNew) {
2048     const FunctionProtoType *Proto =
2049         OperatorNew->getType()->getAs<FunctionProtoType>();
2050     VariadicCallType CallType = Proto->isVariadic() ? VariadicFunction
2051                                                     : VariadicDoesNotApply;
2052 
2053     // We've already converted the placement args, just fill in any default
2054     // arguments. Skip the first parameter because we don't have a corresponding
2055     // argument. Skip the second parameter too if we're passing in the
2056     // alignment; we've already filled it in.
2057     if (GatherArgumentsForCall(PlacementLParen, OperatorNew, Proto,
2058                                PassAlignment ? 2 : 1, PlacementArgs,
2059                                AllPlaceArgs, CallType))
2060       return ExprError();
2061 
2062     if (!AllPlaceArgs.empty())
2063       PlacementArgs = AllPlaceArgs;
2064 
2065     // FIXME: This is wrong: PlacementArgs misses out the first (size) argument.
2066     DiagnoseSentinelCalls(OperatorNew, PlacementLParen, PlacementArgs);
2067 
2068     // FIXME: Missing call to CheckFunctionCall or equivalent
2069 
2070     // Warn if the type is over-aligned and is being allocated by (unaligned)
2071     // global operator new.
2072     if (PlacementArgs.empty() && !PassAlignment &&
2073         (OperatorNew->isImplicit() ||
2074          (OperatorNew->getLocStart().isValid() &&
2075           getSourceManager().isInSystemHeader(OperatorNew->getLocStart())))) {
2076       if (Alignment > NewAlignment)
2077         Diag(StartLoc, diag::warn_overaligned_type)
2078             << AllocType
2079             << unsigned(Alignment / Context.getCharWidth())
2080             << unsigned(NewAlignment / Context.getCharWidth());
2081     }
2082   }
2083 
2084   // Array 'new' can't have any initializers except empty parentheses.
2085   // Initializer lists are also allowed, in C++11. Rely on the parser for the
2086   // dialect distinction.
2087   if (ArraySize && !isLegalArrayNewInitializer(initStyle, Initializer)) {
2088     SourceRange InitRange(Inits[0]->getLocStart(),
2089                           Inits[NumInits - 1]->getLocEnd());
2090     Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
2091     return ExprError();
2092   }
2093 
2094   // If we can perform the initialization, and we've not already done so,
2095   // do it now.
2096   if (!AllocType->isDependentType() &&
2097       !Expr::hasAnyTypeDependentArguments(
2098           llvm::makeArrayRef(Inits, NumInits))) {
2099     // The type we initialize is the complete type, including the array bound.
2100     QualType InitType;
2101     if (KnownArraySize)
2102       InitType = Context.getConstantArrayType(
2103           AllocType, llvm::APInt(Context.getTypeSize(Context.getSizeType()),
2104                                  *KnownArraySize),
2105           ArrayType::Normal, 0);
2106     else if (ArraySize)
2107       InitType =
2108           Context.getIncompleteArrayType(AllocType, ArrayType::Normal, 0);
2109     else
2110       InitType = AllocType;
2111 
2112     InitializedEntity Entity
2113       = InitializedEntity::InitializeNew(StartLoc, InitType);
2114     InitializationSequence InitSeq(*this, Entity, Kind,
2115                                    MultiExprArg(Inits, NumInits));
2116     ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
2117                                           MultiExprArg(Inits, NumInits));
2118     if (FullInit.isInvalid())
2119       return ExprError();
2120 
2121     // FullInit is our initializer; strip off CXXBindTemporaryExprs, because
2122     // we don't want the initialized object to be destructed.
2123     // FIXME: We should not create these in the first place.
2124     if (CXXBindTemporaryExpr *Binder =
2125             dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.get()))
2126       FullInit = Binder->getSubExpr();
2127 
2128     Initializer = FullInit.get();
2129   }
2130 
2131   // Mark the new and delete operators as referenced.
2132   if (OperatorNew) {
2133     if (DiagnoseUseOfDecl(OperatorNew, StartLoc))
2134       return ExprError();
2135     MarkFunctionReferenced(StartLoc, OperatorNew);
2136     diagnoseUnavailableAlignedAllocation(*OperatorNew, StartLoc, false, *this);
2137   }
2138   if (OperatorDelete) {
2139     if (DiagnoseUseOfDecl(OperatorDelete, StartLoc))
2140       return ExprError();
2141     MarkFunctionReferenced(StartLoc, OperatorDelete);
2142     diagnoseUnavailableAlignedAllocation(*OperatorDelete, StartLoc, true, *this);
2143   }
2144 
2145   // C++0x [expr.new]p17:
2146   //   If the new expression creates an array of objects of class type,
2147   //   access and ambiguity control are done for the destructor.
2148   QualType BaseAllocType = Context.getBaseElementType(AllocType);
2149   if (ArraySize && !BaseAllocType->isDependentType()) {
2150     if (const RecordType *BaseRecordType = BaseAllocType->getAs<RecordType>()) {
2151       if (CXXDestructorDecl *dtor = LookupDestructor(
2152               cast<CXXRecordDecl>(BaseRecordType->getDecl()))) {
2153         MarkFunctionReferenced(StartLoc, dtor);
2154         CheckDestructorAccess(StartLoc, dtor,
2155                               PDiag(diag::err_access_dtor)
2156                                 << BaseAllocType);
2157         if (DiagnoseUseOfDecl(dtor, StartLoc))
2158           return ExprError();
2159       }
2160     }
2161   }
2162 
2163   return new (Context)
2164       CXXNewExpr(Context, UseGlobal, OperatorNew, OperatorDelete, PassAlignment,
2165                  UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,
2166                  ArraySize, initStyle, Initializer, ResultType, AllocTypeInfo,
2167                  Range, DirectInitRange);
2168 }
2169 
2170 /// Checks that a type is suitable as the allocated type
2171 /// in a new-expression.
2172 bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
2173                               SourceRange R) {
2174   // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
2175   //   abstract class type or array thereof.
2176   if (AllocType->isFunctionType())
2177     return Diag(Loc, diag::err_bad_new_type)
2178       << AllocType << 0 << R;
2179   else if (AllocType->isReferenceType())
2180     return Diag(Loc, diag::err_bad_new_type)
2181       << AllocType << 1 << R;
2182   else if (!AllocType->isDependentType() &&
2183            RequireCompleteType(Loc, AllocType, diag::err_new_incomplete_type,R))
2184     return true;
2185   else if (RequireNonAbstractType(Loc, AllocType,
2186                                   diag::err_allocation_of_abstract_type))
2187     return true;
2188   else if (AllocType->isVariablyModifiedType())
2189     return Diag(Loc, diag::err_variably_modified_new_type)
2190              << AllocType;
2191   else if (AllocType.getAddressSpace() != LangAS::Default &&
2192            !getLangOpts().OpenCLCPlusPlus)
2193     return Diag(Loc, diag::err_address_space_qualified_new)
2194       << AllocType.getUnqualifiedType()
2195       << AllocType.getQualifiers().getAddressSpaceAttributePrintValue();
2196   else if (getLangOpts().ObjCAutoRefCount) {
2197     if (const ArrayType *AT = Context.getAsArrayType(AllocType)) {
2198       QualType BaseAllocType = Context.getBaseElementType(AT);
2199       if (BaseAllocType.getObjCLifetime() == Qualifiers::OCL_None &&
2200           BaseAllocType->isObjCLifetimeType())
2201         return Diag(Loc, diag::err_arc_new_array_without_ownership)
2202           << BaseAllocType;
2203     }
2204   }
2205 
2206   return false;
2207 }
2208 
2209 static bool resolveAllocationOverload(
2210     Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl<Expr *> &Args,
2211     bool &PassAlignment, FunctionDecl *&Operator,
2212     OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose) {
2213   OverloadCandidateSet Candidates(R.getNameLoc(),
2214                                   OverloadCandidateSet::CSK_Normal);
2215   for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
2216        Alloc != AllocEnd; ++Alloc) {
2217     // Even member operator new/delete are implicitly treated as
2218     // static, so don't use AddMemberCandidate.
2219     NamedDecl *D = (*Alloc)->getUnderlyingDecl();
2220 
2221     if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
2222       S.AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
2223                                      /*ExplicitTemplateArgs=*/nullptr, Args,
2224                                      Candidates,
2225                                      /*SuppressUserConversions=*/false);
2226       continue;
2227     }
2228 
2229     FunctionDecl *Fn = cast<FunctionDecl>(D);
2230     S.AddOverloadCandidate(Fn, Alloc.getPair(), Args, Candidates,
2231                            /*SuppressUserConversions=*/false);
2232   }
2233 
2234   // Do the resolution.
2235   OverloadCandidateSet::iterator Best;
2236   switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) {
2237   case OR_Success: {
2238     // Got one!
2239     FunctionDecl *FnDecl = Best->Function;
2240     if (S.CheckAllocationAccess(R.getNameLoc(), Range, R.getNamingClass(),
2241                                 Best->FoundDecl) == Sema::AR_inaccessible)
2242       return true;
2243 
2244     Operator = FnDecl;
2245     return false;
2246   }
2247 
2248   case OR_No_Viable_Function:
2249     // C++17 [expr.new]p13:
2250     //   If no matching function is found and the allocated object type has
2251     //   new-extended alignment, the alignment argument is removed from the
2252     //   argument list, and overload resolution is performed again.
2253     if (PassAlignment) {
2254       PassAlignment = false;
2255       AlignArg = Args[1];
2256       Args.erase(Args.begin() + 1);
2257       return resolveAllocationOverload(S, R, Range, Args, PassAlignment,
2258                                        Operator, &Candidates, AlignArg,
2259                                        Diagnose);
2260     }
2261 
2262     // MSVC will fall back on trying to find a matching global operator new
2263     // if operator new[] cannot be found.  Also, MSVC will leak by not
2264     // generating a call to operator delete or operator delete[], but we
2265     // will not replicate that bug.
2266     // FIXME: Find out how this interacts with the std::align_val_t fallback
2267     // once MSVC implements it.
2268     if (R.getLookupName().getCXXOverloadedOperator() == OO_Array_New &&
2269         S.Context.getLangOpts().MSVCCompat) {
2270       R.clear();
2271       R.setLookupName(S.Context.DeclarationNames.getCXXOperatorName(OO_New));
2272       S.LookupQualifiedName(R, S.Context.getTranslationUnitDecl());
2273       // FIXME: This will give bad diagnostics pointing at the wrong functions.
2274       return resolveAllocationOverload(S, R, Range, Args, PassAlignment,
2275                                        Operator, /*Candidates=*/nullptr,
2276                                        /*AlignArg=*/nullptr, Diagnose);
2277     }
2278 
2279     if (Diagnose) {
2280       S.Diag(R.getNameLoc(), diag::err_ovl_no_viable_function_in_call)
2281           << R.getLookupName() << Range;
2282 
2283       // If we have aligned candidates, only note the align_val_t candidates
2284       // from AlignedCandidates and the non-align_val_t candidates from
2285       // Candidates.
2286       if (AlignedCandidates) {
2287         auto IsAligned = [](OverloadCandidate &C) {
2288           return C.Function->getNumParams() > 1 &&
2289                  C.Function->getParamDecl(1)->getType()->isAlignValT();
2290         };
2291         auto IsUnaligned = [&](OverloadCandidate &C) { return !IsAligned(C); };
2292 
2293         // This was an overaligned allocation, so list the aligned candidates
2294         // first.
2295         Args.insert(Args.begin() + 1, AlignArg);
2296         AlignedCandidates->NoteCandidates(S, OCD_AllCandidates, Args, "",
2297                                           R.getNameLoc(), IsAligned);
2298         Args.erase(Args.begin() + 1);
2299         Candidates.NoteCandidates(S, OCD_AllCandidates, Args, "", R.getNameLoc(),
2300                                   IsUnaligned);
2301       } else {
2302         Candidates.NoteCandidates(S, OCD_AllCandidates, Args);
2303       }
2304     }
2305     return true;
2306 
2307   case OR_Ambiguous:
2308     if (Diagnose) {
2309       S.Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call)
2310           << R.getLookupName() << Range;
2311       Candidates.NoteCandidates(S, OCD_ViableCandidates, Args);
2312     }
2313     return true;
2314 
2315   case OR_Deleted: {
2316     if (Diagnose) {
2317       S.Diag(R.getNameLoc(), diag::err_ovl_deleted_call)
2318           << Best->Function->isDeleted() << R.getLookupName()
2319           << S.getDeletedOrUnavailableSuffix(Best->Function) << Range;
2320       Candidates.NoteCandidates(S, OCD_AllCandidates, Args);
2321     }
2322     return true;
2323   }
2324   }
2325   llvm_unreachable("Unreachable, bad result from BestViableFunction");
2326 }
2327 
2328 bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
2329                                    AllocationFunctionScope NewScope,
2330                                    AllocationFunctionScope DeleteScope,
2331                                    QualType AllocType, bool IsArray,
2332                                    bool &PassAlignment, MultiExprArg PlaceArgs,
2333                                    FunctionDecl *&OperatorNew,
2334                                    FunctionDecl *&OperatorDelete,
2335                                    bool Diagnose) {
2336   // --- Choosing an allocation function ---
2337   // C++ 5.3.4p8 - 14 & 18
2338   // 1) If looking in AFS_Global scope for allocation functions, only look in
2339   //    the global scope. Else, if AFS_Class, only look in the scope of the
2340   //    allocated class. If AFS_Both, look in both.
2341   // 2) If an array size is given, look for operator new[], else look for
2342   //   operator new.
2343   // 3) The first argument is always size_t. Append the arguments from the
2344   //   placement form.
2345 
2346   SmallVector<Expr*, 8> AllocArgs;
2347   AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
2348 
2349   // We don't care about the actual value of these arguments.
2350   // FIXME: Should the Sema create the expression and embed it in the syntax
2351   // tree? Or should the consumer just recalculate the value?
2352   // FIXME: Using a dummy value will interact poorly with attribute enable_if.
2353   IntegerLiteral Size(Context, llvm::APInt::getNullValue(
2354                       Context.getTargetInfo().getPointerWidth(0)),
2355                       Context.getSizeType(),
2356                       SourceLocation());
2357   AllocArgs.push_back(&Size);
2358 
2359   QualType AlignValT = Context.VoidTy;
2360   if (PassAlignment) {
2361     DeclareGlobalNewDelete();
2362     AlignValT = Context.getTypeDeclType(getStdAlignValT());
2363   }
2364   CXXScalarValueInitExpr Align(AlignValT, nullptr, SourceLocation());
2365   if (PassAlignment)
2366     AllocArgs.push_back(&Align);
2367 
2368   AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());
2369 
2370   // C++ [expr.new]p8:
2371   //   If the allocated type is a non-array type, the allocation
2372   //   function's name is operator new and the deallocation function's
2373   //   name is operator delete. If the allocated type is an array
2374   //   type, the allocation function's name is operator new[] and the
2375   //   deallocation function's name is operator delete[].
2376   DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
2377       IsArray ? OO_Array_New : OO_New);
2378 
2379   QualType AllocElemType = Context.getBaseElementType(AllocType);
2380 
2381   // Find the allocation function.
2382   {
2383     LookupResult R(*this, NewName, StartLoc, LookupOrdinaryName);
2384 
2385     // C++1z [expr.new]p9:
2386     //   If the new-expression begins with a unary :: operator, the allocation
2387     //   function's name is looked up in the global scope. Otherwise, if the
2388     //   allocated type is a class type T or array thereof, the allocation
2389     //   function's name is looked up in the scope of T.
2390     if (AllocElemType->isRecordType() && NewScope != AFS_Global)
2391       LookupQualifiedName(R, AllocElemType->getAsCXXRecordDecl());
2392 
2393     // We can see ambiguity here if the allocation function is found in
2394     // multiple base classes.
2395     if (R.isAmbiguous())
2396       return true;
2397 
2398     //   If this lookup fails to find the name, or if the allocated type is not
2399     //   a class type, the allocation function's name is looked up in the
2400     //   global scope.
2401     if (R.empty()) {
2402       if (NewScope == AFS_Class)
2403         return true;
2404 
2405       LookupQualifiedName(R, Context.getTranslationUnitDecl());
2406     }
2407 
2408     if (getLangOpts().OpenCLCPlusPlus && R.empty()) {
2409       Diag(StartLoc, diag::err_openclcxx_not_supported) << "default new";
2410       return true;
2411     }
2412 
2413     assert(!R.empty() && "implicitly declared allocation functions not found");
2414     assert(!R.isAmbiguous() && "global allocation functions are ambiguous");
2415 
2416     // We do our own custom access checks below.
2417     R.suppressDiagnostics();
2418 
2419     if (resolveAllocationOverload(*this, R, Range, AllocArgs, PassAlignment,
2420                                   OperatorNew, /*Candidates=*/nullptr,
2421                                   /*AlignArg=*/nullptr, Diagnose))
2422       return true;
2423   }
2424 
2425   // We don't need an operator delete if we're running under -fno-exceptions.
2426   if (!getLangOpts().Exceptions) {
2427     OperatorDelete = nullptr;
2428     return false;
2429   }
2430 
2431   // Note, the name of OperatorNew might have been changed from array to
2432   // non-array by resolveAllocationOverload.
2433   DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
2434       OperatorNew->getDeclName().getCXXOverloadedOperator() == OO_Array_New
2435           ? OO_Array_Delete
2436           : OO_Delete);
2437 
2438   // C++ [expr.new]p19:
2439   //
2440   //   If the new-expression begins with a unary :: operator, the
2441   //   deallocation function's name is looked up in the global
2442   //   scope. Otherwise, if the allocated type is a class type T or an
2443   //   array thereof, the deallocation function's name is looked up in
2444   //   the scope of T. If this lookup fails to find the name, or if
2445   //   the allocated type is not a class type or array thereof, the
2446   //   deallocation function's name is looked up in the global scope.
2447   LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName);
2448   if (AllocElemType->isRecordType() && DeleteScope != AFS_Global) {
2449     CXXRecordDecl *RD
2450       = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl());
2451     LookupQualifiedName(FoundDelete, RD);
2452   }
2453   if (FoundDelete.isAmbiguous())
2454     return true; // FIXME: clean up expressions?
2455 
2456   bool FoundGlobalDelete = FoundDelete.empty();
2457   if (FoundDelete.empty()) {
2458     if (DeleteScope == AFS_Class)
2459       return true;
2460 
2461     DeclareGlobalNewDelete();
2462     LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
2463   }
2464 
2465   FoundDelete.suppressDiagnostics();
2466 
2467   SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches;
2468 
2469   // Whether we're looking for a placement operator delete is dictated
2470   // by whether we selected a placement operator new, not by whether
2471   // we had explicit placement arguments.  This matters for things like
2472   //   struct A { void *operator new(size_t, int = 0); ... };
2473   //   A *a = new A()
2474   //
2475   // We don't have any definition for what a "placement allocation function"
2476   // is, but we assume it's any allocation function whose
2477   // parameter-declaration-clause is anything other than (size_t).
2478   //
2479   // FIXME: Should (size_t, std::align_val_t) also be considered non-placement?
2480   // This affects whether an exception from the constructor of an overaligned
2481   // type uses the sized or non-sized form of aligned operator delete.
2482   bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->param_size() != 1 ||
2483                         OperatorNew->isVariadic();
2484 
2485   if (isPlacementNew) {
2486     // C++ [expr.new]p20:
2487     //   A declaration of a placement deallocation function matches the
2488     //   declaration of a placement allocation function if it has the
2489     //   same number of parameters and, after parameter transformations
2490     //   (8.3.5), all parameter types except the first are
2491     //   identical. [...]
2492     //
2493     // To perform this comparison, we compute the function type that
2494     // the deallocation function should have, and use that type both
2495     // for template argument deduction and for comparison purposes.
2496     QualType ExpectedFunctionType;
2497     {
2498       const FunctionProtoType *Proto
2499         = OperatorNew->getType()->getAs<FunctionProtoType>();
2500 
2501       SmallVector<QualType, 4> ArgTypes;
2502       ArgTypes.push_back(Context.VoidPtrTy);
2503       for (unsigned I = 1, N = Proto->getNumParams(); I < N; ++I)
2504         ArgTypes.push_back(Proto->getParamType(I));
2505 
2506       FunctionProtoType::ExtProtoInfo EPI;
2507       // FIXME: This is not part of the standard's rule.
2508       EPI.Variadic = Proto->isVariadic();
2509 
2510       ExpectedFunctionType
2511         = Context.getFunctionType(Context.VoidTy, ArgTypes, EPI);
2512     }
2513 
2514     for (LookupResult::iterator D = FoundDelete.begin(),
2515                              DEnd = FoundDelete.end();
2516          D != DEnd; ++D) {
2517       FunctionDecl *Fn = nullptr;
2518       if (FunctionTemplateDecl *FnTmpl =
2519               dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
2520         // Perform template argument deduction to try to match the
2521         // expected function type.
2522         TemplateDeductionInfo Info(StartLoc);
2523         if (DeduceTemplateArguments(FnTmpl, nullptr, ExpectedFunctionType, Fn,
2524                                     Info))
2525           continue;
2526       } else
2527         Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
2528 
2529       if (Context.hasSameType(adjustCCAndNoReturn(Fn->getType(),
2530                                                   ExpectedFunctionType,
2531                                                   /*AdjustExcpetionSpec*/true),
2532                               ExpectedFunctionType))
2533         Matches.push_back(std::make_pair(D.getPair(), Fn));
2534     }
2535 
2536     if (getLangOpts().CUDA)
2537       EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches);
2538   } else {
2539     // C++1y [expr.new]p22:
2540     //   For a non-placement allocation function, the normal deallocation
2541     //   function lookup is used
2542     //
2543     // Per [expr.delete]p10, this lookup prefers a member operator delete
2544     // without a size_t argument, but prefers a non-member operator delete
2545     // with a size_t where possible (which it always is in this case).
2546     llvm::SmallVector<UsualDeallocFnInfo, 4> BestDeallocFns;
2547     UsualDeallocFnInfo Selected = resolveDeallocationOverload(
2548         *this, FoundDelete, /*WantSize*/ FoundGlobalDelete,
2549         /*WantAlign*/ hasNewExtendedAlignment(*this, AllocElemType),
2550         &BestDeallocFns);
2551     if (Selected)
2552       Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
2553     else {
2554       // If we failed to select an operator, all remaining functions are viable
2555       // but ambiguous.
2556       for (auto Fn : BestDeallocFns)
2557         Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
2558     }
2559   }
2560 
2561   // C++ [expr.new]p20:
2562   //   [...] If the lookup finds a single matching deallocation
2563   //   function, that function will be called; otherwise, no
2564   //   deallocation function will be called.
2565   if (Matches.size() == 1) {
2566     OperatorDelete = Matches[0].second;
2567 
2568     // C++1z [expr.new]p23:
2569     //   If the lookup finds a usual deallocation function (3.7.4.2)
2570     //   with a parameter of type std::size_t and that function, considered
2571     //   as a placement deallocation function, would have been
2572     //   selected as a match for the allocation function, the program
2573     //   is ill-formed.
2574     if (getLangOpts().CPlusPlus11 && isPlacementNew &&
2575         isNonPlacementDeallocationFunction(*this, OperatorDelete)) {
2576       UsualDeallocFnInfo Info(*this,
2577                               DeclAccessPair::make(OperatorDelete, AS_public));
2578       // Core issue, per mail to core reflector, 2016-10-09:
2579       //   If this is a member operator delete, and there is a corresponding
2580       //   non-sized member operator delete, this isn't /really/ a sized
2581       //   deallocation function, it just happens to have a size_t parameter.
2582       bool IsSizedDelete = Info.HasSizeT;
2583       if (IsSizedDelete && !FoundGlobalDelete) {
2584         auto NonSizedDelete =
2585             resolveDeallocationOverload(*this, FoundDelete, /*WantSize*/false,
2586                                         /*WantAlign*/Info.HasAlignValT);
2587         if (NonSizedDelete && !NonSizedDelete.HasSizeT &&
2588             NonSizedDelete.HasAlignValT == Info.HasAlignValT)
2589           IsSizedDelete = false;
2590       }
2591 
2592       if (IsSizedDelete) {
2593         SourceRange R = PlaceArgs.empty()
2594                             ? SourceRange()
2595                             : SourceRange(PlaceArgs.front()->getLocStart(),
2596                                           PlaceArgs.back()->getLocEnd());
2597         Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
2598         if (!OperatorDelete->isImplicit())
2599           Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
2600               << DeleteName;
2601       }
2602     }
2603 
2604     CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
2605                           Matches[0].first);
2606   } else if (!Matches.empty()) {
2607     // We found multiple suitable operators. Per [expr.new]p20, that means we
2608     // call no 'operator delete' function, but we should at least warn the user.
2609     // FIXME: Suppress this warning if the construction cannot throw.
2610     Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
2611       << DeleteName << AllocElemType;
2612 
2613     for (auto &Match : Matches)
2614       Diag(Match.second->getLocation(),
2615            diag::note_member_declared_here) << DeleteName;
2616   }
2617 
2618   return false;
2619 }
2620 
2621 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
2622 /// delete. These are:
2623 /// @code
2624 ///   // C++03:
2625 ///   void* operator new(std::size_t) throw(std::bad_alloc);
2626 ///   void* operator new[](std::size_t) throw(std::bad_alloc);
2627 ///   void operator delete(void *) throw();
2628 ///   void operator delete[](void *) throw();
2629 ///   // C++11:
2630 ///   void* operator new(std::size_t);
2631 ///   void* operator new[](std::size_t);
2632 ///   void operator delete(void *) noexcept;
2633 ///   void operator delete[](void *) noexcept;
2634 ///   // C++1y:
2635 ///   void* operator new(std::size_t);
2636 ///   void* operator new[](std::size_t);
2637 ///   void operator delete(void *) noexcept;
2638 ///   void operator delete[](void *) noexcept;
2639 ///   void operator delete(void *, std::size_t) noexcept;
2640 ///   void operator delete[](void *, std::size_t) noexcept;
2641 /// @endcode
2642 /// Note that the placement and nothrow forms of new are *not* implicitly
2643 /// declared. Their use requires including \<new\>.
2644 void Sema::DeclareGlobalNewDelete() {
2645   if (GlobalNewDeleteDeclared)
2646     return;
2647 
2648   // OpenCL C++ 1.0 s2.9: the implicitly declared new and delete operators
2649   // are not supported.
2650   if (getLangOpts().OpenCLCPlusPlus)
2651     return;
2652 
2653   // C++ [basic.std.dynamic]p2:
2654   //   [...] The following allocation and deallocation functions (18.4) are
2655   //   implicitly declared in global scope in each translation unit of a
2656   //   program
2657   //
2658   //     C++03:
2659   //     void* operator new(std::size_t) throw(std::bad_alloc);
2660   //     void* operator new[](std::size_t) throw(std::bad_alloc);
2661   //     void  operator delete(void*) throw();
2662   //     void  operator delete[](void*) throw();
2663   //     C++11:
2664   //     void* operator new(std::size_t);
2665   //     void* operator new[](std::size_t);
2666   //     void  operator delete(void*) noexcept;
2667   //     void  operator delete[](void*) noexcept;
2668   //     C++1y:
2669   //     void* operator new(std::size_t);
2670   //     void* operator new[](std::size_t);
2671   //     void  operator delete(void*) noexcept;
2672   //     void  operator delete[](void*) noexcept;
2673   //     void  operator delete(void*, std::size_t) noexcept;
2674   //     void  operator delete[](void*, std::size_t) noexcept;
2675   //
2676   //   These implicit declarations introduce only the function names operator
2677   //   new, operator new[], operator delete, operator delete[].
2678   //
2679   // Here, we need to refer to std::bad_alloc, so we will implicitly declare
2680   // "std" or "bad_alloc" as necessary to form the exception specification.
2681   // However, we do not make these implicit declarations visible to name
2682   // lookup.
2683   if (!StdBadAlloc && !getLangOpts().CPlusPlus11) {
2684     // The "std::bad_alloc" class has not yet been declared, so build it
2685     // implicitly.
2686     StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class,
2687                                         getOrCreateStdNamespace(),
2688                                         SourceLocation(), SourceLocation(),
2689                                       &PP.getIdentifierTable().get("bad_alloc"),
2690                                         nullptr);
2691     getStdBadAlloc()->setImplicit(true);
2692   }
2693   if (!StdAlignValT && getLangOpts().AlignedAllocation) {
2694     // The "std::align_val_t" enum class has not yet been declared, so build it
2695     // implicitly.
2696     auto *AlignValT = EnumDecl::Create(
2697         Context, getOrCreateStdNamespace(), SourceLocation(), SourceLocation(),
2698         &PP.getIdentifierTable().get("align_val_t"), nullptr, true, true, true);
2699     AlignValT->setIntegerType(Context.getSizeType());
2700     AlignValT->setPromotionType(Context.getSizeType());
2701     AlignValT->setImplicit(true);
2702     StdAlignValT = AlignValT;
2703   }
2704 
2705   GlobalNewDeleteDeclared = true;
2706 
2707   QualType VoidPtr = Context.getPointerType(Context.VoidTy);
2708   QualType SizeT = Context.getSizeType();
2709 
2710   auto DeclareGlobalAllocationFunctions = [&](OverloadedOperatorKind Kind,
2711                                               QualType Return, QualType Param) {
2712     llvm::SmallVector<QualType, 3> Params;
2713     Params.push_back(Param);
2714 
2715     // Create up to four variants of the function (sized/aligned).
2716     bool HasSizedVariant = getLangOpts().SizedDeallocation &&
2717                            (Kind == OO_Delete || Kind == OO_Array_Delete);
2718     bool HasAlignedVariant = getLangOpts().AlignedAllocation;
2719 
2720     int NumSizeVariants = (HasSizedVariant ? 2 : 1);
2721     int NumAlignVariants = (HasAlignedVariant ? 2 : 1);
2722     for (int Sized = 0; Sized < NumSizeVariants; ++Sized) {
2723       if (Sized)
2724         Params.push_back(SizeT);
2725 
2726       for (int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {
2727         if (Aligned)
2728           Params.push_back(Context.getTypeDeclType(getStdAlignValT()));
2729 
2730         DeclareGlobalAllocationFunction(
2731             Context.DeclarationNames.getCXXOperatorName(Kind), Return, Params);
2732 
2733         if (Aligned)
2734           Params.pop_back();
2735       }
2736     }
2737   };
2738 
2739   DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT);
2740   DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT);
2741   DeclareGlobalAllocationFunctions(OO_Delete, Context.VoidTy, VoidPtr);
2742   DeclareGlobalAllocationFunctions(OO_Array_Delete, Context.VoidTy, VoidPtr);
2743 }
2744 
2745 /// DeclareGlobalAllocationFunction - Declares a single implicit global
2746 /// allocation function if it doesn't already exist.
2747 void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
2748                                            QualType Return,
2749                                            ArrayRef<QualType> Params) {
2750   DeclContext *GlobalCtx = Context.getTranslationUnitDecl();
2751 
2752   // Check if this function is already declared.
2753   DeclContext::lookup_result R = GlobalCtx->lookup(Name);
2754   for (DeclContext::lookup_iterator Alloc = R.begin(), AllocEnd = R.end();
2755        Alloc != AllocEnd; ++Alloc) {
2756     // Only look at non-template functions, as it is the predefined,
2757     // non-templated allocation function we are trying to declare here.
2758     if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
2759       if (Func->getNumParams() == Params.size()) {
2760         llvm::SmallVector<QualType, 3> FuncParams;
2761         for (auto *P : Func->parameters())
2762           FuncParams.push_back(
2763               Context.getCanonicalType(P->getType().getUnqualifiedType()));
2764         if (llvm::makeArrayRef(FuncParams) == Params) {
2765           // Make the function visible to name lookup, even if we found it in
2766           // an unimported module. It either is an implicitly-declared global
2767           // allocation function, or is suppressing that function.
2768           Func->setVisibleDespiteOwningModule();
2769           return;
2770         }
2771       }
2772     }
2773   }
2774 
2775   FunctionProtoType::ExtProtoInfo EPI;
2776 
2777   QualType BadAllocType;
2778   bool HasBadAllocExceptionSpec
2779     = (Name.getCXXOverloadedOperator() == OO_New ||
2780        Name.getCXXOverloadedOperator() == OO_Array_New);
2781   if (HasBadAllocExceptionSpec) {
2782     if (!getLangOpts().CPlusPlus11) {
2783       BadAllocType = Context.getTypeDeclType(getStdBadAlloc());
2784       assert(StdBadAlloc && "Must have std::bad_alloc declared");
2785       EPI.ExceptionSpec.Type = EST_Dynamic;
2786       EPI.ExceptionSpec.Exceptions = llvm::makeArrayRef(BadAllocType);
2787     }
2788   } else {
2789     EPI.ExceptionSpec =
2790         getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
2791   }
2792 
2793   auto CreateAllocationFunctionDecl = [&](Attr *ExtraAttr) {
2794     QualType FnType = Context.getFunctionType(Return, Params, EPI);
2795     FunctionDecl *Alloc = FunctionDecl::Create(
2796         Context, GlobalCtx, SourceLocation(), SourceLocation(), Name,
2797         FnType, /*TInfo=*/nullptr, SC_None, false, true);
2798     Alloc->setImplicit();
2799     // Global allocation functions should always be visible.
2800     Alloc->setVisibleDespiteOwningModule();
2801 
2802     // Implicit sized deallocation functions always have default visibility.
2803     Alloc->addAttr(
2804         VisibilityAttr::CreateImplicit(Context, VisibilityAttr::Default));
2805 
2806     llvm::SmallVector<ParmVarDecl *, 3> ParamDecls;
2807     for (QualType T : Params) {
2808       ParamDecls.push_back(ParmVarDecl::Create(
2809           Context, Alloc, SourceLocation(), SourceLocation(), nullptr, T,
2810           /*TInfo=*/nullptr, SC_None, nullptr));
2811       ParamDecls.back()->setImplicit();
2812     }
2813     Alloc->setParams(ParamDecls);
2814     if (ExtraAttr)
2815       Alloc->addAttr(ExtraAttr);
2816     Context.getTranslationUnitDecl()->addDecl(Alloc);
2817     IdResolver.tryAddTopLevelDecl(Alloc, Name);
2818   };
2819 
2820   if (!LangOpts.CUDA)
2821     CreateAllocationFunctionDecl(nullptr);
2822   else {
2823     // Host and device get their own declaration so each can be
2824     // defined or re-declared independently.
2825     CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(Context));
2826     CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(Context));
2827   }
2828 }
2829 
2830 FunctionDecl *Sema::FindUsualDeallocationFunction(SourceLocation StartLoc,
2831                                                   bool CanProvideSize,
2832                                                   bool Overaligned,
2833                                                   DeclarationName Name) {
2834   DeclareGlobalNewDelete();
2835 
2836   LookupResult FoundDelete(*this, Name, StartLoc, LookupOrdinaryName);
2837   LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
2838 
2839   // FIXME: It's possible for this to result in ambiguity, through a
2840   // user-declared variadic operator delete or the enable_if attribute. We
2841   // should probably not consider those cases to be usual deallocation
2842   // functions. But for now we just make an arbitrary choice in that case.
2843   auto Result = resolveDeallocationOverload(*this, FoundDelete, CanProvideSize,
2844                                             Overaligned);
2845   assert(Result.FD && "operator delete missing from global scope?");
2846   return Result.FD;
2847 }
2848 
2849 FunctionDecl *Sema::FindDeallocationFunctionForDestructor(SourceLocation Loc,
2850                                                           CXXRecordDecl *RD) {
2851   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Delete);
2852 
2853   FunctionDecl *OperatorDelete = nullptr;
2854   if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
2855     return nullptr;
2856   if (OperatorDelete)
2857     return OperatorDelete;
2858 
2859   // If there's no class-specific operator delete, look up the global
2860   // non-array delete.
2861   return FindUsualDeallocationFunction(
2862       Loc, true, hasNewExtendedAlignment(*this, Context.getRecordType(RD)),
2863       Name);
2864 }
2865 
2866 bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
2867                                     DeclarationName Name,
2868                                     FunctionDecl *&Operator, bool Diagnose) {
2869   LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
2870   // Try to find operator delete/operator delete[] in class scope.
2871   LookupQualifiedName(Found, RD);
2872 
2873   if (Found.isAmbiguous())
2874     return true;
2875 
2876   Found.suppressDiagnostics();
2877 
2878   bool Overaligned = hasNewExtendedAlignment(*this, Context.getRecordType(RD));
2879 
2880   // C++17 [expr.delete]p10:
2881   //   If the deallocation functions have class scope, the one without a
2882   //   parameter of type std::size_t is selected.
2883   llvm::SmallVector<UsualDeallocFnInfo, 4> Matches;
2884   resolveDeallocationOverload(*this, Found, /*WantSize*/ false,
2885                               /*WantAlign*/ Overaligned, &Matches);
2886 
2887   // If we could find an overload, use it.
2888   if (Matches.size() == 1) {
2889     Operator = cast<CXXMethodDecl>(Matches[0].FD);
2890 
2891     // FIXME: DiagnoseUseOfDecl?
2892     if (Operator->isDeleted()) {
2893       if (Diagnose) {
2894         Diag(StartLoc, diag::err_deleted_function_use);
2895         NoteDeletedFunction(Operator);
2896       }
2897       return true;
2898     }
2899 
2900     if (CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(),
2901                               Matches[0].Found, Diagnose) == AR_inaccessible)
2902       return true;
2903 
2904     return false;
2905   }
2906 
2907   // We found multiple suitable operators; complain about the ambiguity.
2908   // FIXME: The standard doesn't say to do this; it appears that the intent
2909   // is that this should never happen.
2910   if (!Matches.empty()) {
2911     if (Diagnose) {
2912       Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
2913         << Name << RD;
2914       for (auto &Match : Matches)
2915         Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name;
2916     }
2917     return true;
2918   }
2919 
2920   // We did find operator delete/operator delete[] declarations, but
2921   // none of them were suitable.
2922   if (!Found.empty()) {
2923     if (Diagnose) {
2924       Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
2925         << Name << RD;
2926 
2927       for (NamedDecl *D : Found)
2928         Diag(D->getUnderlyingDecl()->getLocation(),
2929              diag::note_member_declared_here) << Name;
2930     }
2931     return true;
2932   }
2933 
2934   Operator = nullptr;
2935   return false;
2936 }
2937 
2938 namespace {
2939 /// Checks whether delete-expression, and new-expression used for
2940 ///  initializing deletee have the same array form.
2941 class MismatchingNewDeleteDetector {
2942 public:
2943   enum MismatchResult {
2944     /// Indicates that there is no mismatch or a mismatch cannot be proven.
2945     NoMismatch,
2946     /// Indicates that variable is initialized with mismatching form of \a new.
2947     VarInitMismatches,
2948     /// Indicates that member is initialized with mismatching form of \a new.
2949     MemberInitMismatches,
2950     /// Indicates that 1 or more constructors' definitions could not been
2951     /// analyzed, and they will be checked again at the end of translation unit.
2952     AnalyzeLater
2953   };
2954 
2955   /// \param EndOfTU True, if this is the final analysis at the end of
2956   /// translation unit. False, if this is the initial analysis at the point
2957   /// delete-expression was encountered.
2958   explicit MismatchingNewDeleteDetector(bool EndOfTU)
2959       : Field(nullptr), IsArrayForm(false), EndOfTU(EndOfTU),
2960         HasUndefinedConstructors(false) {}
2961 
2962   /// Checks whether pointee of a delete-expression is initialized with
2963   /// matching form of new-expression.
2964   ///
2965   /// If return value is \c VarInitMismatches or \c MemberInitMismatches at the
2966   /// point where delete-expression is encountered, then a warning will be
2967   /// issued immediately. If return value is \c AnalyzeLater at the point where
2968   /// delete-expression is seen, then member will be analyzed at the end of
2969   /// translation unit. \c AnalyzeLater is returned iff at least one constructor
2970   /// couldn't be analyzed. If at least one constructor initializes the member
2971   /// with matching type of new, the return value is \c NoMismatch.
2972   MismatchResult analyzeDeleteExpr(const CXXDeleteExpr *DE);
2973   /// Analyzes a class member.
2974   /// \param Field Class member to analyze.
2975   /// \param DeleteWasArrayForm Array form-ness of the delete-expression used
2976   /// for deleting the \p Field.
2977   MismatchResult analyzeField(FieldDecl *Field, bool DeleteWasArrayForm);
2978   FieldDecl *Field;
2979   /// List of mismatching new-expressions used for initialization of the pointee
2980   llvm::SmallVector<const CXXNewExpr *, 4> NewExprs;
2981   /// Indicates whether delete-expression was in array form.
2982   bool IsArrayForm;
2983 
2984 private:
2985   const bool EndOfTU;
2986   /// Indicates that there is at least one constructor without body.
2987   bool HasUndefinedConstructors;
2988   /// Returns \c CXXNewExpr from given initialization expression.
2989   /// \param E Expression used for initializing pointee in delete-expression.
2990   /// E can be a single-element \c InitListExpr consisting of new-expression.
2991   const CXXNewExpr *getNewExprFromInitListOrExpr(const Expr *E);
2992   /// Returns whether member is initialized with mismatching form of
2993   /// \c new either by the member initializer or in-class initialization.
2994   ///
2995   /// If bodies of all constructors are not visible at the end of translation
2996   /// unit or at least one constructor initializes member with the matching
2997   /// form of \c new, mismatch cannot be proven, and this function will return
2998   /// \c NoMismatch.
2999   MismatchResult analyzeMemberExpr(const MemberExpr *ME);
3000   /// Returns whether variable is initialized with mismatching form of
3001   /// \c new.
3002   ///
3003   /// If variable is initialized with matching form of \c new or variable is not
3004   /// initialized with a \c new expression, this function will return true.
3005   /// If variable is initialized with mismatching form of \c new, returns false.
3006   /// \param D Variable to analyze.
3007   bool hasMatchingVarInit(const DeclRefExpr *D);
3008   /// Checks whether the constructor initializes pointee with mismatching
3009   /// form of \c new.
3010   ///
3011   /// Returns true, if member is initialized with matching form of \c new in
3012   /// member initializer list. Returns false, if member is initialized with the
3013   /// matching form of \c new in this constructor's initializer or given
3014   /// constructor isn't defined at the point where delete-expression is seen, or
3015   /// member isn't initialized by the constructor.
3016   bool hasMatchingNewInCtor(const CXXConstructorDecl *CD);
3017   /// Checks whether member is initialized with matching form of
3018   /// \c new in member initializer list.
3019   bool hasMatchingNewInCtorInit(const CXXCtorInitializer *CI);
3020   /// Checks whether member is initialized with mismatching form of \c new by
3021   /// in-class initializer.
3022   MismatchResult analyzeInClassInitializer();
3023 };
3024 }
3025 
3026 MismatchingNewDeleteDetector::MismatchResult
3027 MismatchingNewDeleteDetector::analyzeDeleteExpr(const CXXDeleteExpr *DE) {
3028   NewExprs.clear();
3029   assert(DE && "Expected delete-expression");
3030   IsArrayForm = DE->isArrayForm();
3031   const Expr *E = DE->getArgument()->IgnoreParenImpCasts();
3032   if (const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
3033     return analyzeMemberExpr(ME);
3034   } else if (const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
3035     if (!hasMatchingVarInit(D))
3036       return VarInitMismatches;
3037   }
3038   return NoMismatch;
3039 }
3040 
3041 const CXXNewExpr *
3042 MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(const Expr *E) {
3043   assert(E != nullptr && "Expected a valid initializer expression");
3044   E = E->IgnoreParenImpCasts();
3045   if (const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
3046     if (ILE->getNumInits() == 1)
3047       E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
3048   }
3049 
3050   return dyn_cast_or_null<const CXXNewExpr>(E);
3051 }
3052 
3053 bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
3054     const CXXCtorInitializer *CI) {
3055   const CXXNewExpr *NE = nullptr;
3056   if (Field == CI->getMember() &&
3057       (NE = getNewExprFromInitListOrExpr(CI->getInit()))) {
3058     if (NE->isArray() == IsArrayForm)
3059       return true;
3060     else
3061       NewExprs.push_back(NE);
3062   }
3063   return false;
3064 }
3065 
3066 bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
3067     const CXXConstructorDecl *CD) {
3068   if (CD->isImplicit())
3069     return false;
3070   const FunctionDecl *Definition = CD;
3071   if (!CD->isThisDeclarationADefinition() && !CD->isDefined(Definition)) {
3072     HasUndefinedConstructors = true;
3073     return EndOfTU;
3074   }
3075   for (const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) {
3076     if (hasMatchingNewInCtorInit(CI))
3077       return true;
3078   }
3079   return false;
3080 }
3081 
3082 MismatchingNewDeleteDetector::MismatchResult
3083 MismatchingNewDeleteDetector::analyzeInClassInitializer() {
3084   assert(Field != nullptr && "This should be called only for members");
3085   const Expr *InitExpr = Field->getInClassInitializer();
3086   if (!InitExpr)
3087     return EndOfTU ? NoMismatch : AnalyzeLater;
3088   if (const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
3089     if (NE->isArray() != IsArrayForm) {
3090       NewExprs.push_back(NE);
3091       return MemberInitMismatches;
3092     }
3093   }
3094   return NoMismatch;
3095 }
3096 
3097 MismatchingNewDeleteDetector::MismatchResult
3098 MismatchingNewDeleteDetector::analyzeField(FieldDecl *Field,
3099                                            bool DeleteWasArrayForm) {
3100   assert(Field != nullptr && "Analysis requires a valid class member.");
3101   this->Field = Field;
3102   IsArrayForm = DeleteWasArrayForm;
3103   const CXXRecordDecl *RD = cast<const CXXRecordDecl>(Field->getParent());
3104   for (const auto *CD : RD->ctors()) {
3105     if (hasMatchingNewInCtor(CD))
3106       return NoMismatch;
3107   }
3108   if (HasUndefinedConstructors)
3109     return EndOfTU ? NoMismatch : AnalyzeLater;
3110   if (!NewExprs.empty())
3111     return MemberInitMismatches;
3112   return Field->hasInClassInitializer() ? analyzeInClassInitializer()
3113                                         : NoMismatch;
3114 }
3115 
3116 MismatchingNewDeleteDetector::MismatchResult
3117 MismatchingNewDeleteDetector::analyzeMemberExpr(const MemberExpr *ME) {
3118   assert(ME != nullptr && "Expected a member expression");
3119   if (FieldDecl *F = dyn_cast<FieldDecl>(ME->getMemberDecl()))
3120     return analyzeField(F, IsArrayForm);
3121   return NoMismatch;
3122 }
3123 
3124 bool MismatchingNewDeleteDetector::hasMatchingVarInit(const DeclRefExpr *D) {
3125   const CXXNewExpr *NE = nullptr;
3126   if (const VarDecl *VD = dyn_cast<const VarDecl>(D->getDecl())) {
3127     if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
3128         NE->isArray() != IsArrayForm) {
3129       NewExprs.push_back(NE);
3130     }
3131   }
3132   return NewExprs.empty();
3133 }
3134 
3135 static void
3136 DiagnoseMismatchedNewDelete(Sema &SemaRef, SourceLocation DeleteLoc,
3137                             const MismatchingNewDeleteDetector &Detector) {
3138   SourceLocation EndOfDelete = SemaRef.getLocForEndOfToken(DeleteLoc);
3139   FixItHint H;
3140   if (!Detector.IsArrayForm)
3141     H = FixItHint::CreateInsertion(EndOfDelete, "[]");
3142   else {
3143     SourceLocation RSquare = Lexer::findLocationAfterToken(
3144         DeleteLoc, tok::l_square, SemaRef.getSourceManager(),
3145         SemaRef.getLangOpts(), true);
3146     if (RSquare.isValid())
3147       H = FixItHint::CreateRemoval(SourceRange(EndOfDelete, RSquare));
3148   }
3149   SemaRef.Diag(DeleteLoc, diag::warn_mismatched_delete_new)
3150       << Detector.IsArrayForm << H;
3151 
3152   for (const auto *NE : Detector.NewExprs)
3153     SemaRef.Diag(NE->getExprLoc(), diag::note_allocated_here)
3154         << Detector.IsArrayForm;
3155 }
3156 
3157 void Sema::AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE) {
3158   if (Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation()))
3159     return;
3160   MismatchingNewDeleteDetector Detector(/*EndOfTU=*/false);
3161   switch (Detector.analyzeDeleteExpr(DE)) {
3162   case MismatchingNewDeleteDetector::VarInitMismatches:
3163   case MismatchingNewDeleteDetector::MemberInitMismatches: {
3164     DiagnoseMismatchedNewDelete(*this, DE->getLocStart(), Detector);
3165     break;
3166   }
3167   case MismatchingNewDeleteDetector::AnalyzeLater: {
3168     DeleteExprs[Detector.Field].push_back(
3169         std::make_pair(DE->getLocStart(), DE->isArrayForm()));
3170     break;
3171   }
3172   case MismatchingNewDeleteDetector::NoMismatch:
3173     break;
3174   }
3175 }
3176 
3177 void Sema::AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
3178                                      bool DeleteWasArrayForm) {
3179   MismatchingNewDeleteDetector Detector(/*EndOfTU=*/true);
3180   switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
3181   case MismatchingNewDeleteDetector::VarInitMismatches:
3182     llvm_unreachable("This analysis should have been done for class members.");
3183   case MismatchingNewDeleteDetector::AnalyzeLater:
3184     llvm_unreachable("Analysis cannot be postponed any point beyond end of "
3185                      "translation unit.");
3186   case MismatchingNewDeleteDetector::MemberInitMismatches:
3187     DiagnoseMismatchedNewDelete(*this, DeleteLoc, Detector);
3188     break;
3189   case MismatchingNewDeleteDetector::NoMismatch:
3190     break;
3191   }
3192 }
3193 
3194 /// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
3195 /// @code ::delete ptr; @endcode
3196 /// or
3197 /// @code delete [] ptr; @endcode
3198 ExprResult
3199 Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
3200                      bool ArrayForm, Expr *ExE) {
3201   // C++ [expr.delete]p1:
3202   //   The operand shall have a pointer type, or a class type having a single
3203   //   non-explicit conversion function to a pointer type. The result has type
3204   //   void.
3205   //
3206   // DR599 amends "pointer type" to "pointer to object type" in both cases.
3207 
3208   ExprResult Ex = ExE;
3209   FunctionDecl *OperatorDelete = nullptr;
3210   bool ArrayFormAsWritten = ArrayForm;
3211   bool UsualArrayDeleteWantsSize = false;
3212 
3213   if (!Ex.get()->isTypeDependent()) {
3214     // Perform lvalue-to-rvalue cast, if needed.
3215     Ex = DefaultLvalueConversion(Ex.get());
3216     if (Ex.isInvalid())
3217       return ExprError();
3218 
3219     QualType Type = Ex.get()->getType();
3220 
3221     class DeleteConverter : public ContextualImplicitConverter {
3222     public:
3223       DeleteConverter() : ContextualImplicitConverter(false, true) {}
3224 
3225       bool match(QualType ConvType) override {
3226         // FIXME: If we have an operator T* and an operator void*, we must pick
3227         // the operator T*.
3228         if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
3229           if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
3230             return true;
3231         return false;
3232       }
3233 
3234       SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc,
3235                                             QualType T) override {
3236         return S.Diag(Loc, diag::err_delete_operand) << T;
3237       }
3238 
3239       SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
3240                                                QualType T) override {
3241         return S.Diag(Loc, diag::err_delete_incomplete_class_type) << T;
3242       }
3243 
3244       SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
3245                                                  QualType T,
3246                                                  QualType ConvTy) override {
3247         return S.Diag(Loc, diag::err_delete_explicit_conversion) << T << ConvTy;
3248       }
3249 
3250       SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
3251                                              QualType ConvTy) override {
3252         return S.Diag(Conv->getLocation(), diag::note_delete_conversion)
3253           << ConvTy;
3254       }
3255 
3256       SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
3257                                               QualType T) override {
3258         return S.Diag(Loc, diag::err_ambiguous_delete_operand) << T;
3259       }
3260 
3261       SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
3262                                           QualType ConvTy) override {
3263         return S.Diag(Conv->getLocation(), diag::note_delete_conversion)
3264           << ConvTy;
3265       }
3266 
3267       SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
3268                                                QualType T,
3269                                                QualType ConvTy) override {
3270         llvm_unreachable("conversion functions are permitted");
3271       }
3272     } Converter;
3273 
3274     Ex = PerformContextualImplicitConversion(StartLoc, Ex.get(), Converter);
3275     if (Ex.isInvalid())
3276       return ExprError();
3277     Type = Ex.get()->getType();
3278     if (!Converter.match(Type))
3279       // FIXME: PerformContextualImplicitConversion should return ExprError
3280       //        itself in this case.
3281       return ExprError();
3282 
3283     QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
3284     QualType PointeeElem = Context.getBaseElementType(Pointee);
3285 
3286     if (Pointee.getAddressSpace() != LangAS::Default &&
3287         !getLangOpts().OpenCLCPlusPlus)
3288       return Diag(Ex.get()->getLocStart(),
3289                   diag::err_address_space_qualified_delete)
3290                << Pointee.getUnqualifiedType()
3291                << Pointee.getQualifiers().getAddressSpaceAttributePrintValue();
3292 
3293     CXXRecordDecl *PointeeRD = nullptr;
3294     if (Pointee->isVoidType() && !isSFINAEContext()) {
3295       // The C++ standard bans deleting a pointer to a non-object type, which
3296       // effectively bans deletion of "void*". However, most compilers support
3297       // this, so we treat it as a warning unless we're in a SFINAE context.
3298       Diag(StartLoc, diag::ext_delete_void_ptr_operand)
3299         << Type << Ex.get()->getSourceRange();
3300     } else if (Pointee->isFunctionType() || Pointee->isVoidType()) {
3301       return ExprError(Diag(StartLoc, diag::err_delete_operand)
3302         << Type << Ex.get()->getSourceRange());
3303     } else if (!Pointee->isDependentType()) {
3304       // FIXME: This can result in errors if the definition was imported from a
3305       // module but is hidden.
3306       if (!RequireCompleteType(StartLoc, Pointee,
3307                                diag::warn_delete_incomplete, Ex.get())) {
3308         if (const RecordType *RT = PointeeElem->getAs<RecordType>())
3309           PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
3310       }
3311     }
3312 
3313     if (Pointee->isArrayType() && !ArrayForm) {
3314       Diag(StartLoc, diag::warn_delete_array_type)
3315           << Type << Ex.get()->getSourceRange()
3316           << FixItHint::CreateInsertion(getLocForEndOfToken(StartLoc), "[]");
3317       ArrayForm = true;
3318     }
3319 
3320     DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
3321                                       ArrayForm ? OO_Array_Delete : OO_Delete);
3322 
3323     if (PointeeRD) {
3324       if (!UseGlobal &&
3325           FindDeallocationFunction(StartLoc, PointeeRD, DeleteName,
3326                                    OperatorDelete))
3327         return ExprError();
3328 
3329       // If we're allocating an array of records, check whether the
3330       // usual operator delete[] has a size_t parameter.
3331       if (ArrayForm) {
3332         // If the user specifically asked to use the global allocator,
3333         // we'll need to do the lookup into the class.
3334         if (UseGlobal)
3335           UsualArrayDeleteWantsSize =
3336             doesUsualArrayDeleteWantSize(*this, StartLoc, PointeeElem);
3337 
3338         // Otherwise, the usual operator delete[] should be the
3339         // function we just found.
3340         else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
3341           UsualArrayDeleteWantsSize =
3342             UsualDeallocFnInfo(*this,
3343                                DeclAccessPair::make(OperatorDelete, AS_public))
3344               .HasSizeT;
3345       }
3346 
3347       if (!PointeeRD->hasIrrelevantDestructor())
3348         if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
3349           MarkFunctionReferenced(StartLoc,
3350                                     const_cast<CXXDestructorDecl*>(Dtor));
3351           if (DiagnoseUseOfDecl(Dtor, StartLoc))
3352             return ExprError();
3353         }
3354 
3355       CheckVirtualDtorCall(PointeeRD->getDestructor(), StartLoc,
3356                            /*IsDelete=*/true, /*CallCanBeVirtual=*/true,
3357                            /*WarnOnNonAbstractTypes=*/!ArrayForm,
3358                            SourceLocation());
3359     }
3360 
3361     if (!OperatorDelete) {
3362       if (getLangOpts().OpenCLCPlusPlus) {
3363         Diag(StartLoc, diag::err_openclcxx_not_supported) << "default delete";
3364         return ExprError();
3365       }
3366 
3367       bool IsComplete = isCompleteType(StartLoc, Pointee);
3368       bool CanProvideSize =
3369           IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
3370                          Pointee.isDestructedType());
3371       bool Overaligned = hasNewExtendedAlignment(*this, Pointee);
3372 
3373       // Look for a global declaration.
3374       OperatorDelete = FindUsualDeallocationFunction(StartLoc, CanProvideSize,
3375                                                      Overaligned, DeleteName);
3376     }
3377 
3378     MarkFunctionReferenced(StartLoc, OperatorDelete);
3379 
3380     // Check access and ambiguity of destructor if we're going to call it.
3381     // Note that this is required even for a virtual delete.
3382     bool IsVirtualDelete = false;
3383     if (PointeeRD) {
3384       if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {
3385         CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor,
3386                               PDiag(diag::err_access_dtor) << PointeeElem);
3387         IsVirtualDelete = Dtor->isVirtual();
3388       }
3389     }
3390 
3391     diagnoseUnavailableAlignedAllocation(*OperatorDelete, StartLoc, true,
3392                                          *this);
3393 
3394     // Convert the operand to the type of the first parameter of operator
3395     // delete. This is only necessary if we selected a destroying operator
3396     // delete that we are going to call (non-virtually); converting to void*
3397     // is trivial and left to AST consumers to handle.
3398     QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
3399     if (!IsVirtualDelete && !ParamType->getPointeeType()->isVoidType()) {
3400       Qualifiers Qs = Pointee.getQualifiers();
3401       if (Qs.hasCVRQualifiers()) {
3402         // Qualifiers are irrelevant to this conversion; we're only looking
3403         // for access and ambiguity.
3404         Qs.removeCVRQualifiers();
3405         QualType Unqual = Context.getPointerType(
3406             Context.getQualifiedType(Pointee.getUnqualifiedType(), Qs));
3407         Ex = ImpCastExprToType(Ex.get(), Unqual, CK_NoOp);
3408       }
3409       Ex = PerformImplicitConversion(Ex.get(), ParamType, AA_Passing);
3410       if (Ex.isInvalid())
3411         return ExprError();
3412     }
3413   }
3414 
3415   CXXDeleteExpr *Result = new (Context) CXXDeleteExpr(
3416       Context.VoidTy, UseGlobal, ArrayForm, ArrayFormAsWritten,
3417       UsualArrayDeleteWantsSize, OperatorDelete, Ex.get(), StartLoc);
3418   AnalyzeDeleteExprMismatch(Result);
3419   return Result;
3420 }
3421 
3422 static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall,
3423                                             bool IsDelete,
3424                                             FunctionDecl *&Operator) {
3425 
3426   DeclarationName NewName = S.Context.DeclarationNames.getCXXOperatorName(
3427       IsDelete ? OO_Delete : OO_New);
3428 
3429   LookupResult R(S, NewName, TheCall->getLocStart(), Sema::LookupOrdinaryName);
3430   S.LookupQualifiedName(R, S.Context.getTranslationUnitDecl());
3431   assert(!R.empty() && "implicitly declared allocation functions not found");
3432   assert(!R.isAmbiguous() && "global allocation functions are ambiguous");
3433 
3434   // We do our own custom access checks below.
3435   R.suppressDiagnostics();
3436 
3437   SmallVector<Expr *, 8> Args(TheCall->arg_begin(), TheCall->arg_end());
3438   OverloadCandidateSet Candidates(R.getNameLoc(),
3439                                   OverloadCandidateSet::CSK_Normal);
3440   for (LookupResult::iterator FnOvl = R.begin(), FnOvlEnd = R.end();
3441        FnOvl != FnOvlEnd; ++FnOvl) {
3442     // Even member operator new/delete are implicitly treated as
3443     // static, so don't use AddMemberCandidate.
3444     NamedDecl *D = (*FnOvl)->getUnderlyingDecl();
3445 
3446     if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
3447       S.AddTemplateOverloadCandidate(FnTemplate, FnOvl.getPair(),
3448                                      /*ExplicitTemplateArgs=*/nullptr, Args,
3449                                      Candidates,
3450                                      /*SuppressUserConversions=*/false);
3451       continue;
3452     }
3453 
3454     FunctionDecl *Fn = cast<FunctionDecl>(D);
3455     S.AddOverloadCandidate(Fn, FnOvl.getPair(), Args, Candidates,
3456                            /*SuppressUserConversions=*/false);
3457   }
3458 
3459   SourceRange Range = TheCall->getSourceRange();
3460 
3461   // Do the resolution.
3462   OverloadCandidateSet::iterator Best;
3463   switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) {
3464   case OR_Success: {
3465     // Got one!
3466     FunctionDecl *FnDecl = Best->Function;
3467     assert(R.getNamingClass() == nullptr &&
3468            "class members should not be considered");
3469 
3470     if (!FnDecl->isReplaceableGlobalAllocationFunction()) {
3471       S.Diag(R.getNameLoc(), diag::err_builtin_operator_new_delete_not_usual)
3472           << (IsDelete ? 1 : 0) << Range;
3473       S.Diag(FnDecl->getLocation(), diag::note_non_usual_function_declared_here)
3474           << R.getLookupName() << FnDecl->getSourceRange();
3475       return true;
3476     }
3477 
3478     Operator = FnDecl;
3479     return false;
3480   }
3481 
3482   case OR_No_Viable_Function:
3483     S.Diag(R.getNameLoc(), diag::err_ovl_no_viable_function_in_call)
3484         << R.getLookupName() << Range;
3485     Candidates.NoteCandidates(S, OCD_AllCandidates, Args);
3486     return true;
3487 
3488   case OR_Ambiguous:
3489     S.Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call)
3490         << R.getLookupName() << Range;
3491     Candidates.NoteCandidates(S, OCD_ViableCandidates, Args);
3492     return true;
3493 
3494   case OR_Deleted: {
3495     S.Diag(R.getNameLoc(), diag::err_ovl_deleted_call)
3496         << Best->Function->isDeleted() << R.getLookupName()
3497         << S.getDeletedOrUnavailableSuffix(Best->Function) << Range;
3498     Candidates.NoteCandidates(S, OCD_AllCandidates, Args);
3499     return true;
3500   }
3501   }
3502   llvm_unreachable("Unreachable, bad result from BestViableFunction");
3503 }
3504 
3505 ExprResult
3506 Sema::SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult,
3507                                              bool IsDelete) {
3508   CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
3509   if (!getLangOpts().CPlusPlus) {
3510     Diag(TheCall->getExprLoc(), diag::err_builtin_requires_language)
3511         << (IsDelete ? "__builtin_operator_delete" : "__builtin_operator_new")
3512         << "C++";
3513     return ExprError();
3514   }
3515   // CodeGen assumes it can find the global new and delete to call,
3516   // so ensure that they are declared.
3517   DeclareGlobalNewDelete();
3518 
3519   FunctionDecl *OperatorNewOrDelete = nullptr;
3520   if (resolveBuiltinNewDeleteOverload(*this, TheCall, IsDelete,
3521                                       OperatorNewOrDelete))
3522     return ExprError();
3523   assert(OperatorNewOrDelete && "should be found");
3524 
3525   TheCall->setType(OperatorNewOrDelete->getReturnType());
3526   for (unsigned i = 0; i != TheCall->getNumArgs(); ++i) {
3527     QualType ParamTy = OperatorNewOrDelete->getParamDecl(i)->getType();
3528     InitializedEntity Entity =
3529         InitializedEntity::InitializeParameter(Context, ParamTy, false);
3530     ExprResult Arg = PerformCopyInitialization(
3531         Entity, TheCall->getArg(i)->getLocStart(), TheCall->getArg(i));
3532     if (Arg.isInvalid())
3533       return ExprError();
3534     TheCall->setArg(i, Arg.get());
3535   }
3536   auto Callee = dyn_cast<ImplicitCastExpr>(TheCall->getCallee());
3537   assert(Callee && Callee->getCastKind() == CK_BuiltinFnToFnPtr &&
3538          "Callee expected to be implicit cast to a builtin function pointer");
3539   Callee->setType(OperatorNewOrDelete->getType());
3540 
3541   return TheCallResult;
3542 }
3543 
3544 void Sema::CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,
3545                                 bool IsDelete, bool CallCanBeVirtual,
3546                                 bool WarnOnNonAbstractTypes,
3547                                 SourceLocation DtorLoc) {
3548   if (!dtor || dtor->isVirtual() || !CallCanBeVirtual || isUnevaluatedContext())
3549     return;
3550 
3551   // C++ [expr.delete]p3:
3552   //   In the first alternative (delete object), if the static type of the
3553   //   object to be deleted is different from its dynamic type, the static
3554   //   type shall be a base class of the dynamic type of the object to be
3555   //   deleted and the static type shall have a virtual destructor or the
3556   //   behavior is undefined.
3557   //
3558   const CXXRecordDecl *PointeeRD = dtor->getParent();
3559   // Note: a final class cannot be derived from, no issue there
3560   if (!PointeeRD->isPolymorphic() || PointeeRD->hasAttr<FinalAttr>())
3561     return;
3562 
3563   // If the superclass is in a system header, there's nothing that can be done.
3564   // The `delete` (where we emit the warning) can be in a system header,
3565   // what matters for this warning is where the deleted type is defined.
3566   if (getSourceManager().isInSystemHeader(PointeeRD->getLocation()))
3567     return;
3568 
3569   QualType ClassType = dtor->getThisType(Context)->getPointeeType();
3570   if (PointeeRD->isAbstract()) {
3571     // If the class is abstract, we warn by default, because we're
3572     // sure the code has undefined behavior.
3573     Diag(Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)
3574                                                            << ClassType;
3575   } else if (WarnOnNonAbstractTypes) {
3576     // Otherwise, if this is not an array delete, it's a bit suspect,
3577     // but not necessarily wrong.
3578     Diag(Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)
3579                                                   << ClassType;
3580   }
3581   if (!IsDelete) {
3582     std::string TypeStr;
3583     ClassType.getAsStringInternal(TypeStr, getPrintingPolicy());
3584     Diag(DtorLoc, diag::note_delete_non_virtual)
3585         << FixItHint::CreateInsertion(DtorLoc, TypeStr + "::");
3586   }
3587 }
3588 
3589 Sema::ConditionResult Sema::ActOnConditionVariable(Decl *ConditionVar,
3590                                                    SourceLocation StmtLoc,
3591                                                    ConditionKind CK) {
3592   ExprResult E =
3593       CheckConditionVariable(cast<VarDecl>(ConditionVar), StmtLoc, CK);
3594   if (E.isInvalid())
3595     return ConditionError();
3596   return ConditionResult(*this, ConditionVar, MakeFullExpr(E.get(), StmtLoc),
3597                          CK == ConditionKind::ConstexprIf);
3598 }
3599 
3600 /// Check the use of the given variable as a C++ condition in an if,
3601 /// while, do-while, or switch statement.
3602 ExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar,
3603                                         SourceLocation StmtLoc,
3604                                         ConditionKind CK) {
3605   if (ConditionVar->isInvalidDecl())
3606     return ExprError();
3607 
3608   QualType T = ConditionVar->getType();
3609 
3610   // C++ [stmt.select]p2:
3611   //   The declarator shall not specify a function or an array.
3612   if (T->isFunctionType())
3613     return ExprError(Diag(ConditionVar->getLocation(),
3614                           diag::err_invalid_use_of_function_type)
3615                        << ConditionVar->getSourceRange());
3616   else if (T->isArrayType())
3617     return ExprError(Diag(ConditionVar->getLocation(),
3618                           diag::err_invalid_use_of_array_type)
3619                      << ConditionVar->getSourceRange());
3620 
3621   ExprResult Condition = DeclRefExpr::Create(
3622       Context, NestedNameSpecifierLoc(), SourceLocation(), ConditionVar,
3623       /*enclosing*/ false, ConditionVar->getLocation(),
3624       ConditionVar->getType().getNonReferenceType(), VK_LValue);
3625 
3626   MarkDeclRefReferenced(cast<DeclRefExpr>(Condition.get()));
3627 
3628   switch (CK) {
3629   case ConditionKind::Boolean:
3630     return CheckBooleanCondition(StmtLoc, Condition.get());
3631 
3632   case ConditionKind::ConstexprIf:
3633     return CheckBooleanCondition(StmtLoc, Condition.get(), true);
3634 
3635   case ConditionKind::Switch:
3636     return CheckSwitchCondition(StmtLoc, Condition.get());
3637   }
3638 
3639   llvm_unreachable("unexpected condition kind");
3640 }
3641 
3642 /// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
3643 ExprResult Sema::CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr) {
3644   // C++ 6.4p4:
3645   // The value of a condition that is an initialized declaration in a statement
3646   // other than a switch statement is the value of the declared variable
3647   // implicitly converted to type bool. If that conversion is ill-formed, the
3648   // program is ill-formed.
3649   // The value of a condition that is an expression is the value of the
3650   // expression, implicitly converted to bool.
3651   //
3652   // FIXME: Return this value to the caller so they don't need to recompute it.
3653   llvm::APSInt Value(/*BitWidth*/1);
3654   return (IsConstexpr && !CondExpr->isValueDependent())
3655              ? CheckConvertedConstantExpression(CondExpr, Context.BoolTy, Value,
3656                                                 CCEK_ConstexprIf)
3657              : PerformContextuallyConvertToBool(CondExpr);
3658 }
3659 
3660 /// Helper function to determine whether this is the (deprecated) C++
3661 /// conversion from a string literal to a pointer to non-const char or
3662 /// non-const wchar_t (for narrow and wide string literals,
3663 /// respectively).
3664 bool
3665 Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
3666   // Look inside the implicit cast, if it exists.
3667   if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
3668     From = Cast->getSubExpr();
3669 
3670   // A string literal (2.13.4) that is not a wide string literal can
3671   // be converted to an rvalue of type "pointer to char"; a wide
3672   // string literal can be converted to an rvalue of type "pointer
3673   // to wchar_t" (C++ 4.2p2).
3674   if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens()))
3675     if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
3676       if (const BuiltinType *ToPointeeType
3677           = ToPtrType->getPointeeType()->getAs<BuiltinType>()) {
3678         // This conversion is considered only when there is an
3679         // explicit appropriate pointer target type (C++ 4.2p2).
3680         if (!ToPtrType->getPointeeType().hasQualifiers()) {
3681           switch (StrLit->getKind()) {
3682             case StringLiteral::UTF8:
3683             case StringLiteral::UTF16:
3684             case StringLiteral::UTF32:
3685               // We don't allow UTF literals to be implicitly converted
3686               break;
3687             case StringLiteral::Ascii:
3688               return (ToPointeeType->getKind() == BuiltinType::Char_U ||
3689                       ToPointeeType->getKind() == BuiltinType::Char_S);
3690             case StringLiteral::Wide:
3691               return Context.typesAreCompatible(Context.getWideCharType(),
3692                                                 QualType(ToPointeeType, 0));
3693           }
3694         }
3695       }
3696 
3697   return false;
3698 }
3699 
3700 static ExprResult BuildCXXCastArgument(Sema &S,
3701                                        SourceLocation CastLoc,
3702                                        QualType Ty,
3703                                        CastKind Kind,
3704                                        CXXMethodDecl *Method,
3705                                        DeclAccessPair FoundDecl,
3706                                        bool HadMultipleCandidates,
3707                                        Expr *From) {
3708   switch (Kind) {
3709   default: llvm_unreachable("Unhandled cast kind!");
3710   case CK_ConstructorConversion: {
3711     CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Method);
3712     SmallVector<Expr*, 8> ConstructorArgs;
3713 
3714     if (S.RequireNonAbstractType(CastLoc, Ty,
3715                                  diag::err_allocation_of_abstract_type))
3716       return ExprError();
3717 
3718     if (S.CompleteConstructorCall(Constructor, From, CastLoc, ConstructorArgs))
3719       return ExprError();
3720 
3721     S.CheckConstructorAccess(CastLoc, Constructor, FoundDecl,
3722                              InitializedEntity::InitializeTemporary(Ty));
3723     if (S.DiagnoseUseOfDecl(Method, CastLoc))
3724       return ExprError();
3725 
3726     ExprResult Result = S.BuildCXXConstructExpr(
3727         CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method),
3728         ConstructorArgs, HadMultipleCandidates,
3729         /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3730         CXXConstructExpr::CK_Complete, SourceRange());
3731     if (Result.isInvalid())
3732       return ExprError();
3733 
3734     return S.MaybeBindToTemporary(Result.getAs<Expr>());
3735   }
3736 
3737   case CK_UserDefinedConversion: {
3738     assert(!From->getType()->isPointerType() && "Arg can't have pointer type!");
3739 
3740     S.CheckMemberOperatorAccess(CastLoc, From, /*arg*/ nullptr, FoundDecl);
3741     if (S.DiagnoseUseOfDecl(Method, CastLoc))
3742       return ExprError();
3743 
3744     // Create an implicit call expr that calls it.
3745     CXXConversionDecl *Conv = cast<CXXConversionDecl>(Method);
3746     ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Conv,
3747                                                  HadMultipleCandidates);
3748     if (Result.isInvalid())
3749       return ExprError();
3750     // Record usage of conversion in an implicit cast.
3751     Result = ImplicitCastExpr::Create(S.Context, Result.get()->getType(),
3752                                       CK_UserDefinedConversion, Result.get(),
3753                                       nullptr, Result.get()->getValueKind());
3754 
3755     return S.MaybeBindToTemporary(Result.get());
3756   }
3757   }
3758 }
3759 
3760 /// PerformImplicitConversion - Perform an implicit conversion of the
3761 /// expression From to the type ToType using the pre-computed implicit
3762 /// conversion sequence ICS. Returns the converted
3763 /// expression. Action is the kind of conversion we're performing,
3764 /// used in the error message.
3765 ExprResult
3766 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
3767                                 const ImplicitConversionSequence &ICS,
3768                                 AssignmentAction Action,
3769                                 CheckedConversionKind CCK) {
3770   // C++ [over.match.oper]p7: [...] operands of class type are converted [...]
3771   if (CCK == CCK_ForBuiltinOverloadedOp && !From->getType()->isRecordType())
3772     return From;
3773 
3774   switch (ICS.getKind()) {
3775   case ImplicitConversionSequence::StandardConversion: {
3776     ExprResult Res = PerformImplicitConversion(From, ToType, ICS.Standard,
3777                                                Action, CCK);
3778     if (Res.isInvalid())
3779       return ExprError();
3780     From = Res.get();
3781     break;
3782   }
3783 
3784   case ImplicitConversionSequence::UserDefinedConversion: {
3785 
3786       FunctionDecl *FD = ICS.UserDefined.ConversionFunction;
3787       CastKind CastKind;
3788       QualType BeforeToType;
3789       assert(FD && "no conversion function for user-defined conversion seq");
3790       if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) {
3791         CastKind = CK_UserDefinedConversion;
3792 
3793         // If the user-defined conversion is specified by a conversion function,
3794         // the initial standard conversion sequence converts the source type to
3795         // the implicit object parameter of the conversion function.
3796         BeforeToType = Context.getTagDeclType(Conv->getParent());
3797       } else {
3798         const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD);
3799         CastKind = CK_ConstructorConversion;
3800         // Do no conversion if dealing with ... for the first conversion.
3801         if (!ICS.UserDefined.EllipsisConversion) {
3802           // If the user-defined conversion is specified by a constructor, the
3803           // initial standard conversion sequence converts the source type to
3804           // the type required by the argument of the constructor
3805           BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType();
3806         }
3807       }
3808       // Watch out for ellipsis conversion.
3809       if (!ICS.UserDefined.EllipsisConversion) {
3810         ExprResult Res =
3811           PerformImplicitConversion(From, BeforeToType,
3812                                     ICS.UserDefined.Before, AA_Converting,
3813                                     CCK);
3814         if (Res.isInvalid())
3815           return ExprError();
3816         From = Res.get();
3817       }
3818 
3819       ExprResult CastArg
3820         = BuildCXXCastArgument(*this,
3821                                From->getLocStart(),
3822                                ToType.getNonReferenceType(),
3823                                CastKind, cast<CXXMethodDecl>(FD),
3824                                ICS.UserDefined.FoundConversionFunction,
3825                                ICS.UserDefined.HadMultipleCandidates,
3826                                From);
3827 
3828       if (CastArg.isInvalid())
3829         return ExprError();
3830 
3831       From = CastArg.get();
3832 
3833       // C++ [over.match.oper]p7:
3834       //   [...] the second standard conversion sequence of a user-defined
3835       //   conversion sequence is not applied.
3836       if (CCK == CCK_ForBuiltinOverloadedOp)
3837         return From;
3838 
3839       return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
3840                                        AA_Converting, CCK);
3841   }
3842 
3843   case ImplicitConversionSequence::AmbiguousConversion:
3844     ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(),
3845                           PDiag(diag::err_typecheck_ambiguous_condition)
3846                             << From->getSourceRange());
3847      return ExprError();
3848 
3849   case ImplicitConversionSequence::EllipsisConversion:
3850     llvm_unreachable("Cannot perform an ellipsis conversion");
3851 
3852   case ImplicitConversionSequence::BadConversion:
3853     bool Diagnosed =
3854         DiagnoseAssignmentResult(Incompatible, From->getExprLoc(), ToType,
3855                                  From->getType(), From, Action);
3856     assert(Diagnosed && "failed to diagnose bad conversion"); (void)Diagnosed;
3857     return ExprError();
3858   }
3859 
3860   // Everything went well.
3861   return From;
3862 }
3863 
3864 /// PerformImplicitConversion - Perform an implicit conversion of the
3865 /// expression From to the type ToType by following the standard
3866 /// conversion sequence SCS. Returns the converted
3867 /// expression. Flavor is the context in which we're performing this
3868 /// conversion, for use in error messages.
3869 ExprResult
3870 Sema::PerformImplicitConversion(Expr *From, QualType ToType,
3871                                 const StandardConversionSequence& SCS,
3872                                 AssignmentAction Action,
3873                                 CheckedConversionKind CCK) {
3874   bool CStyle = (CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast);
3875 
3876   // Overall FIXME: we are recomputing too many types here and doing far too
3877   // much extra work. What this means is that we need to keep track of more
3878   // information that is computed when we try the implicit conversion initially,
3879   // so that we don't need to recompute anything here.
3880   QualType FromType = From->getType();
3881 
3882   if (SCS.CopyConstructor) {
3883     // FIXME: When can ToType be a reference type?
3884     assert(!ToType->isReferenceType());
3885     if (SCS.Second == ICK_Derived_To_Base) {
3886       SmallVector<Expr*, 8> ConstructorArgs;
3887       if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
3888                                   From, /*FIXME:ConstructLoc*/SourceLocation(),
3889                                   ConstructorArgs))
3890         return ExprError();
3891       return BuildCXXConstructExpr(
3892           /*FIXME:ConstructLoc*/ SourceLocation(), ToType,
3893           SCS.FoundCopyConstructor, SCS.CopyConstructor,
3894           ConstructorArgs, /*HadMultipleCandidates*/ false,
3895           /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3896           CXXConstructExpr::CK_Complete, SourceRange());
3897     }
3898     return BuildCXXConstructExpr(
3899         /*FIXME:ConstructLoc*/ SourceLocation(), ToType,
3900         SCS.FoundCopyConstructor, SCS.CopyConstructor,
3901         From, /*HadMultipleCandidates*/ false,
3902         /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
3903         CXXConstructExpr::CK_Complete, SourceRange());
3904   }
3905 
3906   // Resolve overloaded function references.
3907   if (Context.hasSameType(FromType, Context.OverloadTy)) {
3908     DeclAccessPair Found;
3909     FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType,
3910                                                           true, Found);
3911     if (!Fn)
3912       return ExprError();
3913 
3914     if (DiagnoseUseOfDecl(Fn, From->getLocStart()))
3915       return ExprError();
3916 
3917     From = FixOverloadedFunctionReference(From, Found, Fn);
3918     FromType = From->getType();
3919   }
3920 
3921   // If we're converting to an atomic type, first convert to the corresponding
3922   // non-atomic type.
3923   QualType ToAtomicType;
3924   if (const AtomicType *ToAtomic = ToType->getAs<AtomicType>()) {
3925     ToAtomicType = ToType;
3926     ToType = ToAtomic->getValueType();
3927   }
3928 
3929   QualType InitialFromType = FromType;
3930   // Perform the first implicit conversion.
3931   switch (SCS.First) {
3932   case ICK_Identity:
3933     if (const AtomicType *FromAtomic = FromType->getAs<AtomicType>()) {
3934       FromType = FromAtomic->getValueType().getUnqualifiedType();
3935       From = ImplicitCastExpr::Create(Context, FromType, CK_AtomicToNonAtomic,
3936                                       From, /*BasePath=*/nullptr, VK_RValue);
3937     }
3938     break;
3939 
3940   case ICK_Lvalue_To_Rvalue: {
3941     assert(From->getObjectKind() != OK_ObjCProperty);
3942     ExprResult FromRes = DefaultLvalueConversion(From);
3943     assert(!FromRes.isInvalid() && "Can't perform deduced conversion?!");
3944     From = FromRes.get();
3945     FromType = From->getType();
3946     break;
3947   }
3948 
3949   case ICK_Array_To_Pointer:
3950     FromType = Context.getArrayDecayedType(FromType);
3951     From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay,
3952                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
3953     break;
3954 
3955   case ICK_Function_To_Pointer:
3956     FromType = Context.getPointerType(FromType);
3957     From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay,
3958                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
3959     break;
3960 
3961   default:
3962     llvm_unreachable("Improper first standard conversion");
3963   }
3964 
3965   // Perform the second implicit conversion
3966   switch (SCS.Second) {
3967   case ICK_Identity:
3968     // C++ [except.spec]p5:
3969     //   [For] assignment to and initialization of pointers to functions,
3970     //   pointers to member functions, and references to functions: the
3971     //   target entity shall allow at least the exceptions allowed by the
3972     //   source value in the assignment or initialization.
3973     switch (Action) {
3974     case AA_Assigning:
3975     case AA_Initializing:
3976       // Note, function argument passing and returning are initialization.
3977     case AA_Passing:
3978     case AA_Returning:
3979     case AA_Sending:
3980     case AA_Passing_CFAudited:
3981       if (CheckExceptionSpecCompatibility(From, ToType))
3982         return ExprError();
3983       break;
3984 
3985     case AA_Casting:
3986     case AA_Converting:
3987       // Casts and implicit conversions are not initialization, so are not
3988       // checked for exception specification mismatches.
3989       break;
3990     }
3991     // Nothing else to do.
3992     break;
3993 
3994   case ICK_Integral_Promotion:
3995   case ICK_Integral_Conversion:
3996     if (ToType->isBooleanType()) {
3997       assert(FromType->castAs<EnumType>()->getDecl()->isFixed() &&
3998              SCS.Second == ICK_Integral_Promotion &&
3999              "only enums with fixed underlying type can promote to bool");
4000       From = ImpCastExprToType(From, ToType, CK_IntegralToBoolean,
4001                                VK_RValue, /*BasePath=*/nullptr, CCK).get();
4002     } else {
4003       From = ImpCastExprToType(From, ToType, CK_IntegralCast,
4004                                VK_RValue, /*BasePath=*/nullptr, CCK).get();
4005     }
4006     break;
4007 
4008   case ICK_Floating_Promotion:
4009   case ICK_Floating_Conversion:
4010     From = ImpCastExprToType(From, ToType, CK_FloatingCast,
4011                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
4012     break;
4013 
4014   case ICK_Complex_Promotion:
4015   case ICK_Complex_Conversion: {
4016     QualType FromEl = From->getType()->getAs<ComplexType>()->getElementType();
4017     QualType ToEl = ToType->getAs<ComplexType>()->getElementType();
4018     CastKind CK;
4019     if (FromEl->isRealFloatingType()) {
4020       if (ToEl->isRealFloatingType())
4021         CK = CK_FloatingComplexCast;
4022       else
4023         CK = CK_FloatingComplexToIntegralComplex;
4024     } else if (ToEl->isRealFloatingType()) {
4025       CK = CK_IntegralComplexToFloatingComplex;
4026     } else {
4027       CK = CK_IntegralComplexCast;
4028     }
4029     From = ImpCastExprToType(From, ToType, CK,
4030                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
4031     break;
4032   }
4033 
4034   case ICK_Floating_Integral:
4035     if (ToType->isRealFloatingType())
4036       From = ImpCastExprToType(From, ToType, CK_IntegralToFloating,
4037                                VK_RValue, /*BasePath=*/nullptr, CCK).get();
4038     else
4039       From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral,
4040                                VK_RValue, /*BasePath=*/nullptr, CCK).get();
4041     break;
4042 
4043   case ICK_Compatible_Conversion:
4044       From = ImpCastExprToType(From, ToType, CK_NoOp,
4045                                VK_RValue, /*BasePath=*/nullptr, CCK).get();
4046     break;
4047 
4048   case ICK_Writeback_Conversion:
4049   case ICK_Pointer_Conversion: {
4050     if (SCS.IncompatibleObjC && Action != AA_Casting) {
4051       // Diagnose incompatible Objective-C conversions
4052       if (Action == AA_Initializing || Action == AA_Assigning)
4053         Diag(From->getLocStart(),
4054              diag::ext_typecheck_convert_incompatible_pointer)
4055           << ToType << From->getType() << Action
4056           << From->getSourceRange() << 0;
4057       else
4058         Diag(From->getLocStart(),
4059              diag::ext_typecheck_convert_incompatible_pointer)
4060           << From->getType() << ToType << Action
4061           << From->getSourceRange() << 0;
4062 
4063       if (From->getType()->isObjCObjectPointerType() &&
4064           ToType->isObjCObjectPointerType())
4065         EmitRelatedResultTypeNote(From);
4066     } else if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
4067                !CheckObjCARCUnavailableWeakConversion(ToType,
4068                                                       From->getType())) {
4069       if (Action == AA_Initializing)
4070         Diag(From->getLocStart(),
4071              diag::err_arc_weak_unavailable_assign);
4072       else
4073         Diag(From->getLocStart(),
4074              diag::err_arc_convesion_of_weak_unavailable)
4075           << (Action == AA_Casting) << From->getType() << ToType
4076           << From->getSourceRange();
4077     }
4078 
4079     CastKind Kind;
4080     CXXCastPath BasePath;
4081     if (CheckPointerConversion(From, ToType, Kind, BasePath, CStyle))
4082       return ExprError();
4083 
4084     // Make sure we extend blocks if necessary.
4085     // FIXME: doing this here is really ugly.
4086     if (Kind == CK_BlockPointerToObjCPointerCast) {
4087       ExprResult E = From;
4088       (void) PrepareCastToObjCObjectPointer(E);
4089       From = E.get();
4090     }
4091     if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers())
4092       CheckObjCConversion(SourceRange(), ToType, From, CCK);
4093     From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
4094              .get();
4095     break;
4096   }
4097 
4098   case ICK_Pointer_Member: {
4099     CastKind Kind;
4100     CXXCastPath BasePath;
4101     if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle))
4102       return ExprError();
4103     if (CheckExceptionSpecCompatibility(From, ToType))
4104       return ExprError();
4105 
4106     // We may not have been able to figure out what this member pointer resolved
4107     // to up until this exact point.  Attempt to lock-in it's inheritance model.
4108     if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
4109       (void)isCompleteType(From->getExprLoc(), From->getType());
4110       (void)isCompleteType(From->getExprLoc(), ToType);
4111     }
4112 
4113     From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
4114              .get();
4115     break;
4116   }
4117 
4118   case ICK_Boolean_Conversion:
4119     // Perform half-to-boolean conversion via float.
4120     if (From->getType()->isHalfType()) {
4121       From = ImpCastExprToType(From, Context.FloatTy, CK_FloatingCast).get();
4122       FromType = Context.FloatTy;
4123     }
4124 
4125     From = ImpCastExprToType(From, Context.BoolTy,
4126                              ScalarTypeToBooleanCastKind(FromType),
4127                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
4128     break;
4129 
4130   case ICK_Derived_To_Base: {
4131     CXXCastPath BasePath;
4132     if (CheckDerivedToBaseConversion(From->getType(),
4133                                      ToType.getNonReferenceType(),
4134                                      From->getLocStart(),
4135                                      From->getSourceRange(),
4136                                      &BasePath,
4137                                      CStyle))
4138       return ExprError();
4139 
4140     From = ImpCastExprToType(From, ToType.getNonReferenceType(),
4141                       CK_DerivedToBase, From->getValueKind(),
4142                       &BasePath, CCK).get();
4143     break;
4144   }
4145 
4146   case ICK_Vector_Conversion:
4147     From = ImpCastExprToType(From, ToType, CK_BitCast,
4148                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
4149     break;
4150 
4151   case ICK_Vector_Splat: {
4152     // Vector splat from any arithmetic type to a vector.
4153     Expr *Elem = prepareVectorSplat(ToType, From).get();
4154     From = ImpCastExprToType(Elem, ToType, CK_VectorSplat, VK_RValue,
4155                              /*BasePath=*/nullptr, CCK).get();
4156     break;
4157   }
4158 
4159   case ICK_Complex_Real:
4160     // Case 1.  x -> _Complex y
4161     if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) {
4162       QualType ElType = ToComplex->getElementType();
4163       bool isFloatingComplex = ElType->isRealFloatingType();
4164 
4165       // x -> y
4166       if (Context.hasSameUnqualifiedType(ElType, From->getType())) {
4167         // do nothing
4168       } else if (From->getType()->isRealFloatingType()) {
4169         From = ImpCastExprToType(From, ElType,
4170                 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).get();
4171       } else {
4172         assert(From->getType()->isIntegerType());
4173         From = ImpCastExprToType(From, ElType,
4174                 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).get();
4175       }
4176       // y -> _Complex y
4177       From = ImpCastExprToType(From, ToType,
4178                    isFloatingComplex ? CK_FloatingRealToComplex
4179                                      : CK_IntegralRealToComplex).get();
4180 
4181     // Case 2.  _Complex x -> y
4182     } else {
4183       const ComplexType *FromComplex = From->getType()->getAs<ComplexType>();
4184       assert(FromComplex);
4185 
4186       QualType ElType = FromComplex->getElementType();
4187       bool isFloatingComplex = ElType->isRealFloatingType();
4188 
4189       // _Complex x -> x
4190       From = ImpCastExprToType(From, ElType,
4191                    isFloatingComplex ? CK_FloatingComplexToReal
4192                                      : CK_IntegralComplexToReal,
4193                                VK_RValue, /*BasePath=*/nullptr, CCK).get();
4194 
4195       // x -> y
4196       if (Context.hasSameUnqualifiedType(ElType, ToType)) {
4197         // do nothing
4198       } else if (ToType->isRealFloatingType()) {
4199         From = ImpCastExprToType(From, ToType,
4200                    isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
4201                                  VK_RValue, /*BasePath=*/nullptr, CCK).get();
4202       } else {
4203         assert(ToType->isIntegerType());
4204         From = ImpCastExprToType(From, ToType,
4205                    isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
4206                                  VK_RValue, /*BasePath=*/nullptr, CCK).get();
4207       }
4208     }
4209     break;
4210 
4211   case ICK_Block_Pointer_Conversion: {
4212     From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
4213                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
4214     break;
4215   }
4216 
4217   case ICK_TransparentUnionConversion: {
4218     ExprResult FromRes = From;
4219     Sema::AssignConvertType ConvTy =
4220       CheckTransparentUnionArgumentConstraints(ToType, FromRes);
4221     if (FromRes.isInvalid())
4222       return ExprError();
4223     From = FromRes.get();
4224     assert ((ConvTy == Sema::Compatible) &&
4225             "Improper transparent union conversion");
4226     (void)ConvTy;
4227     break;
4228   }
4229 
4230   case ICK_Zero_Event_Conversion:
4231     From = ImpCastExprToType(From, ToType,
4232                              CK_ZeroToOCLEvent,
4233                              From->getValueKind()).get();
4234     break;
4235 
4236   case ICK_Zero_Queue_Conversion:
4237     From = ImpCastExprToType(From, ToType,
4238                              CK_ZeroToOCLQueue,
4239                              From->getValueKind()).get();
4240     break;
4241 
4242   case ICK_Lvalue_To_Rvalue:
4243   case ICK_Array_To_Pointer:
4244   case ICK_Function_To_Pointer:
4245   case ICK_Function_Conversion:
4246   case ICK_Qualification:
4247   case ICK_Num_Conversion_Kinds:
4248   case ICK_C_Only_Conversion:
4249   case ICK_Incompatible_Pointer_Conversion:
4250     llvm_unreachable("Improper second standard conversion");
4251   }
4252 
4253   switch (SCS.Third) {
4254   case ICK_Identity:
4255     // Nothing to do.
4256     break;
4257 
4258   case ICK_Function_Conversion:
4259     // If both sides are functions (or pointers/references to them), there could
4260     // be incompatible exception declarations.
4261     if (CheckExceptionSpecCompatibility(From, ToType))
4262       return ExprError();
4263 
4264     From = ImpCastExprToType(From, ToType, CK_NoOp,
4265                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
4266     break;
4267 
4268   case ICK_Qualification: {
4269     // The qualification keeps the category of the inner expression, unless the
4270     // target type isn't a reference.
4271     ExprValueKind VK = ToType->isReferenceType() ?
4272                                   From->getValueKind() : VK_RValue;
4273     From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
4274                              CK_NoOp, VK, /*BasePath=*/nullptr, CCK).get();
4275 
4276     if (SCS.DeprecatedStringLiteralToCharPtr &&
4277         !getLangOpts().WritableStrings) {
4278       Diag(From->getLocStart(), getLangOpts().CPlusPlus11
4279            ? diag::ext_deprecated_string_literal_conversion
4280            : diag::warn_deprecated_string_literal_conversion)
4281         << ToType.getNonReferenceType();
4282     }
4283 
4284     break;
4285   }
4286 
4287   default:
4288     llvm_unreachable("Improper third standard conversion");
4289   }
4290 
4291   // If this conversion sequence involved a scalar -> atomic conversion, perform
4292   // that conversion now.
4293   if (!ToAtomicType.isNull()) {
4294     assert(Context.hasSameType(
4295         ToAtomicType->castAs<AtomicType>()->getValueType(), From->getType()));
4296     From = ImpCastExprToType(From, ToAtomicType, CK_NonAtomicToAtomic,
4297                              VK_RValue, nullptr, CCK).get();
4298   }
4299 
4300   // If this conversion sequence succeeded and involved implicitly converting a
4301   // _Nullable type to a _Nonnull one, complain.
4302   if (!isCast(CCK))
4303     diagnoseNullableToNonnullConversion(ToType, InitialFromType,
4304                                         From->getLocStart());
4305 
4306   return From;
4307 }
4308 
4309 /// Check the completeness of a type in a unary type trait.
4310 ///
4311 /// If the particular type trait requires a complete type, tries to complete
4312 /// it. If completing the type fails, a diagnostic is emitted and false
4313 /// returned. If completing the type succeeds or no completion was required,
4314 /// returns true.
4315 static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
4316                                                 SourceLocation Loc,
4317                                                 QualType ArgTy) {
4318   // C++0x [meta.unary.prop]p3:
4319   //   For all of the class templates X declared in this Clause, instantiating
4320   //   that template with a template argument that is a class template
4321   //   specialization may result in the implicit instantiation of the template
4322   //   argument if and only if the semantics of X require that the argument
4323   //   must be a complete type.
4324   // We apply this rule to all the type trait expressions used to implement
4325   // these class templates. We also try to follow any GCC documented behavior
4326   // in these expressions to ensure portability of standard libraries.
4327   switch (UTT) {
4328   default: llvm_unreachable("not a UTT");
4329     // is_complete_type somewhat obviously cannot require a complete type.
4330   case UTT_IsCompleteType:
4331     // Fall-through
4332 
4333     // These traits are modeled on the type predicates in C++0x
4334     // [meta.unary.cat] and [meta.unary.comp]. They are not specified as
4335     // requiring a complete type, as whether or not they return true cannot be
4336     // impacted by the completeness of the type.
4337   case UTT_IsVoid:
4338   case UTT_IsIntegral:
4339   case UTT_IsFloatingPoint:
4340   case UTT_IsArray:
4341   case UTT_IsPointer:
4342   case UTT_IsLvalueReference:
4343   case UTT_IsRvalueReference:
4344   case UTT_IsMemberFunctionPointer:
4345   case UTT_IsMemberObjectPointer:
4346   case UTT_IsEnum:
4347   case UTT_IsUnion:
4348   case UTT_IsClass:
4349   case UTT_IsFunction:
4350   case UTT_IsReference:
4351   case UTT_IsArithmetic:
4352   case UTT_IsFundamental:
4353   case UTT_IsObject:
4354   case UTT_IsScalar:
4355   case UTT_IsCompound:
4356   case UTT_IsMemberPointer:
4357     // Fall-through
4358 
4359     // These traits are modeled on type predicates in C++0x [meta.unary.prop]
4360     // which requires some of its traits to have the complete type. However,
4361     // the completeness of the type cannot impact these traits' semantics, and
4362     // so they don't require it. This matches the comments on these traits in
4363     // Table 49.
4364   case UTT_IsConst:
4365   case UTT_IsVolatile:
4366   case UTT_IsSigned:
4367   case UTT_IsUnsigned:
4368 
4369   // This type trait always returns false, checking the type is moot.
4370   case UTT_IsInterfaceClass:
4371     return true;
4372 
4373   // C++14 [meta.unary.prop]:
4374   //   If T is a non-union class type, T shall be a complete type.
4375   case UTT_IsEmpty:
4376   case UTT_IsPolymorphic:
4377   case UTT_IsAbstract:
4378     if (const auto *RD = ArgTy->getAsCXXRecordDecl())
4379       if (!RD->isUnion())
4380         return !S.RequireCompleteType(
4381             Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4382     return true;
4383 
4384   // C++14 [meta.unary.prop]:
4385   //   If T is a class type, T shall be a complete type.
4386   case UTT_IsFinal:
4387   case UTT_IsSealed:
4388     if (ArgTy->getAsCXXRecordDecl())
4389       return !S.RequireCompleteType(
4390           Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4391     return true;
4392 
4393   // C++1z [meta.unary.prop]:
4394   //   remove_all_extents_t<T> shall be a complete type or cv void.
4395   case UTT_IsAggregate:
4396   case UTT_IsTrivial:
4397   case UTT_IsTriviallyCopyable:
4398   case UTT_IsStandardLayout:
4399   case UTT_IsPOD:
4400   case UTT_IsLiteral:
4401   // Per the GCC type traits documentation, T shall be a complete type, cv void,
4402   // or an array of unknown bound. But GCC actually imposes the same constraints
4403   // as above.
4404   case UTT_HasNothrowAssign:
4405   case UTT_HasNothrowMoveAssign:
4406   case UTT_HasNothrowConstructor:
4407   case UTT_HasNothrowCopy:
4408   case UTT_HasTrivialAssign:
4409   case UTT_HasTrivialMoveAssign:
4410   case UTT_HasTrivialDefaultConstructor:
4411   case UTT_HasTrivialMoveConstructor:
4412   case UTT_HasTrivialCopy:
4413   case UTT_HasTrivialDestructor:
4414   case UTT_HasVirtualDestructor:
4415     ArgTy = QualType(ArgTy->getBaseElementTypeUnsafe(), 0);
4416     LLVM_FALLTHROUGH;
4417 
4418   // C++1z [meta.unary.prop]:
4419   //   T shall be a complete type, cv void, or an array of unknown bound.
4420   case UTT_IsDestructible:
4421   case UTT_IsNothrowDestructible:
4422   case UTT_IsTriviallyDestructible:
4423   case UTT_HasUniqueObjectRepresentations:
4424     if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType())
4425       return true;
4426 
4427     return !S.RequireCompleteType(
4428         Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
4429   }
4430 }
4431 
4432 static bool HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op,
4433                                Sema &Self, SourceLocation KeyLoc, ASTContext &C,
4434                                bool (CXXRecordDecl::*HasTrivial)() const,
4435                                bool (CXXRecordDecl::*HasNonTrivial)() const,
4436                                bool (CXXMethodDecl::*IsDesiredOp)() const)
4437 {
4438   CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
4439   if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
4440     return true;
4441 
4442   DeclarationName Name = C.DeclarationNames.getCXXOperatorName(Op);
4443   DeclarationNameInfo NameInfo(Name, KeyLoc);
4444   LookupResult Res(Self, NameInfo, Sema::LookupOrdinaryName);
4445   if (Self.LookupQualifiedName(Res, RD)) {
4446     bool FoundOperator = false;
4447     Res.suppressDiagnostics();
4448     for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end();
4449          Op != OpEnd; ++Op) {
4450       if (isa<FunctionTemplateDecl>(*Op))
4451         continue;
4452 
4453       CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
4454       if((Operator->*IsDesiredOp)()) {
4455         FoundOperator = true;
4456         const FunctionProtoType *CPT =
4457           Operator->getType()->getAs<FunctionProtoType>();
4458         CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4459         if (!CPT || !CPT->isNothrow())
4460           return false;
4461       }
4462     }
4463     return FoundOperator;
4464   }
4465   return false;
4466 }
4467 
4468 static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
4469                                    SourceLocation KeyLoc, QualType T) {
4470   assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
4471 
4472   ASTContext &C = Self.Context;
4473   switch(UTT) {
4474   default: llvm_unreachable("not a UTT");
4475     // Type trait expressions corresponding to the primary type category
4476     // predicates in C++0x [meta.unary.cat].
4477   case UTT_IsVoid:
4478     return T->isVoidType();
4479   case UTT_IsIntegral:
4480     return T->isIntegralType(C);
4481   case UTT_IsFloatingPoint:
4482     return T->isFloatingType();
4483   case UTT_IsArray:
4484     return T->isArrayType();
4485   case UTT_IsPointer:
4486     return T->isPointerType();
4487   case UTT_IsLvalueReference:
4488     return T->isLValueReferenceType();
4489   case UTT_IsRvalueReference:
4490     return T->isRValueReferenceType();
4491   case UTT_IsMemberFunctionPointer:
4492     return T->isMemberFunctionPointerType();
4493   case UTT_IsMemberObjectPointer:
4494     return T->isMemberDataPointerType();
4495   case UTT_IsEnum:
4496     return T->isEnumeralType();
4497   case UTT_IsUnion:
4498     return T->isUnionType();
4499   case UTT_IsClass:
4500     return T->isClassType() || T->isStructureType() || T->isInterfaceType();
4501   case UTT_IsFunction:
4502     return T->isFunctionType();
4503 
4504     // Type trait expressions which correspond to the convenient composition
4505     // predicates in C++0x [meta.unary.comp].
4506   case UTT_IsReference:
4507     return T->isReferenceType();
4508   case UTT_IsArithmetic:
4509     return T->isArithmeticType() && !T->isEnumeralType();
4510   case UTT_IsFundamental:
4511     return T->isFundamentalType();
4512   case UTT_IsObject:
4513     return T->isObjectType();
4514   case UTT_IsScalar:
4515     // Note: semantic analysis depends on Objective-C lifetime types to be
4516     // considered scalar types. However, such types do not actually behave
4517     // like scalar types at run time (since they may require retain/release
4518     // operations), so we report them as non-scalar.
4519     if (T->isObjCLifetimeType()) {
4520       switch (T.getObjCLifetime()) {
4521       case Qualifiers::OCL_None:
4522       case Qualifiers::OCL_ExplicitNone:
4523         return true;
4524 
4525       case Qualifiers::OCL_Strong:
4526       case Qualifiers::OCL_Weak:
4527       case Qualifiers::OCL_Autoreleasing:
4528         return false;
4529       }
4530     }
4531 
4532     return T->isScalarType();
4533   case UTT_IsCompound:
4534     return T->isCompoundType();
4535   case UTT_IsMemberPointer:
4536     return T->isMemberPointerType();
4537 
4538     // Type trait expressions which correspond to the type property predicates
4539     // in C++0x [meta.unary.prop].
4540   case UTT_IsConst:
4541     return T.isConstQualified();
4542   case UTT_IsVolatile:
4543     return T.isVolatileQualified();
4544   case UTT_IsTrivial:
4545     return T.isTrivialType(C);
4546   case UTT_IsTriviallyCopyable:
4547     return T.isTriviallyCopyableType(C);
4548   case UTT_IsStandardLayout:
4549     return T->isStandardLayoutType();
4550   case UTT_IsPOD:
4551     return T.isPODType(C);
4552   case UTT_IsLiteral:
4553     return T->isLiteralType(C);
4554   case UTT_IsEmpty:
4555     if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4556       return !RD->isUnion() && RD->isEmpty();
4557     return false;
4558   case UTT_IsPolymorphic:
4559     if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4560       return !RD->isUnion() && RD->isPolymorphic();
4561     return false;
4562   case UTT_IsAbstract:
4563     if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4564       return !RD->isUnion() && RD->isAbstract();
4565     return false;
4566   case UTT_IsAggregate:
4567     // Report vector extensions and complex types as aggregates because they
4568     // support aggregate initialization. GCC mirrors this behavior for vectors
4569     // but not _Complex.
4570     return T->isAggregateType() || T->isVectorType() || T->isExtVectorType() ||
4571            T->isAnyComplexType();
4572   // __is_interface_class only returns true when CL is invoked in /CLR mode and
4573   // even then only when it is used with the 'interface struct ...' syntax
4574   // Clang doesn't support /CLR which makes this type trait moot.
4575   case UTT_IsInterfaceClass:
4576     return false;
4577   case UTT_IsFinal:
4578   case UTT_IsSealed:
4579     if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4580       return RD->hasAttr<FinalAttr>();
4581     return false;
4582   case UTT_IsSigned:
4583     return T->isSignedIntegerType();
4584   case UTT_IsUnsigned:
4585     return T->isUnsignedIntegerType();
4586 
4587     // Type trait expressions which query classes regarding their construction,
4588     // destruction, and copying. Rather than being based directly on the
4589     // related type predicates in the standard, they are specified by both
4590     // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those
4591     // specifications.
4592     //
4593     //   1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html
4594     //   2: http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
4595     //
4596     // Note that these builtins do not behave as documented in g++: if a class
4597     // has both a trivial and a non-trivial special member of a particular kind,
4598     // they return false! For now, we emulate this behavior.
4599     // FIXME: This appears to be a g++ bug: more complex cases reveal that it
4600     // does not correctly compute triviality in the presence of multiple special
4601     // members of the same kind. Revisit this once the g++ bug is fixed.
4602   case UTT_HasTrivialDefaultConstructor:
4603     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4604     //   If __is_pod (type) is true then the trait is true, else if type is
4605     //   a cv class or union type (or array thereof) with a trivial default
4606     //   constructor ([class.ctor]) then the trait is true, else it is false.
4607     if (T.isPODType(C))
4608       return true;
4609     if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4610       return RD->hasTrivialDefaultConstructor() &&
4611              !RD->hasNonTrivialDefaultConstructor();
4612     return false;
4613   case UTT_HasTrivialMoveConstructor:
4614     //  This trait is implemented by MSVC 2012 and needed to parse the
4615     //  standard library headers. Specifically this is used as the logic
4616     //  behind std::is_trivially_move_constructible (20.9.4.3).
4617     if (T.isPODType(C))
4618       return true;
4619     if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4620       return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
4621     return false;
4622   case UTT_HasTrivialCopy:
4623     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4624     //   If __is_pod (type) is true or type is a reference type then
4625     //   the trait is true, else if type is a cv class or union type
4626     //   with a trivial copy constructor ([class.copy]) then the trait
4627     //   is true, else it is false.
4628     if (T.isPODType(C) || T->isReferenceType())
4629       return true;
4630     if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4631       return RD->hasTrivialCopyConstructor() &&
4632              !RD->hasNonTrivialCopyConstructor();
4633     return false;
4634   case UTT_HasTrivialMoveAssign:
4635     //  This trait is implemented by MSVC 2012 and needed to parse the
4636     //  standard library headers. Specifically it is used as the logic
4637     //  behind std::is_trivially_move_assignable (20.9.4.3)
4638     if (T.isPODType(C))
4639       return true;
4640     if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4641       return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
4642     return false;
4643   case UTT_HasTrivialAssign:
4644     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4645     //   If type is const qualified or is a reference type then the
4646     //   trait is false. Otherwise if __is_pod (type) is true then the
4647     //   trait is true, else if type is a cv class or union type with
4648     //   a trivial copy assignment ([class.copy]) then the trait is
4649     //   true, else it is false.
4650     // Note: the const and reference restrictions are interesting,
4651     // given that const and reference members don't prevent a class
4652     // from having a trivial copy assignment operator (but do cause
4653     // errors if the copy assignment operator is actually used, q.v.
4654     // [class.copy]p12).
4655 
4656     if (T.isConstQualified())
4657       return false;
4658     if (T.isPODType(C))
4659       return true;
4660     if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4661       return RD->hasTrivialCopyAssignment() &&
4662              !RD->hasNonTrivialCopyAssignment();
4663     return false;
4664   case UTT_IsDestructible:
4665   case UTT_IsTriviallyDestructible:
4666   case UTT_IsNothrowDestructible:
4667     // C++14 [meta.unary.prop]:
4668     //   For reference types, is_destructible<T>::value is true.
4669     if (T->isReferenceType())
4670       return true;
4671 
4672     // Objective-C++ ARC: autorelease types don't require destruction.
4673     if (T->isObjCLifetimeType() &&
4674         T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing)
4675       return true;
4676 
4677     // C++14 [meta.unary.prop]:
4678     //   For incomplete types and function types, is_destructible<T>::value is
4679     //   false.
4680     if (T->isIncompleteType() || T->isFunctionType())
4681       return false;
4682 
4683     // A type that requires destruction (via a non-trivial destructor or ARC
4684     // lifetime semantics) is not trivially-destructible.
4685     if (UTT == UTT_IsTriviallyDestructible && T.isDestructedType())
4686       return false;
4687 
4688     // C++14 [meta.unary.prop]:
4689     //   For object types and given U equal to remove_all_extents_t<T>, if the
4690     //   expression std::declval<U&>().~U() is well-formed when treated as an
4691     //   unevaluated operand (Clause 5), then is_destructible<T>::value is true
4692     if (auto *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4693       CXXDestructorDecl *Destructor = Self.LookupDestructor(RD);
4694       if (!Destructor)
4695         return false;
4696       //  C++14 [dcl.fct.def.delete]p2:
4697       //    A program that refers to a deleted function implicitly or
4698       //    explicitly, other than to declare it, is ill-formed.
4699       if (Destructor->isDeleted())
4700         return false;
4701       if (C.getLangOpts().AccessControl && Destructor->getAccess() != AS_public)
4702         return false;
4703       if (UTT == UTT_IsNothrowDestructible) {
4704         const FunctionProtoType *CPT =
4705             Destructor->getType()->getAs<FunctionProtoType>();
4706         CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4707         if (!CPT || !CPT->isNothrow())
4708           return false;
4709       }
4710     }
4711     return true;
4712 
4713   case UTT_HasTrivialDestructor:
4714     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
4715     //   If __is_pod (type) is true or type is a reference type
4716     //   then the trait is true, else if type is a cv class or union
4717     //   type (or array thereof) with a trivial destructor
4718     //   ([class.dtor]) then the trait is true, else it is
4719     //   false.
4720     if (T.isPODType(C) || T->isReferenceType())
4721       return true;
4722 
4723     // Objective-C++ ARC: autorelease types don't require destruction.
4724     if (T->isObjCLifetimeType() &&
4725         T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing)
4726       return true;
4727 
4728     if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
4729       return RD->hasTrivialDestructor();
4730     return false;
4731   // TODO: Propagate nothrowness for implicitly declared special members.
4732   case UTT_HasNothrowAssign:
4733     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4734     //   If type is const qualified or is a reference type then the
4735     //   trait is false. Otherwise if __has_trivial_assign (type)
4736     //   is true then the trait is true, else if type is a cv class
4737     //   or union type with copy assignment operators that are known
4738     //   not to throw an exception then the trait is true, else it is
4739     //   false.
4740     if (C.getBaseElementType(T).isConstQualified())
4741       return false;
4742     if (T->isReferenceType())
4743       return false;
4744     if (T.isPODType(C) || T->isObjCLifetimeType())
4745       return true;
4746 
4747     if (const RecordType *RT = T->getAs<RecordType>())
4748       return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
4749                                 &CXXRecordDecl::hasTrivialCopyAssignment,
4750                                 &CXXRecordDecl::hasNonTrivialCopyAssignment,
4751                                 &CXXMethodDecl::isCopyAssignmentOperator);
4752     return false;
4753   case UTT_HasNothrowMoveAssign:
4754     //  This trait is implemented by MSVC 2012 and needed to parse the
4755     //  standard library headers. Specifically this is used as the logic
4756     //  behind std::is_nothrow_move_assignable (20.9.4.3).
4757     if (T.isPODType(C))
4758       return true;
4759 
4760     if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>())
4761       return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C,
4762                                 &CXXRecordDecl::hasTrivialMoveAssignment,
4763                                 &CXXRecordDecl::hasNonTrivialMoveAssignment,
4764                                 &CXXMethodDecl::isMoveAssignmentOperator);
4765     return false;
4766   case UTT_HasNothrowCopy:
4767     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4768     //   If __has_trivial_copy (type) is true then the trait is true, else
4769     //   if type is a cv class or union type with copy constructors that are
4770     //   known not to throw an exception then the trait is true, else it is
4771     //   false.
4772     if (T.isPODType(C) || T->isReferenceType() || T->isObjCLifetimeType())
4773       return true;
4774     if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {
4775       if (RD->hasTrivialCopyConstructor() &&
4776           !RD->hasNonTrivialCopyConstructor())
4777         return true;
4778 
4779       bool FoundConstructor = false;
4780       unsigned FoundTQs;
4781       for (const auto *ND : Self.LookupConstructors(RD)) {
4782         // A template constructor is never a copy constructor.
4783         // FIXME: However, it may actually be selected at the actual overload
4784         // resolution point.
4785         if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4786           continue;
4787         // UsingDecl itself is not a constructor
4788         if (isa<UsingDecl>(ND))
4789           continue;
4790         auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4791         if (Constructor->isCopyConstructor(FoundTQs)) {
4792           FoundConstructor = true;
4793           const FunctionProtoType *CPT
4794               = Constructor->getType()->getAs<FunctionProtoType>();
4795           CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4796           if (!CPT)
4797             return false;
4798           // TODO: check whether evaluating default arguments can throw.
4799           // For now, we'll be conservative and assume that they can throw.
4800           if (!CPT->isNothrow() || CPT->getNumParams() > 1)
4801             return false;
4802         }
4803       }
4804 
4805       return FoundConstructor;
4806     }
4807     return false;
4808   case UTT_HasNothrowConstructor:
4809     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
4810     //   If __has_trivial_constructor (type) is true then the trait is
4811     //   true, else if type is a cv class or union type (or array
4812     //   thereof) with a default constructor that is known not to
4813     //   throw an exception then the trait is true, else it is false.
4814     if (T.isPODType(C) || T->isObjCLifetimeType())
4815       return true;
4816     if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) {
4817       if (RD->hasTrivialDefaultConstructor() &&
4818           !RD->hasNonTrivialDefaultConstructor())
4819         return true;
4820 
4821       bool FoundConstructor = false;
4822       for (const auto *ND : Self.LookupConstructors(RD)) {
4823         // FIXME: In C++0x, a constructor template can be a default constructor.
4824         if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
4825           continue;
4826         // UsingDecl itself is not a constructor
4827         if (isa<UsingDecl>(ND))
4828           continue;
4829         auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
4830         if (Constructor->isDefaultConstructor()) {
4831           FoundConstructor = true;
4832           const FunctionProtoType *CPT
4833               = Constructor->getType()->getAs<FunctionProtoType>();
4834           CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
4835           if (!CPT)
4836             return false;
4837           // FIXME: check whether evaluating default arguments can throw.
4838           // For now, we'll be conservative and assume that they can throw.
4839           if (!CPT->isNothrow() || CPT->getNumParams() > 0)
4840             return false;
4841         }
4842       }
4843       return FoundConstructor;
4844     }
4845     return false;
4846   case UTT_HasVirtualDestructor:
4847     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
4848     //   If type is a class type with a virtual destructor ([class.dtor])
4849     //   then the trait is true, else it is false.
4850     if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4851       if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD))
4852         return Destructor->isVirtual();
4853     return false;
4854 
4855     // These type trait expressions are modeled on the specifications for the
4856     // Embarcadero C++0x type trait functions:
4857     //   http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index
4858   case UTT_IsCompleteType:
4859     // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_):
4860     //   Returns True if and only if T is a complete type at the point of the
4861     //   function call.
4862     return !T->isIncompleteType();
4863   case UTT_HasUniqueObjectRepresentations:
4864     return C.hasUniqueObjectRepresentations(T);
4865   }
4866 }
4867 
4868 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
4869                                     QualType RhsT, SourceLocation KeyLoc);
4870 
4871 static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
4872                               ArrayRef<TypeSourceInfo *> Args,
4873                               SourceLocation RParenLoc) {
4874   if (Kind <= UTT_Last)
4875     return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType());
4876 
4877   // Evaluate BTT_ReferenceBindsToTemporary alongside the IsConstructible
4878   // traits to avoid duplication.
4879   if (Kind <= BTT_Last && Kind != BTT_ReferenceBindsToTemporary)
4880     return EvaluateBinaryTypeTrait(S, Kind, Args[0]->getType(),
4881                                    Args[1]->getType(), RParenLoc);
4882 
4883   switch (Kind) {
4884   case clang::BTT_ReferenceBindsToTemporary:
4885   case clang::TT_IsConstructible:
4886   case clang::TT_IsNothrowConstructible:
4887   case clang::TT_IsTriviallyConstructible: {
4888     // C++11 [meta.unary.prop]:
4889     //   is_trivially_constructible is defined as:
4890     //
4891     //     is_constructible<T, Args...>::value is true and the variable
4892     //     definition for is_constructible, as defined below, is known to call
4893     //     no operation that is not trivial.
4894     //
4895     //   The predicate condition for a template specialization
4896     //   is_constructible<T, Args...> shall be satisfied if and only if the
4897     //   following variable definition would be well-formed for some invented
4898     //   variable t:
4899     //
4900     //     T t(create<Args>()...);
4901     assert(!Args.empty());
4902 
4903     // Precondition: T and all types in the parameter pack Args shall be
4904     // complete types, (possibly cv-qualified) void, or arrays of
4905     // unknown bound.
4906     for (const auto *TSI : Args) {
4907       QualType ArgTy = TSI->getType();
4908       if (ArgTy->isVoidType() || ArgTy->isIncompleteArrayType())
4909         continue;
4910 
4911       if (S.RequireCompleteType(KWLoc, ArgTy,
4912           diag::err_incomplete_type_used_in_type_trait_expr))
4913         return false;
4914     }
4915 
4916     // Make sure the first argument is not incomplete nor a function type.
4917     QualType T = Args[0]->getType();
4918     if (T->isIncompleteType() || T->isFunctionType())
4919       return false;
4920 
4921     // Make sure the first argument is not an abstract type.
4922     CXXRecordDecl *RD = T->getAsCXXRecordDecl();
4923     if (RD && RD->isAbstract())
4924       return false;
4925 
4926     SmallVector<OpaqueValueExpr, 2> OpaqueArgExprs;
4927     SmallVector<Expr *, 2> ArgExprs;
4928     ArgExprs.reserve(Args.size() - 1);
4929     for (unsigned I = 1, N = Args.size(); I != N; ++I) {
4930       QualType ArgTy = Args[I]->getType();
4931       if (ArgTy->isObjectType() || ArgTy->isFunctionType())
4932         ArgTy = S.Context.getRValueReferenceType(ArgTy);
4933       OpaqueArgExprs.push_back(
4934           OpaqueValueExpr(Args[I]->getTypeLoc().getLocStart(),
4935                           ArgTy.getNonLValueExprType(S.Context),
4936                           Expr::getValueKindForType(ArgTy)));
4937     }
4938     for (Expr &E : OpaqueArgExprs)
4939       ArgExprs.push_back(&E);
4940 
4941     // Perform the initialization in an unevaluated context within a SFINAE
4942     // trap at translation unit scope.
4943     EnterExpressionEvaluationContext Unevaluated(
4944         S, Sema::ExpressionEvaluationContext::Unevaluated);
4945     Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/true);
4946     Sema::ContextRAII TUContext(S, S.Context.getTranslationUnitDecl());
4947     InitializedEntity To(InitializedEntity::InitializeTemporary(Args[0]));
4948     InitializationKind InitKind(InitializationKind::CreateDirect(KWLoc, KWLoc,
4949                                                                  RParenLoc));
4950     InitializationSequence Init(S, To, InitKind, ArgExprs);
4951     if (Init.Failed())
4952       return false;
4953 
4954     ExprResult Result = Init.Perform(S, To, InitKind, ArgExprs);
4955     if (Result.isInvalid() || SFINAE.hasErrorOccurred())
4956       return false;
4957 
4958     if (Kind == clang::TT_IsConstructible)
4959       return true;
4960 
4961     if (Kind == clang::BTT_ReferenceBindsToTemporary) {
4962       if (!T->isReferenceType())
4963         return false;
4964 
4965       return !Init.isDirectReferenceBinding();
4966     }
4967 
4968     if (Kind == clang::TT_IsNothrowConstructible)
4969       return S.canThrow(Result.get()) == CT_Cannot;
4970 
4971     if (Kind == clang::TT_IsTriviallyConstructible) {
4972       // Under Objective-C ARC and Weak, if the destination has non-trivial
4973       // Objective-C lifetime, this is a non-trivial construction.
4974       if (T.getNonReferenceType().hasNonTrivialObjCLifetime())
4975         return false;
4976 
4977       // The initialization succeeded; now make sure there are no non-trivial
4978       // calls.
4979       return !Result.get()->hasNonTrivialCall(S.Context);
4980     }
4981 
4982     llvm_unreachable("unhandled type trait");
4983     return false;
4984   }
4985     default: llvm_unreachable("not a TT");
4986   }
4987 
4988   return false;
4989 }
4990 
4991 ExprResult Sema::BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
4992                                 ArrayRef<TypeSourceInfo *> Args,
4993                                 SourceLocation RParenLoc) {
4994   QualType ResultType = Context.getLogicalOperationType();
4995 
4996   if (Kind <= UTT_Last && !CheckUnaryTypeTraitTypeCompleteness(
4997                                *this, Kind, KWLoc, Args[0]->getType()))
4998     return ExprError();
4999 
5000   bool Dependent = false;
5001   for (unsigned I = 0, N = Args.size(); I != N; ++I) {
5002     if (Args[I]->getType()->isDependentType()) {
5003       Dependent = true;
5004       break;
5005     }
5006   }
5007 
5008   bool Result = false;
5009   if (!Dependent)
5010     Result = evaluateTypeTrait(*this, Kind, KWLoc, Args, RParenLoc);
5011 
5012   return TypeTraitExpr::Create(Context, ResultType, KWLoc, Kind, Args,
5013                                RParenLoc, Result);
5014 }
5015 
5016 ExprResult Sema::ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
5017                                 ArrayRef<ParsedType> Args,
5018                                 SourceLocation RParenLoc) {
5019   SmallVector<TypeSourceInfo *, 4> ConvertedArgs;
5020   ConvertedArgs.reserve(Args.size());
5021 
5022   for (unsigned I = 0, N = Args.size(); I != N; ++I) {
5023     TypeSourceInfo *TInfo;
5024     QualType T = GetTypeFromParser(Args[I], &TInfo);
5025     if (!TInfo)
5026       TInfo = Context.getTrivialTypeSourceInfo(T, KWLoc);
5027 
5028     ConvertedArgs.push_back(TInfo);
5029   }
5030 
5031   return BuildTypeTrait(Kind, KWLoc, ConvertedArgs, RParenLoc);
5032 }
5033 
5034 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
5035                                     QualType RhsT, SourceLocation KeyLoc) {
5036   assert(!LhsT->isDependentType() && !RhsT->isDependentType() &&
5037          "Cannot evaluate traits of dependent types");
5038 
5039   switch(BTT) {
5040   case BTT_IsBaseOf: {
5041     // C++0x [meta.rel]p2
5042     // Base is a base class of Derived without regard to cv-qualifiers or
5043     // Base and Derived are not unions and name the same class type without
5044     // regard to cv-qualifiers.
5045 
5046     const RecordType *lhsRecord = LhsT->getAs<RecordType>();
5047     const RecordType *rhsRecord = RhsT->getAs<RecordType>();
5048     if (!rhsRecord || !lhsRecord) {
5049       const ObjCObjectType *LHSObjTy = LhsT->getAs<ObjCObjectType>();
5050       const ObjCObjectType *RHSObjTy = RhsT->getAs<ObjCObjectType>();
5051       if (!LHSObjTy || !RHSObjTy)
5052         return false;
5053 
5054       ObjCInterfaceDecl *BaseInterface = LHSObjTy->getInterface();
5055       ObjCInterfaceDecl *DerivedInterface = RHSObjTy->getInterface();
5056       if (!BaseInterface || !DerivedInterface)
5057         return false;
5058 
5059       if (Self.RequireCompleteType(
5060               KeyLoc, RhsT, diag::err_incomplete_type_used_in_type_trait_expr))
5061         return false;
5062 
5063       return BaseInterface->isSuperClassOf(DerivedInterface);
5064     }
5065 
5066     assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT)
5067              == (lhsRecord == rhsRecord));
5068 
5069     if (lhsRecord == rhsRecord)
5070       return !lhsRecord->getDecl()->isUnion();
5071 
5072     // C++0x [meta.rel]p2:
5073     //   If Base and Derived are class types and are different types
5074     //   (ignoring possible cv-qualifiers) then Derived shall be a
5075     //   complete type.
5076     if (Self.RequireCompleteType(KeyLoc, RhsT,
5077                           diag::err_incomplete_type_used_in_type_trait_expr))
5078       return false;
5079 
5080     return cast<CXXRecordDecl>(rhsRecord->getDecl())
5081       ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl()));
5082   }
5083   case BTT_IsSame:
5084     return Self.Context.hasSameType(LhsT, RhsT);
5085   case BTT_TypeCompatible: {
5086     // GCC ignores cv-qualifiers on arrays for this builtin.
5087     Qualifiers LhsQuals, RhsQuals;
5088     QualType Lhs = Self.getASTContext().getUnqualifiedArrayType(LhsT, LhsQuals);
5089     QualType Rhs = Self.getASTContext().getUnqualifiedArrayType(RhsT, RhsQuals);
5090     return Self.Context.typesAreCompatible(Lhs, Rhs);
5091   }
5092   case BTT_IsConvertible:
5093   case BTT_IsConvertibleTo: {
5094     // C++0x [meta.rel]p4:
5095     //   Given the following function prototype:
5096     //
5097     //     template <class T>
5098     //       typename add_rvalue_reference<T>::type create();
5099     //
5100     //   the predicate condition for a template specialization
5101     //   is_convertible<From, To> shall be satisfied if and only if
5102     //   the return expression in the following code would be
5103     //   well-formed, including any implicit conversions to the return
5104     //   type of the function:
5105     //
5106     //     To test() {
5107     //       return create<From>();
5108     //     }
5109     //
5110     //   Access checking is performed as if in a context unrelated to To and
5111     //   From. Only the validity of the immediate context of the expression
5112     //   of the return-statement (including conversions to the return type)
5113     //   is considered.
5114     //
5115     // We model the initialization as a copy-initialization of a temporary
5116     // of the appropriate type, which for this expression is identical to the
5117     // return statement (since NRVO doesn't apply).
5118 
5119     // Functions aren't allowed to return function or array types.
5120     if (RhsT->isFunctionType() || RhsT->isArrayType())
5121       return false;
5122 
5123     // A return statement in a void function must have void type.
5124     if (RhsT->isVoidType())
5125       return LhsT->isVoidType();
5126 
5127     // A function definition requires a complete, non-abstract return type.
5128     if (!Self.isCompleteType(KeyLoc, RhsT) || Self.isAbstractType(KeyLoc, RhsT))
5129       return false;
5130 
5131     // Compute the result of add_rvalue_reference.
5132     if (LhsT->isObjectType() || LhsT->isFunctionType())
5133       LhsT = Self.Context.getRValueReferenceType(LhsT);
5134 
5135     // Build a fake source and destination for initialization.
5136     InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT));
5137     OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
5138                          Expr::getValueKindForType(LhsT));
5139     Expr *FromPtr = &From;
5140     InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc,
5141                                                            SourceLocation()));
5142 
5143     // Perform the initialization in an unevaluated context within a SFINAE
5144     // trap at translation unit scope.
5145     EnterExpressionEvaluationContext Unevaluated(
5146         Self, Sema::ExpressionEvaluationContext::Unevaluated);
5147     Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
5148     Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
5149     InitializationSequence Init(Self, To, Kind, FromPtr);
5150     if (Init.Failed())
5151       return false;
5152 
5153     ExprResult Result = Init.Perform(Self, To, Kind, FromPtr);
5154     return !Result.isInvalid() && !SFINAE.hasErrorOccurred();
5155   }
5156 
5157   case BTT_IsAssignable:
5158   case BTT_IsNothrowAssignable:
5159   case BTT_IsTriviallyAssignable: {
5160     // C++11 [meta.unary.prop]p3:
5161     //   is_trivially_assignable is defined as:
5162     //     is_assignable<T, U>::value is true and the assignment, as defined by
5163     //     is_assignable, is known to call no operation that is not trivial
5164     //
5165     //   is_assignable is defined as:
5166     //     The expression declval<T>() = declval<U>() is well-formed when
5167     //     treated as an unevaluated operand (Clause 5).
5168     //
5169     //   For both, T and U shall be complete types, (possibly cv-qualified)
5170     //   void, or arrays of unknown bound.
5171     if (!LhsT->isVoidType() && !LhsT->isIncompleteArrayType() &&
5172         Self.RequireCompleteType(KeyLoc, LhsT,
5173           diag::err_incomplete_type_used_in_type_trait_expr))
5174       return false;
5175     if (!RhsT->isVoidType() && !RhsT->isIncompleteArrayType() &&
5176         Self.RequireCompleteType(KeyLoc, RhsT,
5177           diag::err_incomplete_type_used_in_type_trait_expr))
5178       return false;
5179 
5180     // cv void is never assignable.
5181     if (LhsT->isVoidType() || RhsT->isVoidType())
5182       return false;
5183 
5184     // Build expressions that emulate the effect of declval<T>() and
5185     // declval<U>().
5186     if (LhsT->isObjectType() || LhsT->isFunctionType())
5187       LhsT = Self.Context.getRValueReferenceType(LhsT);
5188     if (RhsT->isObjectType() || RhsT->isFunctionType())
5189       RhsT = Self.Context.getRValueReferenceType(RhsT);
5190     OpaqueValueExpr Lhs(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
5191                         Expr::getValueKindForType(LhsT));
5192     OpaqueValueExpr Rhs(KeyLoc, RhsT.getNonLValueExprType(Self.Context),
5193                         Expr::getValueKindForType(RhsT));
5194 
5195     // Attempt the assignment in an unevaluated context within a SFINAE
5196     // trap at translation unit scope.
5197     EnterExpressionEvaluationContext Unevaluated(
5198         Self, Sema::ExpressionEvaluationContext::Unevaluated);
5199     Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
5200     Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
5201     ExprResult Result = Self.BuildBinOp(/*S=*/nullptr, KeyLoc, BO_Assign, &Lhs,
5202                                         &Rhs);
5203     if (Result.isInvalid() || SFINAE.hasErrorOccurred())
5204       return false;
5205 
5206     if (BTT == BTT_IsAssignable)
5207       return true;
5208 
5209     if (BTT == BTT_IsNothrowAssignable)
5210       return Self.canThrow(Result.get()) == CT_Cannot;
5211 
5212     if (BTT == BTT_IsTriviallyAssignable) {
5213       // Under Objective-C ARC and Weak, if the destination has non-trivial
5214       // Objective-C lifetime, this is a non-trivial assignment.
5215       if (LhsT.getNonReferenceType().hasNonTrivialObjCLifetime())
5216         return false;
5217 
5218       return !Result.get()->hasNonTrivialCall(Self.Context);
5219     }
5220 
5221     llvm_unreachable("unhandled type trait");
5222     return false;
5223   }
5224     default: llvm_unreachable("not a BTT");
5225   }
5226   llvm_unreachable("Unknown type trait or not implemented");
5227 }
5228 
5229 ExprResult Sema::ActOnArrayTypeTrait(ArrayTypeTrait ATT,
5230                                      SourceLocation KWLoc,
5231                                      ParsedType Ty,
5232                                      Expr* DimExpr,
5233                                      SourceLocation RParen) {
5234   TypeSourceInfo *TSInfo;
5235   QualType T = GetTypeFromParser(Ty, &TSInfo);
5236   if (!TSInfo)
5237     TSInfo = Context.getTrivialTypeSourceInfo(T);
5238 
5239   return BuildArrayTypeTrait(ATT, KWLoc, TSInfo, DimExpr, RParen);
5240 }
5241 
5242 static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT,
5243                                            QualType T, Expr *DimExpr,
5244                                            SourceLocation KeyLoc) {
5245   assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
5246 
5247   switch(ATT) {
5248   case ATT_ArrayRank:
5249     if (T->isArrayType()) {
5250       unsigned Dim = 0;
5251       while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
5252         ++Dim;
5253         T = AT->getElementType();
5254       }
5255       return Dim;
5256     }
5257     return 0;
5258 
5259   case ATT_ArrayExtent: {
5260     llvm::APSInt Value;
5261     uint64_t Dim;
5262     if (Self.VerifyIntegerConstantExpression(DimExpr, &Value,
5263           diag::err_dimension_expr_not_constant_integer,
5264           false).isInvalid())
5265       return 0;
5266     if (Value.isSigned() && Value.isNegative()) {
5267       Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
5268         << DimExpr->getSourceRange();
5269       return 0;
5270     }
5271     Dim = Value.getLimitedValue();
5272 
5273     if (T->isArrayType()) {
5274       unsigned D = 0;
5275       bool Matched = false;
5276       while (const ArrayType *AT = Self.Context.getAsArrayType(T)) {
5277         if (Dim == D) {
5278           Matched = true;
5279           break;
5280         }
5281         ++D;
5282         T = AT->getElementType();
5283       }
5284 
5285       if (Matched && T->isArrayType()) {
5286         if (const ConstantArrayType *CAT = Self.Context.getAsConstantArrayType(T))
5287           return CAT->getSize().getLimitedValue();
5288       }
5289     }
5290     return 0;
5291   }
5292   }
5293   llvm_unreachable("Unknown type trait or not implemented");
5294 }
5295 
5296 ExprResult Sema::BuildArrayTypeTrait(ArrayTypeTrait ATT,
5297                                      SourceLocation KWLoc,
5298                                      TypeSourceInfo *TSInfo,
5299                                      Expr* DimExpr,
5300                                      SourceLocation RParen) {
5301   QualType T = TSInfo->getType();
5302 
5303   // FIXME: This should likely be tracked as an APInt to remove any host
5304   // assumptions about the width of size_t on the target.
5305   uint64_t Value = 0;
5306   if (!T->isDependentType())
5307     Value = EvaluateArrayTypeTrait(*this, ATT, T, DimExpr, KWLoc);
5308 
5309   // While the specification for these traits from the Embarcadero C++
5310   // compiler's documentation says the return type is 'unsigned int', Clang
5311   // returns 'size_t'. On Windows, the primary platform for the Embarcadero
5312   // compiler, there is no difference. On several other platforms this is an
5313   // important distinction.
5314   return new (Context) ArrayTypeTraitExpr(KWLoc, ATT, TSInfo, Value, DimExpr,
5315                                           RParen, Context.getSizeType());
5316 }
5317 
5318 ExprResult Sema::ActOnExpressionTrait(ExpressionTrait ET,
5319                                       SourceLocation KWLoc,
5320                                       Expr *Queried,
5321                                       SourceLocation RParen) {
5322   // If error parsing the expression, ignore.
5323   if (!Queried)
5324     return ExprError();
5325 
5326   ExprResult Result = BuildExpressionTrait(ET, KWLoc, Queried, RParen);
5327 
5328   return Result;
5329 }
5330 
5331 static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) {
5332   switch (ET) {
5333   case ET_IsLValueExpr: return E->isLValue();
5334   case ET_IsRValueExpr: return E->isRValue();
5335   }
5336   llvm_unreachable("Expression trait not covered by switch");
5337 }
5338 
5339 ExprResult Sema::BuildExpressionTrait(ExpressionTrait ET,
5340                                       SourceLocation KWLoc,
5341                                       Expr *Queried,
5342                                       SourceLocation RParen) {
5343   if (Queried->isTypeDependent()) {
5344     // Delay type-checking for type-dependent expressions.
5345   } else if (Queried->getType()->isPlaceholderType()) {
5346     ExprResult PE = CheckPlaceholderExpr(Queried);
5347     if (PE.isInvalid()) return ExprError();
5348     return BuildExpressionTrait(ET, KWLoc, PE.get(), RParen);
5349   }
5350 
5351   bool Value = EvaluateExpressionTrait(ET, Queried);
5352 
5353   return new (Context)
5354       ExpressionTraitExpr(KWLoc, ET, Queried, Value, RParen, Context.BoolTy);
5355 }
5356 
5357 QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS,
5358                                             ExprValueKind &VK,
5359                                             SourceLocation Loc,
5360                                             bool isIndirect) {
5361   assert(!LHS.get()->getType()->isPlaceholderType() &&
5362          !RHS.get()->getType()->isPlaceholderType() &&
5363          "placeholders should have been weeded out by now");
5364 
5365   // The LHS undergoes lvalue conversions if this is ->*, and undergoes the
5366   // temporary materialization conversion otherwise.
5367   if (isIndirect)
5368     LHS = DefaultLvalueConversion(LHS.get());
5369   else if (LHS.get()->isRValue())
5370     LHS = TemporaryMaterializationConversion(LHS.get());
5371   if (LHS.isInvalid())
5372     return QualType();
5373 
5374   // The RHS always undergoes lvalue conversions.
5375   RHS = DefaultLvalueConversion(RHS.get());
5376   if (RHS.isInvalid()) return QualType();
5377 
5378   const char *OpSpelling = isIndirect ? "->*" : ".*";
5379   // C++ 5.5p2
5380   //   The binary operator .* [p3: ->*] binds its second operand, which shall
5381   //   be of type "pointer to member of T" (where T is a completely-defined
5382   //   class type) [...]
5383   QualType RHSType = RHS.get()->getType();
5384   const MemberPointerType *MemPtr = RHSType->getAs<MemberPointerType>();
5385   if (!MemPtr) {
5386     Diag(Loc, diag::err_bad_memptr_rhs)
5387       << OpSpelling << RHSType << RHS.get()->getSourceRange();
5388     return QualType();
5389   }
5390 
5391   QualType Class(MemPtr->getClass(), 0);
5392 
5393   // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the
5394   // member pointer points must be completely-defined. However, there is no
5395   // reason for this semantic distinction, and the rule is not enforced by
5396   // other compilers. Therefore, we do not check this property, as it is
5397   // likely to be considered a defect.
5398 
5399   // C++ 5.5p2
5400   //   [...] to its first operand, which shall be of class T or of a class of
5401   //   which T is an unambiguous and accessible base class. [p3: a pointer to
5402   //   such a class]
5403   QualType LHSType = LHS.get()->getType();
5404   if (isIndirect) {
5405     if (const PointerType *Ptr = LHSType->getAs<PointerType>())
5406       LHSType = Ptr->getPointeeType();
5407     else {
5408       Diag(Loc, diag::err_bad_memptr_lhs)
5409         << OpSpelling << 1 << LHSType
5410         << FixItHint::CreateReplacement(SourceRange(Loc), ".*");
5411       return QualType();
5412     }
5413   }
5414 
5415   if (!Context.hasSameUnqualifiedType(Class, LHSType)) {
5416     // If we want to check the hierarchy, we need a complete type.
5417     if (RequireCompleteType(Loc, LHSType, diag::err_bad_memptr_lhs,
5418                             OpSpelling, (int)isIndirect)) {
5419       return QualType();
5420     }
5421 
5422     if (!IsDerivedFrom(Loc, LHSType, Class)) {
5423       Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
5424         << (int)isIndirect << LHS.get()->getType();
5425       return QualType();
5426     }
5427 
5428     CXXCastPath BasePath;
5429     if (CheckDerivedToBaseConversion(LHSType, Class, Loc,
5430                                      SourceRange(LHS.get()->getLocStart(),
5431                                                  RHS.get()->getLocEnd()),
5432                                      &BasePath))
5433       return QualType();
5434 
5435     // Cast LHS to type of use.
5436     QualType UseType = Context.getQualifiedType(Class, LHSType.getQualifiers());
5437     if (isIndirect)
5438       UseType = Context.getPointerType(UseType);
5439     ExprValueKind VK = isIndirect ? VK_RValue : LHS.get()->getValueKind();
5440     LHS = ImpCastExprToType(LHS.get(), UseType, CK_DerivedToBase, VK,
5441                             &BasePath);
5442   }
5443 
5444   if (isa<CXXScalarValueInitExpr>(RHS.get()->IgnoreParens())) {
5445     // Diagnose use of pointer-to-member type which when used as
5446     // the functional cast in a pointer-to-member expression.
5447     Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
5448      return QualType();
5449   }
5450 
5451   // C++ 5.5p2
5452   //   The result is an object or a function of the type specified by the
5453   //   second operand.
5454   // The cv qualifiers are the union of those in the pointer and the left side,
5455   // in accordance with 5.5p5 and 5.2.5.
5456   QualType Result = MemPtr->getPointeeType();
5457   Result = Context.getCVRQualifiedType(Result, LHSType.getCVRQualifiers());
5458 
5459   // C++0x [expr.mptr.oper]p6:
5460   //   In a .* expression whose object expression is an rvalue, the program is
5461   //   ill-formed if the second operand is a pointer to member function with
5462   //   ref-qualifier &. In a ->* expression or in a .* expression whose object
5463   //   expression is an lvalue, the program is ill-formed if the second operand
5464   //   is a pointer to member function with ref-qualifier &&.
5465   if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) {
5466     switch (Proto->getRefQualifier()) {
5467     case RQ_None:
5468       // Do nothing
5469       break;
5470 
5471     case RQ_LValue:
5472       if (!isIndirect && !LHS.get()->Classify(Context).isLValue()) {
5473         // C++2a allows functions with ref-qualifier & if they are also 'const'.
5474         if (Proto->isConst())
5475           Diag(Loc, getLangOpts().CPlusPlus2a
5476                         ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
5477                         : diag::ext_pointer_to_const_ref_member_on_rvalue);
5478         else
5479           Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5480               << RHSType << 1 << LHS.get()->getSourceRange();
5481       }
5482       break;
5483 
5484     case RQ_RValue:
5485       if (isIndirect || !LHS.get()->Classify(Context).isRValue())
5486         Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5487           << RHSType << 0 << LHS.get()->getSourceRange();
5488       break;
5489     }
5490   }
5491 
5492   // C++ [expr.mptr.oper]p6:
5493   //   The result of a .* expression whose second operand is a pointer
5494   //   to a data member is of the same value category as its
5495   //   first operand. The result of a .* expression whose second
5496   //   operand is a pointer to a member function is a prvalue. The
5497   //   result of an ->* expression is an lvalue if its second operand
5498   //   is a pointer to data member and a prvalue otherwise.
5499   if (Result->isFunctionType()) {
5500     VK = VK_RValue;
5501     return Context.BoundMemberTy;
5502   } else if (isIndirect) {
5503     VK = VK_LValue;
5504   } else {
5505     VK = LHS.get()->getValueKind();
5506   }
5507 
5508   return Result;
5509 }
5510 
5511 /// Try to convert a type to another according to C++11 5.16p3.
5512 ///
5513 /// This is part of the parameter validation for the ? operator. If either
5514 /// value operand is a class type, the two operands are attempted to be
5515 /// converted to each other. This function does the conversion in one direction.
5516 /// It returns true if the program is ill-formed and has already been diagnosed
5517 /// as such.
5518 static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
5519                                 SourceLocation QuestionLoc,
5520                                 bool &HaveConversion,
5521                                 QualType &ToType) {
5522   HaveConversion = false;
5523   ToType = To->getType();
5524 
5525   InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(),
5526                                                            SourceLocation());
5527   // C++11 5.16p3
5528   //   The process for determining whether an operand expression E1 of type T1
5529   //   can be converted to match an operand expression E2 of type T2 is defined
5530   //   as follows:
5531   //   -- If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
5532   //      implicitly converted to type "lvalue reference to T2", subject to the
5533   //      constraint that in the conversion the reference must bind directly to
5534   //      an lvalue.
5535   //   -- If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
5536   //      implicitly converted to the type "rvalue reference to R2", subject to
5537   //      the constraint that the reference must bind directly.
5538   if (To->isLValue() || To->isXValue()) {
5539     QualType T = To->isLValue() ? Self.Context.getLValueReferenceType(ToType)
5540                                 : Self.Context.getRValueReferenceType(ToType);
5541 
5542     InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
5543 
5544     InitializationSequence InitSeq(Self, Entity, Kind, From);
5545     if (InitSeq.isDirectReferenceBinding()) {
5546       ToType = T;
5547       HaveConversion = true;
5548       return false;
5549     }
5550 
5551     if (InitSeq.isAmbiguous())
5552       return InitSeq.Diagnose(Self, Entity, Kind, From);
5553   }
5554 
5555   //   -- If E2 is an rvalue, or if the conversion above cannot be done:
5556   //      -- if E1 and E2 have class type, and the underlying class types are
5557   //         the same or one is a base class of the other:
5558   QualType FTy = From->getType();
5559   QualType TTy = To->getType();
5560   const RecordType *FRec = FTy->getAs<RecordType>();
5561   const RecordType *TRec = TTy->getAs<RecordType>();
5562   bool FDerivedFromT = FRec && TRec && FRec != TRec &&
5563                        Self.IsDerivedFrom(QuestionLoc, FTy, TTy);
5564   if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
5565                        Self.IsDerivedFrom(QuestionLoc, TTy, FTy))) {
5566     //         E1 can be converted to match E2 if the class of T2 is the
5567     //         same type as, or a base class of, the class of T1, and
5568     //         [cv2 > cv1].
5569     if (FRec == TRec || FDerivedFromT) {
5570       if (TTy.isAtLeastAsQualifiedAs(FTy)) {
5571         InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
5572         InitializationSequence InitSeq(Self, Entity, Kind, From);
5573         if (InitSeq) {
5574           HaveConversion = true;
5575           return false;
5576         }
5577 
5578         if (InitSeq.isAmbiguous())
5579           return InitSeq.Diagnose(Self, Entity, Kind, From);
5580       }
5581     }
5582 
5583     return false;
5584   }
5585 
5586   //     -- Otherwise: E1 can be converted to match E2 if E1 can be
5587   //        implicitly converted to the type that expression E2 would have
5588   //        if E2 were converted to an rvalue (or the type it has, if E2 is
5589   //        an rvalue).
5590   //
5591   // This actually refers very narrowly to the lvalue-to-rvalue conversion, not
5592   // to the array-to-pointer or function-to-pointer conversions.
5593   TTy = TTy.getNonLValueExprType(Self.Context);
5594 
5595   InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
5596   InitializationSequence InitSeq(Self, Entity, Kind, From);
5597   HaveConversion = !InitSeq.Failed();
5598   ToType = TTy;
5599   if (InitSeq.isAmbiguous())
5600     return InitSeq.Diagnose(Self, Entity, Kind, From);
5601 
5602   return false;
5603 }
5604 
5605 /// Try to find a common type for two according to C++0x 5.16p5.
5606 ///
5607 /// This is part of the parameter validation for the ? operator. If either
5608 /// value operand is a class type, overload resolution is used to find a
5609 /// conversion to a common type.
5610 static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS,
5611                                     SourceLocation QuestionLoc) {
5612   Expr *Args[2] = { LHS.get(), RHS.get() };
5613   OverloadCandidateSet CandidateSet(QuestionLoc,
5614                                     OverloadCandidateSet::CSK_Operator);
5615   Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args,
5616                                     CandidateSet);
5617 
5618   OverloadCandidateSet::iterator Best;
5619   switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) {
5620     case OR_Success: {
5621       // We found a match. Perform the conversions on the arguments and move on.
5622       ExprResult LHSRes = Self.PerformImplicitConversion(
5623           LHS.get(), Best->BuiltinParamTypes[0], Best->Conversions[0],
5624           Sema::AA_Converting);
5625       if (LHSRes.isInvalid())
5626         break;
5627       LHS = LHSRes;
5628 
5629       ExprResult RHSRes = Self.PerformImplicitConversion(
5630           RHS.get(), Best->BuiltinParamTypes[1], Best->Conversions[1],
5631           Sema::AA_Converting);
5632       if (RHSRes.isInvalid())
5633         break;
5634       RHS = RHSRes;
5635       if (Best->Function)
5636         Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
5637       return false;
5638     }
5639 
5640     case OR_No_Viable_Function:
5641 
5642       // Emit a better diagnostic if one of the expressions is a null pointer
5643       // constant and the other is a pointer type. In this case, the user most
5644       // likely forgot to take the address of the other expression.
5645       if (Self.DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
5646         return true;
5647 
5648       Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5649         << LHS.get()->getType() << RHS.get()->getType()
5650         << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5651       return true;
5652 
5653     case OR_Ambiguous:
5654       Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
5655         << LHS.get()->getType() << RHS.get()->getType()
5656         << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5657       // FIXME: Print the possible common types by printing the return types of
5658       // the viable candidates.
5659       break;
5660 
5661     case OR_Deleted:
5662       llvm_unreachable("Conditional operator has only built-in overloads");
5663   }
5664   return true;
5665 }
5666 
5667 /// Perform an "extended" implicit conversion as returned by
5668 /// TryClassUnification.
5669 static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T) {
5670   InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
5671   InitializationKind Kind = InitializationKind::CreateCopy(E.get()->getLocStart(),
5672                                                            SourceLocation());
5673   Expr *Arg = E.get();
5674   InitializationSequence InitSeq(Self, Entity, Kind, Arg);
5675   ExprResult Result = InitSeq.Perform(Self, Entity, Kind, Arg);
5676   if (Result.isInvalid())
5677     return true;
5678 
5679   E = Result;
5680   return false;
5681 }
5682 
5683 /// Check the operands of ?: under C++ semantics.
5684 ///
5685 /// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
5686 /// extension. In this case, LHS == Cond. (But they're not aliases.)
5687 QualType Sema::CXXCheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
5688                                            ExprResult &RHS, ExprValueKind &VK,
5689                                            ExprObjectKind &OK,
5690                                            SourceLocation QuestionLoc) {
5691   // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
5692   // interface pointers.
5693 
5694   // C++11 [expr.cond]p1
5695   //   The first expression is contextually converted to bool.
5696   //
5697   // FIXME; GCC's vector extension permits the use of a?b:c where the type of
5698   //        a is that of a integer vector with the same number of elements and
5699   //        size as the vectors of b and c. If one of either b or c is a scalar
5700   //        it is implicitly converted to match the type of the vector.
5701   //        Otherwise the expression is ill-formed. If both b and c are scalars,
5702   //        then b and c are checked and converted to the type of a if possible.
5703   //        Unlike the OpenCL ?: operator, the expression is evaluated as
5704   //        (a[0] != 0 ? b[0] : c[0], .. , a[n] != 0 ? b[n] : c[n]).
5705   if (!Cond.get()->isTypeDependent()) {
5706     ExprResult CondRes = CheckCXXBooleanCondition(Cond.get());
5707     if (CondRes.isInvalid())
5708       return QualType();
5709     Cond = CondRes;
5710   }
5711 
5712   // Assume r-value.
5713   VK = VK_RValue;
5714   OK = OK_Ordinary;
5715 
5716   // Either of the arguments dependent?
5717   if (LHS.get()->isTypeDependent() || RHS.get()->isTypeDependent())
5718     return Context.DependentTy;
5719 
5720   // C++11 [expr.cond]p2
5721   //   If either the second or the third operand has type (cv) void, ...
5722   QualType LTy = LHS.get()->getType();
5723   QualType RTy = RHS.get()->getType();
5724   bool LVoid = LTy->isVoidType();
5725   bool RVoid = RTy->isVoidType();
5726   if (LVoid || RVoid) {
5727     //   ... one of the following shall hold:
5728     //   -- The second or the third operand (but not both) is a (possibly
5729     //      parenthesized) throw-expression; the result is of the type
5730     //      and value category of the other.
5731     bool LThrow = isa<CXXThrowExpr>(LHS.get()->IgnoreParenImpCasts());
5732     bool RThrow = isa<CXXThrowExpr>(RHS.get()->IgnoreParenImpCasts());
5733     if (LThrow != RThrow) {
5734       Expr *NonThrow = LThrow ? RHS.get() : LHS.get();
5735       VK = NonThrow->getValueKind();
5736       // DR (no number yet): the result is a bit-field if the
5737       // non-throw-expression operand is a bit-field.
5738       OK = NonThrow->getObjectKind();
5739       return NonThrow->getType();
5740     }
5741 
5742     //   -- Both the second and third operands have type void; the result is of
5743     //      type void and is a prvalue.
5744     if (LVoid && RVoid)
5745       return Context.VoidTy;
5746 
5747     // Neither holds, error.
5748     Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
5749       << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
5750       << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5751     return QualType();
5752   }
5753 
5754   // Neither is void.
5755 
5756   // C++11 [expr.cond]p3
5757   //   Otherwise, if the second and third operand have different types, and
5758   //   either has (cv) class type [...] an attempt is made to convert each of
5759   //   those operands to the type of the other.
5760   if (!Context.hasSameType(LTy, RTy) &&
5761       (LTy->isRecordType() || RTy->isRecordType())) {
5762     // These return true if a single direction is already ambiguous.
5763     QualType L2RType, R2LType;
5764     bool HaveL2R, HaveR2L;
5765     if (TryClassUnification(*this, LHS.get(), RHS.get(), QuestionLoc, HaveL2R, L2RType))
5766       return QualType();
5767     if (TryClassUnification(*this, RHS.get(), LHS.get(), QuestionLoc, HaveR2L, R2LType))
5768       return QualType();
5769 
5770     //   If both can be converted, [...] the program is ill-formed.
5771     if (HaveL2R && HaveR2L) {
5772       Diag(QuestionLoc, diag::err_conditional_ambiguous)
5773         << LTy << RTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5774       return QualType();
5775     }
5776 
5777     //   If exactly one conversion is possible, that conversion is applied to
5778     //   the chosen operand and the converted operands are used in place of the
5779     //   original operands for the remainder of this section.
5780     if (HaveL2R) {
5781       if (ConvertForConditional(*this, LHS, L2RType) || LHS.isInvalid())
5782         return QualType();
5783       LTy = LHS.get()->getType();
5784     } else if (HaveR2L) {
5785       if (ConvertForConditional(*this, RHS, R2LType) || RHS.isInvalid())
5786         return QualType();
5787       RTy = RHS.get()->getType();
5788     }
5789   }
5790 
5791   // C++11 [expr.cond]p3
5792   //   if both are glvalues of the same value category and the same type except
5793   //   for cv-qualification, an attempt is made to convert each of those
5794   //   operands to the type of the other.
5795   // FIXME:
5796   //   Resolving a defect in P0012R1: we extend this to cover all cases where
5797   //   one of the operands is reference-compatible with the other, in order
5798   //   to support conditionals between functions differing in noexcept.
5799   ExprValueKind LVK = LHS.get()->getValueKind();
5800   ExprValueKind RVK = RHS.get()->getValueKind();
5801   if (!Context.hasSameType(LTy, RTy) &&
5802       LVK == RVK && LVK != VK_RValue) {
5803     // DerivedToBase was already handled by the class-specific case above.
5804     // FIXME: Should we allow ObjC conversions here?
5805     bool DerivedToBase, ObjCConversion, ObjCLifetimeConversion;
5806     if (CompareReferenceRelationship(
5807             QuestionLoc, LTy, RTy, DerivedToBase,
5808             ObjCConversion, ObjCLifetimeConversion) == Ref_Compatible &&
5809         !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5810         // [...] subject to the constraint that the reference must bind
5811         // directly [...]
5812         !RHS.get()->refersToBitField() &&
5813         !RHS.get()->refersToVectorElement()) {
5814       RHS = ImpCastExprToType(RHS.get(), LTy, CK_NoOp, RVK);
5815       RTy = RHS.get()->getType();
5816     } else if (CompareReferenceRelationship(
5817                    QuestionLoc, RTy, LTy, DerivedToBase,
5818                    ObjCConversion, ObjCLifetimeConversion) == Ref_Compatible &&
5819                !DerivedToBase && !ObjCConversion && !ObjCLifetimeConversion &&
5820                !LHS.get()->refersToBitField() &&
5821                !LHS.get()->refersToVectorElement()) {
5822       LHS = ImpCastExprToType(LHS.get(), RTy, CK_NoOp, LVK);
5823       LTy = LHS.get()->getType();
5824     }
5825   }
5826 
5827   // C++11 [expr.cond]p4
5828   //   If the second and third operands are glvalues of the same value
5829   //   category and have the same type, the result is of that type and
5830   //   value category and it is a bit-field if the second or the third
5831   //   operand is a bit-field, or if both are bit-fields.
5832   // We only extend this to bitfields, not to the crazy other kinds of
5833   // l-values.
5834   bool Same = Context.hasSameType(LTy, RTy);
5835   if (Same && LVK == RVK && LVK != VK_RValue &&
5836       LHS.get()->isOrdinaryOrBitFieldObject() &&
5837       RHS.get()->isOrdinaryOrBitFieldObject()) {
5838     VK = LHS.get()->getValueKind();
5839     if (LHS.get()->getObjectKind() == OK_BitField ||
5840         RHS.get()->getObjectKind() == OK_BitField)
5841       OK = OK_BitField;
5842 
5843     // If we have function pointer types, unify them anyway to unify their
5844     // exception specifications, if any.
5845     if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5846       Qualifiers Qs = LTy.getQualifiers();
5847       LTy = FindCompositePointerType(QuestionLoc, LHS, RHS,
5848                                      /*ConvertArgs*/false);
5849       LTy = Context.getQualifiedType(LTy, Qs);
5850 
5851       assert(!LTy.isNull() && "failed to find composite pointer type for "
5852                               "canonically equivalent function ptr types");
5853       assert(Context.hasSameType(LTy, RTy) && "bad composite pointer type");
5854     }
5855 
5856     return LTy;
5857   }
5858 
5859   // C++11 [expr.cond]p5
5860   //   Otherwise, the result is a prvalue. If the second and third operands
5861   //   do not have the same type, and either has (cv) class type, ...
5862   if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
5863     //   ... overload resolution is used to determine the conversions (if any)
5864     //   to be applied to the operands. If the overload resolution fails, the
5865     //   program is ill-formed.
5866     if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
5867       return QualType();
5868   }
5869 
5870   // C++11 [expr.cond]p6
5871   //   Lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard
5872   //   conversions are performed on the second and third operands.
5873   LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
5874   RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
5875   if (LHS.isInvalid() || RHS.isInvalid())
5876     return QualType();
5877   LTy = LHS.get()->getType();
5878   RTy = RHS.get()->getType();
5879 
5880   //   After those conversions, one of the following shall hold:
5881   //   -- The second and third operands have the same type; the result
5882   //      is of that type. If the operands have class type, the result
5883   //      is a prvalue temporary of the result type, which is
5884   //      copy-initialized from either the second operand or the third
5885   //      operand depending on the value of the first operand.
5886   if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) {
5887     if (LTy->isRecordType()) {
5888       // The operands have class type. Make a temporary copy.
5889       InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy);
5890 
5891       ExprResult LHSCopy = PerformCopyInitialization(Entity,
5892                                                      SourceLocation(),
5893                                                      LHS);
5894       if (LHSCopy.isInvalid())
5895         return QualType();
5896 
5897       ExprResult RHSCopy = PerformCopyInitialization(Entity,
5898                                                      SourceLocation(),
5899                                                      RHS);
5900       if (RHSCopy.isInvalid())
5901         return QualType();
5902 
5903       LHS = LHSCopy;
5904       RHS = RHSCopy;
5905     }
5906 
5907     // If we have function pointer types, unify them anyway to unify their
5908     // exception specifications, if any.
5909     if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
5910       LTy = FindCompositePointerType(QuestionLoc, LHS, RHS);
5911       assert(!LTy.isNull() && "failed to find composite pointer type for "
5912                               "canonically equivalent function ptr types");
5913     }
5914 
5915     return LTy;
5916   }
5917 
5918   // Extension: conditional operator involving vector types.
5919   if (LTy->isVectorType() || RTy->isVectorType())
5920     return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
5921                                /*AllowBothBool*/true,
5922                                /*AllowBoolConversions*/false);
5923 
5924   //   -- The second and third operands have arithmetic or enumeration type;
5925   //      the usual arithmetic conversions are performed to bring them to a
5926   //      common type, and the result is of that type.
5927   if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
5928     QualType ResTy = UsualArithmeticConversions(LHS, RHS);
5929     if (LHS.isInvalid() || RHS.isInvalid())
5930       return QualType();
5931     if (ResTy.isNull()) {
5932       Diag(QuestionLoc,
5933            diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
5934         << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5935       return QualType();
5936     }
5937 
5938     LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
5939     RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
5940 
5941     return ResTy;
5942   }
5943 
5944   //   -- The second and third operands have pointer type, or one has pointer
5945   //      type and the other is a null pointer constant, or both are null
5946   //      pointer constants, at least one of which is non-integral; pointer
5947   //      conversions and qualification conversions are performed to bring them
5948   //      to their composite pointer type. The result is of the composite
5949   //      pointer type.
5950   //   -- The second and third operands have pointer to member type, or one has
5951   //      pointer to member type and the other is a null pointer constant;
5952   //      pointer to member conversions and qualification conversions are
5953   //      performed to bring them to a common type, whose cv-qualification
5954   //      shall match the cv-qualification of either the second or the third
5955   //      operand. The result is of the common type.
5956   QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS);
5957   if (!Composite.isNull())
5958     return Composite;
5959 
5960   // Similarly, attempt to find composite type of two objective-c pointers.
5961   Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc);
5962   if (!Composite.isNull())
5963     return Composite;
5964 
5965   // Check if we are using a null with a non-pointer type.
5966   if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
5967     return QualType();
5968 
5969   Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5970     << LHS.get()->getType() << RHS.get()->getType()
5971     << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5972   return QualType();
5973 }
5974 
5975 static FunctionProtoType::ExceptionSpecInfo
5976 mergeExceptionSpecs(Sema &S, FunctionProtoType::ExceptionSpecInfo ESI1,
5977                     FunctionProtoType::ExceptionSpecInfo ESI2,
5978                     SmallVectorImpl<QualType> &ExceptionTypeStorage) {
5979   ExceptionSpecificationType EST1 = ESI1.Type;
5980   ExceptionSpecificationType EST2 = ESI2.Type;
5981 
5982   // If either of them can throw anything, that is the result.
5983   if (EST1 == EST_None) return ESI1;
5984   if (EST2 == EST_None) return ESI2;
5985   if (EST1 == EST_MSAny) return ESI1;
5986   if (EST2 == EST_MSAny) return ESI2;
5987   if (EST1 == EST_NoexceptFalse) return ESI1;
5988   if (EST2 == EST_NoexceptFalse) return ESI2;
5989 
5990   // If either of them is non-throwing, the result is the other.
5991   if (EST1 == EST_DynamicNone) return ESI2;
5992   if (EST2 == EST_DynamicNone) return ESI1;
5993   if (EST1 == EST_BasicNoexcept) return ESI2;
5994   if (EST2 == EST_BasicNoexcept) return ESI1;
5995   if (EST1 == EST_NoexceptTrue) return ESI2;
5996   if (EST2 == EST_NoexceptTrue) return ESI1;
5997 
5998   // If we're left with value-dependent computed noexcept expressions, we're
5999   // stuck. Before C++17, we can just drop the exception specification entirely,
6000   // since it's not actually part of the canonical type. And this should never
6001   // happen in C++17, because it would mean we were computing the composite
6002   // pointer type of dependent types, which should never happen.
6003   if (EST1 == EST_DependentNoexcept || EST2 == EST_DependentNoexcept) {
6004     assert(!S.getLangOpts().CPlusPlus17 &&
6005            "computing composite pointer type of dependent types");
6006     return FunctionProtoType::ExceptionSpecInfo();
6007   }
6008 
6009   // Switch over the possibilities so that people adding new values know to
6010   // update this function.
6011   switch (EST1) {
6012   case EST_None:
6013   case EST_DynamicNone:
6014   case EST_MSAny:
6015   case EST_BasicNoexcept:
6016   case EST_DependentNoexcept:
6017   case EST_NoexceptFalse:
6018   case EST_NoexceptTrue:
6019     llvm_unreachable("handled above");
6020 
6021   case EST_Dynamic: {
6022     // This is the fun case: both exception specifications are dynamic. Form
6023     // the union of the two lists.
6024     assert(EST2 == EST_Dynamic && "other cases should already be handled");
6025     llvm::SmallPtrSet<QualType, 8> Found;
6026     for (auto &Exceptions : {ESI1.Exceptions, ESI2.Exceptions})
6027       for (QualType E : Exceptions)
6028         if (Found.insert(S.Context.getCanonicalType(E)).second)
6029           ExceptionTypeStorage.push_back(E);
6030 
6031     FunctionProtoType::ExceptionSpecInfo Result(EST_Dynamic);
6032     Result.Exceptions = ExceptionTypeStorage;
6033     return Result;
6034   }
6035 
6036   case EST_Unevaluated:
6037   case EST_Uninstantiated:
6038   case EST_Unparsed:
6039     llvm_unreachable("shouldn't see unresolved exception specifications here");
6040   }
6041 
6042   llvm_unreachable("invalid ExceptionSpecificationType");
6043 }
6044 
6045 /// Find a merged pointer type and convert the two expressions to it.
6046 ///
6047 /// This finds the composite pointer type (or member pointer type) for @p E1
6048 /// and @p E2 according to C++1z 5p14. It converts both expressions to this
6049 /// type and returns it.
6050 /// It does not emit diagnostics.
6051 ///
6052 /// \param Loc The location of the operator requiring these two expressions to
6053 /// be converted to the composite pointer type.
6054 ///
6055 /// \param ConvertArgs If \c false, do not convert E1 and E2 to the target type.
6056 QualType Sema::FindCompositePointerType(SourceLocation Loc,
6057                                         Expr *&E1, Expr *&E2,
6058                                         bool ConvertArgs) {
6059   assert(getLangOpts().CPlusPlus && "This function assumes C++");
6060 
6061   // C++1z [expr]p14:
6062   //   The composite pointer type of two operands p1 and p2 having types T1
6063   //   and T2
6064   QualType T1 = E1->getType(), T2 = E2->getType();
6065 
6066   //   where at least one is a pointer or pointer to member type or
6067   //   std::nullptr_t is:
6068   bool T1IsPointerLike = T1->isAnyPointerType() || T1->isMemberPointerType() ||
6069                          T1->isNullPtrType();
6070   bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||
6071                          T2->isNullPtrType();
6072   if (!T1IsPointerLike && !T2IsPointerLike)
6073     return QualType();
6074 
6075   //   - if both p1 and p2 are null pointer constants, std::nullptr_t;
6076   // This can't actually happen, following the standard, but we also use this
6077   // to implement the end of [expr.conv], which hits this case.
6078   //
6079   //   - if either p1 or p2 is a null pointer constant, T2 or T1, respectively;
6080   if (T1IsPointerLike &&
6081       E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
6082     if (ConvertArgs)
6083       E2 = ImpCastExprToType(E2, T1, T1->isMemberPointerType()
6084                                          ? CK_NullToMemberPointer
6085                                          : CK_NullToPointer).get();
6086     return T1;
6087   }
6088   if (T2IsPointerLike &&
6089       E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
6090     if (ConvertArgs)
6091       E1 = ImpCastExprToType(E1, T2, T2->isMemberPointerType()
6092                                          ? CK_NullToMemberPointer
6093                                          : CK_NullToPointer).get();
6094     return T2;
6095   }
6096 
6097   // Now both have to be pointers or member pointers.
6098   if (!T1IsPointerLike || !T2IsPointerLike)
6099     return QualType();
6100   assert(!T1->isNullPtrType() && !T2->isNullPtrType() &&
6101          "nullptr_t should be a null pointer constant");
6102 
6103   //  - if T1 or T2 is "pointer to cv1 void" and the other type is
6104   //    "pointer to cv2 T", "pointer to cv12 void", where cv12 is
6105   //    the union of cv1 and cv2;
6106   //  - if T1 or T2 is "pointer to noexcept function" and the other type is
6107   //    "pointer to function", where the function types are otherwise the same,
6108   //    "pointer to function";
6109   //     FIXME: This rule is defective: it should also permit removing noexcept
6110   //     from a pointer to member function.  As a Clang extension, we also
6111   //     permit removing 'noreturn', so we generalize this rule to;
6112   //     - [Clang] If T1 and T2 are both of type "pointer to function" or
6113   //       "pointer to member function" and the pointee types can be unified
6114   //       by a function pointer conversion, that conversion is applied
6115   //       before checking the following rules.
6116   //  - if T1 is "pointer to cv1 C1" and T2 is "pointer to cv2 C2", where C1
6117   //    is reference-related to C2 or C2 is reference-related to C1 (8.6.3),
6118   //    the cv-combined type of T1 and T2 or the cv-combined type of T2 and T1,
6119   //    respectively;
6120   //  - if T1 is "pointer to member of C1 of type cv1 U1" and T2 is "pointer
6121   //    to member of C2 of type cv2 U2" where C1 is reference-related to C2 or
6122   //    C2 is reference-related to C1 (8.6.3), the cv-combined type of T2 and
6123   //    T1 or the cv-combined type of T1 and T2, respectively;
6124   //  - if T1 and T2 are similar types (4.5), the cv-combined type of T1 and
6125   //    T2;
6126   //
6127   // If looked at in the right way, these bullets all do the same thing.
6128   // What we do here is, we build the two possible cv-combined types, and try
6129   // the conversions in both directions. If only one works, or if the two
6130   // composite types are the same, we have succeeded.
6131   // FIXME: extended qualifiers?
6132   //
6133   // Note that this will fail to find a composite pointer type for "pointer
6134   // to void" and "pointer to function". We can't actually perform the final
6135   // conversion in this case, even though a composite pointer type formally
6136   // exists.
6137   SmallVector<unsigned, 4> QualifierUnion;
6138   SmallVector<std::pair<const Type *, const Type *>, 4> MemberOfClass;
6139   QualType Composite1 = T1;
6140   QualType Composite2 = T2;
6141   unsigned NeedConstBefore = 0;
6142   while (true) {
6143     const PointerType *Ptr1, *Ptr2;
6144     if ((Ptr1 = Composite1->getAs<PointerType>()) &&
6145         (Ptr2 = Composite2->getAs<PointerType>())) {
6146       Composite1 = Ptr1->getPointeeType();
6147       Composite2 = Ptr2->getPointeeType();
6148 
6149       // If we're allowed to create a non-standard composite type, keep track
6150       // of where we need to fill in additional 'const' qualifiers.
6151       if (Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
6152         NeedConstBefore = QualifierUnion.size();
6153 
6154       QualifierUnion.push_back(
6155                  Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
6156       MemberOfClass.push_back(std::make_pair(nullptr, nullptr));
6157       continue;
6158     }
6159 
6160     const MemberPointerType *MemPtr1, *MemPtr2;
6161     if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
6162         (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
6163       Composite1 = MemPtr1->getPointeeType();
6164       Composite2 = MemPtr2->getPointeeType();
6165 
6166       // If we're allowed to create a non-standard composite type, keep track
6167       // of where we need to fill in additional 'const' qualifiers.
6168       if (Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
6169         NeedConstBefore = QualifierUnion.size();
6170 
6171       QualifierUnion.push_back(
6172                  Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
6173       MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(),
6174                                              MemPtr2->getClass()));
6175       continue;
6176     }
6177 
6178     // FIXME: block pointer types?
6179 
6180     // Cannot unwrap any more types.
6181     break;
6182   }
6183 
6184   // Apply the function pointer conversion to unify the types. We've already
6185   // unwrapped down to the function types, and we want to merge rather than
6186   // just convert, so do this ourselves rather than calling
6187   // IsFunctionConversion.
6188   //
6189   // FIXME: In order to match the standard wording as closely as possible, we
6190   // currently only do this under a single level of pointers. Ideally, we would
6191   // allow this in general, and set NeedConstBefore to the relevant depth on
6192   // the side(s) where we changed anything.
6193   if (QualifierUnion.size() == 1) {
6194     if (auto *FPT1 = Composite1->getAs<FunctionProtoType>()) {
6195       if (auto *FPT2 = Composite2->getAs<FunctionProtoType>()) {
6196         FunctionProtoType::ExtProtoInfo EPI1 = FPT1->getExtProtoInfo();
6197         FunctionProtoType::ExtProtoInfo EPI2 = FPT2->getExtProtoInfo();
6198 
6199         // The result is noreturn if both operands are.
6200         bool Noreturn =
6201             EPI1.ExtInfo.getNoReturn() && EPI2.ExtInfo.getNoReturn();
6202         EPI1.ExtInfo = EPI1.ExtInfo.withNoReturn(Noreturn);
6203         EPI2.ExtInfo = EPI2.ExtInfo.withNoReturn(Noreturn);
6204 
6205         // The result is nothrow if both operands are.
6206         SmallVector<QualType, 8> ExceptionTypeStorage;
6207         EPI1.ExceptionSpec = EPI2.ExceptionSpec =
6208             mergeExceptionSpecs(*this, EPI1.ExceptionSpec, EPI2.ExceptionSpec,
6209                                 ExceptionTypeStorage);
6210 
6211         Composite1 = Context.getFunctionType(FPT1->getReturnType(),
6212                                              FPT1->getParamTypes(), EPI1);
6213         Composite2 = Context.getFunctionType(FPT2->getReturnType(),
6214                                              FPT2->getParamTypes(), EPI2);
6215       }
6216     }
6217   }
6218 
6219   if (NeedConstBefore) {
6220     // Extension: Add 'const' to qualifiers that come before the first qualifier
6221     // mismatch, so that our (non-standard!) composite type meets the
6222     // requirements of C++ [conv.qual]p4 bullet 3.
6223     for (unsigned I = 0; I != NeedConstBefore; ++I)
6224       if ((QualifierUnion[I] & Qualifiers::Const) == 0)
6225         QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
6226   }
6227 
6228   // Rewrap the composites as pointers or member pointers with the union CVRs.
6229   auto MOC = MemberOfClass.rbegin();
6230   for (unsigned CVR : llvm::reverse(QualifierUnion)) {
6231     Qualifiers Quals = Qualifiers::fromCVRMask(CVR);
6232     auto Classes = *MOC++;
6233     if (Classes.first && Classes.second) {
6234       // Rebuild member pointer type
6235       Composite1 = Context.getMemberPointerType(
6236           Context.getQualifiedType(Composite1, Quals), Classes.first);
6237       Composite2 = Context.getMemberPointerType(
6238           Context.getQualifiedType(Composite2, Quals), Classes.second);
6239     } else {
6240       // Rebuild pointer type
6241       Composite1 =
6242           Context.getPointerType(Context.getQualifiedType(Composite1, Quals));
6243       Composite2 =
6244           Context.getPointerType(Context.getQualifiedType(Composite2, Quals));
6245     }
6246   }
6247 
6248   struct Conversion {
6249     Sema &S;
6250     Expr *&E1, *&E2;
6251     QualType Composite;
6252     InitializedEntity Entity;
6253     InitializationKind Kind;
6254     InitializationSequence E1ToC, E2ToC;
6255     bool Viable;
6256 
6257     Conversion(Sema &S, SourceLocation Loc, Expr *&E1, Expr *&E2,
6258                QualType Composite)
6259         : S(S), E1(E1), E2(E2), Composite(Composite),
6260           Entity(InitializedEntity::InitializeTemporary(Composite)),
6261           Kind(InitializationKind::CreateCopy(Loc, SourceLocation())),
6262           E1ToC(S, Entity, Kind, E1), E2ToC(S, Entity, Kind, E2),
6263           Viable(E1ToC && E2ToC) {}
6264 
6265     bool perform() {
6266       ExprResult E1Result = E1ToC.Perform(S, Entity, Kind, E1);
6267       if (E1Result.isInvalid())
6268         return true;
6269       E1 = E1Result.getAs<Expr>();
6270 
6271       ExprResult E2Result = E2ToC.Perform(S, Entity, Kind, E2);
6272       if (E2Result.isInvalid())
6273         return true;
6274       E2 = E2Result.getAs<Expr>();
6275 
6276       return false;
6277     }
6278   };
6279 
6280   // Try to convert to each composite pointer type.
6281   Conversion C1(*this, Loc, E1, E2, Composite1);
6282   if (C1.Viable && Context.hasSameType(Composite1, Composite2)) {
6283     if (ConvertArgs && C1.perform())
6284       return QualType();
6285     return C1.Composite;
6286   }
6287   Conversion C2(*this, Loc, E1, E2, Composite2);
6288 
6289   if (C1.Viable == C2.Viable) {
6290     // Either Composite1 and Composite2 are viable and are different, or
6291     // neither is viable.
6292     // FIXME: How both be viable and different?
6293     return QualType();
6294   }
6295 
6296   // Convert to the chosen type.
6297   if (ConvertArgs && (C1.Viable ? C1 : C2).perform())
6298     return QualType();
6299 
6300   return C1.Viable ? C1.Composite : C2.Composite;
6301 }
6302 
6303 ExprResult Sema::MaybeBindToTemporary(Expr *E) {
6304   if (!E)
6305     return ExprError();
6306 
6307   assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
6308 
6309   // If the result is a glvalue, we shouldn't bind it.
6310   if (!E->isRValue())
6311     return E;
6312 
6313   // In ARC, calls that return a retainable type can return retained,
6314   // in which case we have to insert a consuming cast.
6315   if (getLangOpts().ObjCAutoRefCount &&
6316       E->getType()->isObjCRetainableType()) {
6317 
6318     bool ReturnsRetained;
6319 
6320     // For actual calls, we compute this by examining the type of the
6321     // called value.
6322     if (CallExpr *Call = dyn_cast<CallExpr>(E)) {
6323       Expr *Callee = Call->getCallee()->IgnoreParens();
6324       QualType T = Callee->getType();
6325 
6326       if (T == Context.BoundMemberTy) {
6327         // Handle pointer-to-members.
6328         if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Callee))
6329           T = BinOp->getRHS()->getType();
6330         else if (MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
6331           T = Mem->getMemberDecl()->getType();
6332       }
6333 
6334       if (const PointerType *Ptr = T->getAs<PointerType>())
6335         T = Ptr->getPointeeType();
6336       else if (const BlockPointerType *Ptr = T->getAs<BlockPointerType>())
6337         T = Ptr->getPointeeType();
6338       else if (const MemberPointerType *MemPtr = T->getAs<MemberPointerType>())
6339         T = MemPtr->getPointeeType();
6340 
6341       const FunctionType *FTy = T->getAs<FunctionType>();
6342       assert(FTy && "call to value not of function type?");
6343       ReturnsRetained = FTy->getExtInfo().getProducesResult();
6344 
6345     // ActOnStmtExpr arranges things so that StmtExprs of retainable
6346     // type always produce a +1 object.
6347     } else if (isa<StmtExpr>(E)) {
6348       ReturnsRetained = true;
6349 
6350     // We hit this case with the lambda conversion-to-block optimization;
6351     // we don't want any extra casts here.
6352     } else if (isa<CastExpr>(E) &&
6353                isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
6354       return E;
6355 
6356     // For message sends and property references, we try to find an
6357     // actual method.  FIXME: we should infer retention by selector in
6358     // cases where we don't have an actual method.
6359     } else {
6360       ObjCMethodDecl *D = nullptr;
6361       if (ObjCMessageExpr *Send = dyn_cast<ObjCMessageExpr>(E)) {
6362         D = Send->getMethodDecl();
6363       } else if (ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
6364         D = BoxedExpr->getBoxingMethod();
6365       } else if (ObjCArrayLiteral *ArrayLit = dyn_cast<ObjCArrayLiteral>(E)) {
6366         // Don't do reclaims if we're using the zero-element array
6367         // constant.
6368         if (ArrayLit->getNumElements() == 0 &&
6369             Context.getLangOpts().ObjCRuntime.hasEmptyCollections())
6370           return E;
6371 
6372         D = ArrayLit->getArrayWithObjectsMethod();
6373       } else if (ObjCDictionaryLiteral *DictLit
6374                                         = dyn_cast<ObjCDictionaryLiteral>(E)) {
6375         // Don't do reclaims if we're using the zero-element dictionary
6376         // constant.
6377         if (DictLit->getNumElements() == 0 &&
6378             Context.getLangOpts().ObjCRuntime.hasEmptyCollections())
6379           return E;
6380 
6381         D = DictLit->getDictWithObjectsMethod();
6382       }
6383 
6384       ReturnsRetained = (D && D->hasAttr<NSReturnsRetainedAttr>());
6385 
6386       // Don't do reclaims on performSelector calls; despite their
6387       // return type, the invoked method doesn't necessarily actually
6388       // return an object.
6389       if (!ReturnsRetained &&
6390           D && D->getMethodFamily() == OMF_performSelector)
6391         return E;
6392     }
6393 
6394     // Don't reclaim an object of Class type.
6395     if (!ReturnsRetained && E->getType()->isObjCARCImplicitlyUnretainedType())
6396       return E;
6397 
6398     Cleanup.setExprNeedsCleanups(true);
6399 
6400     CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
6401                                    : CK_ARCReclaimReturnedObject);
6402     return ImplicitCastExpr::Create(Context, E->getType(), ck, E, nullptr,
6403                                     VK_RValue);
6404   }
6405 
6406   if (!getLangOpts().CPlusPlus)
6407     return E;
6408 
6409   // Search for the base element type (cf. ASTContext::getBaseElementType) with
6410   // a fast path for the common case that the type is directly a RecordType.
6411   const Type *T = Context.getCanonicalType(E->getType().getTypePtr());
6412   const RecordType *RT = nullptr;
6413   while (!RT) {
6414     switch (T->getTypeClass()) {
6415     case Type::Record:
6416       RT = cast<RecordType>(T);
6417       break;
6418     case Type::ConstantArray:
6419     case Type::IncompleteArray:
6420     case Type::VariableArray:
6421     case Type::DependentSizedArray:
6422       T = cast<ArrayType>(T)->getElementType().getTypePtr();
6423       break;
6424     default:
6425       return E;
6426     }
6427   }
6428 
6429   // That should be enough to guarantee that this type is complete, if we're
6430   // not processing a decltype expression.
6431   CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
6432   if (RD->isInvalidDecl() || RD->isDependentContext())
6433     return E;
6434 
6435   bool IsDecltype = ExprEvalContexts.back().IsDecltype;
6436   CXXDestructorDecl *Destructor = IsDecltype ? nullptr : LookupDestructor(RD);
6437 
6438   if (Destructor) {
6439     MarkFunctionReferenced(E->getExprLoc(), Destructor);
6440     CheckDestructorAccess(E->getExprLoc(), Destructor,
6441                           PDiag(diag::err_access_dtor_temp)
6442                             << E->getType());
6443     if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
6444       return ExprError();
6445 
6446     // If destructor is trivial, we can avoid the extra copy.
6447     if (Destructor->isTrivial())
6448       return E;
6449 
6450     // We need a cleanup, but we don't need to remember the temporary.
6451     Cleanup.setExprNeedsCleanups(true);
6452   }
6453 
6454   CXXTemporary *Temp = CXXTemporary::Create(Context, Destructor);
6455   CXXBindTemporaryExpr *Bind = CXXBindTemporaryExpr::Create(Context, Temp, E);
6456 
6457   if (IsDecltype)
6458     ExprEvalContexts.back().DelayedDecltypeBinds.push_back(Bind);
6459 
6460   return Bind;
6461 }
6462 
6463 ExprResult
6464 Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr) {
6465   if (SubExpr.isInvalid())
6466     return ExprError();
6467 
6468   return MaybeCreateExprWithCleanups(SubExpr.get());
6469 }
6470 
6471 Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) {
6472   assert(SubExpr && "subexpression can't be null!");
6473 
6474   CleanupVarDeclMarking();
6475 
6476   unsigned FirstCleanup = ExprEvalContexts.back().NumCleanupObjects;
6477   assert(ExprCleanupObjects.size() >= FirstCleanup);
6478   assert(Cleanup.exprNeedsCleanups() ||
6479          ExprCleanupObjects.size() == FirstCleanup);
6480   if (!Cleanup.exprNeedsCleanups())
6481     return SubExpr;
6482 
6483   auto Cleanups = llvm::makeArrayRef(ExprCleanupObjects.begin() + FirstCleanup,
6484                                      ExprCleanupObjects.size() - FirstCleanup);
6485 
6486   auto *E = ExprWithCleanups::Create(
6487       Context, SubExpr, Cleanup.cleanupsHaveSideEffects(), Cleanups);
6488   DiscardCleanupsInEvaluationContext();
6489 
6490   return E;
6491 }
6492 
6493 Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) {
6494   assert(SubStmt && "sub-statement can't be null!");
6495 
6496   CleanupVarDeclMarking();
6497 
6498   if (!Cleanup.exprNeedsCleanups())
6499     return SubStmt;
6500 
6501   // FIXME: In order to attach the temporaries, wrap the statement into
6502   // a StmtExpr; currently this is only used for asm statements.
6503   // This is hacky, either create a new CXXStmtWithTemporaries statement or
6504   // a new AsmStmtWithTemporaries.
6505   CompoundStmt *CompStmt = CompoundStmt::Create(
6506       Context, SubStmt, SourceLocation(), SourceLocation());
6507   Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(),
6508                                    SourceLocation());
6509   return MaybeCreateExprWithCleanups(E);
6510 }
6511 
6512 /// Process the expression contained within a decltype. For such expressions,
6513 /// certain semantic checks on temporaries are delayed until this point, and
6514 /// are omitted for the 'topmost' call in the decltype expression. If the
6515 /// topmost call bound a temporary, strip that temporary off the expression.
6516 ExprResult Sema::ActOnDecltypeExpression(Expr *E) {
6517   assert(ExprEvalContexts.back().IsDecltype && "not in a decltype expression");
6518 
6519   // C++11 [expr.call]p11:
6520   //   If a function call is a prvalue of object type,
6521   // -- if the function call is either
6522   //   -- the operand of a decltype-specifier, or
6523   //   -- the right operand of a comma operator that is the operand of a
6524   //      decltype-specifier,
6525   //   a temporary object is not introduced for the prvalue.
6526 
6527   // Recursively rebuild ParenExprs and comma expressions to strip out the
6528   // outermost CXXBindTemporaryExpr, if any.
6529   if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
6530     ExprResult SubExpr = ActOnDecltypeExpression(PE->getSubExpr());
6531     if (SubExpr.isInvalid())
6532       return ExprError();
6533     if (SubExpr.get() == PE->getSubExpr())
6534       return E;
6535     return ActOnParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.get());
6536   }
6537   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
6538     if (BO->getOpcode() == BO_Comma) {
6539       ExprResult RHS = ActOnDecltypeExpression(BO->getRHS());
6540       if (RHS.isInvalid())
6541         return ExprError();
6542       if (RHS.get() == BO->getRHS())
6543         return E;
6544       return new (Context) BinaryOperator(
6545           BO->getLHS(), RHS.get(), BO_Comma, BO->getType(), BO->getValueKind(),
6546           BO->getObjectKind(), BO->getOperatorLoc(), BO->getFPFeatures());
6547     }
6548   }
6549 
6550   CXXBindTemporaryExpr *TopBind = dyn_cast<CXXBindTemporaryExpr>(E);
6551   CallExpr *TopCall = TopBind ? dyn_cast<CallExpr>(TopBind->getSubExpr())
6552                               : nullptr;
6553   if (TopCall)
6554     E = TopCall;
6555   else
6556     TopBind = nullptr;
6557 
6558   // Disable the special decltype handling now.
6559   ExprEvalContexts.back().IsDecltype = false;
6560 
6561   // In MS mode, don't perform any extra checking of call return types within a
6562   // decltype expression.
6563   if (getLangOpts().MSVCCompat)
6564     return E;
6565 
6566   // Perform the semantic checks we delayed until this point.
6567   for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeCalls.size();
6568        I != N; ++I) {
6569     CallExpr *Call = ExprEvalContexts.back().DelayedDecltypeCalls[I];
6570     if (Call == TopCall)
6571       continue;
6572 
6573     if (CheckCallReturnType(Call->getCallReturnType(Context),
6574                             Call->getLocStart(),
6575                             Call, Call->getDirectCallee()))
6576       return ExprError();
6577   }
6578 
6579   // Now all relevant types are complete, check the destructors are accessible
6580   // and non-deleted, and annotate them on the temporaries.
6581   for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeBinds.size();
6582        I != N; ++I) {
6583     CXXBindTemporaryExpr *Bind =
6584       ExprEvalContexts.back().DelayedDecltypeBinds[I];
6585     if (Bind == TopBind)
6586       continue;
6587 
6588     CXXTemporary *Temp = Bind->getTemporary();
6589 
6590     CXXRecordDecl *RD =
6591       Bind->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
6592     CXXDestructorDecl *Destructor = LookupDestructor(RD);
6593     Temp->setDestructor(Destructor);
6594 
6595     MarkFunctionReferenced(Bind->getExprLoc(), Destructor);
6596     CheckDestructorAccess(Bind->getExprLoc(), Destructor,
6597                           PDiag(diag::err_access_dtor_temp)
6598                             << Bind->getType());
6599     if (DiagnoseUseOfDecl(Destructor, Bind->getExprLoc()))
6600       return ExprError();
6601 
6602     // We need a cleanup, but we don't need to remember the temporary.
6603     Cleanup.setExprNeedsCleanups(true);
6604   }
6605 
6606   // Possibly strip off the top CXXBindTemporaryExpr.
6607   return E;
6608 }
6609 
6610 /// Note a set of 'operator->' functions that were used for a member access.
6611 static void noteOperatorArrows(Sema &S,
6612                                ArrayRef<FunctionDecl *> OperatorArrows) {
6613   unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
6614   // FIXME: Make this configurable?
6615   unsigned Limit = 9;
6616   if (OperatorArrows.size() > Limit) {
6617     // Produce Limit-1 normal notes and one 'skipping' note.
6618     SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
6619     SkipCount = OperatorArrows.size() - (Limit - 1);
6620   }
6621 
6622   for (unsigned I = 0; I < OperatorArrows.size(); /**/) {
6623     if (I == SkipStart) {
6624       S.Diag(OperatorArrows[I]->getLocation(),
6625              diag::note_operator_arrows_suppressed)
6626           << SkipCount;
6627       I += SkipCount;
6628     } else {
6629       S.Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
6630           << OperatorArrows[I]->getCallResultType();
6631       ++I;
6632     }
6633   }
6634 }
6635 
6636 ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
6637                                               SourceLocation OpLoc,
6638                                               tok::TokenKind OpKind,
6639                                               ParsedType &ObjectType,
6640                                               bool &MayBePseudoDestructor) {
6641   // Since this might be a postfix expression, get rid of ParenListExprs.
6642   ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
6643   if (Result.isInvalid()) return ExprError();
6644   Base = Result.get();
6645 
6646   Result = CheckPlaceholderExpr(Base);
6647   if (Result.isInvalid()) return ExprError();
6648   Base = Result.get();
6649 
6650   QualType BaseType = Base->getType();
6651   MayBePseudoDestructor = false;
6652   if (BaseType->isDependentType()) {
6653     // If we have a pointer to a dependent type and are using the -> operator,
6654     // the object type is the type that the pointer points to. We might still
6655     // have enough information about that type to do something useful.
6656     if (OpKind == tok::arrow)
6657       if (const PointerType *Ptr = BaseType->getAs<PointerType>())
6658         BaseType = Ptr->getPointeeType();
6659 
6660     ObjectType = ParsedType::make(BaseType);
6661     MayBePseudoDestructor = true;
6662     return Base;
6663   }
6664 
6665   // C++ [over.match.oper]p8:
6666   //   [...] When operator->returns, the operator-> is applied  to the value
6667   //   returned, with the original second operand.
6668   if (OpKind == tok::arrow) {
6669     QualType StartingType = BaseType;
6670     bool NoArrowOperatorFound = false;
6671     bool FirstIteration = true;
6672     FunctionDecl *CurFD = dyn_cast<FunctionDecl>(CurContext);
6673     // The set of types we've considered so far.
6674     llvm::SmallPtrSet<CanQualType,8> CTypes;
6675     SmallVector<FunctionDecl*, 8> OperatorArrows;
6676     CTypes.insert(Context.getCanonicalType(BaseType));
6677 
6678     while (BaseType->isRecordType()) {
6679       if (OperatorArrows.size() >= getLangOpts().ArrowDepth) {
6680         Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
6681           << StartingType << getLangOpts().ArrowDepth << Base->getSourceRange();
6682         noteOperatorArrows(*this, OperatorArrows);
6683         Diag(OpLoc, diag::note_operator_arrow_depth)
6684           << getLangOpts().ArrowDepth;
6685         return ExprError();
6686       }
6687 
6688       Result = BuildOverloadedArrowExpr(
6689           S, Base, OpLoc,
6690           // When in a template specialization and on the first loop iteration,
6691           // potentially give the default diagnostic (with the fixit in a
6692           // separate note) instead of having the error reported back to here
6693           // and giving a diagnostic with a fixit attached to the error itself.
6694           (FirstIteration && CurFD && CurFD->isFunctionTemplateSpecialization())
6695               ? nullptr
6696               : &NoArrowOperatorFound);
6697       if (Result.isInvalid()) {
6698         if (NoArrowOperatorFound) {
6699           if (FirstIteration) {
6700             Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6701               << BaseType << 1 << Base->getSourceRange()
6702               << FixItHint::CreateReplacement(OpLoc, ".");
6703             OpKind = tok::period;
6704             break;
6705           }
6706           Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
6707             << BaseType << Base->getSourceRange();
6708           CallExpr *CE = dyn_cast<CallExpr>(Base);
6709           if (Decl *CD = (CE ? CE->getCalleeDecl() : nullptr)) {
6710             Diag(CD->getLocStart(),
6711                  diag::note_member_reference_arrow_from_operator_arrow);
6712           }
6713         }
6714         return ExprError();
6715       }
6716       Base = Result.get();
6717       if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base))
6718         OperatorArrows.push_back(OpCall->getDirectCallee());
6719       BaseType = Base->getType();
6720       CanQualType CBaseType = Context.getCanonicalType(BaseType);
6721       if (!CTypes.insert(CBaseType).second) {
6722         Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
6723         noteOperatorArrows(*this, OperatorArrows);
6724         return ExprError();
6725       }
6726       FirstIteration = false;
6727     }
6728 
6729     if (OpKind == tok::arrow &&
6730         (BaseType->isPointerType() || BaseType->isObjCObjectPointerType()))
6731       BaseType = BaseType->getPointeeType();
6732   }
6733 
6734   // Objective-C properties allow "." access on Objective-C pointer types,
6735   // so adjust the base type to the object type itself.
6736   if (BaseType->isObjCObjectPointerType())
6737     BaseType = BaseType->getPointeeType();
6738 
6739   // C++ [basic.lookup.classref]p2:
6740   //   [...] If the type of the object expression is of pointer to scalar
6741   //   type, the unqualified-id is looked up in the context of the complete
6742   //   postfix-expression.
6743   //
6744   // This also indicates that we could be parsing a pseudo-destructor-name.
6745   // Note that Objective-C class and object types can be pseudo-destructor
6746   // expressions or normal member (ivar or property) access expressions, and
6747   // it's legal for the type to be incomplete if this is a pseudo-destructor
6748   // call.  We'll do more incomplete-type checks later in the lookup process,
6749   // so just skip this check for ObjC types.
6750   if (BaseType->isObjCObjectOrInterfaceType()) {
6751     ObjectType = ParsedType::make(BaseType);
6752     MayBePseudoDestructor = true;
6753     return Base;
6754   } else if (!BaseType->isRecordType()) {
6755     ObjectType = nullptr;
6756     MayBePseudoDestructor = true;
6757     return Base;
6758   }
6759 
6760   // The object type must be complete (or dependent), or
6761   // C++11 [expr.prim.general]p3:
6762   //   Unlike the object expression in other contexts, *this is not required to
6763   //   be of complete type for purposes of class member access (5.2.5) outside
6764   //   the member function body.
6765   if (!BaseType->isDependentType() &&
6766       !isThisOutsideMemberFunctionBody(BaseType) &&
6767       RequireCompleteType(OpLoc, BaseType, diag::err_incomplete_member_access))
6768     return ExprError();
6769 
6770   // C++ [basic.lookup.classref]p2:
6771   //   If the id-expression in a class member access (5.2.5) is an
6772   //   unqualified-id, and the type of the object expression is of a class
6773   //   type C (or of pointer to a class type C), the unqualified-id is looked
6774   //   up in the scope of class C. [...]
6775   ObjectType = ParsedType::make(BaseType);
6776   return Base;
6777 }
6778 
6779 static bool CheckArrow(Sema& S, QualType& ObjectType, Expr *&Base,
6780                    tok::TokenKind& OpKind, SourceLocation OpLoc) {
6781   if (Base->hasPlaceholderType()) {
6782     ExprResult result = S.CheckPlaceholderExpr(Base);
6783     if (result.isInvalid()) return true;
6784     Base = result.get();
6785   }
6786   ObjectType = Base->getType();
6787 
6788   // C++ [expr.pseudo]p2:
6789   //   The left-hand side of the dot operator shall be of scalar type. The
6790   //   left-hand side of the arrow operator shall be of pointer to scalar type.
6791   //   This scalar type is the object type.
6792   // Note that this is rather different from the normal handling for the
6793   // arrow operator.
6794   if (OpKind == tok::arrow) {
6795     if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
6796       ObjectType = Ptr->getPointeeType();
6797     } else if (!Base->isTypeDependent()) {
6798       // The user wrote "p->" when they probably meant "p."; fix it.
6799       S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6800         << ObjectType << true
6801         << FixItHint::CreateReplacement(OpLoc, ".");
6802       if (S.isSFINAEContext())
6803         return true;
6804 
6805       OpKind = tok::period;
6806     }
6807   }
6808 
6809   return false;
6810 }
6811 
6812 /// Check if it's ok to try and recover dot pseudo destructor calls on
6813 /// pointer objects.
6814 static bool
6815 canRecoverDotPseudoDestructorCallsOnPointerObjects(Sema &SemaRef,
6816                                                    QualType DestructedType) {
6817   // If this is a record type, check if its destructor is callable.
6818   if (auto *RD = DestructedType->getAsCXXRecordDecl()) {
6819     if (CXXDestructorDecl *D = SemaRef.LookupDestructor(RD))
6820       return SemaRef.CanUseDecl(D, /*TreatUnavailableAsInvalid=*/false);
6821     return false;
6822   }
6823 
6824   // Otherwise, check if it's a type for which it's valid to use a pseudo-dtor.
6825   return DestructedType->isDependentType() || DestructedType->isScalarType() ||
6826          DestructedType->isVectorType();
6827 }
6828 
6829 ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base,
6830                                            SourceLocation OpLoc,
6831                                            tok::TokenKind OpKind,
6832                                            const CXXScopeSpec &SS,
6833                                            TypeSourceInfo *ScopeTypeInfo,
6834                                            SourceLocation CCLoc,
6835                                            SourceLocation TildeLoc,
6836                                          PseudoDestructorTypeStorage Destructed) {
6837   TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo();
6838 
6839   QualType ObjectType;
6840   if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
6841     return ExprError();
6842 
6843   if (!ObjectType->isDependentType() && !ObjectType->isScalarType() &&
6844       !ObjectType->isVectorType()) {
6845     if (getLangOpts().MSVCCompat && ObjectType->isVoidType())
6846       Diag(OpLoc, diag::ext_pseudo_dtor_on_void) << Base->getSourceRange();
6847     else {
6848       Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
6849         << ObjectType << Base->getSourceRange();
6850       return ExprError();
6851     }
6852   }
6853 
6854   // C++ [expr.pseudo]p2:
6855   //   [...] The cv-unqualified versions of the object type and of the type
6856   //   designated by the pseudo-destructor-name shall be the same type.
6857   if (DestructedTypeInfo) {
6858     QualType DestructedType = DestructedTypeInfo->getType();
6859     SourceLocation DestructedTypeStart
6860       = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin();
6861     if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) {
6862       if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {
6863         // Detect dot pseudo destructor calls on pointer objects, e.g.:
6864         //   Foo *foo;
6865         //   foo.~Foo();
6866         if (OpKind == tok::period && ObjectType->isPointerType() &&
6867             Context.hasSameUnqualifiedType(DestructedType,
6868                                            ObjectType->getPointeeType())) {
6869           auto Diagnostic =
6870               Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6871               << ObjectType << /*IsArrow=*/0 << Base->getSourceRange();
6872 
6873           // Issue a fixit only when the destructor is valid.
6874           if (canRecoverDotPseudoDestructorCallsOnPointerObjects(
6875                   *this, DestructedType))
6876             Diagnostic << FixItHint::CreateReplacement(OpLoc, "->");
6877 
6878           // Recover by setting the object type to the destructed type and the
6879           // operator to '->'.
6880           ObjectType = DestructedType;
6881           OpKind = tok::arrow;
6882         } else {
6883           Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
6884               << ObjectType << DestructedType << Base->getSourceRange()
6885               << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
6886 
6887           // Recover by setting the destructed type to the object type.
6888           DestructedType = ObjectType;
6889           DestructedTypeInfo =
6890               Context.getTrivialTypeSourceInfo(ObjectType, DestructedTypeStart);
6891           Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
6892         }
6893       } else if (DestructedType.getObjCLifetime() !=
6894                                                 ObjectType.getObjCLifetime()) {
6895 
6896         if (DestructedType.getObjCLifetime() == Qualifiers::OCL_None) {
6897           // Okay: just pretend that the user provided the correctly-qualified
6898           // type.
6899         } else {
6900           Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
6901             << ObjectType << DestructedType << Base->getSourceRange()
6902             << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
6903         }
6904 
6905         // Recover by setting the destructed type to the object type.
6906         DestructedType = ObjectType;
6907         DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
6908                                                            DestructedTypeStart);
6909         Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
6910       }
6911     }
6912   }
6913 
6914   // C++ [expr.pseudo]p2:
6915   //   [...] Furthermore, the two type-names in a pseudo-destructor-name of the
6916   //   form
6917   //
6918   //     ::[opt] nested-name-specifier[opt] type-name :: ~ type-name
6919   //
6920   //   shall designate the same scalar type.
6921   if (ScopeTypeInfo) {
6922     QualType ScopeType = ScopeTypeInfo->getType();
6923     if (!ScopeType->isDependentType() && !ObjectType->isDependentType() &&
6924         !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) {
6925 
6926       Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(),
6927            diag::err_pseudo_dtor_type_mismatch)
6928         << ObjectType << ScopeType << Base->getSourceRange()
6929         << ScopeTypeInfo->getTypeLoc().getLocalSourceRange();
6930 
6931       ScopeType = QualType();
6932       ScopeTypeInfo = nullptr;
6933     }
6934   }
6935 
6936   Expr *Result
6937     = new (Context) CXXPseudoDestructorExpr(Context, Base,
6938                                             OpKind == tok::arrow, OpLoc,
6939                                             SS.getWithLocInContext(Context),
6940                                             ScopeTypeInfo,
6941                                             CCLoc,
6942                                             TildeLoc,
6943                                             Destructed);
6944 
6945   return Result;
6946 }
6947 
6948 ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
6949                                            SourceLocation OpLoc,
6950                                            tok::TokenKind OpKind,
6951                                            CXXScopeSpec &SS,
6952                                            UnqualifiedId &FirstTypeName,
6953                                            SourceLocation CCLoc,
6954                                            SourceLocation TildeLoc,
6955                                            UnqualifiedId &SecondTypeName) {
6956   assert((FirstTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||
6957           FirstTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) &&
6958          "Invalid first type name in pseudo-destructor");
6959   assert((SecondTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||
6960           SecondTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) &&
6961          "Invalid second type name in pseudo-destructor");
6962 
6963   QualType ObjectType;
6964   if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
6965     return ExprError();
6966 
6967   // Compute the object type that we should use for name lookup purposes. Only
6968   // record types and dependent types matter.
6969   ParsedType ObjectTypePtrForLookup;
6970   if (!SS.isSet()) {
6971     if (ObjectType->isRecordType())
6972       ObjectTypePtrForLookup = ParsedType::make(ObjectType);
6973     else if (ObjectType->isDependentType())
6974       ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy);
6975   }
6976 
6977   // Convert the name of the type being destructed (following the ~) into a
6978   // type (with source-location information).
6979   QualType DestructedType;
6980   TypeSourceInfo *DestructedTypeInfo = nullptr;
6981   PseudoDestructorTypeStorage Destructed;
6982   if (SecondTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) {
6983     ParsedType T = getTypeName(*SecondTypeName.Identifier,
6984                                SecondTypeName.StartLocation,
6985                                S, &SS, true, false, ObjectTypePtrForLookup,
6986                                /*IsCtorOrDtorName*/true);
6987     if (!T &&
6988         ((SS.isSet() && !computeDeclContext(SS, false)) ||
6989          (!SS.isSet() && ObjectType->isDependentType()))) {
6990       // The name of the type being destroyed is a dependent name, and we
6991       // couldn't find anything useful in scope. Just store the identifier and
6992       // it's location, and we'll perform (qualified) name lookup again at
6993       // template instantiation time.
6994       Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier,
6995                                                SecondTypeName.StartLocation);
6996     } else if (!T) {
6997       Diag(SecondTypeName.StartLocation,
6998            diag::err_pseudo_dtor_destructor_non_type)
6999         << SecondTypeName.Identifier << ObjectType;
7000       if (isSFINAEContext())
7001         return ExprError();
7002 
7003       // Recover by assuming we had the right type all along.
7004       DestructedType = ObjectType;
7005     } else
7006       DestructedType = GetTypeFromParser(T, &DestructedTypeInfo);
7007   } else {
7008     // Resolve the template-id to a type.
7009     TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId;
7010     ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
7011                                        TemplateId->NumArgs);
7012     TypeResult T = ActOnTemplateIdType(TemplateId->SS,
7013                                        TemplateId->TemplateKWLoc,
7014                                        TemplateId->Template,
7015                                        TemplateId->Name,
7016                                        TemplateId->TemplateNameLoc,
7017                                        TemplateId->LAngleLoc,
7018                                        TemplateArgsPtr,
7019                                        TemplateId->RAngleLoc,
7020                                        /*IsCtorOrDtorName*/true);
7021     if (T.isInvalid() || !T.get()) {
7022       // Recover by assuming we had the right type all along.
7023       DestructedType = ObjectType;
7024     } else
7025       DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo);
7026   }
7027 
7028   // If we've performed some kind of recovery, (re-)build the type source
7029   // information.
7030   if (!DestructedType.isNull()) {
7031     if (!DestructedTypeInfo)
7032       DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType,
7033                                                   SecondTypeName.StartLocation);
7034     Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
7035   }
7036 
7037   // Convert the name of the scope type (the type prior to '::') into a type.
7038   TypeSourceInfo *ScopeTypeInfo = nullptr;
7039   QualType ScopeType;
7040   if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||
7041       FirstTypeName.Identifier) {
7042     if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) {
7043       ParsedType T = getTypeName(*FirstTypeName.Identifier,
7044                                  FirstTypeName.StartLocation,
7045                                  S, &SS, true, false, ObjectTypePtrForLookup,
7046                                  /*IsCtorOrDtorName*/true);
7047       if (!T) {
7048         Diag(FirstTypeName.StartLocation,
7049              diag::err_pseudo_dtor_destructor_non_type)
7050           << FirstTypeName.Identifier << ObjectType;
7051 
7052         if (isSFINAEContext())
7053           return ExprError();
7054 
7055         // Just drop this type. It's unnecessary anyway.
7056         ScopeType = QualType();
7057       } else
7058         ScopeType = GetTypeFromParser(T, &ScopeTypeInfo);
7059     } else {
7060       // Resolve the template-id to a type.
7061       TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId;
7062       ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
7063                                          TemplateId->NumArgs);
7064       TypeResult T = ActOnTemplateIdType(TemplateId->SS,
7065                                          TemplateId->TemplateKWLoc,
7066                                          TemplateId->Template,
7067                                          TemplateId->Name,
7068                                          TemplateId->TemplateNameLoc,
7069                                          TemplateId->LAngleLoc,
7070                                          TemplateArgsPtr,
7071                                          TemplateId->RAngleLoc,
7072                                          /*IsCtorOrDtorName*/true);
7073       if (T.isInvalid() || !T.get()) {
7074         // Recover by dropping this type.
7075         ScopeType = QualType();
7076       } else
7077         ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo);
7078     }
7079   }
7080 
7081   if (!ScopeType.isNull() && !ScopeTypeInfo)
7082     ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType,
7083                                                   FirstTypeName.StartLocation);
7084 
7085 
7086   return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS,
7087                                    ScopeTypeInfo, CCLoc, TildeLoc,
7088                                    Destructed);
7089 }
7090 
7091 ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
7092                                            SourceLocation OpLoc,
7093                                            tok::TokenKind OpKind,
7094                                            SourceLocation TildeLoc,
7095                                            const DeclSpec& DS) {
7096   QualType ObjectType;
7097   if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
7098     return ExprError();
7099 
7100   QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc(),
7101                                  false);
7102 
7103   TypeLocBuilder TLB;
7104   DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
7105   DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
7106   TypeSourceInfo *DestructedTypeInfo = TLB.getTypeSourceInfo(Context, T);
7107   PseudoDestructorTypeStorage Destructed(DestructedTypeInfo);
7108 
7109   return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, CXXScopeSpec(),
7110                                    nullptr, SourceLocation(), TildeLoc,
7111                                    Destructed);
7112 }
7113 
7114 ExprResult Sema::BuildCXXMemberCallExpr(Expr *E, NamedDecl *FoundDecl,
7115                                         CXXConversionDecl *Method,
7116                                         bool HadMultipleCandidates) {
7117   if (Method->getParent()->isLambda() &&
7118       Method->getConversionType()->isBlockPointerType()) {
7119     // This is a lambda coversion to block pointer; check if the argument
7120     // is a LambdaExpr.
7121     Expr *SubE = E;
7122     CastExpr *CE = dyn_cast<CastExpr>(SubE);
7123     if (CE && CE->getCastKind() == CK_NoOp)
7124       SubE = CE->getSubExpr();
7125     SubE = SubE->IgnoreParens();
7126     if (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(SubE))
7127       SubE = BE->getSubExpr();
7128     if (isa<LambdaExpr>(SubE)) {
7129       // For the conversion to block pointer on a lambda expression, we
7130       // construct a special BlockLiteral instead; this doesn't really make
7131       // a difference in ARC, but outside of ARC the resulting block literal
7132       // follows the normal lifetime rules for block literals instead of being
7133       // autoreleased.
7134       DiagnosticErrorTrap Trap(Diags);
7135       PushExpressionEvaluationContext(
7136           ExpressionEvaluationContext::PotentiallyEvaluated);
7137       ExprResult Exp = BuildBlockForLambdaConversion(E->getExprLoc(),
7138                                                      E->getExprLoc(),
7139                                                      Method, E);
7140       PopExpressionEvaluationContext();
7141 
7142       if (Exp.isInvalid())
7143         Diag(E->getExprLoc(), diag::note_lambda_to_block_conv);
7144       return Exp;
7145     }
7146   }
7147 
7148   ExprResult Exp = PerformObjectArgumentInitialization(E, /*Qualifier=*/nullptr,
7149                                           FoundDecl, Method);
7150   if (Exp.isInvalid())
7151     return true;
7152 
7153   MemberExpr *ME = new (Context) MemberExpr(
7154       Exp.get(), /*IsArrow=*/false, SourceLocation(), Method, SourceLocation(),
7155       Context.BoundMemberTy, VK_RValue, OK_Ordinary);
7156   if (HadMultipleCandidates)
7157     ME->setHadMultipleCandidates(true);
7158   MarkMemberReferenced(ME);
7159 
7160   QualType ResultType = Method->getReturnType();
7161   ExprValueKind VK = Expr::getValueKindForType(ResultType);
7162   ResultType = ResultType.getNonLValueExprType(Context);
7163 
7164   CXXMemberCallExpr *CE =
7165     new (Context) CXXMemberCallExpr(Context, ME, None, ResultType, VK,
7166                                     Exp.get()->getLocEnd());
7167 
7168   if (CheckFunctionCall(Method, CE,
7169                         Method->getType()->castAs<FunctionProtoType>()))
7170     return ExprError();
7171 
7172   return CE;
7173 }
7174 
7175 ExprResult Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
7176                                       SourceLocation RParen) {
7177   // If the operand is an unresolved lookup expression, the expression is ill-
7178   // formed per [over.over]p1, because overloaded function names cannot be used
7179   // without arguments except in explicit contexts.
7180   ExprResult R = CheckPlaceholderExpr(Operand);
7181   if (R.isInvalid())
7182     return R;
7183 
7184   // The operand may have been modified when checking the placeholder type.
7185   Operand = R.get();
7186 
7187   if (!inTemplateInstantiation() && Operand->HasSideEffects(Context, false)) {
7188     // The expression operand for noexcept is in an unevaluated expression
7189     // context, so side effects could result in unintended consequences.
7190     Diag(Operand->getExprLoc(), diag::warn_side_effects_unevaluated_context);
7191   }
7192 
7193   CanThrowResult CanThrow = canThrow(Operand);
7194   return new (Context)
7195       CXXNoexceptExpr(Context.BoolTy, Operand, CanThrow, KeyLoc, RParen);
7196 }
7197 
7198 ExprResult Sema::ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation,
7199                                    Expr *Operand, SourceLocation RParen) {
7200   return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen);
7201 }
7202 
7203 static bool IsSpecialDiscardedValue(Expr *E) {
7204   // In C++11, discarded-value expressions of a certain form are special,
7205   // according to [expr]p10:
7206   //   The lvalue-to-rvalue conversion (4.1) is applied only if the
7207   //   expression is an lvalue of volatile-qualified type and it has
7208   //   one of the following forms:
7209   E = E->IgnoreParens();
7210 
7211   //   - id-expression (5.1.1),
7212   if (isa<DeclRefExpr>(E))
7213     return true;
7214 
7215   //   - subscripting (5.2.1),
7216   if (isa<ArraySubscriptExpr>(E))
7217     return true;
7218 
7219   //   - class member access (5.2.5),
7220   if (isa<MemberExpr>(E))
7221     return true;
7222 
7223   //   - indirection (5.3.1),
7224   if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
7225     if (UO->getOpcode() == UO_Deref)
7226       return true;
7227 
7228   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
7229     //   - pointer-to-member operation (5.5),
7230     if (BO->isPtrMemOp())
7231       return true;
7232 
7233     //   - comma expression (5.18) where the right operand is one of the above.
7234     if (BO->getOpcode() == BO_Comma)
7235       return IsSpecialDiscardedValue(BO->getRHS());
7236   }
7237 
7238   //   - conditional expression (5.16) where both the second and the third
7239   //     operands are one of the above, or
7240   if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
7241     return IsSpecialDiscardedValue(CO->getTrueExpr()) &&
7242            IsSpecialDiscardedValue(CO->getFalseExpr());
7243   // The related edge case of "*x ?: *x".
7244   if (BinaryConditionalOperator *BCO =
7245           dyn_cast<BinaryConditionalOperator>(E)) {
7246     if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
7247       return IsSpecialDiscardedValue(OVE->getSourceExpr()) &&
7248              IsSpecialDiscardedValue(BCO->getFalseExpr());
7249   }
7250 
7251   // Objective-C++ extensions to the rule.
7252   if (isa<PseudoObjectExpr>(E) || isa<ObjCIvarRefExpr>(E))
7253     return true;
7254 
7255   return false;
7256 }
7257 
7258 /// Perform the conversions required for an expression used in a
7259 /// context that ignores the result.
7260 ExprResult Sema::IgnoredValueConversions(Expr *E) {
7261   if (E->hasPlaceholderType()) {
7262     ExprResult result = CheckPlaceholderExpr(E);
7263     if (result.isInvalid()) return E;
7264     E = result.get();
7265   }
7266 
7267   // C99 6.3.2.1:
7268   //   [Except in specific positions,] an lvalue that does not have
7269   //   array type is converted to the value stored in the
7270   //   designated object (and is no longer an lvalue).
7271   if (E->isRValue()) {
7272     // In C, function designators (i.e. expressions of function type)
7273     // are r-values, but we still want to do function-to-pointer decay
7274     // on them.  This is both technically correct and convenient for
7275     // some clients.
7276     if (!getLangOpts().CPlusPlus && E->getType()->isFunctionType())
7277       return DefaultFunctionArrayConversion(E);
7278 
7279     return E;
7280   }
7281 
7282   if (getLangOpts().CPlusPlus)  {
7283     // The C++11 standard defines the notion of a discarded-value expression;
7284     // normally, we don't need to do anything to handle it, but if it is a
7285     // volatile lvalue with a special form, we perform an lvalue-to-rvalue
7286     // conversion.
7287     if (getLangOpts().CPlusPlus11 && E->isGLValue() &&
7288         E->getType().isVolatileQualified() &&
7289         IsSpecialDiscardedValue(E)) {
7290       ExprResult Res = DefaultLvalueConversion(E);
7291       if (Res.isInvalid())
7292         return E;
7293       E = Res.get();
7294     }
7295 
7296     // C++1z:
7297     //   If the expression is a prvalue after this optional conversion, the
7298     //   temporary materialization conversion is applied.
7299     //
7300     // We skip this step: IR generation is able to synthesize the storage for
7301     // itself in the aggregate case, and adding the extra node to the AST is
7302     // just clutter.
7303     // FIXME: We don't emit lifetime markers for the temporaries due to this.
7304     // FIXME: Do any other AST consumers care about this?
7305     return E;
7306   }
7307 
7308   // GCC seems to also exclude expressions of incomplete enum type.
7309   if (const EnumType *T = E->getType()->getAs<EnumType>()) {
7310     if (!T->getDecl()->isComplete()) {
7311       // FIXME: stupid workaround for a codegen bug!
7312       E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).get();
7313       return E;
7314     }
7315   }
7316 
7317   ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
7318   if (Res.isInvalid())
7319     return E;
7320   E = Res.get();
7321 
7322   if (!E->getType()->isVoidType())
7323     RequireCompleteType(E->getExprLoc(), E->getType(),
7324                         diag::err_incomplete_type);
7325   return E;
7326 }
7327 
7328 // If we can unambiguously determine whether Var can never be used
7329 // in a constant expression, return true.
7330 //  - if the variable and its initializer are non-dependent, then
7331 //    we can unambiguously check if the variable is a constant expression.
7332 //  - if the initializer is not value dependent - we can determine whether
7333 //    it can be used to initialize a constant expression.  If Init can not
7334 //    be used to initialize a constant expression we conclude that Var can
7335 //    never be a constant expression.
7336 //  - FXIME: if the initializer is dependent, we can still do some analysis and
7337 //    identify certain cases unambiguously as non-const by using a Visitor:
7338 //      - such as those that involve odr-use of a ParmVarDecl, involve a new
7339 //        delete, lambda-expr, dynamic-cast, reinterpret-cast etc...
7340 static inline bool VariableCanNeverBeAConstantExpression(VarDecl *Var,
7341     ASTContext &Context) {
7342   if (isa<ParmVarDecl>(Var)) return true;
7343   const VarDecl *DefVD = nullptr;
7344 
7345   // If there is no initializer - this can not be a constant expression.
7346   if (!Var->getAnyInitializer(DefVD)) return true;
7347   assert(DefVD);
7348   if (DefVD->isWeak()) return false;
7349   EvaluatedStmt *Eval = DefVD->ensureEvaluatedStmt();
7350 
7351   Expr *Init = cast<Expr>(Eval->Value);
7352 
7353   if (Var->getType()->isDependentType() || Init->isValueDependent()) {
7354     // FIXME: Teach the constant evaluator to deal with the non-dependent parts
7355     // of value-dependent expressions, and use it here to determine whether the
7356     // initializer is a potential constant expression.
7357     return false;
7358   }
7359 
7360   return !IsVariableAConstantExpression(Var, Context);
7361 }
7362 
7363 /// Check if the current lambda has any potential captures
7364 /// that must be captured by any of its enclosing lambdas that are ready to
7365 /// capture. If there is a lambda that can capture a nested
7366 /// potential-capture, go ahead and do so.  Also, check to see if any
7367 /// variables are uncaptureable or do not involve an odr-use so do not
7368 /// need to be captured.
7369 
7370 static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(
7371     Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S) {
7372 
7373   assert(!S.isUnevaluatedContext());
7374   assert(S.CurContext->isDependentContext());
7375 #ifndef NDEBUG
7376   DeclContext *DC = S.CurContext;
7377   while (DC && isa<CapturedDecl>(DC))
7378     DC = DC->getParent();
7379   assert(
7380       CurrentLSI->CallOperator == DC &&
7381       "The current call operator must be synchronized with Sema's CurContext");
7382 #endif // NDEBUG
7383 
7384   const bool IsFullExprInstantiationDependent = FE->isInstantiationDependent();
7385 
7386   // All the potentially captureable variables in the current nested
7387   // lambda (within a generic outer lambda), must be captured by an
7388   // outer lambda that is enclosed within a non-dependent context.
7389   const unsigned NumPotentialCaptures =
7390       CurrentLSI->getNumPotentialVariableCaptures();
7391   for (unsigned I = 0; I != NumPotentialCaptures; ++I) {
7392     Expr *VarExpr = nullptr;
7393     VarDecl *Var = nullptr;
7394     CurrentLSI->getPotentialVariableCapture(I, Var, VarExpr);
7395     // If the variable is clearly identified as non-odr-used and the full
7396     // expression is not instantiation dependent, only then do we not
7397     // need to check enclosing lambda's for speculative captures.
7398     // For e.g.:
7399     // Even though 'x' is not odr-used, it should be captured.
7400     // int test() {
7401     //   const int x = 10;
7402     //   auto L = [=](auto a) {
7403     //     (void) +x + a;
7404     //   };
7405     // }
7406     if (CurrentLSI->isVariableExprMarkedAsNonODRUsed(VarExpr) &&
7407         !IsFullExprInstantiationDependent)
7408       continue;
7409 
7410     // If we have a capture-capable lambda for the variable, go ahead and
7411     // capture the variable in that lambda (and all its enclosing lambdas).
7412     if (const Optional<unsigned> Index =
7413             getStackIndexOfNearestEnclosingCaptureCapableLambda(
7414                 S.FunctionScopes, Var, S)) {
7415       const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7416       MarkVarDeclODRUsed(Var, VarExpr->getExprLoc(), S,
7417                          &FunctionScopeIndexOfCapturableLambda);
7418     }
7419     const bool IsVarNeverAConstantExpression =
7420         VariableCanNeverBeAConstantExpression(Var, S.Context);
7421     if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
7422       // This full expression is not instantiation dependent or the variable
7423       // can not be used in a constant expression - which means
7424       // this variable must be odr-used here, so diagnose a
7425       // capture violation early, if the variable is un-captureable.
7426       // This is purely for diagnosing errors early.  Otherwise, this
7427       // error would get diagnosed when the lambda becomes capture ready.
7428       QualType CaptureType, DeclRefType;
7429       SourceLocation ExprLoc = VarExpr->getExprLoc();
7430       if (S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit,
7431                           /*EllipsisLoc*/ SourceLocation(),
7432                           /*BuildAndDiagnose*/false, CaptureType,
7433                           DeclRefType, nullptr)) {
7434         // We will never be able to capture this variable, and we need
7435         // to be able to in any and all instantiations, so diagnose it.
7436         S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit,
7437                           /*EllipsisLoc*/ SourceLocation(),
7438                           /*BuildAndDiagnose*/true, CaptureType,
7439                           DeclRefType, nullptr);
7440       }
7441     }
7442   }
7443 
7444   // Check if 'this' needs to be captured.
7445   if (CurrentLSI->hasPotentialThisCapture()) {
7446     // If we have a capture-capable lambda for 'this', go ahead and capture
7447     // 'this' in that lambda (and all its enclosing lambdas).
7448     if (const Optional<unsigned> Index =
7449             getStackIndexOfNearestEnclosingCaptureCapableLambda(
7450                 S.FunctionScopes, /*0 is 'this'*/ nullptr, S)) {
7451       const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue();
7452       S.CheckCXXThisCapture(CurrentLSI->PotentialThisCaptureLocation,
7453                             /*Explicit*/ false, /*BuildAndDiagnose*/ true,
7454                             &FunctionScopeIndexOfCapturableLambda);
7455     }
7456   }
7457 
7458   // Reset all the potential captures at the end of each full-expression.
7459   CurrentLSI->clearPotentialCaptures();
7460 }
7461 
7462 static ExprResult attemptRecovery(Sema &SemaRef,
7463                                   const TypoCorrectionConsumer &Consumer,
7464                                   const TypoCorrection &TC) {
7465   LookupResult R(SemaRef, Consumer.getLookupResult().getLookupNameInfo(),
7466                  Consumer.getLookupResult().getLookupKind());
7467   const CXXScopeSpec *SS = Consumer.getSS();
7468   CXXScopeSpec NewSS;
7469 
7470   // Use an approprate CXXScopeSpec for building the expr.
7471   if (auto *NNS = TC.getCorrectionSpecifier())
7472     NewSS.MakeTrivial(SemaRef.Context, NNS, TC.getCorrectionRange());
7473   else if (SS && !TC.WillReplaceSpecifier())
7474     NewSS = *SS;
7475 
7476   if (auto *ND = TC.getFoundDecl()) {
7477     R.setLookupName(ND->getDeclName());
7478     R.addDecl(ND);
7479     if (ND->isCXXClassMember()) {
7480       // Figure out the correct naming class to add to the LookupResult.
7481       CXXRecordDecl *Record = nullptr;
7482       if (auto *NNS = TC.getCorrectionSpecifier())
7483         Record = NNS->getAsType()->getAsCXXRecordDecl();
7484       if (!Record)
7485         Record =
7486             dyn_cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
7487       if (Record)
7488         R.setNamingClass(Record);
7489 
7490       // Detect and handle the case where the decl might be an implicit
7491       // member.
7492       bool MightBeImplicitMember;
7493       if (!Consumer.isAddressOfOperand())
7494         MightBeImplicitMember = true;
7495       else if (!NewSS.isEmpty())
7496         MightBeImplicitMember = false;
7497       else if (R.isOverloadedResult())
7498         MightBeImplicitMember = false;
7499       else if (R.isUnresolvableResult())
7500         MightBeImplicitMember = true;
7501       else
7502         MightBeImplicitMember = isa<FieldDecl>(ND) ||
7503                                 isa<IndirectFieldDecl>(ND) ||
7504                                 isa<MSPropertyDecl>(ND);
7505 
7506       if (MightBeImplicitMember)
7507         return SemaRef.BuildPossibleImplicitMemberExpr(
7508             NewSS, /*TemplateKWLoc*/ SourceLocation(), R,
7509             /*TemplateArgs*/ nullptr, /*S*/ nullptr);
7510     } else if (auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
7511       return SemaRef.LookupInObjCMethod(R, Consumer.getScope(),
7512                                         Ivar->getIdentifier());
7513     }
7514   }
7515 
7516   return SemaRef.BuildDeclarationNameExpr(NewSS, R, /*NeedsADL*/ false,
7517                                           /*AcceptInvalidDecl*/ true);
7518 }
7519 
7520 namespace {
7521 class FindTypoExprs : public RecursiveASTVisitor<FindTypoExprs> {
7522   llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs;
7523 
7524 public:
7525   explicit FindTypoExprs(llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs)
7526       : TypoExprs(TypoExprs) {}
7527   bool VisitTypoExpr(TypoExpr *TE) {
7528     TypoExprs.insert(TE);
7529     return true;
7530   }
7531 };
7532 
7533 class TransformTypos : public TreeTransform<TransformTypos> {
7534   typedef TreeTransform<TransformTypos> BaseTransform;
7535 
7536   VarDecl *InitDecl; // A decl to avoid as a correction because it is in the
7537                      // process of being initialized.
7538   llvm::function_ref<ExprResult(Expr *)> ExprFilter;
7539   llvm::SmallSetVector<TypoExpr *, 2> TypoExprs, AmbiguousTypoExprs;
7540   llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
7541   llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
7542 
7543   /// Emit diagnostics for all of the TypoExprs encountered.
7544   /// If the TypoExprs were successfully corrected, then the diagnostics should
7545   /// suggest the corrections. Otherwise the diagnostics will not suggest
7546   /// anything (having been passed an empty TypoCorrection).
7547   void EmitAllDiagnostics() {
7548     for (TypoExpr *TE : TypoExprs) {
7549       auto &State = SemaRef.getTypoExprState(TE);
7550       if (State.DiagHandler) {
7551         TypoCorrection TC = State.Consumer->getCurrentCorrection();
7552         ExprResult Replacement = TransformCache[TE];
7553 
7554         // Extract the NamedDecl from the transformed TypoExpr and add it to the
7555         // TypoCorrection, replacing the existing decls. This ensures the right
7556         // NamedDecl is used in diagnostics e.g. in the case where overload
7557         // resolution was used to select one from several possible decls that
7558         // had been stored in the TypoCorrection.
7559         if (auto *ND = getDeclFromExpr(
7560                 Replacement.isInvalid() ? nullptr : Replacement.get()))
7561           TC.setCorrectionDecl(ND);
7562 
7563         State.DiagHandler(TC);
7564       }
7565       SemaRef.clearDelayedTypo(TE);
7566     }
7567   }
7568 
7569   /// If corrections for the first TypoExpr have been exhausted for a
7570   /// given combination of the other TypoExprs, retry those corrections against
7571   /// the next combination of substitutions for the other TypoExprs by advancing
7572   /// to the next potential correction of the second TypoExpr. For the second
7573   /// and subsequent TypoExprs, if its stream of corrections has been exhausted,
7574   /// the stream is reset and the next TypoExpr's stream is advanced by one (a
7575   /// TypoExpr's correction stream is advanced by removing the TypoExpr from the
7576   /// TransformCache). Returns true if there is still any untried combinations
7577   /// of corrections.
7578   bool CheckAndAdvanceTypoExprCorrectionStreams() {
7579     for (auto TE : TypoExprs) {
7580       auto &State = SemaRef.getTypoExprState(TE);
7581       TransformCache.erase(TE);
7582       if (!State.Consumer->finished())
7583         return true;
7584       State.Consumer->resetCorrectionStream();
7585     }
7586     return false;
7587   }
7588 
7589   NamedDecl *getDeclFromExpr(Expr *E) {
7590     if (auto *OE = dyn_cast_or_null<OverloadExpr>(E))
7591       E = OverloadResolution[OE];
7592 
7593     if (!E)
7594       return nullptr;
7595     if (auto *DRE = dyn_cast<DeclRefExpr>(E))
7596       return DRE->getFoundDecl();
7597     if (auto *ME = dyn_cast<MemberExpr>(E))
7598       return ME->getFoundDecl();
7599     // FIXME: Add any other expr types that could be be seen by the delayed typo
7600     // correction TreeTransform for which the corresponding TypoCorrection could
7601     // contain multiple decls.
7602     return nullptr;
7603   }
7604 
7605   ExprResult TryTransform(Expr *E) {
7606     Sema::SFINAETrap Trap(SemaRef);
7607     ExprResult Res = TransformExpr(E);
7608     if (Trap.hasErrorOccurred() || Res.isInvalid())
7609       return ExprError();
7610 
7611     return ExprFilter(Res.get());
7612   }
7613 
7614 public:
7615   TransformTypos(Sema &SemaRef, VarDecl *InitDecl, llvm::function_ref<ExprResult(Expr *)> Filter)
7616       : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(Filter) {}
7617 
7618   ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
7619                                    MultiExprArg Args,
7620                                    SourceLocation RParenLoc,
7621                                    Expr *ExecConfig = nullptr) {
7622     auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
7623                                                  RParenLoc, ExecConfig);
7624     if (auto *OE = dyn_cast<OverloadExpr>(Callee)) {
7625       if (Result.isUsable()) {
7626         Expr *ResultCall = Result.get();
7627         if (auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
7628           ResultCall = BE->getSubExpr();
7629         if (auto *CE = dyn_cast<CallExpr>(ResultCall))
7630           OverloadResolution[OE] = CE->getCallee();
7631       }
7632     }
7633     return Result;
7634   }
7635 
7636   ExprResult TransformLambdaExpr(LambdaExpr *E) { return Owned(E); }
7637 
7638   ExprResult TransformBlockExpr(BlockExpr *E) { return Owned(E); }
7639 
7640   ExprResult Transform(Expr *E) {
7641     ExprResult Res;
7642     while (true) {
7643       Res = TryTransform(E);
7644 
7645       // Exit if either the transform was valid or if there were no TypoExprs
7646       // to transform that still have any untried correction candidates..
7647       if (!Res.isInvalid() ||
7648           !CheckAndAdvanceTypoExprCorrectionStreams())
7649         break;
7650     }
7651 
7652     // Ensure none of the TypoExprs have multiple typo correction candidates
7653     // with the same edit length that pass all the checks and filters.
7654     // TODO: Properly handle various permutations of possible corrections when
7655     // there is more than one potentially ambiguous typo correction.
7656     // Also, disable typo correction while attempting the transform when
7657     // handling potentially ambiguous typo corrections as any new TypoExprs will
7658     // have been introduced by the application of one of the correction
7659     // candidates and add little to no value if corrected.
7660     SemaRef.DisableTypoCorrection = true;
7661     while (!AmbiguousTypoExprs.empty()) {
7662       auto TE  = AmbiguousTypoExprs.back();
7663       auto Cached = TransformCache[TE];
7664       auto &State = SemaRef.getTypoExprState(TE);
7665       State.Consumer->saveCurrentPosition();
7666       TransformCache.erase(TE);
7667       if (!TryTransform(E).isInvalid()) {
7668         State.Consumer->resetCorrectionStream();
7669         TransformCache.erase(TE);
7670         Res = ExprError();
7671         break;
7672       }
7673       AmbiguousTypoExprs.remove(TE);
7674       State.Consumer->restoreSavedPosition();
7675       TransformCache[TE] = Cached;
7676     }
7677     SemaRef.DisableTypoCorrection = false;
7678 
7679     // Ensure that all of the TypoExprs within the current Expr have been found.
7680     if (!Res.isUsable())
7681       FindTypoExprs(TypoExprs).TraverseStmt(E);
7682 
7683     EmitAllDiagnostics();
7684 
7685     return Res;
7686   }
7687 
7688   ExprResult TransformTypoExpr(TypoExpr *E) {
7689     // If the TypoExpr hasn't been seen before, record it. Otherwise, return the
7690     // cached transformation result if there is one and the TypoExpr isn't the
7691     // first one that was encountered.
7692     auto &CacheEntry = TransformCache[E];
7693     if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) {
7694       return CacheEntry;
7695     }
7696 
7697     auto &State = SemaRef.getTypoExprState(E);
7698     assert(State.Consumer && "Cannot transform a cleared TypoExpr");
7699 
7700     // For the first TypoExpr and an uncached TypoExpr, find the next likely
7701     // typo correction and return it.
7702     while (TypoCorrection TC = State.Consumer->getNextCorrection()) {
7703       if (InitDecl && TC.getFoundDecl() == InitDecl)
7704         continue;
7705       // FIXME: If we would typo-correct to an invalid declaration, it's
7706       // probably best to just suppress all errors from this typo correction.
7707       ExprResult NE = State.RecoveryHandler ?
7708           State.RecoveryHandler(SemaRef, E, TC) :
7709           attemptRecovery(SemaRef, *State.Consumer, TC);
7710       if (!NE.isInvalid()) {
7711         // Check whether there may be a second viable correction with the same
7712         // edit distance; if so, remember this TypoExpr may have an ambiguous
7713         // correction so it can be more thoroughly vetted later.
7714         TypoCorrection Next;
7715         if ((Next = State.Consumer->peekNextCorrection()) &&
7716             Next.getEditDistance(false) == TC.getEditDistance(false)) {
7717           AmbiguousTypoExprs.insert(E);
7718         } else {
7719           AmbiguousTypoExprs.remove(E);
7720         }
7721         assert(!NE.isUnset() &&
7722                "Typo was transformed into a valid-but-null ExprResult");
7723         return CacheEntry = NE;
7724       }
7725     }
7726     return CacheEntry = ExprError();
7727   }
7728 };
7729 }
7730 
7731 ExprResult
7732 Sema::CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl,
7733                                 llvm::function_ref<ExprResult(Expr *)> Filter) {
7734   // If the current evaluation context indicates there are uncorrected typos
7735   // and the current expression isn't guaranteed to not have typos, try to
7736   // resolve any TypoExpr nodes that might be in the expression.
7737   if (E && !ExprEvalContexts.empty() && ExprEvalContexts.back().NumTypos &&
7738       (E->isTypeDependent() || E->isValueDependent() ||
7739        E->isInstantiationDependent())) {
7740     auto TyposResolved = DelayedTypos.size();
7741     auto Result = TransformTypos(*this, InitDecl, Filter).Transform(E);
7742     TyposResolved -= DelayedTypos.size();
7743     if (Result.isInvalid() || Result.get() != E) {
7744       ExprEvalContexts.back().NumTypos -= TyposResolved;
7745       return Result;
7746     }
7747     assert(TyposResolved == 0 && "Corrected typo but got same Expr back?");
7748   }
7749   return E;
7750 }
7751 
7752 ExprResult Sema::ActOnFinishFullExpr(Expr *FE, SourceLocation CC,
7753                                      bool DiscardedValue,
7754                                      bool IsConstexpr,
7755                                      bool IsLambdaInitCaptureInitializer) {
7756   ExprResult FullExpr = FE;
7757 
7758   if (!FullExpr.get())
7759     return ExprError();
7760 
7761   // If we are an init-expression in a lambdas init-capture, we should not
7762   // diagnose an unexpanded pack now (will be diagnosed once lambda-expr
7763   // containing full-expression is done).
7764   // template<class ... Ts> void test(Ts ... t) {
7765   //   test([&a(t)]() { <-- (t) is an init-expr that shouldn't be diagnosed now.
7766   //     return a;
7767   //   }() ...);
7768   // }
7769   // FIXME: This is a hack. It would be better if we pushed the lambda scope
7770   // when we parse the lambda introducer, and teach capturing (but not
7771   // unexpanded pack detection) to walk over LambdaScopeInfos which don't have a
7772   // corresponding class yet (that is, have LambdaScopeInfo either represent a
7773   // lambda where we've entered the introducer but not the body, or represent a
7774   // lambda where we've entered the body, depending on where the
7775   // parser/instantiation has got to).
7776   if (!IsLambdaInitCaptureInitializer &&
7777       DiagnoseUnexpandedParameterPack(FullExpr.get()))
7778     return ExprError();
7779 
7780   // Top-level expressions default to 'id' when we're in a debugger.
7781   if (DiscardedValue && getLangOpts().DebuggerCastResultToId &&
7782       FullExpr.get()->getType() == Context.UnknownAnyTy) {
7783     FullExpr = forceUnknownAnyToType(FullExpr.get(), Context.getObjCIdType());
7784     if (FullExpr.isInvalid())
7785       return ExprError();
7786   }
7787 
7788   if (DiscardedValue) {
7789     FullExpr = CheckPlaceholderExpr(FullExpr.get());
7790     if (FullExpr.isInvalid())
7791       return ExprError();
7792 
7793     FullExpr = IgnoredValueConversions(FullExpr.get());
7794     if (FullExpr.isInvalid())
7795       return ExprError();
7796   }
7797 
7798   FullExpr = CorrectDelayedTyposInExpr(FullExpr.get());
7799   if (FullExpr.isInvalid())
7800     return ExprError();
7801 
7802   CheckCompletedExpr(FullExpr.get(), CC, IsConstexpr);
7803 
7804   // At the end of this full expression (which could be a deeply nested
7805   // lambda), if there is a potential capture within the nested lambda,
7806   // have the outer capture-able lambda try and capture it.
7807   // Consider the following code:
7808   // void f(int, int);
7809   // void f(const int&, double);
7810   // void foo() {
7811   //  const int x = 10, y = 20;
7812   //  auto L = [=](auto a) {
7813   //      auto M = [=](auto b) {
7814   //         f(x, b); <-- requires x to be captured by L and M
7815   //         f(y, a); <-- requires y to be captured by L, but not all Ms
7816   //      };
7817   //   };
7818   // }
7819 
7820   // FIXME: Also consider what happens for something like this that involves
7821   // the gnu-extension statement-expressions or even lambda-init-captures:
7822   //   void f() {
7823   //     const int n = 0;
7824   //     auto L =  [&](auto a) {
7825   //       +n + ({ 0; a; });
7826   //     };
7827   //   }
7828   //
7829   // Here, we see +n, and then the full-expression 0; ends, so we don't
7830   // capture n (and instead remove it from our list of potential captures),
7831   // and then the full-expression +n + ({ 0; }); ends, but it's too late
7832   // for us to see that we need to capture n after all.
7833 
7834   LambdaScopeInfo *const CurrentLSI =
7835       getCurLambda(/*IgnoreCapturedRegions=*/true);
7836   // FIXME: PR 17877 showed that getCurLambda() can return a valid pointer
7837   // even if CurContext is not a lambda call operator. Refer to that Bug Report
7838   // for an example of the code that might cause this asynchrony.
7839   // By ensuring we are in the context of a lambda's call operator
7840   // we can fix the bug (we only need to check whether we need to capture
7841   // if we are within a lambda's body); but per the comments in that
7842   // PR, a proper fix would entail :
7843   //   "Alternative suggestion:
7844   //   - Add to Sema an integer holding the smallest (outermost) scope
7845   //     index that we are *lexically* within, and save/restore/set to
7846   //     FunctionScopes.size() in InstantiatingTemplate's
7847   //     constructor/destructor.
7848   //  - Teach the handful of places that iterate over FunctionScopes to
7849   //    stop at the outermost enclosing lexical scope."
7850   DeclContext *DC = CurContext;
7851   while (DC && isa<CapturedDecl>(DC))
7852     DC = DC->getParent();
7853   const bool IsInLambdaDeclContext = isLambdaCallOperator(DC);
7854   if (IsInLambdaDeclContext && CurrentLSI &&
7855       CurrentLSI->hasPotentialCaptures() && !FullExpr.isInvalid())
7856     CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(FE, CurrentLSI,
7857                                                               *this);
7858   return MaybeCreateExprWithCleanups(FullExpr);
7859 }
7860 
7861 StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) {
7862   if (!FullStmt) return StmtError();
7863 
7864   return MaybeCreateStmtWithCleanups(FullStmt);
7865 }
7866 
7867 Sema::IfExistsResult
7868 Sema::CheckMicrosoftIfExistsSymbol(Scope *S,
7869                                    CXXScopeSpec &SS,
7870                                    const DeclarationNameInfo &TargetNameInfo) {
7871   DeclarationName TargetName = TargetNameInfo.getName();
7872   if (!TargetName)
7873     return IER_DoesNotExist;
7874 
7875   // If the name itself is dependent, then the result is dependent.
7876   if (TargetName.isDependentName())
7877     return IER_Dependent;
7878 
7879   // Do the redeclaration lookup in the current scope.
7880   LookupResult R(*this, TargetNameInfo, Sema::LookupAnyName,
7881                  Sema::NotForRedeclaration);
7882   LookupParsedName(R, S, &SS);
7883   R.suppressDiagnostics();
7884 
7885   switch (R.getResultKind()) {
7886   case LookupResult::Found:
7887   case LookupResult::FoundOverloaded:
7888   case LookupResult::FoundUnresolvedValue:
7889   case LookupResult::Ambiguous:
7890     return IER_Exists;
7891 
7892   case LookupResult::NotFound:
7893     return IER_DoesNotExist;
7894 
7895   case LookupResult::NotFoundInCurrentInstantiation:
7896     return IER_Dependent;
7897   }
7898 
7899   llvm_unreachable("Invalid LookupResult Kind!");
7900 }
7901 
7902 Sema::IfExistsResult
7903 Sema::CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
7904                                    bool IsIfExists, CXXScopeSpec &SS,
7905                                    UnqualifiedId &Name) {
7906   DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
7907 
7908   // Check for an unexpanded parameter pack.
7909   auto UPPC = IsIfExists ? UPPC_IfExists : UPPC_IfNotExists;
7910   if (DiagnoseUnexpandedParameterPack(SS, UPPC) ||
7911       DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC))
7912     return IER_Error;
7913 
7914   return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo);
7915 }
7916